lestes: tm_instr.mdg.cc Source File

00001 /* This file is generated from machine description */
00002 #include <lestes/std/set.hh>
00003 #include <lestes/md/types/tm_data_type.g.hh>
00004 #include <lestes/md/registers/tm_register.g.hh>
00005 #include <lestes/md/instructions/tm_instr.g.hh>
00006 #include <lestes/md/instructions/execution_info.g.hh>
00007 
00008 /*! \file
00009         \brief Target-machine instruction.
00010         \author jaz
00011 */
00012 
00013 package(lestes);
00014 package(md);
00015 package(instructions);
00016 
00017 using namespace ::lestes::md::types;
00018 using namespace ::lestes::md::registers;
00019 
00020 
00021 
00022 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOV__1() {
00023         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00024         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00025         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00026         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00027         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00028         ptr<execution_info> einfo;
00029         ptr<set<ulint> > versions;
00030         
00031         //input operands
00032         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00033         dt_list_I_1->insert(DT_INT_8P);
00034         dt_list_I_1->insert(DT_INT_8U);
00035         dt_list_I_1->insert(DT_INT_8S);
00036         dt_list_I_1->insert(DT_INT_16U);
00037         dt_list_I_1->insert(DT_INT_16S);
00038         dt_list_I_1->insert(DT_INT_32U);
00039         dt_list_I_1->insert(DT_INT_32S);
00040         dt_list_I_1->insert(DT_COND);
00041         dt_list_I_1->insert(DT_BOOL);
00042         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
00043         reg_list_I_1->insert(R_EAX);
00044         reg_list_I_1->insert(R_EBX);
00045         reg_list_I_1->insert(R_ECX);
00046         reg_list_I_1->insert(R_EDX);
00047         reg_list_I_1->insert(R_EDI);
00048         reg_list_I_1->insert(R_ESI);
00049         reg_list_I_1->insert(R_AX);
00050         reg_list_I_1->insert(R_BX);
00051         reg_list_I_1->insert(R_CX);
00052         reg_list_I_1->insert(R_DX);
00053         reg_list_I_1->insert(R_DI);
00054         reg_list_I_1->insert(R_SI);
00055         reg_list_I_1->insert(R_AL);
00056         reg_list_I_1->insert(R_AH);
00057         reg_list_I_1->insert(R_BL);
00058         reg_list_I_1->insert(R_BH);
00059         reg_list_I_1->insert(R_CL);
00060         reg_list_I_1->insert(R_CH);
00061         reg_list_I_1->insert(R_DL);
00062         reg_list_I_1->insert(R_DH);
00063         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
00064         in_operands->push_back(op_I_1);
00065 
00066         //output operands
00067         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00068         dt_list_O_1->insert(DT_INT_8P);
00069         dt_list_O_1->insert(DT_INT_8U);
00070         dt_list_O_1->insert(DT_INT_8S);
00071         dt_list_O_1->insert(DT_INT_16U);
00072         dt_list_O_1->insert(DT_INT_16S);
00073         dt_list_O_1->insert(DT_INT_32U);
00074         dt_list_O_1->insert(DT_INT_32S);
00075         dt_list_O_1->insert(DT_COND);
00076         dt_list_O_1->insert(DT_BOOL);
00077         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
00078         reg_list_O_1->insert(R_EAX);
00079         reg_list_O_1->insert(R_EBX);
00080         reg_list_O_1->insert(R_ECX);
00081         reg_list_O_1->insert(R_EDX);
00082         reg_list_O_1->insert(R_EDI);
00083         reg_list_O_1->insert(R_ESI);
00084         reg_list_O_1->insert(R_AX);
00085         reg_list_O_1->insert(R_BX);
00086         reg_list_O_1->insert(R_CX);
00087         reg_list_O_1->insert(R_DX);
00088         reg_list_O_1->insert(R_DI);
00089         reg_list_O_1->insert(R_SI);
00090         reg_list_O_1->insert(R_AL);
00091         reg_list_O_1->insert(R_AH);
00092         reg_list_O_1->insert(R_BL);
00093         reg_list_O_1->insert(R_BH);
00094         reg_list_O_1->insert(R_CL);
00095         reg_list_O_1->insert(R_CH);
00096         reg_list_O_1->insert(R_DL);
00097         reg_list_O_1->insert(R_DH);
00098         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
00099         out_operands->push_back(op_O_1);
00100 
00101         //execution info
00102         einfo = execution_info::create(10);
00103 
00104         //properties
00105 
00106         //versions
00107         versions = set<ulint>::create();
00108         versions->insert(INSTRUCTION_MOV__2);
00109         versions->insert(INSTRUCTION_MOV__3);
00110         versions->insert(INSTRUCTION_MOV__4);
00111         versions->insert(INSTRUCTION_MOV__5);
00112         versions->insert(INSTRUCTION_MOV__7);
00113         versions->insert(INSTRUCTION_MOV__71);
00114         versions->insert(INSTRUCTION_MOV__8);
00115         versions->insert(INSTRUCTION_MOVZX__1);
00116         versions->insert(INSTRUCTION_MOVZX__2);
00117         versions->insert(INSTRUCTION_MOVZX__3);
00118         versions->insert(INSTRUCTION_MOVZX__4);
00119         versions->insert(INSTRUCTION_MOVZX__5);
00120         versions->insert(INSTRUCTION_MOVZX__6);
00121         versions->insert(INSTRUCTION_MOVSX__1);
00122         versions->insert(INSTRUCTION_MOVSX__11);
00123         versions->insert(INSTRUCTION_MOVSX__2);
00124         versions->insert(INSTRUCTION_MOVSX__21);
00125 
00126 
00127         //return target pseudoinstruction
00128         return tm_instr::create(INSTRUCTION_MOV__1,in_operands,out_operands,lstring("mov $O_1, $I_1"), props,versions,IF_COPY,einfo);
00129 }
00130 
00131 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOV__2() {
00132         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00133         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00134         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00135         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00136         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00137         ptr<execution_info> einfo;
00138         ptr<set<ulint> > versions;
00139         
00140         //input operands
00141         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00142         dt_list_I_1->insert(DT_INT_8P);
00143         dt_list_I_1->insert(DT_INT_8U);
00144         dt_list_I_1->insert(DT_INT_8S);
00145         dt_list_I_1->insert(DT_INT_16U);
00146         dt_list_I_1->insert(DT_INT_16S);
00147         dt_list_I_1->insert(DT_INT_32U);
00148         dt_list_I_1->insert(DT_INT_32S);
00149         dt_list_I_1->insert(DT_COND);
00150         dt_list_I_1->insert(DT_BOOL);
00151         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
00152         reg_list_I_1->insert(R_EAX);
00153         reg_list_I_1->insert(R_EBX);
00154         reg_list_I_1->insert(R_ECX);
00155         reg_list_I_1->insert(R_EDX);
00156         reg_list_I_1->insert(R_EDI);
00157         reg_list_I_1->insert(R_ESI);
00158         reg_list_I_1->insert(R_AX);
00159         reg_list_I_1->insert(R_BX);
00160         reg_list_I_1->insert(R_CX);
00161         reg_list_I_1->insert(R_DX);
00162         reg_list_I_1->insert(R_DI);
00163         reg_list_I_1->insert(R_SI);
00164         reg_list_I_1->insert(R_AL);
00165         reg_list_I_1->insert(R_AH);
00166         reg_list_I_1->insert(R_BL);
00167         reg_list_I_1->insert(R_BH);
00168         reg_list_I_1->insert(R_CL);
00169         reg_list_I_1->insert(R_CH);
00170         reg_list_I_1->insert(R_DL);
00171         reg_list_I_1->insert(R_DH);
00172         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
00173         in_operands->push_back(op_I_1);
00174 
00175         //output operands
00176         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00177         dt_list_O_1->insert(DT_INT_8P);
00178         dt_list_O_1->insert(DT_INT_8U);
00179         dt_list_O_1->insert(DT_INT_8S);
00180         dt_list_O_1->insert(DT_INT_16U);
00181         dt_list_O_1->insert(DT_INT_16S);
00182         dt_list_O_1->insert(DT_INT_32U);
00183         dt_list_O_1->insert(DT_INT_32S);
00184         dt_list_O_1->insert(DT_COND);
00185         dt_list_O_1->insert(DT_BOOL);
00186         ptr<tm_instr_op_mem> op_O_1 = tm_instr_op_mem::create(O_1, dt_list_O_1);
00187         out_operands->push_back(op_O_1);
00188 
00189         //execution info
00190         einfo = execution_info::create(30);
00191 
00192         //properties
00193 
00194         //versions
00195         versions = set<ulint>::create();
00196         versions->insert(INSTRUCTION_MOV__1);
00197         versions->insert(INSTRUCTION_MOV__3);
00198         versions->insert(INSTRUCTION_MOV__4);
00199         versions->insert(INSTRUCTION_MOV__5);
00200         versions->insert(INSTRUCTION_MOV__7);
00201         versions->insert(INSTRUCTION_MOV__71);
00202         versions->insert(INSTRUCTION_MOV__8);
00203         versions->insert(INSTRUCTION_MOVZX__1);
00204         versions->insert(INSTRUCTION_MOVZX__2);
00205         versions->insert(INSTRUCTION_MOVZX__3);
00206         versions->insert(INSTRUCTION_MOVZX__4);
00207         versions->insert(INSTRUCTION_MOVZX__5);
00208         versions->insert(INSTRUCTION_MOVZX__6);
00209         versions->insert(INSTRUCTION_MOVSX__1);
00210         versions->insert(INSTRUCTION_MOVSX__11);
00211         versions->insert(INSTRUCTION_MOVSX__2);
00212         versions->insert(INSTRUCTION_MOVSX__21);
00213 
00214 
00215         //return target pseudoinstruction
00216         return tm_instr::create(INSTRUCTION_MOV__2,in_operands,out_operands,lstring("mov $TYPE_O_1 $O_1, $I_1"), props,versions,IF_STORE,einfo);
00217 }
00218 
00219 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOV__3() {
00220         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00221         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00222         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00223         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00224         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00225         ptr<execution_info> einfo;
00226         ptr<set<ulint> > versions;
00227         
00228         //input operands
00229         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00230         dt_list_I_1->insert(DT_INT_8P);
00231         dt_list_I_1->insert(DT_INT_8U);
00232         dt_list_I_1->insert(DT_INT_8S);
00233         dt_list_I_1->insert(DT_INT_16U);
00234         dt_list_I_1->insert(DT_INT_16S);
00235         dt_list_I_1->insert(DT_INT_32U);
00236         dt_list_I_1->insert(DT_INT_32S);
00237         dt_list_I_1->insert(DT_COND);
00238         dt_list_I_1->insert(DT_BOOL);
00239         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
00240         in_operands->push_back(op_I_1);
00241 
00242         //output operands
00243         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00244         dt_list_O_1->insert(DT_INT_8P);
00245         dt_list_O_1->insert(DT_INT_8U);
00246         dt_list_O_1->insert(DT_INT_8S);
00247         dt_list_O_1->insert(DT_INT_16U);
00248         dt_list_O_1->insert(DT_INT_16S);
00249         dt_list_O_1->insert(DT_INT_32U);
00250         dt_list_O_1->insert(DT_INT_32S);
00251         dt_list_O_1->insert(DT_COND);
00252         dt_list_O_1->insert(DT_BOOL);
00253         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
00254         reg_list_O_1->insert(R_EAX);
00255         reg_list_O_1->insert(R_EBX);
00256         reg_list_O_1->insert(R_ECX);
00257         reg_list_O_1->insert(R_EDX);
00258         reg_list_O_1->insert(R_EDI);
00259         reg_list_O_1->insert(R_ESI);
00260         reg_list_O_1->insert(R_AX);
00261         reg_list_O_1->insert(R_BX);
00262         reg_list_O_1->insert(R_CX);
00263         reg_list_O_1->insert(R_DX);
00264         reg_list_O_1->insert(R_DI);
00265         reg_list_O_1->insert(R_SI);
00266         reg_list_O_1->insert(R_AL);
00267         reg_list_O_1->insert(R_AH);
00268         reg_list_O_1->insert(R_BL);
00269         reg_list_O_1->insert(R_BH);
00270         reg_list_O_1->insert(R_CL);
00271         reg_list_O_1->insert(R_CH);
00272         reg_list_O_1->insert(R_DL);
00273         reg_list_O_1->insert(R_DH);
00274         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
00275         out_operands->push_back(op_O_1);
00276 
00277         //execution info
00278         einfo = execution_info::create(30);
00279 
00280         //properties
00281 
00282         //versions
00283         versions = set<ulint>::create();
00284         versions->insert(INSTRUCTION_MOV__1);
00285         versions->insert(INSTRUCTION_MOV__2);
00286         versions->insert(INSTRUCTION_MOV__4);
00287         versions->insert(INSTRUCTION_MOV__5);
00288         versions->insert(INSTRUCTION_MOV__7);
00289         versions->insert(INSTRUCTION_MOV__71);
00290         versions->insert(INSTRUCTION_MOV__8);
00291         versions->insert(INSTRUCTION_MOVZX__1);
00292         versions->insert(INSTRUCTION_MOVZX__2);
00293         versions->insert(INSTRUCTION_MOVZX__3);
00294         versions->insert(INSTRUCTION_MOVZX__4);
00295         versions->insert(INSTRUCTION_MOVZX__5);
00296         versions->insert(INSTRUCTION_MOVZX__6);
00297         versions->insert(INSTRUCTION_MOVSX__1);
00298         versions->insert(INSTRUCTION_MOVSX__11);
00299         versions->insert(INSTRUCTION_MOVSX__2);
00300         versions->insert(INSTRUCTION_MOVSX__21);
00301 
00302 
00303         //return target pseudoinstruction
00304         return tm_instr::create(INSTRUCTION_MOV__3,in_operands,out_operands,lstring("mov $O_1, $TYPE_I_1 $I_1"), props,versions,IF_LOAD,einfo);
00305 }
00306 
00307 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOV__4() {
00308         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00309         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00310         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00311         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00312         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00313         ptr<execution_info> einfo;
00314         ptr<set<ulint> > versions;
00315         
00316         //input operands
00317         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00318         dt_list_I_1->insert(DT_INT_8P);
00319         dt_list_I_1->insert(DT_INT_8U);
00320         dt_list_I_1->insert(DT_INT_8S);
00321         dt_list_I_1->insert(DT_INT_16U);
00322         dt_list_I_1->insert(DT_INT_16S);
00323         dt_list_I_1->insert(DT_INT_32U);
00324         dt_list_I_1->insert(DT_INT_32S);
00325         dt_list_I_1->insert(DT_BOOL);
00326         ptr<tm_instr_op_imm> op_I_1 = tm_instr_op_imm::create(I_1, dt_list_I_1);
00327         in_operands->push_back(op_I_1);
00328 
00329         //output operands
00330         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00331         dt_list_O_1->insert(DT_INT_8P);
00332         dt_list_O_1->insert(DT_INT_8U);
00333         dt_list_O_1->insert(DT_INT_8S);
00334         dt_list_O_1->insert(DT_INT_16U);
00335         dt_list_O_1->insert(DT_INT_16S);
00336         dt_list_O_1->insert(DT_INT_32U);
00337         dt_list_O_1->insert(DT_INT_32S);
00338         dt_list_O_1->insert(DT_BOOL);
00339         ptr<tm_instr_op_mem> op_O_1 = tm_instr_op_mem::create(O_1, dt_list_O_1);
00340         out_operands->push_back(op_O_1);
00341 
00342         //execution info
00343         einfo = execution_info::create(30);
00344 
00345         //properties
00346 
00347         //versions
00348         versions = set<ulint>::create();
00349         versions->insert(INSTRUCTION_MOV__1);
00350         versions->insert(INSTRUCTION_MOV__2);
00351         versions->insert(INSTRUCTION_MOV__3);
00352         versions->insert(INSTRUCTION_MOV__5);
00353         versions->insert(INSTRUCTION_MOV__7);
00354         versions->insert(INSTRUCTION_MOV__71);
00355         versions->insert(INSTRUCTION_MOV__8);
00356         versions->insert(INSTRUCTION_MOVZX__1);
00357         versions->insert(INSTRUCTION_MOVZX__2);
00358         versions->insert(INSTRUCTION_MOVZX__3);
00359         versions->insert(INSTRUCTION_MOVZX__4);
00360         versions->insert(INSTRUCTION_MOVZX__5);
00361         versions->insert(INSTRUCTION_MOVZX__6);
00362         versions->insert(INSTRUCTION_MOVSX__1);
00363         versions->insert(INSTRUCTION_MOVSX__11);
00364         versions->insert(INSTRUCTION_MOVSX__2);
00365         versions->insert(INSTRUCTION_MOVSX__21);
00366 
00367 
00368         //return target pseudoinstruction
00369         return tm_instr::create(INSTRUCTION_MOV__4,in_operands,out_operands,lstring("mov $TYPE_O_1 $O_1, $TYPE_I_1 $I_1"), props,versions,IF_LOAD | IF_STORE,einfo);
00370 }
00371 
00372 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOV__5() {
00373         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00374         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00375         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00376         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00377         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00378         ptr<execution_info> einfo;
00379         ptr<set<ulint> > versions;
00380         
00381         //input operands
00382         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00383         dt_list_I_1->insert(DT_INT_8P);
00384         dt_list_I_1->insert(DT_INT_8U);
00385         dt_list_I_1->insert(DT_INT_8S);
00386         dt_list_I_1->insert(DT_INT_16U);
00387         dt_list_I_1->insert(DT_INT_16S);
00388         dt_list_I_1->insert(DT_INT_32U);
00389         dt_list_I_1->insert(DT_INT_32S);
00390         dt_list_I_1->insert(DT_BOOL);
00391         ptr<tm_instr_op_imm> op_I_1 = tm_instr_op_imm::create(I_1, dt_list_I_1);
00392         in_operands->push_back(op_I_1);
00393 
00394         //output operands
00395         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00396         dt_list_O_1->insert(DT_INT_8P);
00397         dt_list_O_1->insert(DT_INT_8U);
00398         dt_list_O_1->insert(DT_INT_8S);
00399         dt_list_O_1->insert(DT_INT_16U);
00400         dt_list_O_1->insert(DT_INT_16S);
00401         dt_list_O_1->insert(DT_INT_32U);
00402         dt_list_O_1->insert(DT_INT_32S);
00403         dt_list_O_1->insert(DT_BOOL);
00404         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
00405         reg_list_O_1->insert(R_EAX);
00406         reg_list_O_1->insert(R_EBX);
00407         reg_list_O_1->insert(R_ECX);
00408         reg_list_O_1->insert(R_EDX);
00409         reg_list_O_1->insert(R_EDI);
00410         reg_list_O_1->insert(R_ESI);
00411         reg_list_O_1->insert(R_AX);
00412         reg_list_O_1->insert(R_BX);
00413         reg_list_O_1->insert(R_CX);
00414         reg_list_O_1->insert(R_DX);
00415         reg_list_O_1->insert(R_DI);
00416         reg_list_O_1->insert(R_SI);
00417         reg_list_O_1->insert(R_AL);
00418         reg_list_O_1->insert(R_AH);
00419         reg_list_O_1->insert(R_BL);
00420         reg_list_O_1->insert(R_BH);
00421         reg_list_O_1->insert(R_CL);
00422         reg_list_O_1->insert(R_CH);
00423         reg_list_O_1->insert(R_DL);
00424         reg_list_O_1->insert(R_DH);
00425         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
00426         out_operands->push_back(op_O_1);
00427 
00428         //execution info
00429         einfo = execution_info::create(10);
00430 
00431         //properties
00432 
00433         //versions
00434         versions = set<ulint>::create();
00435         versions->insert(INSTRUCTION_MOV__1);
00436         versions->insert(INSTRUCTION_MOV__2);
00437         versions->insert(INSTRUCTION_MOV__3);
00438         versions->insert(INSTRUCTION_MOV__4);
00439         versions->insert(INSTRUCTION_MOV__7);
00440         versions->insert(INSTRUCTION_MOV__71);
00441         versions->insert(INSTRUCTION_MOV__8);
00442         versions->insert(INSTRUCTION_MOVZX__1);
00443         versions->insert(INSTRUCTION_MOVZX__2);
00444         versions->insert(INSTRUCTION_MOVZX__3);
00445         versions->insert(INSTRUCTION_MOVZX__4);
00446         versions->insert(INSTRUCTION_MOVZX__5);
00447         versions->insert(INSTRUCTION_MOVZX__6);
00448         versions->insert(INSTRUCTION_MOVSX__1);
00449         versions->insert(INSTRUCTION_MOVSX__11);
00450         versions->insert(INSTRUCTION_MOVSX__2);
00451         versions->insert(INSTRUCTION_MOVSX__21);
00452 
00453 
00454         //return target pseudoinstruction
00455         return tm_instr::create(INSTRUCTION_MOV__5,in_operands,out_operands,lstring("mov $O_1, $TYPE_I_1 $I_1"), props,versions,IF_LOAD,einfo);
00456 }
00457 
00458 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOV__7() {
00459         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00460         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00461         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00462         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00463         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00464         ptr<execution_info> einfo;
00465         ptr<set<ulint> > versions;
00466         
00467         //input operands
00468         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00469         dt_list_I_1->insert(DT_INT_8P);
00470         dt_list_I_1->insert(DT_INT_8U);
00471         dt_list_I_1->insert(DT_INT_8S);
00472         dt_list_I_1->insert(DT_INT_16U);
00473         dt_list_I_1->insert(DT_INT_16S);
00474         dt_list_I_1->insert(DT_INT_32U);
00475         dt_list_I_1->insert(DT_INT_32S);
00476         dt_list_I_1->insert(DT_COND);
00477         dt_list_I_1->insert(DT_BOOL);
00478         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
00479         reg_list_I_1->insert(R_EAX);
00480         reg_list_I_1->insert(R_EBX);
00481         reg_list_I_1->insert(R_ECX);
00482         reg_list_I_1->insert(R_EDX);
00483         reg_list_I_1->insert(R_EDI);
00484         reg_list_I_1->insert(R_ESI);
00485         reg_list_I_1->insert(R_AX);
00486         reg_list_I_1->insert(R_BX);
00487         reg_list_I_1->insert(R_CX);
00488         reg_list_I_1->insert(R_DX);
00489         reg_list_I_1->insert(R_DI);
00490         reg_list_I_1->insert(R_SI);
00491         reg_list_I_1->insert(R_AL);
00492         reg_list_I_1->insert(R_AH);
00493         reg_list_I_1->insert(R_BL);
00494         reg_list_I_1->insert(R_BH);
00495         reg_list_I_1->insert(R_CL);
00496         reg_list_I_1->insert(R_CH);
00497         reg_list_I_1->insert(R_DL);
00498         reg_list_I_1->insert(R_DH);
00499         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
00500         in_operands->push_back(op_I_1);
00501         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
00502         dt_list_I_2->insert(DT_INT_32U);
00503         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
00504         reg_list_I_2->insert(R_EAX);
00505         reg_list_I_2->insert(R_EBX);
00506         reg_list_I_2->insert(R_ECX);
00507         reg_list_I_2->insert(R_EDX);
00508         reg_list_I_2->insert(R_EDI);
00509         reg_list_I_2->insert(R_ESI);
00510         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
00511         in_operands->push_back(op_I_2);
00512 
00513         //output operands
00514         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00515         dt_list_O_1->insert(DT_INT_8P);
00516         dt_list_O_1->insert(DT_INT_8U);
00517         dt_list_O_1->insert(DT_INT_8S);
00518         dt_list_O_1->insert(DT_INT_16U);
00519         dt_list_O_1->insert(DT_INT_16S);
00520         dt_list_O_1->insert(DT_INT_32U);
00521         dt_list_O_1->insert(DT_INT_32S);
00522         dt_list_O_1->insert(DT_COND);
00523         dt_list_O_1->insert(DT_BOOL);
00524         ptr<tm_instr_op_mem> op_O_1 = tm_instr_op_mem::create(O_1, dt_list_O_1);
00525         out_operands->push_back(op_O_1);
00526 
00527         //execution info
00528         einfo = execution_info::create(30);
00529 
00530         //properties
00531 
00532         //versions
00533         versions = set<ulint>::create();
00534         versions->insert(INSTRUCTION_MOV__1);
00535         versions->insert(INSTRUCTION_MOV__2);
00536         versions->insert(INSTRUCTION_MOV__3);
00537         versions->insert(INSTRUCTION_MOV__4);
00538         versions->insert(INSTRUCTION_MOV__5);
00539         versions->insert(INSTRUCTION_MOV__71);
00540         versions->insert(INSTRUCTION_MOV__8);
00541         versions->insert(INSTRUCTION_MOVZX__1);
00542         versions->insert(INSTRUCTION_MOVZX__2);
00543         versions->insert(INSTRUCTION_MOVZX__3);
00544         versions->insert(INSTRUCTION_MOVZX__4);
00545         versions->insert(INSTRUCTION_MOVZX__5);
00546         versions->insert(INSTRUCTION_MOVZX__6);
00547         versions->insert(INSTRUCTION_MOVSX__1);
00548         versions->insert(INSTRUCTION_MOVSX__11);
00549         versions->insert(INSTRUCTION_MOVSX__2);
00550         versions->insert(INSTRUCTION_MOVSX__21);
00551 
00552 
00553         //return target pseudoinstruction
00554         return tm_instr::create(INSTRUCTION_MOV__7,in_operands,out_operands,lstring("mov $TYPE_O_1 $O_1, $I_1"), props,versions,IF_STORE,einfo);
00555 }
00556 
00557 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOV__71() {
00558         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00559         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00560         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00561         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00562         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00563         ptr<execution_info> einfo;
00564         ptr<set<ulint> > versions;
00565         
00566         //input operands
00567         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00568         dt_list_I_1->insert(DT_INT_8P);
00569         dt_list_I_1->insert(DT_INT_8U);
00570         dt_list_I_1->insert(DT_INT_8S);
00571         dt_list_I_1->insert(DT_INT_16U);
00572         dt_list_I_1->insert(DT_INT_16S);
00573         dt_list_I_1->insert(DT_INT_32U);
00574         dt_list_I_1->insert(DT_INT_32S);
00575         dt_list_I_1->insert(DT_COND);
00576         dt_list_I_1->insert(DT_BOOL);
00577         ptr<tm_instr_op_imm> op_I_1 = tm_instr_op_imm::create(I_1, dt_list_I_1);
00578         in_operands->push_back(op_I_1);
00579         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
00580         dt_list_I_2->insert(DT_INT_32U);
00581         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
00582         reg_list_I_2->insert(R_EAX);
00583         reg_list_I_2->insert(R_EBX);
00584         reg_list_I_2->insert(R_ECX);
00585         reg_list_I_2->insert(R_EDX);
00586         reg_list_I_2->insert(R_EDI);
00587         reg_list_I_2->insert(R_ESI);
00588         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
00589         in_operands->push_back(op_I_2);
00590 
00591         //output operands
00592         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00593         dt_list_O_1->insert(DT_INT_8P);
00594         dt_list_O_1->insert(DT_INT_8U);
00595         dt_list_O_1->insert(DT_INT_8S);
00596         dt_list_O_1->insert(DT_INT_16U);
00597         dt_list_O_1->insert(DT_INT_16S);
00598         dt_list_O_1->insert(DT_INT_32U);
00599         dt_list_O_1->insert(DT_INT_32S);
00600         dt_list_O_1->insert(DT_COND);
00601         dt_list_O_1->insert(DT_BOOL);
00602         ptr<tm_instr_op_mem> op_O_1 = tm_instr_op_mem::create(O_1, dt_list_O_1);
00603         out_operands->push_back(op_O_1);
00604 
00605         //execution info
00606         einfo = execution_info::create(30);
00607 
00608         //properties
00609 
00610         //versions
00611         versions = set<ulint>::create();
00612         versions->insert(INSTRUCTION_MOV__1);
00613         versions->insert(INSTRUCTION_MOV__2);
00614         versions->insert(INSTRUCTION_MOV__3);
00615         versions->insert(INSTRUCTION_MOV__4);
00616         versions->insert(INSTRUCTION_MOV__5);
00617         versions->insert(INSTRUCTION_MOV__7);
00618         versions->insert(INSTRUCTION_MOV__8);
00619         versions->insert(INSTRUCTION_MOVZX__1);
00620         versions->insert(INSTRUCTION_MOVZX__2);
00621         versions->insert(INSTRUCTION_MOVZX__3);
00622         versions->insert(INSTRUCTION_MOVZX__4);
00623         versions->insert(INSTRUCTION_MOVZX__5);
00624         versions->insert(INSTRUCTION_MOVZX__6);
00625         versions->insert(INSTRUCTION_MOVSX__1);
00626         versions->insert(INSTRUCTION_MOVSX__11);
00627         versions->insert(INSTRUCTION_MOVSX__2);
00628         versions->insert(INSTRUCTION_MOVSX__21);
00629 
00630 
00631         //return target pseudoinstruction
00632         return tm_instr::create(INSTRUCTION_MOV__71,in_operands,out_operands,lstring("mov $TYPE_O_1 $O_1, $TYPE_I_1 $I_1"), props,versions,IF_STORE,einfo);
00633 }
00634 
00635 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOV__8() {
00636         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00637         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00638         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00639         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00640         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00641         ptr<execution_info> einfo;
00642         ptr<set<ulint> > versions;
00643         
00644         //input operands
00645         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00646         dt_list_I_1->insert(DT_INT_8P);
00647         dt_list_I_1->insert(DT_INT_8U);
00648         dt_list_I_1->insert(DT_INT_8S);
00649         dt_list_I_1->insert(DT_INT_16U);
00650         dt_list_I_1->insert(DT_INT_16S);
00651         dt_list_I_1->insert(DT_INT_32U);
00652         dt_list_I_1->insert(DT_INT_32S);
00653         dt_list_I_1->insert(DT_COND);
00654         dt_list_I_1->insert(DT_BOOL);
00655         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
00656         in_operands->push_back(op_I_1);
00657         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
00658         dt_list_I_2->insert(DT_INT_32U);
00659         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
00660         reg_list_I_2->insert(R_EAX);
00661         reg_list_I_2->insert(R_EBX);
00662         reg_list_I_2->insert(R_ECX);
00663         reg_list_I_2->insert(R_EDX);
00664         reg_list_I_2->insert(R_EDI);
00665         reg_list_I_2->insert(R_ESI);
00666         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
00667         in_operands->push_back(op_I_2);
00668 
00669         //output operands
00670         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00671         dt_list_O_1->insert(DT_INT_8P);
00672         dt_list_O_1->insert(DT_INT_8U);
00673         dt_list_O_1->insert(DT_INT_8S);
00674         dt_list_O_1->insert(DT_INT_16U);
00675         dt_list_O_1->insert(DT_INT_16S);
00676         dt_list_O_1->insert(DT_INT_32U);
00677         dt_list_O_1->insert(DT_INT_32S);
00678         dt_list_O_1->insert(DT_COND);
00679         dt_list_O_1->insert(DT_BOOL);
00680         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
00681         reg_list_O_1->insert(R_EAX);
00682         reg_list_O_1->insert(R_EBX);
00683         reg_list_O_1->insert(R_ECX);
00684         reg_list_O_1->insert(R_EDX);
00685         reg_list_O_1->insert(R_EDI);
00686         reg_list_O_1->insert(R_ESI);
00687         reg_list_O_1->insert(R_AX);
00688         reg_list_O_1->insert(R_BX);
00689         reg_list_O_1->insert(R_CX);
00690         reg_list_O_1->insert(R_DX);
00691         reg_list_O_1->insert(R_DI);
00692         reg_list_O_1->insert(R_SI);
00693         reg_list_O_1->insert(R_AL);
00694         reg_list_O_1->insert(R_AH);
00695         reg_list_O_1->insert(R_BL);
00696         reg_list_O_1->insert(R_BH);
00697         reg_list_O_1->insert(R_CL);
00698         reg_list_O_1->insert(R_CH);
00699         reg_list_O_1->insert(R_DL);
00700         reg_list_O_1->insert(R_DH);
00701         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
00702         out_operands->push_back(op_O_1);
00703 
00704         //execution info
00705         einfo = execution_info::create(30);
00706 
00707         //properties
00708 
00709         //versions
00710         versions = set<ulint>::create();
00711         versions->insert(INSTRUCTION_MOV__1);
00712         versions->insert(INSTRUCTION_MOV__2);
00713         versions->insert(INSTRUCTION_MOV__3);
00714         versions->insert(INSTRUCTION_MOV__4);
00715         versions->insert(INSTRUCTION_MOV__5);
00716         versions->insert(INSTRUCTION_MOV__7);
00717         versions->insert(INSTRUCTION_MOV__71);
00718         versions->insert(INSTRUCTION_MOVZX__1);
00719         versions->insert(INSTRUCTION_MOVZX__2);
00720         versions->insert(INSTRUCTION_MOVZX__3);
00721         versions->insert(INSTRUCTION_MOVZX__4);
00722         versions->insert(INSTRUCTION_MOVZX__5);
00723         versions->insert(INSTRUCTION_MOVZX__6);
00724         versions->insert(INSTRUCTION_MOVSX__1);
00725         versions->insert(INSTRUCTION_MOVSX__11);
00726         versions->insert(INSTRUCTION_MOVSX__2);
00727         versions->insert(INSTRUCTION_MOVSX__21);
00728 
00729 
00730         //return target pseudoinstruction
00731         return tm_instr::create(INSTRUCTION_MOV__8,in_operands,out_operands,lstring("mov $O_1, $TYPE_I_1 $I_1"), props,versions,IF_LOAD,einfo);
00732 }
00733 
00734 ptr<tm_instr> tm_instr_create_INSTRUCTION_SYSMOV__9() {
00735         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00736         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00737         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00738         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00739         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00740         ptr<execution_info> einfo;
00741         ptr<set<ulint> > versions;
00742         
00743         //input operands
00744         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00745         dt_list_I_1->insert(DT_INT_8P);
00746         dt_list_I_1->insert(DT_INT_8U);
00747         dt_list_I_1->insert(DT_INT_8S);
00748         dt_list_I_1->insert(DT_INT_16U);
00749         dt_list_I_1->insert(DT_INT_16S);
00750         dt_list_I_1->insert(DT_INT_32U);
00751         dt_list_I_1->insert(DT_INT_32S);
00752         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
00753         reg_list_I_1->insert(R_ESP);
00754         reg_list_I_1->insert(R_EBP);
00755         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
00756         in_operands->push_back(op_I_1);
00757 
00758         //output operands
00759         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00760         dt_list_O_1->insert(DT_INT_8P);
00761         dt_list_O_1->insert(DT_INT_8U);
00762         dt_list_O_1->insert(DT_INT_8S);
00763         dt_list_O_1->insert(DT_INT_16U);
00764         dt_list_O_1->insert(DT_INT_16S);
00765         dt_list_O_1->insert(DT_INT_32U);
00766         dt_list_O_1->insert(DT_INT_32S);
00767         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
00768         reg_list_O_1->insert(R_ESP);
00769         reg_list_O_1->insert(R_EBP);
00770         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
00771         out_operands->push_back(op_O_1);
00772 
00773         //execution info
00774         einfo = execution_info::create(10);
00775 
00776         //properties
00777 
00778         //versions
00779         versions = set<ulint>::create();
00780         versions->insert(INSTRUCTION_SYSMOV__10);
00781         versions->insert(INSTRUCTION_SYSMOV__11);
00782 
00783 
00784         //return target pseudoinstruction
00785         return tm_instr::create(INSTRUCTION_SYSMOV__9,in_operands,out_operands,lstring("mov $O_1, $I_1"), props,versions,IF_COPY,einfo);
00786 }
00787 
00788 ptr<tm_instr> tm_instr_create_INSTRUCTION_SYSMOV__10() {
00789         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00790         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00791         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00792         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00793         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00794         ptr<execution_info> einfo;
00795         ptr<set<ulint> > versions;
00796         
00797         //input operands
00798         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00799         dt_list_I_1->insert(DT_INT_8P);
00800         dt_list_I_1->insert(DT_INT_8U);
00801         dt_list_I_1->insert(DT_INT_8S);
00802         dt_list_I_1->insert(DT_INT_16U);
00803         dt_list_I_1->insert(DT_INT_16S);
00804         dt_list_I_1->insert(DT_INT_32U);
00805         dt_list_I_1->insert(DT_INT_32S);
00806         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
00807         reg_list_I_1->insert(R_ESP);
00808         reg_list_I_1->insert(R_EBP);
00809         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
00810         in_operands->push_back(op_I_1);
00811 
00812         //output operands
00813         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00814         dt_list_O_1->insert(DT_INT_8P);
00815         dt_list_O_1->insert(DT_INT_8U);
00816         dt_list_O_1->insert(DT_INT_8S);
00817         dt_list_O_1->insert(DT_INT_16U);
00818         dt_list_O_1->insert(DT_INT_16S);
00819         dt_list_O_1->insert(DT_INT_32U);
00820         dt_list_O_1->insert(DT_INT_32S);
00821         ptr<tm_instr_op_mem> op_O_1 = tm_instr_op_mem::create(O_1, dt_list_O_1);
00822         out_operands->push_back(op_O_1);
00823 
00824         //execution info
00825         einfo = execution_info::create(30);
00826 
00827         //properties
00828 
00829         //versions
00830         versions = set<ulint>::create();
00831         versions->insert(INSTRUCTION_SYSMOV__9);
00832         versions->insert(INSTRUCTION_SYSMOV__11);
00833 
00834 
00835         //return target pseudoinstruction
00836         return tm_instr::create(INSTRUCTION_SYSMOV__10,in_operands,out_operands,lstring("mov $TYPE_O_1 $O_1, $I_1"), props,versions,IF_STORE,einfo);
00837 }
00838 
00839 ptr<tm_instr> tm_instr_create_INSTRUCTION_SYSMOV__11() {
00840         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00841         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00842         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00843         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00844         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00845         ptr<execution_info> einfo;
00846         ptr<set<ulint> > versions;
00847         
00848         //input operands
00849         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00850         dt_list_I_1->insert(DT_INT_8P);
00851         dt_list_I_1->insert(DT_INT_8U);
00852         dt_list_I_1->insert(DT_INT_8S);
00853         dt_list_I_1->insert(DT_INT_16U);
00854         dt_list_I_1->insert(DT_INT_16S);
00855         dt_list_I_1->insert(DT_INT_32U);
00856         dt_list_I_1->insert(DT_INT_32S);
00857         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
00858         in_operands->push_back(op_I_1);
00859 
00860         //output operands
00861         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00862         dt_list_O_1->insert(DT_INT_8P);
00863         dt_list_O_1->insert(DT_INT_8U);
00864         dt_list_O_1->insert(DT_INT_8S);
00865         dt_list_O_1->insert(DT_INT_16U);
00866         dt_list_O_1->insert(DT_INT_16S);
00867         dt_list_O_1->insert(DT_INT_32U);
00868         dt_list_O_1->insert(DT_INT_32S);
00869         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
00870         reg_list_O_1->insert(R_ESP);
00871         reg_list_O_1->insert(R_EBP);
00872         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
00873         out_operands->push_back(op_O_1);
00874 
00875         //execution info
00876         einfo = execution_info::create(30);
00877 
00878         //properties
00879 
00880         //versions
00881         versions = set<ulint>::create();
00882         versions->insert(INSTRUCTION_SYSMOV__9);
00883         versions->insert(INSTRUCTION_SYSMOV__10);
00884 
00885 
00886         //return target pseudoinstruction
00887         return tm_instr::create(INSTRUCTION_SYSMOV__11,in_operands,out_operands,lstring("mov $O_1, $TYPE_I_1 $I_1"), props,versions,IF_LOAD,einfo);
00888 }
00889 
00890 ptr<tm_instr> tm_instr_create_INSTRUCTION_SAHF__1() {
00891         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00892         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00893         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00894         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00895         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00896         ptr<execution_info> einfo;
00897         ptr<set<ulint> > versions;
00898         
00899         //input operands
00900         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00901         dt_list_I_1->insert(DT_COND);
00902         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
00903         reg_list_I_1->insert(R_AH);
00904         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
00905         in_operands->push_back(op_I_1);
00906 
00907         //output operands
00908         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00909         dt_list_O_1->insert(DT_COND);
00910         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
00911         reg_list_O_1->insert(R_COND);
00912         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
00913         out_operands->push_back(op_O_1);
00914 
00915         //execution info
00916         einfo = execution_info::create(10);
00917 
00918         //properties
00919 
00920         //versions
00921 
00922 
00923         //return target pseudoinstruction
00924         return tm_instr::create(INSTRUCTION_SAHF__1,in_operands,out_operands,lstring("sahf"), props,versions,0,einfo);
00925 }
00926 
00927 ptr<tm_instr> tm_instr_create_INSTRUCTION_LAHF__1() {
00928         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00929         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00930         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00931         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00932         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00933         ptr<execution_info> einfo;
00934         ptr<set<ulint> > versions;
00935         
00936         //input operands
00937         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00938         dt_list_I_1->insert(DT_COND);
00939         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
00940         reg_list_I_1->insert(R_COND);
00941         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
00942         in_operands->push_back(op_I_1);
00943 
00944         //output operands
00945         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
00946         dt_list_O_1->insert(DT_COND);
00947         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
00948         reg_list_O_1->insert(R_AH);
00949         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
00950         out_operands->push_back(op_O_1);
00951 
00952         //execution info
00953         einfo = execution_info::create(10);
00954 
00955         //properties
00956 
00957         //versions
00958 
00959 
00960         //return target pseudoinstruction
00961         return tm_instr::create(INSTRUCTION_LAHF__1,in_operands,out_operands,lstring("lahf"), props,versions,0,einfo);
00962 }
00963 
00964 ptr<tm_instr> tm_instr_create_INSTRUCTION_ADD__1() {
00965         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
00966         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
00967         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
00968         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
00969         ptr<set<tm_data_type_base::id_type> > allowed_types; 
00970         ptr<execution_info> einfo;
00971         ptr<set<ulint> > versions;
00972         
00973         //input operands
00974         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
00975         dt_list_I_1->insert(DT_INT_8P);
00976         dt_list_I_1->insert(DT_INT_8U);
00977         dt_list_I_1->insert(DT_INT_8S);
00978         dt_list_I_1->insert(DT_INT_16U);
00979         dt_list_I_1->insert(DT_INT_16S);
00980         dt_list_I_1->insert(DT_INT_32U);
00981         dt_list_I_1->insert(DT_INT_32S);
00982         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
00983         reg_list_I_1->insert(R_EAX);
00984         reg_list_I_1->insert(R_EBX);
00985         reg_list_I_1->insert(R_ECX);
00986         reg_list_I_1->insert(R_EDX);
00987         reg_list_I_1->insert(R_EDI);
00988         reg_list_I_1->insert(R_ESI);
00989         reg_list_I_1->insert(R_AX);
00990         reg_list_I_1->insert(R_BX);
00991         reg_list_I_1->insert(R_CX);
00992         reg_list_I_1->insert(R_DX);
00993         reg_list_I_1->insert(R_DI);
00994         reg_list_I_1->insert(R_SI);
00995         reg_list_I_1->insert(R_AL);
00996         reg_list_I_1->insert(R_AH);
00997         reg_list_I_1->insert(R_BL);
00998         reg_list_I_1->insert(R_BH);
00999         reg_list_I_1->insert(R_CL);
01000         reg_list_I_1->insert(R_CH);
01001         reg_list_I_1->insert(R_DL);
01002         reg_list_I_1->insert(R_DH);
01003         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
01004         op_I_1->destroyed_by_get()->push_back(O_1);
01005         in_operands->push_back(op_I_1);
01006         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
01007         dt_list_I_2->insert(DT_INT_8P);
01008         dt_list_I_2->insert(DT_INT_8U);
01009         dt_list_I_2->insert(DT_INT_8S);
01010         dt_list_I_2->insert(DT_INT_16U);
01011         dt_list_I_2->insert(DT_INT_16S);
01012         dt_list_I_2->insert(DT_INT_32U);
01013         dt_list_I_2->insert(DT_INT_32S);
01014         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
01015         reg_list_I_2->insert(R_EAX);
01016         reg_list_I_2->insert(R_EBX);
01017         reg_list_I_2->insert(R_ECX);
01018         reg_list_I_2->insert(R_EDX);
01019         reg_list_I_2->insert(R_EDI);
01020         reg_list_I_2->insert(R_ESI);
01021         reg_list_I_2->insert(R_AX);
01022         reg_list_I_2->insert(R_BX);
01023         reg_list_I_2->insert(R_CX);
01024         reg_list_I_2->insert(R_DX);
01025         reg_list_I_2->insert(R_DI);
01026         reg_list_I_2->insert(R_SI);
01027         reg_list_I_2->insert(R_AL);
01028         reg_list_I_2->insert(R_AH);
01029         reg_list_I_2->insert(R_BL);
01030         reg_list_I_2->insert(R_BH);
01031         reg_list_I_2->insert(R_CL);
01032         reg_list_I_2->insert(R_CH);
01033         reg_list_I_2->insert(R_DL);
01034         reg_list_I_2->insert(R_DH);
01035         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
01036         in_operands->push_back(op_I_2);
01037 
01038         //output operands
01039         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
01040         dt_list_O_1->insert(DT_INT_8P);
01041         dt_list_O_1->insert(DT_INT_8U);
01042         dt_list_O_1->insert(DT_INT_8S);
01043         dt_list_O_1->insert(DT_INT_16U);
01044         dt_list_O_1->insert(DT_INT_16S);
01045         dt_list_O_1->insert(DT_INT_32U);
01046         dt_list_O_1->insert(DT_INT_32S);
01047         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
01048         reg_list_O_1->insert(R_EAX);
01049         reg_list_O_1->insert(R_EBX);
01050         reg_list_O_1->insert(R_ECX);
01051         reg_list_O_1->insert(R_EDX);
01052         reg_list_O_1->insert(R_EDI);
01053         reg_list_O_1->insert(R_ESI);
01054         reg_list_O_1->insert(R_AX);
01055         reg_list_O_1->insert(R_BX);
01056         reg_list_O_1->insert(R_CX);
01057         reg_list_O_1->insert(R_DX);
01058         reg_list_O_1->insert(R_DI);
01059         reg_list_O_1->insert(R_SI);
01060         reg_list_O_1->insert(R_AL);
01061         reg_list_O_1->insert(R_AH);
01062         reg_list_O_1->insert(R_BL);
01063         reg_list_O_1->insert(R_BH);
01064         reg_list_O_1->insert(R_CL);
01065         reg_list_O_1->insert(R_CH);
01066         reg_list_O_1->insert(R_DL);
01067         reg_list_O_1->insert(R_DH);
01068         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
01069         op_O_1->destroys_set(I_1);
01070         out_operands->push_back(op_O_1);
01071         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
01072         dt_list_O_2->insert(DT_COND);
01073         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
01074         reg_list_O_2->insert(R_COND);
01075         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
01076         out_operands->push_back(op_O_2);
01077 
01078         //execution info
01079         einfo = execution_info::create(10);
01080 
01081         //properties
01082 
01083         //versions
01084         versions = set<ulint>::create();
01085         versions->insert(INSTRUCTION_ADD__11);
01086         versions->insert(INSTRUCTION_ADD__12);
01087         versions->insert(INSTRUCTION_ADD__13);
01088         versions->insert(INSTRUCTION_ADD__14);
01089 
01090 
01091         //return target pseudoinstruction
01092         return tm_instr::create(INSTRUCTION_ADD__1,in_operands,out_operands,lstring("add $O_1, $I_2"), props,versions,0,einfo);
01093 }
01094 
01095 ptr<tm_instr> tm_instr_create_INSTRUCTION_ADD__11() {
01096         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
01097         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
01098         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
01099         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
01100         ptr<set<tm_data_type_base::id_type> > allowed_types; 
01101         ptr<execution_info> einfo;
01102         ptr<set<ulint> > versions;
01103         
01104         //input operands
01105         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
01106         dt_list_I_1->insert(DT_INT_8P);
01107         dt_list_I_1->insert(DT_INT_8U);
01108         dt_list_I_1->insert(DT_INT_8S);
01109         dt_list_I_1->insert(DT_INT_16U);
01110         dt_list_I_1->insert(DT_INT_16S);
01111         dt_list_I_1->insert(DT_INT_32U);
01112         dt_list_I_1->insert(DT_INT_32S);
01113         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
01114         reg_list_I_1->insert(R_EAX);
01115         reg_list_I_1->insert(R_EBX);
01116         reg_list_I_1->insert(R_ECX);
01117         reg_list_I_1->insert(R_EDX);
01118         reg_list_I_1->insert(R_EDI);
01119         reg_list_I_1->insert(R_ESI);
01120         reg_list_I_1->insert(R_AX);
01121         reg_list_I_1->insert(R_BX);
01122         reg_list_I_1->insert(R_CX);
01123         reg_list_I_1->insert(R_DX);
01124         reg_list_I_1->insert(R_DI);
01125         reg_list_I_1->insert(R_SI);
01126         reg_list_I_1->insert(R_AL);
01127         reg_list_I_1->insert(R_AH);
01128         reg_list_I_1->insert(R_BL);
01129         reg_list_I_1->insert(R_BH);
01130         reg_list_I_1->insert(R_CL);
01131         reg_list_I_1->insert(R_CH);
01132         reg_list_I_1->insert(R_DL);
01133         reg_list_I_1->insert(R_DH);
01134         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
01135         op_I_1->destroyed_by_get()->push_back(O_1);
01136         in_operands->push_back(op_I_1);
01137         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
01138         dt_list_I_2->insert(DT_INT_8P);
01139         dt_list_I_2->insert(DT_INT_8U);
01140         dt_list_I_2->insert(DT_INT_8S);
01141         dt_list_I_2->insert(DT_INT_16U);
01142         dt_list_I_2->insert(DT_INT_16S);
01143         dt_list_I_2->insert(DT_INT_32U);
01144         dt_list_I_2->insert(DT_INT_32S);
01145         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
01146         in_operands->push_back(op_I_2);
01147 
01148         //output operands
01149         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
01150         dt_list_O_1->insert(DT_INT_8P);
01151         dt_list_O_1->insert(DT_INT_8U);
01152         dt_list_O_1->insert(DT_INT_8S);
01153         dt_list_O_1->insert(DT_INT_16U);
01154         dt_list_O_1->insert(DT_INT_16S);
01155         dt_list_O_1->insert(DT_INT_32U);
01156         dt_list_O_1->insert(DT_INT_32S);
01157         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
01158         reg_list_O_1->insert(R_EAX);
01159         reg_list_O_1->insert(R_EBX);
01160         reg_list_O_1->insert(R_ECX);
01161         reg_list_O_1->insert(R_EDX);
01162         reg_list_O_1->insert(R_EDI);
01163         reg_list_O_1->insert(R_ESI);
01164         reg_list_O_1->insert(R_AX);
01165         reg_list_O_1->insert(R_BX);
01166         reg_list_O_1->insert(R_CX);
01167         reg_list_O_1->insert(R_DX);
01168         reg_list_O_1->insert(R_DI);
01169         reg_list_O_1->insert(R_SI);
01170         reg_list_O_1->insert(R_AL);
01171         reg_list_O_1->insert(R_AH);
01172         reg_list_O_1->insert(R_BL);
01173         reg_list_O_1->insert(R_BH);
01174         reg_list_O_1->insert(R_CL);
01175         reg_list_O_1->insert(R_CH);
01176         reg_list_O_1->insert(R_DL);
01177         reg_list_O_1->insert(R_DH);
01178         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
01179         op_O_1->destroys_set(I_1);
01180         out_operands->push_back(op_O_1);
01181         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
01182         dt_list_O_2->insert(DT_COND);
01183         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
01184         reg_list_O_2->insert(R_COND);
01185         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
01186         out_operands->push_back(op_O_2);
01187 
01188         //execution info
01189         einfo = execution_info::create(30);
01190 
01191         //properties
01192 
01193         //versions
01194         versions = set<ulint>::create();
01195         versions->insert(INSTRUCTION_ADD__1);
01196         versions->insert(INSTRUCTION_ADD__12);
01197         versions->insert(INSTRUCTION_ADD__13);
01198         versions->insert(INSTRUCTION_ADD__14);
01199 
01200 
01201         //return target pseudoinstruction
01202         return tm_instr::create(INSTRUCTION_ADD__11,in_operands,out_operands,lstring("add $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
01203 }
01204 
01205 ptr<tm_instr> tm_instr_create_INSTRUCTION_ADD__12() {
01206         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
01207         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
01208         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
01209         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
01210         ptr<set<tm_data_type_base::id_type> > allowed_types; 
01211         ptr<execution_info> einfo;
01212         ptr<set<ulint> > versions;
01213         
01214         //input operands
01215         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
01216         dt_list_I_1->insert(DT_INT_8P);
01217         dt_list_I_1->insert(DT_INT_8U);
01218         dt_list_I_1->insert(DT_INT_8S);
01219         dt_list_I_1->insert(DT_INT_16U);
01220         dt_list_I_1->insert(DT_INT_16S);
01221         dt_list_I_1->insert(DT_INT_32U);
01222         dt_list_I_1->insert(DT_INT_32S);
01223         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
01224         in_operands->push_back(op_I_1);
01225         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
01226         dt_list_I_2->insert(DT_INT_8P);
01227         dt_list_I_2->insert(DT_INT_8U);
01228         dt_list_I_2->insert(DT_INT_8S);
01229         dt_list_I_2->insert(DT_INT_16U);
01230         dt_list_I_2->insert(DT_INT_16S);
01231         dt_list_I_2->insert(DT_INT_32U);
01232         dt_list_I_2->insert(DT_INT_32S);
01233         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
01234         reg_list_I_2->insert(R_EAX);
01235         reg_list_I_2->insert(R_EBX);
01236         reg_list_I_2->insert(R_ECX);
01237         reg_list_I_2->insert(R_EDX);
01238         reg_list_I_2->insert(R_EDI);
01239         reg_list_I_2->insert(R_ESI);
01240         reg_list_I_2->insert(R_AX);
01241         reg_list_I_2->insert(R_BX);
01242         reg_list_I_2->insert(R_CX);
01243         reg_list_I_2->insert(R_DX);
01244         reg_list_I_2->insert(R_DI);
01245         reg_list_I_2->insert(R_SI);
01246         reg_list_I_2->insert(R_AL);
01247         reg_list_I_2->insert(R_AH);
01248         reg_list_I_2->insert(R_BL);
01249         reg_list_I_2->insert(R_BH);
01250         reg_list_I_2->insert(R_CL);
01251         reg_list_I_2->insert(R_CH);
01252         reg_list_I_2->insert(R_DL);
01253         reg_list_I_2->insert(R_DH);
01254         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
01255         op_I_2->destroyed_by_get()->push_back(O_1);
01256         in_operands->push_back(op_I_2);
01257 
01258         //output operands
01259         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
01260         dt_list_O_1->insert(DT_INT_8P);
01261         dt_list_O_1->insert(DT_INT_8U);
01262         dt_list_O_1->insert(DT_INT_8S);
01263         dt_list_O_1->insert(DT_INT_16U);
01264         dt_list_O_1->insert(DT_INT_16S);
01265         dt_list_O_1->insert(DT_INT_32U);
01266         dt_list_O_1->insert(DT_INT_32S);
01267         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
01268         reg_list_O_1->insert(R_EAX);
01269         reg_list_O_1->insert(R_EBX);
01270         reg_list_O_1->insert(R_ECX);
01271         reg_list_O_1->insert(R_EDX);
01272         reg_list_O_1->insert(R_EDI);
01273         reg_list_O_1->insert(R_ESI);
01274         reg_list_O_1->insert(R_AX);
01275         reg_list_O_1->insert(R_BX);
01276         reg_list_O_1->insert(R_CX);
01277         reg_list_O_1->insert(R_DX);
01278         reg_list_O_1->insert(R_DI);
01279         reg_list_O_1->insert(R_SI);
01280         reg_list_O_1->insert(R_AL);
01281         reg_list_O_1->insert(R_AH);
01282         reg_list_O_1->insert(R_BL);
01283         reg_list_O_1->insert(R_BH);
01284         reg_list_O_1->insert(R_CL);
01285         reg_list_O_1->insert(R_CH);
01286         reg_list_O_1->insert(R_DL);
01287         reg_list_O_1->insert(R_DH);
01288         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
01289         op_O_1->destroys_set(I_2);
01290         out_operands->push_back(op_O_1);
01291         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
01292         dt_list_O_2->insert(DT_COND);
01293         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
01294         reg_list_O_2->insert(R_COND);
01295         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
01296         out_operands->push_back(op_O_2);
01297 
01298         //execution info
01299         einfo = execution_info::create(30);
01300 
01301         //properties
01302 
01303         //versions
01304         versions = set<ulint>::create();
01305         versions->insert(INSTRUCTION_ADD__1);
01306         versions->insert(INSTRUCTION_ADD__11);
01307         versions->insert(INSTRUCTION_ADD__13);
01308         versions->insert(INSTRUCTION_ADD__14);
01309 
01310 
01311         //return target pseudoinstruction
01312         return tm_instr::create(INSTRUCTION_ADD__12,in_operands,out_operands,lstring("add $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
01313 }
01314 
01315 ptr<tm_instr> tm_instr_create_INSTRUCTION_ADD__13() {
01316         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
01317         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
01318         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
01319         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
01320         ptr<set<tm_data_type_base::id_type> > allowed_types; 
01321         ptr<execution_info> einfo;
01322         ptr<set<ulint> > versions;
01323         
01324         //input operands
01325         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
01326         dt_list_I_1->insert(DT_INT_8P);
01327         dt_list_I_1->insert(DT_INT_8U);
01328         dt_list_I_1->insert(DT_INT_8S);
01329         dt_list_I_1->insert(DT_INT_16U);
01330         dt_list_I_1->insert(DT_INT_16S);
01331         dt_list_I_1->insert(DT_INT_32U);
01332         dt_list_I_1->insert(DT_INT_32S);
01333         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
01334         reg_list_I_1->insert(R_EAX);
01335         reg_list_I_1->insert(R_EBX);
01336         reg_list_I_1->insert(R_ECX);
01337         reg_list_I_1->insert(R_EDX);
01338         reg_list_I_1->insert(R_EDI);
01339         reg_list_I_1->insert(R_ESI);
01340         reg_list_I_1->insert(R_AX);
01341         reg_list_I_1->insert(R_BX);
01342         reg_list_I_1->insert(R_CX);
01343         reg_list_I_1->insert(R_DX);
01344         reg_list_I_1->insert(R_DI);
01345         reg_list_I_1->insert(R_SI);
01346         reg_list_I_1->insert(R_AL);
01347         reg_list_I_1->insert(R_AH);
01348         reg_list_I_1->insert(R_BL);
01349         reg_list_I_1->insert(R_BH);
01350         reg_list_I_1->insert(R_CL);
01351         reg_list_I_1->insert(R_CH);
01352         reg_list_I_1->insert(R_DL);
01353         reg_list_I_1->insert(R_DH);
01354         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
01355         op_I_1->destroyed_by_get()->push_back(O_1);
01356         in_operands->push_back(op_I_1);
01357         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
01358         dt_list_I_2->insert(DT_INT_8P);
01359         dt_list_I_2->insert(DT_INT_8U);
01360         dt_list_I_2->insert(DT_INT_8S);
01361         dt_list_I_2->insert(DT_INT_16U);
01362         dt_list_I_2->insert(DT_INT_16S);
01363         dt_list_I_2->insert(DT_INT_32U);
01364         dt_list_I_2->insert(DT_INT_32S);
01365         ptr<tm_instr_op_imm> op_I_2 = tm_instr_op_imm::create(I_2, dt_list_I_2);
01366         in_operands->push_back(op_I_2);
01367 
01368         //output operands
01369         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
01370         dt_list_O_1->insert(DT_INT_8P);
01371         dt_list_O_1->insert(DT_INT_8U);
01372         dt_list_O_1->insert(DT_INT_8S);
01373         dt_list_O_1->insert(DT_INT_16U);
01374         dt_list_O_1->insert(DT_INT_16S);
01375         dt_list_O_1->insert(DT_INT_32U);
01376         dt_list_O_1->insert(DT_INT_32S);
01377         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
01378         reg_list_O_1->insert(R_EAX);
01379         reg_list_O_1->insert(R_EBX);
01380         reg_list_O_1->insert(R_ECX);
01381         reg_list_O_1->insert(R_EDX);
01382         reg_list_O_1->insert(R_EDI);
01383         reg_list_O_1->insert(R_ESI);
01384         reg_list_O_1->insert(R_AX);
01385         reg_list_O_1->insert(R_BX);
01386         reg_list_O_1->insert(R_CX);
01387         reg_list_O_1->insert(R_DX);
01388         reg_list_O_1->insert(R_DI);
01389         reg_list_O_1->insert(R_SI);
01390         reg_list_O_1->insert(R_AL);
01391         reg_list_O_1->insert(R_AH);
01392         reg_list_O_1->insert(R_BL);
01393         reg_list_O_1->insert(R_BH);
01394         reg_list_O_1->insert(R_CL);
01395         reg_list_O_1->insert(R_CH);
01396         reg_list_O_1->insert(R_DL);
01397         reg_list_O_1->insert(R_DH);
01398         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
01399         op_O_1->destroys_set(I_1);
01400         out_operands->push_back(op_O_1);
01401         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
01402         dt_list_O_2->insert(DT_COND);
01403         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
01404         reg_list_O_2->insert(R_COND);
01405         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
01406         out_operands->push_back(op_O_2);
01407 
01408         //execution info
01409         einfo = execution_info::create(10);
01410 
01411         //properties
01412 
01413         //versions
01414         versions = set<ulint>::create();
01415         versions->insert(INSTRUCTION_ADD__1);
01416         versions->insert(INSTRUCTION_ADD__11);
01417         versions->insert(INSTRUCTION_ADD__12);
01418         versions->insert(INSTRUCTION_ADD__14);
01419 
01420 
01421         //return target pseudoinstruction
01422         return tm_instr::create(INSTRUCTION_ADD__13,in_operands,out_operands,lstring("add $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
01423 }
01424 
01425 ptr<tm_instr> tm_instr_create_INSTRUCTION_ADD__14() {
01426         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
01427         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
01428         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
01429         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
01430         ptr<set<tm_data_type_base::id_type> > allowed_types; 
01431         ptr<execution_info> einfo;
01432         ptr<set<ulint> > versions;
01433         
01434         //input operands
01435         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
01436         dt_list_I_1->insert(DT_INT_8P);
01437         dt_list_I_1->insert(DT_INT_8U);
01438         dt_list_I_1->insert(DT_INT_8S);
01439         dt_list_I_1->insert(DT_INT_16U);
01440         dt_list_I_1->insert(DT_INT_16S);
01441         dt_list_I_1->insert(DT_INT_32U);
01442         dt_list_I_1->insert(DT_INT_32S);
01443         ptr<tm_instr_op_imm> op_I_1 = tm_instr_op_imm::create(I_1, dt_list_I_1);
01444         in_operands->push_back(op_I_1);
01445         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
01446         dt_list_I_2->insert(DT_INT_8P);
01447         dt_list_I_2->insert(DT_INT_8U);
01448         dt_list_I_2->insert(DT_INT_8S);
01449         dt_list_I_2->insert(DT_INT_16U);
01450         dt_list_I_2->insert(DT_INT_16S);
01451         dt_list_I_2->insert(DT_INT_32U);
01452         dt_list_I_2->insert(DT_INT_32S);
01453         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
01454         reg_list_I_2->insert(R_EAX);
01455         reg_list_I_2->insert(R_EBX);
01456         reg_list_I_2->insert(R_ECX);
01457         reg_list_I_2->insert(R_EDX);
01458         reg_list_I_2->insert(R_EDI);
01459         reg_list_I_2->insert(R_ESI);
01460         reg_list_I_2->insert(R_AX);
01461         reg_list_I_2->insert(R_BX);
01462         reg_list_I_2->insert(R_CX);
01463         reg_list_I_2->insert(R_DX);
01464         reg_list_I_2->insert(R_DI);
01465         reg_list_I_2->insert(R_SI);
01466         reg_list_I_2->insert(R_AL);
01467         reg_list_I_2->insert(R_AH);
01468         reg_list_I_2->insert(R_BL);
01469         reg_list_I_2->insert(R_BH);
01470         reg_list_I_2->insert(R_CL);
01471         reg_list_I_2->insert(R_CH);
01472         reg_list_I_2->insert(R_DL);
01473         reg_list_I_2->insert(R_DH);
01474         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
01475         op_I_2->destroyed_by_get()->push_back(O_1);
01476         in_operands->push_back(op_I_2);
01477 
01478         //output operands
01479         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
01480         dt_list_O_1->insert(DT_INT_8P);
01481         dt_list_O_1->insert(DT_INT_8U);
01482         dt_list_O_1->insert(DT_INT_8S);
01483         dt_list_O_1->insert(DT_INT_16U);
01484         dt_list_O_1->insert(DT_INT_16S);
01485         dt_list_O_1->insert(DT_INT_32U);
01486         dt_list_O_1->insert(DT_INT_32S);
01487         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
01488         reg_list_O_1->insert(R_EAX);
01489         reg_list_O_1->insert(R_EBX);
01490         reg_list_O_1->insert(R_ECX);
01491         reg_list_O_1->insert(R_EDX);
01492         reg_list_O_1->insert(R_EDI);
01493         reg_list_O_1->insert(R_ESI);
01494         reg_list_O_1->insert(R_AX);
01495         reg_list_O_1->insert(R_BX);
01496         reg_list_O_1->insert(R_CX);
01497         reg_list_O_1->insert(R_DX);
01498         reg_list_O_1->insert(R_DI);
01499         reg_list_O_1->insert(R_SI);
01500         reg_list_O_1->insert(R_AL);
01501         reg_list_O_1->insert(R_AH);
01502         reg_list_O_1->insert(R_BL);
01503         reg_list_O_1->insert(R_BH);
01504         reg_list_O_1->insert(R_CL);
01505         reg_list_O_1->insert(R_CH);
01506         reg_list_O_1->insert(R_DL);
01507         reg_list_O_1->insert(R_DH);
01508         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
01509         op_O_1->destroys_set(I_2);
01510         out_operands->push_back(op_O_1);
01511         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
01512         dt_list_O_2->insert(DT_COND);
01513         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
01514         reg_list_O_2->insert(R_COND);
01515         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
01516         out_operands->push_back(op_O_2);
01517 
01518         //execution info
01519         einfo = execution_info::create(10);
01520 
01521         //properties
01522 
01523         //versions
01524         versions = set<ulint>::create();
01525         versions->insert(INSTRUCTION_ADD__1);
01526         versions->insert(INSTRUCTION_ADD__11);
01527         versions->insert(INSTRUCTION_ADD__12);
01528         versions->insert(INSTRUCTION_ADD__13);
01529 
01530 
01531         //return target pseudoinstruction
01532         return tm_instr::create(INSTRUCTION_ADD__14,in_operands,out_operands,lstring("add $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
01533 }
01534 
01535 ptr<tm_instr> tm_instr_create_INSTRUCTION_SUB__1() {
01536         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
01537         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
01538         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
01539         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
01540         ptr<set<tm_data_type_base::id_type> > allowed_types; 
01541         ptr<execution_info> einfo;
01542         ptr<set<ulint> > versions;
01543         
01544         //input operands
01545         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
01546         dt_list_I_1->insert(DT_INT_8P);
01547         dt_list_I_1->insert(DT_INT_8U);
01548         dt_list_I_1->insert(DT_INT_8S);
01549         dt_list_I_1->insert(DT_INT_16U);
01550         dt_list_I_1->insert(DT_INT_16S);
01551         dt_list_I_1->insert(DT_INT_32U);
01552         dt_list_I_1->insert(DT_INT_32S);
01553         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
01554         reg_list_I_1->insert(R_EAX);
01555         reg_list_I_1->insert(R_EBX);
01556         reg_list_I_1->insert(R_ECX);
01557         reg_list_I_1->insert(R_EDX);
01558         reg_list_I_1->insert(R_EDI);
01559         reg_list_I_1->insert(R_ESI);
01560         reg_list_I_1->insert(R_AX);
01561         reg_list_I_1->insert(R_BX);
01562         reg_list_I_1->insert(R_CX);
01563         reg_list_I_1->insert(R_DX);
01564         reg_list_I_1->insert(R_DI);
01565         reg_list_I_1->insert(R_SI);
01566         reg_list_I_1->insert(R_AL);
01567         reg_list_I_1->insert(R_AH);
01568         reg_list_I_1->insert(R_BL);
01569         reg_list_I_1->insert(R_BH);
01570         reg_list_I_1->insert(R_CL);
01571         reg_list_I_1->insert(R_CH);
01572         reg_list_I_1->insert(R_DL);
01573         reg_list_I_1->insert(R_DH);
01574         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
01575         op_I_1->destroyed_by_get()->push_back(O_1);
01576         in_operands->push_back(op_I_1);
01577         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
01578         dt_list_I_2->insert(DT_INT_8P);
01579         dt_list_I_2->insert(DT_INT_8U);
01580         dt_list_I_2->insert(DT_INT_8S);
01581         dt_list_I_2->insert(DT_INT_16U);
01582         dt_list_I_2->insert(DT_INT_16S);
01583         dt_list_I_2->insert(DT_INT_32U);
01584         dt_list_I_2->insert(DT_INT_32S);
01585         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
01586         reg_list_I_2->insert(R_EAX);
01587         reg_list_I_2->insert(R_EBX);
01588         reg_list_I_2->insert(R_ECX);
01589         reg_list_I_2->insert(R_EDX);
01590         reg_list_I_2->insert(R_EDI);
01591         reg_list_I_2->insert(R_ESI);
01592         reg_list_I_2->insert(R_AX);
01593         reg_list_I_2->insert(R_BX);
01594         reg_list_I_2->insert(R_CX);
01595         reg_list_I_2->insert(R_DX);
01596         reg_list_I_2->insert(R_DI);
01597         reg_list_I_2->insert(R_SI);
01598         reg_list_I_2->insert(R_AL);
01599         reg_list_I_2->insert(R_AH);
01600         reg_list_I_2->insert(R_BL);
01601         reg_list_I_2->insert(R_BH);
01602         reg_list_I_2->insert(R_CL);
01603         reg_list_I_2->insert(R_CH);
01604         reg_list_I_2->insert(R_DL);
01605         reg_list_I_2->insert(R_DH);
01606         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
01607         in_operands->push_back(op_I_2);
01608 
01609         //output operands
01610         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
01611         dt_list_O_1->insert(DT_INT_8P);
01612         dt_list_O_1->insert(DT_INT_8U);
01613         dt_list_O_1->insert(DT_INT_8S);
01614         dt_list_O_1->insert(DT_INT_16U);
01615         dt_list_O_1->insert(DT_INT_16S);
01616         dt_list_O_1->insert(DT_INT_32U);
01617         dt_list_O_1->insert(DT_INT_32S);
01618         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
01619         reg_list_O_1->insert(R_EAX);
01620         reg_list_O_1->insert(R_EBX);
01621         reg_list_O_1->insert(R_ECX);
01622         reg_list_O_1->insert(R_EDX);
01623         reg_list_O_1->insert(R_EDI);
01624         reg_list_O_1->insert(R_ESI);
01625         reg_list_O_1->insert(R_AX);
01626         reg_list_O_1->insert(R_BX);
01627         reg_list_O_1->insert(R_CX);
01628         reg_list_O_1->insert(R_DX);
01629         reg_list_O_1->insert(R_DI);
01630         reg_list_O_1->insert(R_SI);
01631         reg_list_O_1->insert(R_AL);
01632         reg_list_O_1->insert(R_AH);
01633         reg_list_O_1->insert(R_BL);
01634         reg_list_O_1->insert(R_BH);
01635         reg_list_O_1->insert(R_CL);
01636         reg_list_O_1->insert(R_CH);
01637         reg_list_O_1->insert(R_DL);
01638         reg_list_O_1->insert(R_DH);
01639         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
01640         op_O_1->destroys_set(I_1);
01641         out_operands->push_back(op_O_1);
01642         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
01643         dt_list_O_2->insert(DT_COND);
01644         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
01645         reg_list_O_2->insert(R_COND);
01646         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
01647         out_operands->push_back(op_O_2);
01648 
01649         //execution info
01650         einfo = execution_info::create(10);
01651 
01652         //properties
01653 
01654         //versions
01655         versions = set<ulint>::create();
01656         versions->insert(INSTRUCTION_SUB__11);
01657         versions->insert(INSTRUCTION_SUB__12);
01658 
01659 
01660         //return target pseudoinstruction
01661         return tm_instr::create(INSTRUCTION_SUB__1,in_operands,out_operands,lstring("sub $O_1, $I_2"), props,versions,0,einfo);
01662 }
01663 
01664 ptr<tm_instr> tm_instr_create_INSTRUCTION_SUB__11() {
01665         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
01666         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
01667         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
01668         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
01669         ptr<set<tm_data_type_base::id_type> > allowed_types; 
01670         ptr<execution_info> einfo;
01671         ptr<set<ulint> > versions;
01672         
01673         //input operands
01674         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
01675         dt_list_I_1->insert(DT_INT_8P);
01676         dt_list_I_1->insert(DT_INT_8U);
01677         dt_list_I_1->insert(DT_INT_8S);
01678         dt_list_I_1->insert(DT_INT_16U);
01679         dt_list_I_1->insert(DT_INT_16S);
01680         dt_list_I_1->insert(DT_INT_32U);
01681         dt_list_I_1->insert(DT_INT_32S);
01682         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
01683         reg_list_I_1->insert(R_EAX);
01684         reg_list_I_1->insert(R_EBX);
01685         reg_list_I_1->insert(R_ECX);
01686         reg_list_I_1->insert(R_EDX);
01687         reg_list_I_1->insert(R_EDI);
01688         reg_list_I_1->insert(R_ESI);
01689         reg_list_I_1->insert(R_AX);
01690         reg_list_I_1->insert(R_BX);
01691         reg_list_I_1->insert(R_CX);
01692         reg_list_I_1->insert(R_DX);
01693         reg_list_I_1->insert(R_DI);
01694         reg_list_I_1->insert(R_SI);
01695         reg_list_I_1->insert(R_AL);
01696         reg_list_I_1->insert(R_AH);
01697         reg_list_I_1->insert(R_BL);
01698         reg_list_I_1->insert(R_BH);
01699         reg_list_I_1->insert(R_CL);
01700         reg_list_I_1->insert(R_CH);
01701         reg_list_I_1->insert(R_DL);
01702         reg_list_I_1->insert(R_DH);
01703         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
01704         op_I_1->destroyed_by_get()->push_back(O_1);
01705         in_operands->push_back(op_I_1);
01706         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
01707         dt_list_I_2->insert(DT_INT_8P);
01708         dt_list_I_2->insert(DT_INT_8U);
01709         dt_list_I_2->insert(DT_INT_8S);
01710         dt_list_I_2->insert(DT_INT_16U);
01711         dt_list_I_2->insert(DT_INT_16S);
01712         dt_list_I_2->insert(DT_INT_32U);
01713         dt_list_I_2->insert(DT_INT_32S);
01714         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
01715         in_operands->push_back(op_I_2);
01716 
01717         //output operands
01718         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
01719         dt_list_O_1->insert(DT_INT_8P);
01720         dt_list_O_1->insert(DT_INT_8U);
01721         dt_list_O_1->insert(DT_INT_8S);
01722         dt_list_O_1->insert(DT_INT_16U);
01723         dt_list_O_1->insert(DT_INT_16S);
01724         dt_list_O_1->insert(DT_INT_32U);
01725         dt_list_O_1->insert(DT_INT_32S);
01726         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
01727         reg_list_O_1->insert(R_EAX);
01728         reg_list_O_1->insert(R_EBX);
01729         reg_list_O_1->insert(R_ECX);
01730         reg_list_O_1->insert(R_EDX);
01731         reg_list_O_1->insert(R_EDI);
01732         reg_list_O_1->insert(R_ESI);
01733         reg_list_O_1->insert(R_AX);
01734         reg_list_O_1->insert(R_BX);
01735         reg_list_O_1->insert(R_CX);
01736         reg_list_O_1->insert(R_DX);
01737         reg_list_O_1->insert(R_DI);
01738         reg_list_O_1->insert(R_SI);
01739         reg_list_O_1->insert(R_AL);
01740         reg_list_O_1->insert(R_AH);
01741         reg_list_O_1->insert(R_BL);
01742         reg_list_O_1->insert(R_BH);
01743         reg_list_O_1->insert(R_CL);
01744         reg_list_O_1->insert(R_CH);
01745         reg_list_O_1->insert(R_DL);
01746         reg_list_O_1->insert(R_DH);
01747         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
01748         op_O_1->destroys_set(I_1);
01749         out_operands->push_back(op_O_1);
01750         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
01751         dt_list_O_2->insert(DT_COND);
01752         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
01753         reg_list_O_2->insert(R_COND);
01754         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
01755         out_operands->push_back(op_O_2);
01756 
01757         //execution info
01758         einfo = execution_info::create(30);
01759 
01760         //properties
01761 
01762         //versions
01763         versions = set<ulint>::create();
01764         versions->insert(INSTRUCTION_SUB__1);
01765         versions->insert(INSTRUCTION_SUB__12);
01766 
01767 
01768         //return target pseudoinstruction
01769         return tm_instr::create(INSTRUCTION_SUB__11,in_operands,out_operands,lstring("sub $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
01770 }
01771 
01772 ptr<tm_instr> tm_instr_create_INSTRUCTION_SUB__12() {
01773         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
01774         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
01775         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
01776         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
01777         ptr<set<tm_data_type_base::id_type> > allowed_types; 
01778         ptr<execution_info> einfo;
01779         ptr<set<ulint> > versions;
01780         
01781         //input operands
01782         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
01783         dt_list_I_1->insert(DT_INT_8P);
01784         dt_list_I_1->insert(DT_INT_8U);
01785         dt_list_I_1->insert(DT_INT_8S);
01786         dt_list_I_1->insert(DT_INT_16U);
01787         dt_list_I_1->insert(DT_INT_16S);
01788         dt_list_I_1->insert(DT_INT_32U);
01789         dt_list_I_1->insert(DT_INT_32S);
01790         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
01791         reg_list_I_1->insert(R_EAX);
01792         reg_list_I_1->insert(R_EBX);
01793         reg_list_I_1->insert(R_ECX);
01794         reg_list_I_1->insert(R_EDX);
01795         reg_list_I_1->insert(R_EDI);
01796         reg_list_I_1->insert(R_ESI);
01797         reg_list_I_1->insert(R_AX);
01798         reg_list_I_1->insert(R_BX);
01799         reg_list_I_1->insert(R_CX);
01800         reg_list_I_1->insert(R_DX);
01801         reg_list_I_1->insert(R_DI);
01802         reg_list_I_1->insert(R_SI);
01803         reg_list_I_1->insert(R_AL);
01804         reg_list_I_1->insert(R_AH);
01805         reg_list_I_1->insert(R_BL);
01806         reg_list_I_1->insert(R_BH);
01807         reg_list_I_1->insert(R_CL);
01808         reg_list_I_1->insert(R_CH);
01809         reg_list_I_1->insert(R_DL);
01810         reg_list_I_1->insert(R_DH);
01811         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
01812         op_I_1->destroyed_by_get()->push_back(O_1);
01813         in_operands->push_back(op_I_1);
01814         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
01815         dt_list_I_2->insert(DT_INT_8P);
01816         dt_list_I_2->insert(DT_INT_8U);
01817         dt_list_I_2->insert(DT_INT_8S);
01818         dt_list_I_2->insert(DT_INT_16U);
01819         dt_list_I_2->insert(DT_INT_16S);
01820         dt_list_I_2->insert(DT_INT_32U);
01821         dt_list_I_2->insert(DT_INT_32S);
01822         ptr<tm_instr_op_imm> op_I_2 = tm_instr_op_imm::create(I_2, dt_list_I_2);
01823         in_operands->push_back(op_I_2);
01824 
01825         //output operands
01826         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
01827         dt_list_O_1->insert(DT_INT_8P);
01828         dt_list_O_1->insert(DT_INT_8U);
01829         dt_list_O_1->insert(DT_INT_8S);
01830         dt_list_O_1->insert(DT_INT_16U);
01831         dt_list_O_1->insert(DT_INT_16S);
01832         dt_list_O_1->insert(DT_INT_32U);
01833         dt_list_O_1->insert(DT_INT_32S);
01834         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
01835         reg_list_O_1->insert(R_EAX);
01836         reg_list_O_1->insert(R_EBX);
01837         reg_list_O_1->insert(R_ECX);
01838         reg_list_O_1->insert(R_EDX);
01839         reg_list_O_1->insert(R_EDI);
01840         reg_list_O_1->insert(R_ESI);
01841         reg_list_O_1->insert(R_AX);
01842         reg_list_O_1->insert(R_BX);
01843         reg_list_O_1->insert(R_CX);
01844         reg_list_O_1->insert(R_DX);
01845         reg_list_O_1->insert(R_DI);
01846         reg_list_O_1->insert(R_SI);
01847         reg_list_O_1->insert(R_AL);
01848         reg_list_O_1->insert(R_AH);
01849         reg_list_O_1->insert(R_BL);
01850         reg_list_O_1->insert(R_BH);
01851         reg_list_O_1->insert(R_CL);
01852         reg_list_O_1->insert(R_CH);
01853         reg_list_O_1->insert(R_DL);
01854         reg_list_O_1->insert(R_DH);
01855         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
01856         op_O_1->destroys_set(I_1);
01857         out_operands->push_back(op_O_1);
01858         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
01859         dt_list_O_2->insert(DT_COND);
01860         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
01861         reg_list_O_2->insert(R_COND);
01862         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
01863         out_operands->push_back(op_O_2);
01864 
01865         //execution info
01866         einfo = execution_info::create(10);
01867 
01868         //properties
01869 
01870         //versions
01871         versions = set<ulint>::create();
01872         versions->insert(INSTRUCTION_SUB__1);
01873         versions->insert(INSTRUCTION_SUB__11);
01874 
01875 
01876         //return target pseudoinstruction
01877         return tm_instr::create(INSTRUCTION_SUB__12,in_operands,out_operands,lstring("sub $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
01878 }
01879 
01880 ptr<tm_instr> tm_instr_create_INSTRUCTION_IMUL__1() {
01881         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
01882         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
01883         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
01884         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
01885         ptr<set<tm_data_type_base::id_type> > allowed_types; 
01886         ptr<execution_info> einfo;
01887         ptr<set<ulint> > versions;
01888         
01889         //input operands
01890         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
01891         dt_list_I_1->insert(DT_INT_8S);
01892         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
01893         reg_list_I_1->insert(R_AL);
01894         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
01895         op_I_1->destroyed_by_get()->push_back(O_1);
01896         in_operands->push_back(op_I_1);
01897         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
01898         dt_list_I_2->insert(DT_INT_8S);
01899         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
01900         reg_list_I_2->insert(R_AL);
01901         reg_list_I_2->insert(R_AH);
01902         reg_list_I_2->insert(R_BL);
01903         reg_list_I_2->insert(R_BH);
01904         reg_list_I_2->insert(R_CL);
01905         reg_list_I_2->insert(R_CH);
01906         reg_list_I_2->insert(R_DL);
01907         reg_list_I_2->insert(R_DH);
01908         reg_list_I_2->erase(R_AL);
01909         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
01910         in_operands->push_back(op_I_2);
01911 
01912         //output operands
01913         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
01914         dt_list_O_1->insert(DT_INT_8S);
01915         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
01916         reg_list_O_1->insert(R_AL);
01917         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
01918         op_O_1->destroys_set(I_1);
01919         out_operands->push_back(op_O_1);
01920         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
01921         dt_list_O_2->insert(DT_COND);
01922         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
01923         reg_list_O_2->insert(R_COND);
01924         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
01925         out_operands->push_back(op_O_2);
01926 
01927         //execution info
01928         einfo = execution_info::create(100);
01929 
01930         //properties
01931 
01932         //versions
01933         versions = set<ulint>::create();
01934         versions->insert(INSTRUCTION_IMUL__2);
01935         versions->insert(INSTRUCTION_IMUL__21);
01936         versions->insert(INSTRUCTION_IMUL__22);
01937         versions->insert(INSTRUCTION_IMUL__23);
01938         versions->insert(INSTRUCTION_IMUL__24);
01939 
01940 
01941         //return target pseudoinstruction
01942         return tm_instr::create(INSTRUCTION_IMUL__1,in_operands,out_operands,lstring("imul $I_2"), props,versions,0,einfo);
01943 }
01944 
01945 ptr<tm_instr> tm_instr_create_INSTRUCTION_IMUL__2() {
01946         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
01947         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
01948         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
01949         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
01950         ptr<set<tm_data_type_base::id_type> > allowed_types; 
01951         ptr<execution_info> einfo;
01952         ptr<set<ulint> > versions;
01953         
01954         //input operands
01955         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
01956         dt_list_I_1->insert(DT_INT_16S);
01957         dt_list_I_1->insert(DT_INT_32S);
01958         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
01959         reg_list_I_1->insert(R_AX);
01960         reg_list_I_1->insert(R_BX);
01961         reg_list_I_1->insert(R_CX);
01962         reg_list_I_1->insert(R_DX);
01963         reg_list_I_1->insert(R_DI);
01964         reg_list_I_1->insert(R_SI);
01965         reg_list_I_1->insert(R_EAX);
01966         reg_list_I_1->insert(R_EBX);
01967         reg_list_I_1->insert(R_ECX);
01968         reg_list_I_1->insert(R_EDX);
01969         reg_list_I_1->insert(R_EDI);
01970         reg_list_I_1->insert(R_ESI);
01971         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
01972         op_I_1->destroyed_by_get()->push_back(O_1);
01973         in_operands->push_back(op_I_1);
01974         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
01975         dt_list_I_2->insert(DT_INT_16S);
01976         dt_list_I_2->insert(DT_INT_32S);
01977         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
01978         reg_list_I_2->insert(R_AX);
01979         reg_list_I_2->insert(R_BX);
01980         reg_list_I_2->insert(R_CX);
01981         reg_list_I_2->insert(R_DX);
01982         reg_list_I_2->insert(R_DI);
01983         reg_list_I_2->insert(R_SI);
01984         reg_list_I_2->insert(R_EAX);
01985         reg_list_I_2->insert(R_EBX);
01986         reg_list_I_2->insert(R_ECX);
01987         reg_list_I_2->insert(R_EDX);
01988         reg_list_I_2->insert(R_EDI);
01989         reg_list_I_2->insert(R_ESI);
01990         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
01991         in_operands->push_back(op_I_2);
01992 
01993         //output operands
01994         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
01995         dt_list_O_1->insert(DT_INT_16S);
01996         dt_list_O_1->insert(DT_INT_32S);
01997         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
01998         reg_list_O_1->insert(R_AX);
01999         reg_list_O_1->insert(R_BX);
02000         reg_list_O_1->insert(R_CX);
02001         reg_list_O_1->insert(R_DX);
02002         reg_list_O_1->insert(R_DI);
02003         reg_list_O_1->insert(R_SI);
02004         reg_list_O_1->insert(R_EAX);
02005         reg_list_O_1->insert(R_EBX);
02006         reg_list_O_1->insert(R_ECX);
02007         reg_list_O_1->insert(R_EDX);
02008         reg_list_O_1->insert(R_EDI);
02009         reg_list_O_1->insert(R_ESI);
02010         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02011         op_O_1->destroys_set(I_1);
02012         out_operands->push_back(op_O_1);
02013         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02014         dt_list_O_2->insert(DT_COND);
02015         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02016         reg_list_O_2->insert(R_COND);
02017         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02018         out_operands->push_back(op_O_2);
02019 
02020         //execution info
02021         einfo = execution_info::create(100);
02022 
02023         //properties
02024 
02025         //versions
02026         versions = set<ulint>::create();
02027         versions->insert(INSTRUCTION_IMUL__1);
02028         versions->insert(INSTRUCTION_IMUL__21);
02029         versions->insert(INSTRUCTION_IMUL__22);
02030         versions->insert(INSTRUCTION_IMUL__23);
02031         versions->insert(INSTRUCTION_IMUL__24);
02032 
02033 
02034         //return target pseudoinstruction
02035         return tm_instr::create(INSTRUCTION_IMUL__2,in_operands,out_operands,lstring("imul $O_1, $I_2"), props,versions,0,einfo);
02036 }
02037 
02038 ptr<tm_instr> tm_instr_create_INSTRUCTION_IMUL__21() {
02039         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02040         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02041         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02042         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02043         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02044         ptr<execution_info> einfo;
02045         ptr<set<ulint> > versions;
02046         
02047         //input operands
02048         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02049         dt_list_I_1->insert(DT_INT_16S);
02050         dt_list_I_1->insert(DT_INT_32S);
02051         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
02052         reg_list_I_1->insert(R_AX);
02053         reg_list_I_1->insert(R_BX);
02054         reg_list_I_1->insert(R_CX);
02055         reg_list_I_1->insert(R_DX);
02056         reg_list_I_1->insert(R_DI);
02057         reg_list_I_1->insert(R_SI);
02058         reg_list_I_1->insert(R_EAX);
02059         reg_list_I_1->insert(R_EBX);
02060         reg_list_I_1->insert(R_ECX);
02061         reg_list_I_1->insert(R_EDX);
02062         reg_list_I_1->insert(R_EDI);
02063         reg_list_I_1->insert(R_ESI);
02064         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
02065         op_I_1->destroyed_by_get()->push_back(O_1);
02066         in_operands->push_back(op_I_1);
02067         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02068         dt_list_I_2->insert(DT_INT_16S);
02069         dt_list_I_2->insert(DT_INT_32S);
02070         ptr<tm_instr_op_imm> op_I_2 = tm_instr_op_imm::create(I_2, dt_list_I_2);
02071         in_operands->push_back(op_I_2);
02072 
02073         //output operands
02074         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02075         dt_list_O_1->insert(DT_INT_16S);
02076         dt_list_O_1->insert(DT_INT_32S);
02077         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02078         reg_list_O_1->insert(R_AX);
02079         reg_list_O_1->insert(R_BX);
02080         reg_list_O_1->insert(R_CX);
02081         reg_list_O_1->insert(R_DX);
02082         reg_list_O_1->insert(R_DI);
02083         reg_list_O_1->insert(R_SI);
02084         reg_list_O_1->insert(R_EAX);
02085         reg_list_O_1->insert(R_EBX);
02086         reg_list_O_1->insert(R_ECX);
02087         reg_list_O_1->insert(R_EDX);
02088         reg_list_O_1->insert(R_EDI);
02089         reg_list_O_1->insert(R_ESI);
02090         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02091         op_O_1->destroys_set(I_1);
02092         out_operands->push_back(op_O_1);
02093         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02094         dt_list_O_2->insert(DT_COND);
02095         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02096         reg_list_O_2->insert(R_COND);
02097         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02098         out_operands->push_back(op_O_2);
02099 
02100         //execution info
02101         einfo = execution_info::create(100);
02102 
02103         //properties
02104 
02105         //versions
02106         versions = set<ulint>::create();
02107         versions->insert(INSTRUCTION_IMUL__1);
02108         versions->insert(INSTRUCTION_IMUL__2);
02109         versions->insert(INSTRUCTION_IMUL__22);
02110         versions->insert(INSTRUCTION_IMUL__23);
02111         versions->insert(INSTRUCTION_IMUL__24);
02112 
02113 
02114         //return target pseudoinstruction
02115         return tm_instr::create(INSTRUCTION_IMUL__21,in_operands,out_operands,lstring("imul $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
02116 }
02117 
02118 ptr<tm_instr> tm_instr_create_INSTRUCTION_IMUL__22() {
02119         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02120         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02121         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02122         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02123         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02124         ptr<execution_info> einfo;
02125         ptr<set<ulint> > versions;
02126         
02127         //input operands
02128         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02129         dt_list_I_1->insert(DT_INT_16S);
02130         dt_list_I_1->insert(DT_INT_32S);
02131         ptr<tm_instr_op_imm> op_I_1 = tm_instr_op_imm::create(I_1, dt_list_I_1);
02132         in_operands->push_back(op_I_1);
02133         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02134         dt_list_I_2->insert(DT_INT_16S);
02135         dt_list_I_2->insert(DT_INT_32S);
02136         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
02137         reg_list_I_2->insert(R_AX);
02138         reg_list_I_2->insert(R_BX);
02139         reg_list_I_2->insert(R_CX);
02140         reg_list_I_2->insert(R_DX);
02141         reg_list_I_2->insert(R_DI);
02142         reg_list_I_2->insert(R_SI);
02143         reg_list_I_2->insert(R_EAX);
02144         reg_list_I_2->insert(R_EBX);
02145         reg_list_I_2->insert(R_ECX);
02146         reg_list_I_2->insert(R_EDX);
02147         reg_list_I_2->insert(R_EDI);
02148         reg_list_I_2->insert(R_ESI);
02149         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
02150         op_I_2->destroyed_by_get()->push_back(O_1);
02151         in_operands->push_back(op_I_2);
02152 
02153         //output operands
02154         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02155         dt_list_O_1->insert(DT_INT_16S);
02156         dt_list_O_1->insert(DT_INT_32S);
02157         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02158         reg_list_O_1->insert(R_AX);
02159         reg_list_O_1->insert(R_BX);
02160         reg_list_O_1->insert(R_CX);
02161         reg_list_O_1->insert(R_DX);
02162         reg_list_O_1->insert(R_DI);
02163         reg_list_O_1->insert(R_SI);
02164         reg_list_O_1->insert(R_EAX);
02165         reg_list_O_1->insert(R_EBX);
02166         reg_list_O_1->insert(R_ECX);
02167         reg_list_O_1->insert(R_EDX);
02168         reg_list_O_1->insert(R_EDI);
02169         reg_list_O_1->insert(R_ESI);
02170         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02171         op_O_1->destroys_set(I_2);
02172         out_operands->push_back(op_O_1);
02173         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02174         dt_list_O_2->insert(DT_COND);
02175         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02176         reg_list_O_2->insert(R_COND);
02177         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02178         out_operands->push_back(op_O_2);
02179 
02180         //execution info
02181         einfo = execution_info::create(100);
02182 
02183         //properties
02184 
02185         //versions
02186         versions = set<ulint>::create();
02187         versions->insert(INSTRUCTION_IMUL__1);
02188         versions->insert(INSTRUCTION_IMUL__2);
02189         versions->insert(INSTRUCTION_IMUL__21);
02190         versions->insert(INSTRUCTION_IMUL__23);
02191         versions->insert(INSTRUCTION_IMUL__24);
02192 
02193 
02194         //return target pseudoinstruction
02195         return tm_instr::create(INSTRUCTION_IMUL__22,in_operands,out_operands,lstring("imul $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
02196 }
02197 
02198 ptr<tm_instr> tm_instr_create_INSTRUCTION_IMUL__23() {
02199         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02200         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02201         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02202         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02203         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02204         ptr<execution_info> einfo;
02205         ptr<set<ulint> > versions;
02206         
02207         //input operands
02208         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02209         dt_list_I_1->insert(DT_INT_16S);
02210         dt_list_I_1->insert(DT_INT_32S);
02211         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
02212         reg_list_I_1->insert(R_AX);
02213         reg_list_I_1->insert(R_BX);
02214         reg_list_I_1->insert(R_CX);
02215         reg_list_I_1->insert(R_DX);
02216         reg_list_I_1->insert(R_DI);
02217         reg_list_I_1->insert(R_SI);
02218         reg_list_I_1->insert(R_EAX);
02219         reg_list_I_1->insert(R_EBX);
02220         reg_list_I_1->insert(R_ECX);
02221         reg_list_I_1->insert(R_EDX);
02222         reg_list_I_1->insert(R_EDI);
02223         reg_list_I_1->insert(R_ESI);
02224         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
02225         op_I_1->destroyed_by_get()->push_back(O_1);
02226         in_operands->push_back(op_I_1);
02227         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02228         dt_list_I_2->insert(DT_INT_16S);
02229         dt_list_I_2->insert(DT_INT_32S);
02230         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
02231         in_operands->push_back(op_I_2);
02232 
02233         //output operands
02234         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02235         dt_list_O_1->insert(DT_INT_16S);
02236         dt_list_O_1->insert(DT_INT_32S);
02237         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02238         reg_list_O_1->insert(R_AX);
02239         reg_list_O_1->insert(R_BX);
02240         reg_list_O_1->insert(R_CX);
02241         reg_list_O_1->insert(R_DX);
02242         reg_list_O_1->insert(R_DI);
02243         reg_list_O_1->insert(R_SI);
02244         reg_list_O_1->insert(R_EAX);
02245         reg_list_O_1->insert(R_EBX);
02246         reg_list_O_1->insert(R_ECX);
02247         reg_list_O_1->insert(R_EDX);
02248         reg_list_O_1->insert(R_EDI);
02249         reg_list_O_1->insert(R_ESI);
02250         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02251         op_O_1->destroys_set(I_1);
02252         out_operands->push_back(op_O_1);
02253         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02254         dt_list_O_2->insert(DT_COND);
02255         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02256         reg_list_O_2->insert(R_COND);
02257         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02258         out_operands->push_back(op_O_2);
02259 
02260         //execution info
02261         einfo = execution_info::create(120);
02262 
02263         //properties
02264 
02265         //versions
02266         versions = set<ulint>::create();
02267         versions->insert(INSTRUCTION_IMUL__1);
02268         versions->insert(INSTRUCTION_IMUL__2);
02269         versions->insert(INSTRUCTION_IMUL__21);
02270         versions->insert(INSTRUCTION_IMUL__22);
02271         versions->insert(INSTRUCTION_IMUL__24);
02272 
02273 
02274         //return target pseudoinstruction
02275         return tm_instr::create(INSTRUCTION_IMUL__23,in_operands,out_operands,lstring("imul $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
02276 }
02277 
02278 ptr<tm_instr> tm_instr_create_INSTRUCTION_IMUL__24() {
02279         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02280         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02281         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02282         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02283         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02284         ptr<execution_info> einfo;
02285         ptr<set<ulint> > versions;
02286         
02287         //input operands
02288         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02289         dt_list_I_1->insert(DT_INT_16S);
02290         dt_list_I_1->insert(DT_INT_32S);
02291         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
02292         in_operands->push_back(op_I_1);
02293         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02294         dt_list_I_2->insert(DT_INT_16S);
02295         dt_list_I_2->insert(DT_INT_32S);
02296         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
02297         reg_list_I_2->insert(R_AX);
02298         reg_list_I_2->insert(R_BX);
02299         reg_list_I_2->insert(R_CX);
02300         reg_list_I_2->insert(R_DX);
02301         reg_list_I_2->insert(R_DI);
02302         reg_list_I_2->insert(R_SI);
02303         reg_list_I_2->insert(R_EAX);
02304         reg_list_I_2->insert(R_EBX);
02305         reg_list_I_2->insert(R_ECX);
02306         reg_list_I_2->insert(R_EDX);
02307         reg_list_I_2->insert(R_EDI);
02308         reg_list_I_2->insert(R_ESI);
02309         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
02310         op_I_2->destroyed_by_get()->push_back(O_1);
02311         in_operands->push_back(op_I_2);
02312 
02313         //output operands
02314         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02315         dt_list_O_1->insert(DT_INT_16S);
02316         dt_list_O_1->insert(DT_INT_32S);
02317         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02318         reg_list_O_1->insert(R_AX);
02319         reg_list_O_1->insert(R_BX);
02320         reg_list_O_1->insert(R_CX);
02321         reg_list_O_1->insert(R_DX);
02322         reg_list_O_1->insert(R_DI);
02323         reg_list_O_1->insert(R_SI);
02324         reg_list_O_1->insert(R_EAX);
02325         reg_list_O_1->insert(R_EBX);
02326         reg_list_O_1->insert(R_ECX);
02327         reg_list_O_1->insert(R_EDX);
02328         reg_list_O_1->insert(R_EDI);
02329         reg_list_O_1->insert(R_ESI);
02330         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02331         op_O_1->destroys_set(I_2);
02332         out_operands->push_back(op_O_1);
02333         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02334         dt_list_O_2->insert(DT_COND);
02335         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02336         reg_list_O_2->insert(R_COND);
02337         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02338         out_operands->push_back(op_O_2);
02339 
02340         //execution info
02341         einfo = execution_info::create(120);
02342 
02343         //properties
02344 
02345         //versions
02346         versions = set<ulint>::create();
02347         versions->insert(INSTRUCTION_IMUL__1);
02348         versions->insert(INSTRUCTION_IMUL__2);
02349         versions->insert(INSTRUCTION_IMUL__21);
02350         versions->insert(INSTRUCTION_IMUL__22);
02351         versions->insert(INSTRUCTION_IMUL__23);
02352 
02353 
02354         //return target pseudoinstruction
02355         return tm_instr::create(INSTRUCTION_IMUL__24,in_operands,out_operands,lstring("imul $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
02356 }
02357 
02358 ptr<tm_instr> tm_instr_create_INSTRUCTION_MUL__1() {
02359         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02360         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02361         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02362         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02363         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02364         ptr<execution_info> einfo;
02365         ptr<set<ulint> > versions;
02366         
02367         //input operands
02368         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02369         dt_list_I_1->insert(DT_INT_8U);
02370         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
02371         reg_list_I_1->insert(R_AL);
02372         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
02373         op_I_1->destroyed_by_get()->push_back(O_1);
02374         in_operands->push_back(op_I_1);
02375         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02376         dt_list_I_2->insert(DT_INT_8U);
02377         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
02378         reg_list_I_2->insert(R_AL);
02379         reg_list_I_2->insert(R_AH);
02380         reg_list_I_2->insert(R_BL);
02381         reg_list_I_2->insert(R_BH);
02382         reg_list_I_2->insert(R_CL);
02383         reg_list_I_2->insert(R_CH);
02384         reg_list_I_2->insert(R_DL);
02385         reg_list_I_2->insert(R_DH);
02386         reg_list_I_2->erase(R_AL);
02387         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
02388         in_operands->push_back(op_I_2);
02389 
02390         //output operands
02391         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02392         dt_list_O_1->insert(DT_INT_8U);
02393         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02394         reg_list_O_1->insert(R_AL);
02395         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02396         op_O_1->destroys_set(I_1);
02397         out_operands->push_back(op_O_1);
02398         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02399         dt_list_O_2->insert(DT_COND);
02400         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02401         reg_list_O_2->insert(R_COND);
02402         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02403         out_operands->push_back(op_O_2);
02404 
02405         //execution info
02406         einfo = execution_info::create(100);
02407 
02408         //properties
02409 
02410         //versions
02411         versions = set<ulint>::create();
02412         versions->insert(INSTRUCTION_MUL__11);
02413         versions->insert(INSTRUCTION_MUL__12);
02414         versions->insert(INSTRUCTION_MUL__2);
02415         versions->insert(INSTRUCTION_MUL__21);
02416         versions->insert(INSTRUCTION_MUL__22);
02417         versions->insert(INSTRUCTION_MUL__3);
02418         versions->insert(INSTRUCTION_MUL__31);
02419         versions->insert(INSTRUCTION_MUL__32);
02420 
02421 
02422         //return target pseudoinstruction
02423         return tm_instr::create(INSTRUCTION_MUL__1,in_operands,out_operands,lstring("mul $I_2"), props,versions,0,einfo);
02424 }
02425 
02426 ptr<tm_instr> tm_instr_create_INSTRUCTION_MUL__11() {
02427         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02428         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02429         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02430         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02431         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02432         ptr<execution_info> einfo;
02433         ptr<set<ulint> > versions;
02434         
02435         //input operands
02436         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02437         dt_list_I_1->insert(DT_INT_8U);
02438         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
02439         reg_list_I_1->insert(R_AL);
02440         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
02441         op_I_1->destroyed_by_get()->push_back(O_1);
02442         in_operands->push_back(op_I_1);
02443         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02444         dt_list_I_2->insert(DT_INT_8U);
02445         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
02446         in_operands->push_back(op_I_2);
02447 
02448         //output operands
02449         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02450         dt_list_O_1->insert(DT_INT_8U);
02451         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02452         reg_list_O_1->insert(R_AL);
02453         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02454         op_O_1->destroys_set(I_1);
02455         out_operands->push_back(op_O_1);
02456         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02457         dt_list_O_2->insert(DT_COND);
02458         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02459         reg_list_O_2->insert(R_COND);
02460         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02461         out_operands->push_back(op_O_2);
02462 
02463         //execution info
02464         einfo = execution_info::create(120);
02465 
02466         //properties
02467 
02468         //versions
02469         versions = set<ulint>::create();
02470         versions->insert(INSTRUCTION_MUL__1);
02471         versions->insert(INSTRUCTION_MUL__12);
02472         versions->insert(INSTRUCTION_MUL__2);
02473         versions->insert(INSTRUCTION_MUL__21);
02474         versions->insert(INSTRUCTION_MUL__22);
02475         versions->insert(INSTRUCTION_MUL__3);
02476         versions->insert(INSTRUCTION_MUL__31);
02477         versions->insert(INSTRUCTION_MUL__32);
02478 
02479 
02480         //return target pseudoinstruction
02481         return tm_instr::create(INSTRUCTION_MUL__11,in_operands,out_operands,lstring("mul $TYPE_I_2 $I_2"), props,versions,0,einfo);
02482 }
02483 
02484 ptr<tm_instr> tm_instr_create_INSTRUCTION_MUL__12() {
02485         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02486         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02487         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02488         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02489         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02490         ptr<execution_info> einfo;
02491         ptr<set<ulint> > versions;
02492         
02493         //input operands
02494         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02495         dt_list_I_1->insert(DT_INT_8U);
02496         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
02497         in_operands->push_back(op_I_1);
02498         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02499         dt_list_I_2->insert(DT_INT_8U);
02500         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
02501         reg_list_I_2->insert(R_AL);
02502         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
02503         op_I_2->destroyed_by_get()->push_back(O_1);
02504         in_operands->push_back(op_I_2);
02505 
02506         //output operands
02507         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02508         dt_list_O_1->insert(DT_INT_8U);
02509         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02510         reg_list_O_1->insert(R_AL);
02511         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02512         op_O_1->destroys_set(I_2);
02513         out_operands->push_back(op_O_1);
02514         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02515         dt_list_O_2->insert(DT_COND);
02516         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02517         reg_list_O_2->insert(R_COND);
02518         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02519         out_operands->push_back(op_O_2);
02520 
02521         //execution info
02522         einfo = execution_info::create(120);
02523 
02524         //properties
02525 
02526         //versions
02527         versions = set<ulint>::create();
02528         versions->insert(INSTRUCTION_MUL__1);
02529         versions->insert(INSTRUCTION_MUL__11);
02530         versions->insert(INSTRUCTION_MUL__2);
02531         versions->insert(INSTRUCTION_MUL__21);
02532         versions->insert(INSTRUCTION_MUL__22);
02533         versions->insert(INSTRUCTION_MUL__3);
02534         versions->insert(INSTRUCTION_MUL__31);
02535         versions->insert(INSTRUCTION_MUL__32);
02536 
02537 
02538         //return target pseudoinstruction
02539         return tm_instr::create(INSTRUCTION_MUL__12,in_operands,out_operands,lstring("mul $TYPE_I_1 $I_1"), props,versions,0,einfo);
02540 }
02541 
02542 ptr<tm_instr> tm_instr_create_INSTRUCTION_MUL__2() {
02543         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02544         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02545         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02546         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02547         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02548         ptr<execution_info> einfo;
02549         ptr<set<ulint> > versions;
02550         
02551         //input operands
02552         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02553         dt_list_I_1->insert(DT_INT_16U);
02554         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
02555         reg_list_I_1->insert(R_AX);
02556         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
02557         op_I_1->destroyed_by_get()->push_back(O_1);
02558         in_operands->push_back(op_I_1);
02559         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02560         dt_list_I_2->insert(DT_INT_16U);
02561         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
02562         reg_list_I_2->insert(R_AX);
02563         reg_list_I_2->insert(R_BX);
02564         reg_list_I_2->insert(R_CX);
02565         reg_list_I_2->insert(R_DX);
02566         reg_list_I_2->insert(R_DI);
02567         reg_list_I_2->insert(R_SI);
02568         reg_list_I_2->erase(R_DX);
02569         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
02570         in_operands->push_back(op_I_2);
02571 
02572         //output operands
02573         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02574         dt_list_O_1->insert(DT_INT_16U);
02575         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02576         reg_list_O_1->insert(R_AX);
02577         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02578         op_O_1->destroys_set(I_1);
02579         out_operands->push_back(op_O_1);
02580         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02581         dt_list_O_2->insert(DT_INT_16U);
02582         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02583         reg_list_O_2->insert(R_DX);
02584         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02585         out_operands->push_back(op_O_2);
02586         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
02587         dt_list_O_3->insert(DT_COND);
02588         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
02589         reg_list_O_3->insert(R_COND);
02590         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
02591         out_operands->push_back(op_O_3);
02592 
02593         //execution info
02594         einfo = execution_info::create(100);
02595 
02596         //properties
02597 
02598         //versions
02599         versions = set<ulint>::create();
02600         versions->insert(INSTRUCTION_MUL__1);
02601         versions->insert(INSTRUCTION_MUL__11);
02602         versions->insert(INSTRUCTION_MUL__12);
02603         versions->insert(INSTRUCTION_MUL__21);
02604         versions->insert(INSTRUCTION_MUL__22);
02605         versions->insert(INSTRUCTION_MUL__3);
02606         versions->insert(INSTRUCTION_MUL__31);
02607         versions->insert(INSTRUCTION_MUL__32);
02608 
02609 
02610         //return target pseudoinstruction
02611         return tm_instr::create(INSTRUCTION_MUL__2,in_operands,out_operands,lstring("mul $I_2"), props,versions,0,einfo);
02612 }
02613 
02614 ptr<tm_instr> tm_instr_create_INSTRUCTION_MUL__21() {
02615         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02616         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02617         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02618         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02619         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02620         ptr<execution_info> einfo;
02621         ptr<set<ulint> > versions;
02622         
02623         //input operands
02624         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02625         dt_list_I_1->insert(DT_INT_16U);
02626         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
02627         reg_list_I_1->insert(R_AX);
02628         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
02629         op_I_1->destroyed_by_get()->push_back(O_1);
02630         in_operands->push_back(op_I_1);
02631         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02632         dt_list_I_2->insert(DT_INT_16U);
02633         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
02634         in_operands->push_back(op_I_2);
02635 
02636         //output operands
02637         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02638         dt_list_O_1->insert(DT_INT_16U);
02639         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02640         reg_list_O_1->insert(R_AX);
02641         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02642         op_O_1->destroys_set(I_1);
02643         out_operands->push_back(op_O_1);
02644         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02645         dt_list_O_2->insert(DT_INT_16U);
02646         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02647         reg_list_O_2->insert(R_DX);
02648         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02649         out_operands->push_back(op_O_2);
02650         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
02651         dt_list_O_3->insert(DT_COND);
02652         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
02653         reg_list_O_3->insert(R_COND);
02654         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
02655         out_operands->push_back(op_O_3);
02656 
02657         //execution info
02658         einfo = execution_info::create(120);
02659 
02660         //properties
02661 
02662         //versions
02663         versions = set<ulint>::create();
02664         versions->insert(INSTRUCTION_MUL__1);
02665         versions->insert(INSTRUCTION_MUL__11);
02666         versions->insert(INSTRUCTION_MUL__12);
02667         versions->insert(INSTRUCTION_MUL__2);
02668         versions->insert(INSTRUCTION_MUL__22);
02669         versions->insert(INSTRUCTION_MUL__3);
02670         versions->insert(INSTRUCTION_MUL__31);
02671         versions->insert(INSTRUCTION_MUL__32);
02672 
02673 
02674         //return target pseudoinstruction
02675         return tm_instr::create(INSTRUCTION_MUL__21,in_operands,out_operands,lstring("mul $TYPE_I_2 $I_2"), props,versions,0,einfo);
02676 }
02677 
02678 ptr<tm_instr> tm_instr_create_INSTRUCTION_MUL__22() {
02679         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02680         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02681         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02682         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02683         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02684         ptr<execution_info> einfo;
02685         ptr<set<ulint> > versions;
02686         
02687         //input operands
02688         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02689         dt_list_I_1->insert(DT_INT_16U);
02690         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
02691         in_operands->push_back(op_I_1);
02692         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02693         dt_list_I_2->insert(DT_INT_16U);
02694         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
02695         reg_list_I_2->insert(R_AX);
02696         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
02697         op_I_2->destroyed_by_get()->push_back(O_1);
02698         in_operands->push_back(op_I_2);
02699 
02700         //output operands
02701         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02702         dt_list_O_1->insert(DT_INT_16U);
02703         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02704         reg_list_O_1->insert(R_AX);
02705         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02706         op_O_1->destroys_set(I_2);
02707         out_operands->push_back(op_O_1);
02708         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02709         dt_list_O_2->insert(DT_INT_16U);
02710         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02711         reg_list_O_2->insert(R_DX);
02712         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02713         out_operands->push_back(op_O_2);
02714         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
02715         dt_list_O_3->insert(DT_COND);
02716         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
02717         reg_list_O_3->insert(R_COND);
02718         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
02719         out_operands->push_back(op_O_3);
02720 
02721         //execution info
02722         einfo = execution_info::create(120);
02723 
02724         //properties
02725 
02726         //versions
02727         versions = set<ulint>::create();
02728         versions->insert(INSTRUCTION_MUL__1);
02729         versions->insert(INSTRUCTION_MUL__11);
02730         versions->insert(INSTRUCTION_MUL__12);
02731         versions->insert(INSTRUCTION_MUL__2);
02732         versions->insert(INSTRUCTION_MUL__21);
02733         versions->insert(INSTRUCTION_MUL__3);
02734         versions->insert(INSTRUCTION_MUL__31);
02735         versions->insert(INSTRUCTION_MUL__32);
02736 
02737 
02738         //return target pseudoinstruction
02739         return tm_instr::create(INSTRUCTION_MUL__22,in_operands,out_operands,lstring("mul $TYPE_I_1 $I_1"), props,versions,0,einfo);
02740 }
02741 
02742 ptr<tm_instr> tm_instr_create_INSTRUCTION_MUL__3() {
02743         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02744         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02745         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02746         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02747         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02748         ptr<execution_info> einfo;
02749         ptr<set<ulint> > versions;
02750         
02751         //input operands
02752         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02753         dt_list_I_1->insert(DT_INT_32U);
02754         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
02755         reg_list_I_1->insert(R_EAX);
02756         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
02757         op_I_1->destroyed_by_get()->push_back(O_1);
02758         in_operands->push_back(op_I_1);
02759         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02760         dt_list_I_2->insert(DT_INT_32U);
02761         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
02762         reg_list_I_2->insert(R_EAX);
02763         reg_list_I_2->insert(R_EBX);
02764         reg_list_I_2->insert(R_ECX);
02765         reg_list_I_2->insert(R_EDX);
02766         reg_list_I_2->insert(R_EDI);
02767         reg_list_I_2->insert(R_ESI);
02768         reg_list_I_2->erase(R_EDX);
02769         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
02770         in_operands->push_back(op_I_2);
02771 
02772         //output operands
02773         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02774         dt_list_O_1->insert(DT_INT_32U);
02775         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02776         reg_list_O_1->insert(R_EAX);
02777         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02778         op_O_1->destroys_set(I_1);
02779         out_operands->push_back(op_O_1);
02780         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02781         dt_list_O_2->insert(DT_INT_32U);
02782         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02783         reg_list_O_2->insert(R_EDX);
02784         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02785         out_operands->push_back(op_O_2);
02786         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
02787         dt_list_O_3->insert(DT_COND);
02788         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
02789         reg_list_O_3->insert(R_COND);
02790         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
02791         out_operands->push_back(op_O_3);
02792 
02793         //execution info
02794         einfo = execution_info::create(100);
02795 
02796         //properties
02797 
02798         //versions
02799         versions = set<ulint>::create();
02800         versions->insert(INSTRUCTION_MUL__1);
02801         versions->insert(INSTRUCTION_MUL__11);
02802         versions->insert(INSTRUCTION_MUL__12);
02803         versions->insert(INSTRUCTION_MUL__2);
02804         versions->insert(INSTRUCTION_MUL__21);
02805         versions->insert(INSTRUCTION_MUL__22);
02806         versions->insert(INSTRUCTION_MUL__31);
02807         versions->insert(INSTRUCTION_MUL__32);
02808 
02809 
02810         //return target pseudoinstruction
02811         return tm_instr::create(INSTRUCTION_MUL__3,in_operands,out_operands,lstring("mul $I_2"), props,versions,0,einfo);
02812 }
02813 
02814 ptr<tm_instr> tm_instr_create_INSTRUCTION_MUL__31() {
02815         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02816         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02817         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02818         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02819         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02820         ptr<execution_info> einfo;
02821         ptr<set<ulint> > versions;
02822         
02823         //input operands
02824         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02825         dt_list_I_1->insert(DT_INT_32U);
02826         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
02827         reg_list_I_1->insert(R_EAX);
02828         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
02829         op_I_1->destroyed_by_get()->push_back(O_1);
02830         in_operands->push_back(op_I_1);
02831         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02832         dt_list_I_2->insert(DT_INT_32U);
02833         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
02834         in_operands->push_back(op_I_2);
02835 
02836         //output operands
02837         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02838         dt_list_O_1->insert(DT_INT_32U);
02839         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02840         reg_list_O_1->insert(R_EAX);
02841         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02842         op_O_1->destroys_set(I_1);
02843         out_operands->push_back(op_O_1);
02844         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02845         dt_list_O_2->insert(DT_INT_32U);
02846         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02847         reg_list_O_2->insert(R_EDX);
02848         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02849         out_operands->push_back(op_O_2);
02850         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
02851         dt_list_O_3->insert(DT_COND);
02852         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
02853         reg_list_O_3->insert(R_COND);
02854         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
02855         out_operands->push_back(op_O_3);
02856 
02857         //execution info
02858         einfo = execution_info::create(120);
02859 
02860         //properties
02861 
02862         //versions
02863         versions = set<ulint>::create();
02864         versions->insert(INSTRUCTION_MUL__1);
02865         versions->insert(INSTRUCTION_MUL__11);
02866         versions->insert(INSTRUCTION_MUL__12);
02867         versions->insert(INSTRUCTION_MUL__2);
02868         versions->insert(INSTRUCTION_MUL__21);
02869         versions->insert(INSTRUCTION_MUL__22);
02870         versions->insert(INSTRUCTION_MUL__3);
02871         versions->insert(INSTRUCTION_MUL__32);
02872 
02873 
02874         //return target pseudoinstruction
02875         return tm_instr::create(INSTRUCTION_MUL__31,in_operands,out_operands,lstring("mul $TYPE_I_2 $I_2"), props,versions,0,einfo);
02876 }
02877 
02878 ptr<tm_instr> tm_instr_create_INSTRUCTION_MUL__32() {
02879         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02880         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02881         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02882         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02883         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02884         ptr<execution_info> einfo;
02885         ptr<set<ulint> > versions;
02886         
02887         //input operands
02888         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02889         dt_list_I_1->insert(DT_INT_32U);
02890         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
02891         in_operands->push_back(op_I_1);
02892         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
02893         dt_list_I_2->insert(DT_INT_32U);
02894         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
02895         reg_list_I_2->insert(R_EAX);
02896         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
02897         op_I_2->destroyed_by_get()->push_back(O_1);
02898         in_operands->push_back(op_I_2);
02899 
02900         //output operands
02901         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02902         dt_list_O_1->insert(DT_INT_32U);
02903         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02904         reg_list_O_1->insert(R_EAX);
02905         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02906         op_O_1->destroys_set(I_2);
02907         out_operands->push_back(op_O_1);
02908         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
02909         dt_list_O_2->insert(DT_INT_32U);
02910         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
02911         reg_list_O_2->insert(R_EDX);
02912         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
02913         out_operands->push_back(op_O_2);
02914         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
02915         dt_list_O_3->insert(DT_COND);
02916         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
02917         reg_list_O_3->insert(R_COND);
02918         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
02919         out_operands->push_back(op_O_3);
02920 
02921         //execution info
02922         einfo = execution_info::create(120);
02923 
02924         //properties
02925 
02926         //versions
02927         versions = set<ulint>::create();
02928         versions->insert(INSTRUCTION_MUL__1);
02929         versions->insert(INSTRUCTION_MUL__11);
02930         versions->insert(INSTRUCTION_MUL__12);
02931         versions->insert(INSTRUCTION_MUL__2);
02932         versions->insert(INSTRUCTION_MUL__21);
02933         versions->insert(INSTRUCTION_MUL__22);
02934         versions->insert(INSTRUCTION_MUL__3);
02935         versions->insert(INSTRUCTION_MUL__31);
02936 
02937 
02938         //return target pseudoinstruction
02939         return tm_instr::create(INSTRUCTION_MUL__32,in_operands,out_operands,lstring("mul $TYPE_I_1 $I_1"), props,versions,0,einfo);
02940 }
02941 
02942 ptr<tm_instr> tm_instr_create_INSTRUCTION_CBW__1() {
02943         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02944         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02945         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02946         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02947         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02948         ptr<execution_info> einfo;
02949         ptr<set<ulint> > versions;
02950         
02951         //input operands
02952         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02953         dt_list_I_1->insert(DT_INT_8S);
02954         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
02955         reg_list_I_1->insert(R_AL);
02956         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
02957         op_I_1->destroyed_by_get()->push_back(O_1);
02958         in_operands->push_back(op_I_1);
02959 
02960         //output operands
02961         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
02962         dt_list_O_1->insert(DT_INT_16S);
02963         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
02964         reg_list_O_1->insert(R_AX);
02965         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
02966         op_O_1->destroys_set(I_1);
02967         out_operands->push_back(op_O_1);
02968 
02969         //execution info
02970         einfo = execution_info::create(10);
02971 
02972         //properties
02973 
02974         //versions
02975 
02976 
02977         //return target pseudoinstruction
02978         return tm_instr::create(INSTRUCTION_CBW__1,in_operands,out_operands,lstring("cbw"), props,versions,0,einfo);
02979 }
02980 
02981 ptr<tm_instr> tm_instr_create_INSTRUCTION_CWD__1() {
02982         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
02983         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
02984         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
02985         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
02986         ptr<set<tm_data_type_base::id_type> > allowed_types; 
02987         ptr<execution_info> einfo;
02988         ptr<set<ulint> > versions;
02989         
02990         //input operands
02991         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
02992         dt_list_I_1->insert(DT_INT_16S);
02993         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
02994         reg_list_I_1->insert(R_AX);
02995         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
02996         op_I_1->destroyed_by_get()->push_back(O_2);
02997         in_operands->push_back(op_I_1);
02998 
02999         //output operands
03000         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03001         dt_list_O_1->insert(DT_INT_16S);
03002         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03003         reg_list_O_1->insert(R_DX);
03004         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03005         out_operands->push_back(op_O_1);
03006         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03007         dt_list_O_2->insert(DT_INT_16S);
03008         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03009         reg_list_O_2->insert(R_AX);
03010         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03011         op_O_2->destroys_set(I_1);
03012         out_operands->push_back(op_O_2);
03013 
03014         //execution info
03015         einfo = execution_info::create(10);
03016 
03017         //properties
03018 
03019         //versions
03020 
03021 
03022         //return target pseudoinstruction
03023         return tm_instr::create(INSTRUCTION_CWD__1,in_operands,out_operands,lstring("cwd"), props,versions,0,einfo);
03024 }
03025 
03026 ptr<tm_instr> tm_instr_create_INSTRUCTION_CDQ__1() {
03027         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03028         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03029         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03030         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03031         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03032         ptr<execution_info> einfo;
03033         ptr<set<ulint> > versions;
03034         
03035         //input operands
03036         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03037         dt_list_I_1->insert(DT_INT_32S);
03038         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03039         reg_list_I_1->insert(R_EAX);
03040         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03041         op_I_1->destroyed_by_get()->push_back(O_2);
03042         in_operands->push_back(op_I_1);
03043 
03044         //output operands
03045         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03046         dt_list_O_1->insert(DT_INT_32S);
03047         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03048         reg_list_O_1->insert(R_EDX);
03049         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03050         out_operands->push_back(op_O_1);
03051         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03052         dt_list_O_2->insert(DT_INT_32S);
03053         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03054         reg_list_O_2->insert(R_EAX);
03055         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03056         op_O_2->destroys_set(I_1);
03057         out_operands->push_back(op_O_2);
03058 
03059         //execution info
03060         einfo = execution_info::create(10);
03061 
03062         //properties
03063 
03064         //versions
03065 
03066 
03067         //return target pseudoinstruction
03068         return tm_instr::create(INSTRUCTION_CDQ__1,in_operands,out_operands,lstring("cdq"), props,versions,0,einfo);
03069 }
03070 
03071 ptr<tm_instr> tm_instr_create_INSTRUCTION_DIV__1() {
03072         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03073         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03074         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03075         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03076         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03077         ptr<execution_info> einfo;
03078         ptr<set<ulint> > versions;
03079         
03080         //input operands
03081         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03082         dt_list_I_1->insert(DT_INT_8U);
03083         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03084         reg_list_I_1->insert(R_AH);
03085         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03086         op_I_1->destroyed_by_get()->push_back(O_2);
03087         in_operands->push_back(op_I_1);
03088         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03089         dt_list_I_2->insert(DT_INT_8U);
03090         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
03091         reg_list_I_2->insert(R_AL);
03092         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
03093         op_I_2->destroyed_by_get()->push_back(O_1);
03094         in_operands->push_back(op_I_2);
03095         ptr<set<tm_data_type_base::id_type> > dt_list_I_3 = set<tm_data_type_base::id_type>::create();
03096         dt_list_I_3->insert(DT_INT_8U);
03097         ptr<set<tm_register_base::id_type> > reg_list_I_3 = set<tm_register_base::id_type>::create();
03098         reg_list_I_3->insert(R_AL);
03099         reg_list_I_3->insert(R_AH);
03100         reg_list_I_3->insert(R_BL);
03101         reg_list_I_3->insert(R_BH);
03102         reg_list_I_3->insert(R_CL);
03103         reg_list_I_3->insert(R_CH);
03104         reg_list_I_3->insert(R_DL);
03105         reg_list_I_3->insert(R_DH);
03106         reg_list_I_3->erase(R_AL);
03107         ptr<tm_instr_op_reg> op_I_3 = tm_instr_op_reg::create(I_3, dt_list_I_3, reg_list_I_3);
03108         in_operands->push_back(op_I_3);
03109 
03110         //output operands
03111         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03112         dt_list_O_1->insert(DT_INT_8U);
03113         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03114         reg_list_O_1->insert(R_AL);
03115         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03116         op_O_1->destroys_set(I_2);
03117         out_operands->push_back(op_O_1);
03118         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03119         dt_list_O_2->insert(DT_INT_8U);
03120         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03121         reg_list_O_2->insert(R_AH);
03122         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03123         op_O_2->destroys_set(I_1);
03124         out_operands->push_back(op_O_2);
03125         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
03126         dt_list_O_3->insert(DT_COND);
03127         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
03128         reg_list_O_3->insert(R_COND);
03129         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
03130         out_operands->push_back(op_O_3);
03131 
03132         //execution info
03133         einfo = execution_info::create(700);
03134 
03135         //properties
03136 
03137         //versions
03138         versions = set<ulint>::create();
03139         versions->insert(INSTRUCTION_DIV__11);
03140         versions->insert(INSTRUCTION_DIV__2);
03141         versions->insert(INSTRUCTION_DIV__21);
03142         versions->insert(INSTRUCTION_DIV__3);
03143         versions->insert(INSTRUCTION_DIV__31);
03144 
03145 
03146         //return target pseudoinstruction
03147         return tm_instr::create(INSTRUCTION_DIV__1,in_operands,out_operands,lstring("div $I_3"), props,versions,0,einfo);
03148 }
03149 
03150 ptr<tm_instr> tm_instr_create_INSTRUCTION_DIV__11() {
03151         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03152         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03153         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03154         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03155         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03156         ptr<execution_info> einfo;
03157         ptr<set<ulint> > versions;
03158         
03159         //input operands
03160         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03161         dt_list_I_1->insert(DT_INT_8U);
03162         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03163         reg_list_I_1->insert(R_AH);
03164         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03165         op_I_1->destroyed_by_get()->push_back(O_2);
03166         in_operands->push_back(op_I_1);
03167         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03168         dt_list_I_2->insert(DT_INT_8U);
03169         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
03170         reg_list_I_2->insert(R_AL);
03171         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
03172         op_I_2->destroyed_by_get()->push_back(O_1);
03173         in_operands->push_back(op_I_2);
03174         ptr<set<tm_data_type_base::id_type> > dt_list_I_3 = set<tm_data_type_base::id_type>::create();
03175         dt_list_I_3->insert(DT_INT_8U);
03176         ptr<tm_instr_op_mem> op_I_3 = tm_instr_op_mem::create(I_3, dt_list_I_3);
03177         in_operands->push_back(op_I_3);
03178 
03179         //output operands
03180         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03181         dt_list_O_1->insert(DT_INT_8U);
03182         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03183         reg_list_O_1->insert(R_AL);
03184         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03185         op_O_1->destroys_set(I_2);
03186         out_operands->push_back(op_O_1);
03187         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03188         dt_list_O_2->insert(DT_INT_8U);
03189         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03190         reg_list_O_2->insert(R_AH);
03191         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03192         op_O_2->destroys_set(I_1);
03193         out_operands->push_back(op_O_2);
03194         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
03195         dt_list_O_3->insert(DT_COND);
03196         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
03197         reg_list_O_3->insert(R_COND);
03198         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
03199         out_operands->push_back(op_O_3);
03200 
03201         //execution info
03202         einfo = execution_info::create(720);
03203 
03204         //properties
03205 
03206         //versions
03207         versions = set<ulint>::create();
03208         versions->insert(INSTRUCTION_DIV__1);
03209         versions->insert(INSTRUCTION_DIV__2);
03210         versions->insert(INSTRUCTION_DIV__21);
03211         versions->insert(INSTRUCTION_DIV__3);
03212         versions->insert(INSTRUCTION_DIV__31);
03213 
03214 
03215         //return target pseudoinstruction
03216         return tm_instr::create(INSTRUCTION_DIV__11,in_operands,out_operands,lstring("div $TYPE_I_3 $I_3"), props,versions,0,einfo);
03217 }
03218 
03219 ptr<tm_instr> tm_instr_create_INSTRUCTION_DIV__2() {
03220         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03221         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03222         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03223         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03224         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03225         ptr<execution_info> einfo;
03226         ptr<set<ulint> > versions;
03227         
03228         //input operands
03229         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03230         dt_list_I_1->insert(DT_INT_16U);
03231         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03232         reg_list_I_1->insert(R_DX);
03233         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03234         op_I_1->destroyed_by_get()->push_back(O_2);
03235         in_operands->push_back(op_I_1);
03236         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03237         dt_list_I_2->insert(DT_INT_16U);
03238         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
03239         reg_list_I_2->insert(R_AX);
03240         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
03241         op_I_2->destroyed_by_get()->push_back(O_1);
03242         in_operands->push_back(op_I_2);
03243         ptr<set<tm_data_type_base::id_type> > dt_list_I_3 = set<tm_data_type_base::id_type>::create();
03244         dt_list_I_3->insert(DT_INT_16U);
03245         ptr<set<tm_register_base::id_type> > reg_list_I_3 = set<tm_register_base::id_type>::create();
03246         reg_list_I_3->insert(R_AX);
03247         reg_list_I_3->insert(R_BX);
03248         reg_list_I_3->insert(R_CX);
03249         reg_list_I_3->insert(R_DX);
03250         reg_list_I_3->insert(R_DI);
03251         reg_list_I_3->insert(R_SI);
03252         reg_list_I_3->erase(R_DX);
03253         ptr<tm_instr_op_reg> op_I_3 = tm_instr_op_reg::create(I_3, dt_list_I_3, reg_list_I_3);
03254         in_operands->push_back(op_I_3);
03255 
03256         //output operands
03257         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03258         dt_list_O_1->insert(DT_INT_16U);
03259         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03260         reg_list_O_1->insert(R_AX);
03261         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03262         op_O_1->destroys_set(I_2);
03263         out_operands->push_back(op_O_1);
03264         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03265         dt_list_O_2->insert(DT_INT_16U);
03266         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03267         reg_list_O_2->insert(R_DX);
03268         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03269         op_O_2->destroys_set(I_1);
03270         out_operands->push_back(op_O_2);
03271         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
03272         dt_list_O_3->insert(DT_COND);
03273         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
03274         reg_list_O_3->insert(R_COND);
03275         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
03276         out_operands->push_back(op_O_3);
03277 
03278         //execution info
03279         einfo = execution_info::create(700);
03280 
03281         //properties
03282 
03283         //versions
03284         versions = set<ulint>::create();
03285         versions->insert(INSTRUCTION_DIV__1);
03286         versions->insert(INSTRUCTION_DIV__11);
03287         versions->insert(INSTRUCTION_DIV__21);
03288         versions->insert(INSTRUCTION_DIV__3);
03289         versions->insert(INSTRUCTION_DIV__31);
03290 
03291 
03292         //return target pseudoinstruction
03293         return tm_instr::create(INSTRUCTION_DIV__2,in_operands,out_operands,lstring("div $I_3"), props,versions,0,einfo);
03294 }
03295 
03296 ptr<tm_instr> tm_instr_create_INSTRUCTION_DIV__21() {
03297         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03298         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03299         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03300         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03301         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03302         ptr<execution_info> einfo;
03303         ptr<set<ulint> > versions;
03304         
03305         //input operands
03306         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03307         dt_list_I_1->insert(DT_INT_16U);
03308         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03309         reg_list_I_1->insert(R_DX);
03310         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03311         op_I_1->destroyed_by_get()->push_back(O_2);
03312         in_operands->push_back(op_I_1);
03313         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03314         dt_list_I_2->insert(DT_INT_16U);
03315         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
03316         reg_list_I_2->insert(R_AX);
03317         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
03318         op_I_2->destroyed_by_get()->push_back(O_1);
03319         in_operands->push_back(op_I_2);
03320         ptr<set<tm_data_type_base::id_type> > dt_list_I_3 = set<tm_data_type_base::id_type>::create();
03321         dt_list_I_3->insert(DT_INT_16U);
03322         ptr<tm_instr_op_mem> op_I_3 = tm_instr_op_mem::create(I_3, dt_list_I_3);
03323         in_operands->push_back(op_I_3);
03324 
03325         //output operands
03326         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03327         dt_list_O_1->insert(DT_INT_16U);
03328         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03329         reg_list_O_1->insert(R_AX);
03330         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03331         op_O_1->destroys_set(I_2);
03332         out_operands->push_back(op_O_1);
03333         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03334         dt_list_O_2->insert(DT_INT_16U);
03335         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03336         reg_list_O_2->insert(R_DX);
03337         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03338         op_O_2->destroys_set(I_1);
03339         out_operands->push_back(op_O_2);
03340         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
03341         dt_list_O_3->insert(DT_COND);
03342         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
03343         reg_list_O_3->insert(R_COND);
03344         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
03345         out_operands->push_back(op_O_3);
03346 
03347         //execution info
03348         einfo = execution_info::create(720);
03349 
03350         //properties
03351 
03352         //versions
03353         versions = set<ulint>::create();
03354         versions->insert(INSTRUCTION_DIV__1);
03355         versions->insert(INSTRUCTION_DIV__11);
03356         versions->insert(INSTRUCTION_DIV__2);
03357         versions->insert(INSTRUCTION_DIV__3);
03358         versions->insert(INSTRUCTION_DIV__31);
03359 
03360 
03361         //return target pseudoinstruction
03362         return tm_instr::create(INSTRUCTION_DIV__21,in_operands,out_operands,lstring("div $TYPE_I_3 $I_3"), props,versions,0,einfo);
03363 }
03364 
03365 ptr<tm_instr> tm_instr_create_INSTRUCTION_DIV__3() {
03366         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03367         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03368         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03369         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03370         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03371         ptr<execution_info> einfo;
03372         ptr<set<ulint> > versions;
03373         
03374         //input operands
03375         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03376         dt_list_I_1->insert(DT_INT_32U);
03377         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03378         reg_list_I_1->insert(R_EDX);
03379         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03380         op_I_1->destroyed_by_get()->push_back(O_2);
03381         in_operands->push_back(op_I_1);
03382         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03383         dt_list_I_2->insert(DT_INT_32U);
03384         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
03385         reg_list_I_2->insert(R_EAX);
03386         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
03387         op_I_2->destroyed_by_get()->push_back(O_1);
03388         in_operands->push_back(op_I_2);
03389         ptr<set<tm_data_type_base::id_type> > dt_list_I_3 = set<tm_data_type_base::id_type>::create();
03390         dt_list_I_3->insert(DT_INT_32U);
03391         ptr<set<tm_register_base::id_type> > reg_list_I_3 = set<tm_register_base::id_type>::create();
03392         reg_list_I_3->insert(R_EAX);
03393         reg_list_I_3->insert(R_EBX);
03394         reg_list_I_3->insert(R_ECX);
03395         reg_list_I_3->insert(R_EDX);
03396         reg_list_I_3->insert(R_EDI);
03397         reg_list_I_3->insert(R_ESI);
03398         reg_list_I_3->erase(R_EDX);
03399         ptr<tm_instr_op_reg> op_I_3 = tm_instr_op_reg::create(I_3, dt_list_I_3, reg_list_I_3);
03400         in_operands->push_back(op_I_3);
03401 
03402         //output operands
03403         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03404         dt_list_O_1->insert(DT_INT_32U);
03405         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03406         reg_list_O_1->insert(R_EAX);
03407         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03408         op_O_1->destroys_set(I_2);
03409         out_operands->push_back(op_O_1);
03410         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03411         dt_list_O_2->insert(DT_INT_32U);
03412         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03413         reg_list_O_2->insert(R_EDX);
03414         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03415         op_O_2->destroys_set(I_1);
03416         out_operands->push_back(op_O_2);
03417         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
03418         dt_list_O_3->insert(DT_COND);
03419         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
03420         reg_list_O_3->insert(R_COND);
03421         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
03422         out_operands->push_back(op_O_3);
03423 
03424         //execution info
03425         einfo = execution_info::create(700);
03426 
03427         //properties
03428 
03429         //versions
03430         versions = set<ulint>::create();
03431         versions->insert(INSTRUCTION_DIV__1);
03432         versions->insert(INSTRUCTION_DIV__11);
03433         versions->insert(INSTRUCTION_DIV__2);
03434         versions->insert(INSTRUCTION_DIV__21);
03435         versions->insert(INSTRUCTION_DIV__31);
03436 
03437 
03438         //return target pseudoinstruction
03439         return tm_instr::create(INSTRUCTION_DIV__3,in_operands,out_operands,lstring("div $I_3"), props,versions,0,einfo);
03440 }
03441 
03442 ptr<tm_instr> tm_instr_create_INSTRUCTION_DIV__31() {
03443         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03444         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03445         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03446         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03447         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03448         ptr<execution_info> einfo;
03449         ptr<set<ulint> > versions;
03450         
03451         //input operands
03452         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03453         dt_list_I_1->insert(DT_INT_32U);
03454         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03455         reg_list_I_1->insert(R_EDX);
03456         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03457         op_I_1->destroyed_by_get()->push_back(O_2);
03458         in_operands->push_back(op_I_1);
03459         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03460         dt_list_I_2->insert(DT_INT_32U);
03461         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
03462         reg_list_I_2->insert(R_EAX);
03463         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
03464         op_I_2->destroyed_by_get()->push_back(O_1);
03465         in_operands->push_back(op_I_2);
03466         ptr<set<tm_data_type_base::id_type> > dt_list_I_3 = set<tm_data_type_base::id_type>::create();
03467         dt_list_I_3->insert(DT_INT_32U);
03468         ptr<tm_instr_op_mem> op_I_3 = tm_instr_op_mem::create(I_3, dt_list_I_3);
03469         in_operands->push_back(op_I_3);
03470 
03471         //output operands
03472         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03473         dt_list_O_1->insert(DT_INT_32U);
03474         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03475         reg_list_O_1->insert(R_EAX);
03476         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03477         op_O_1->destroys_set(I_2);
03478         out_operands->push_back(op_O_1);
03479         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03480         dt_list_O_2->insert(DT_INT_32U);
03481         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03482         reg_list_O_2->insert(R_EDX);
03483         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03484         op_O_2->destroys_set(I_1);
03485         out_operands->push_back(op_O_2);
03486         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
03487         dt_list_O_3->insert(DT_COND);
03488         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
03489         reg_list_O_3->insert(R_COND);
03490         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
03491         out_operands->push_back(op_O_3);
03492 
03493         //execution info
03494         einfo = execution_info::create(720);
03495 
03496         //properties
03497 
03498         //versions
03499         versions = set<ulint>::create();
03500         versions->insert(INSTRUCTION_DIV__1);
03501         versions->insert(INSTRUCTION_DIV__11);
03502         versions->insert(INSTRUCTION_DIV__2);
03503         versions->insert(INSTRUCTION_DIV__21);
03504         versions->insert(INSTRUCTION_DIV__3);
03505 
03506 
03507         //return target pseudoinstruction
03508         return tm_instr::create(INSTRUCTION_DIV__31,in_operands,out_operands,lstring("div $TYPE_I_3 $I_3"), props,versions,0,einfo);
03509 }
03510 
03511 ptr<tm_instr> tm_instr_create_INSTRUCTION_NULLAH__1() {
03512         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03513         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03514         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03515         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03516         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03517         ptr<execution_info> einfo;
03518         ptr<set<ulint> > versions;
03519         
03520         //input operands
03521 
03522         //output operands
03523         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03524         dt_list_O_1->insert(DT_INT_8U);
03525         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03526         reg_list_O_1->insert(R_AH);
03527         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03528         out_operands->push_back(op_O_1);
03529 
03530         //execution info
03531         einfo = execution_info::create(10);
03532 
03533         //properties
03534 
03535         //versions
03536 
03537 
03538         //return target pseudoinstruction
03539         return tm_instr::create(INSTRUCTION_NULLAH__1,in_operands,out_operands,lstring("xor $O_1, $O_1"), props,versions,0,einfo);
03540 }
03541 
03542 ptr<tm_instr> tm_instr_create_INSTRUCTION_NULLDX__1() {
03543         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03544         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03545         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03546         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03547         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03548         ptr<execution_info> einfo;
03549         ptr<set<ulint> > versions;
03550         
03551         //input operands
03552 
03553         //output operands
03554         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03555         dt_list_O_1->insert(DT_INT_16U);
03556         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03557         reg_list_O_1->insert(R_DX);
03558         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03559         out_operands->push_back(op_O_1);
03560 
03561         //execution info
03562         einfo = execution_info::create(10);
03563 
03564         //properties
03565 
03566         //versions
03567 
03568 
03569         //return target pseudoinstruction
03570         return tm_instr::create(INSTRUCTION_NULLDX__1,in_operands,out_operands,lstring("xor $O_1, $O_1"), props,versions,0,einfo);
03571 }
03572 
03573 ptr<tm_instr> tm_instr_create_INSTRUCTION_NULLEDX__1() {
03574         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03575         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03576         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03577         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03578         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03579         ptr<execution_info> einfo;
03580         ptr<set<ulint> > versions;
03581         
03582         //input operands
03583 
03584         //output operands
03585         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03586         dt_list_O_1->insert(DT_INT_32U);
03587         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03588         reg_list_O_1->insert(R_EDX);
03589         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03590         out_operands->push_back(op_O_1);
03591 
03592         //execution info
03593         einfo = execution_info::create(10);
03594 
03595         //properties
03596 
03597         //versions
03598 
03599 
03600         //return target pseudoinstruction
03601         return tm_instr::create(INSTRUCTION_NULLEDX__1,in_operands,out_operands,lstring("xor $O_1, $O_1"), props,versions,0,einfo);
03602 }
03603 
03604 ptr<tm_instr> tm_instr_create_INSTRUCTION_IDIV__1() {
03605         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03606         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03607         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03608         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03609         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03610         ptr<execution_info> einfo;
03611         ptr<set<ulint> > versions;
03612         
03613         //input operands
03614         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03615         dt_list_I_1->insert(DT_INT_16S);
03616         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03617         reg_list_I_1->insert(R_AX);
03618         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03619         op_I_1->destroyed_by_get()->push_back(O_1);
03620         op_I_1->destroyed_by_get()->push_back(O_2);
03621         in_operands->push_back(op_I_1);
03622         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03623         dt_list_I_2->insert(DT_INT_8S);
03624         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
03625         reg_list_I_2->insert(R_AL);
03626         reg_list_I_2->insert(R_AH);
03627         reg_list_I_2->insert(R_BL);
03628         reg_list_I_2->insert(R_BH);
03629         reg_list_I_2->insert(R_CL);
03630         reg_list_I_2->insert(R_CH);
03631         reg_list_I_2->insert(R_DL);
03632         reg_list_I_2->insert(R_DH);
03633         reg_list_I_2->erase(R_AH);
03634         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
03635         in_operands->push_back(op_I_2);
03636 
03637         //output operands
03638         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03639         dt_list_O_1->insert(DT_INT_8S);
03640         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03641         reg_list_O_1->insert(R_AL);
03642         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03643         op_O_1->destroys_set(I_1);
03644         out_operands->push_back(op_O_1);
03645         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03646         dt_list_O_2->insert(DT_INT_8S);
03647         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03648         reg_list_O_2->insert(R_AH);
03649         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03650         op_O_2->destroys_set(I_1);
03651         out_operands->push_back(op_O_2);
03652         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
03653         dt_list_O_3->insert(DT_COND);
03654         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
03655         reg_list_O_3->insert(R_COND);
03656         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
03657         out_operands->push_back(op_O_3);
03658 
03659         //execution info
03660         einfo = execution_info::create(700);
03661 
03662         //properties
03663 
03664         //versions
03665         versions = set<ulint>::create();
03666         versions->insert(INSTRUCTION_IDIV__11);
03667         versions->insert(INSTRUCTION_IDIV__2);
03668         versions->insert(INSTRUCTION_IDIV__21);
03669         versions->insert(INSTRUCTION_IDIV__3);
03670         versions->insert(INSTRUCTION_IDIV__31);
03671 
03672 
03673         //return target pseudoinstruction
03674         return tm_instr::create(INSTRUCTION_IDIV__1,in_operands,out_operands,lstring("idiv $I_2"), props,versions,0,einfo);
03675 }
03676 
03677 ptr<tm_instr> tm_instr_create_INSTRUCTION_IDIV__11() {
03678         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03679         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03680         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03681         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03682         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03683         ptr<execution_info> einfo;
03684         ptr<set<ulint> > versions;
03685         
03686         //input operands
03687         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03688         dt_list_I_1->insert(DT_INT_16S);
03689         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03690         reg_list_I_1->insert(R_AX);
03691         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03692         op_I_1->destroyed_by_get()->push_back(O_1);
03693         op_I_1->destroyed_by_get()->push_back(O_2);
03694         in_operands->push_back(op_I_1);
03695         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03696         dt_list_I_2->insert(DT_INT_8S);
03697         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
03698         in_operands->push_back(op_I_2);
03699 
03700         //output operands
03701         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03702         dt_list_O_1->insert(DT_INT_8S);
03703         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03704         reg_list_O_1->insert(R_AL);
03705         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03706         op_O_1->destroys_set(I_1);
03707         out_operands->push_back(op_O_1);
03708         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03709         dt_list_O_2->insert(DT_INT_8S);
03710         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03711         reg_list_O_2->insert(R_AH);
03712         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03713         op_O_2->destroys_set(I_1);
03714         out_operands->push_back(op_O_2);
03715         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
03716         dt_list_O_3->insert(DT_COND);
03717         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
03718         reg_list_O_3->insert(R_COND);
03719         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
03720         out_operands->push_back(op_O_3);
03721 
03722         //execution info
03723         einfo = execution_info::create(720);
03724 
03725         //properties
03726 
03727         //versions
03728         versions = set<ulint>::create();
03729         versions->insert(INSTRUCTION_IDIV__1);
03730         versions->insert(INSTRUCTION_IDIV__2);
03731         versions->insert(INSTRUCTION_IDIV__21);
03732         versions->insert(INSTRUCTION_IDIV__3);
03733         versions->insert(INSTRUCTION_IDIV__31);
03734 
03735 
03736         //return target pseudoinstruction
03737         return tm_instr::create(INSTRUCTION_IDIV__11,in_operands,out_operands,lstring("idiv $TYPE_I_2 $I_2"), props,versions,0,einfo);
03738 }
03739 
03740 ptr<tm_instr> tm_instr_create_INSTRUCTION_IDIV__2() {
03741         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03742         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03743         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03744         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03745         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03746         ptr<execution_info> einfo;
03747         ptr<set<ulint> > versions;
03748         
03749         //input operands
03750         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03751         dt_list_I_1->insert(DT_INT_16S);
03752         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03753         reg_list_I_1->insert(R_DX);
03754         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03755         op_I_1->destroyed_by_get()->push_back(O_2);
03756         in_operands->push_back(op_I_1);
03757         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03758         dt_list_I_2->insert(DT_INT_16S);
03759         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
03760         reg_list_I_2->insert(R_AX);
03761         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
03762         op_I_2->destroyed_by_get()->push_back(O_1);
03763         in_operands->push_back(op_I_2);
03764         ptr<set<tm_data_type_base::id_type> > dt_list_I_3 = set<tm_data_type_base::id_type>::create();
03765         dt_list_I_3->insert(DT_INT_16S);
03766         ptr<set<tm_register_base::id_type> > reg_list_I_3 = set<tm_register_base::id_type>::create();
03767         reg_list_I_3->insert(R_AX);
03768         reg_list_I_3->insert(R_BX);
03769         reg_list_I_3->insert(R_CX);
03770         reg_list_I_3->insert(R_DX);
03771         reg_list_I_3->insert(R_DI);
03772         reg_list_I_3->insert(R_SI);
03773         reg_list_I_3->erase(R_DX);
03774         ptr<tm_instr_op_reg> op_I_3 = tm_instr_op_reg::create(I_3, dt_list_I_3, reg_list_I_3);
03775         in_operands->push_back(op_I_3);
03776 
03777         //output operands
03778         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03779         dt_list_O_1->insert(DT_INT_16S);
03780         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03781         reg_list_O_1->insert(R_AX);
03782         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03783         op_O_1->destroys_set(I_2);
03784         out_operands->push_back(op_O_1);
03785         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03786         dt_list_O_2->insert(DT_INT_16S);
03787         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03788         reg_list_O_2->insert(R_DX);
03789         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03790         op_O_2->destroys_set(I_1);
03791         out_operands->push_back(op_O_2);
03792         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
03793         dt_list_O_3->insert(DT_COND);
03794         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
03795         reg_list_O_3->insert(R_COND);
03796         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
03797         out_operands->push_back(op_O_3);
03798 
03799         //execution info
03800         einfo = execution_info::create(700);
03801 
03802         //properties
03803 
03804         //versions
03805         versions = set<ulint>::create();
03806         versions->insert(INSTRUCTION_IDIV__1);
03807         versions->insert(INSTRUCTION_IDIV__11);
03808         versions->insert(INSTRUCTION_IDIV__21);
03809         versions->insert(INSTRUCTION_IDIV__3);
03810         versions->insert(INSTRUCTION_IDIV__31);
03811 
03812 
03813         //return target pseudoinstruction
03814         return tm_instr::create(INSTRUCTION_IDIV__2,in_operands,out_operands,lstring("idiv $I_3"), props,versions,0,einfo);
03815 }
03816 
03817 ptr<tm_instr> tm_instr_create_INSTRUCTION_IDIV__21() {
03818         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03819         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03820         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03821         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03822         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03823         ptr<execution_info> einfo;
03824         ptr<set<ulint> > versions;
03825         
03826         //input operands
03827         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03828         dt_list_I_1->insert(DT_INT_16S);
03829         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03830         reg_list_I_1->insert(R_DX);
03831         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03832         op_I_1->destroyed_by_get()->push_back(O_2);
03833         in_operands->push_back(op_I_1);
03834         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03835         dt_list_I_2->insert(DT_INT_16S);
03836         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
03837         reg_list_I_2->insert(R_AX);
03838         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
03839         op_I_2->destroyed_by_get()->push_back(O_1);
03840         in_operands->push_back(op_I_2);
03841         ptr<set<tm_data_type_base::id_type> > dt_list_I_3 = set<tm_data_type_base::id_type>::create();
03842         dt_list_I_3->insert(DT_INT_16S);
03843         ptr<tm_instr_op_mem> op_I_3 = tm_instr_op_mem::create(I_3, dt_list_I_3);
03844         in_operands->push_back(op_I_3);
03845 
03846         //output operands
03847         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03848         dt_list_O_1->insert(DT_INT_16S);
03849         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03850         reg_list_O_1->insert(R_AX);
03851         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03852         op_O_1->destroys_set(I_2);
03853         out_operands->push_back(op_O_1);
03854         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03855         dt_list_O_2->insert(DT_INT_16S);
03856         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03857         reg_list_O_2->insert(R_DX);
03858         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03859         op_O_2->destroys_set(I_1);
03860         out_operands->push_back(op_O_2);
03861         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
03862         dt_list_O_3->insert(DT_COND);
03863         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
03864         reg_list_O_3->insert(R_COND);
03865         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
03866         out_operands->push_back(op_O_3);
03867 
03868         //execution info
03869         einfo = execution_info::create(720);
03870 
03871         //properties
03872 
03873         //versions
03874         versions = set<ulint>::create();
03875         versions->insert(INSTRUCTION_IDIV__1);
03876         versions->insert(INSTRUCTION_IDIV__11);
03877         versions->insert(INSTRUCTION_IDIV__2);
03878         versions->insert(INSTRUCTION_IDIV__3);
03879         versions->insert(INSTRUCTION_IDIV__31);
03880 
03881 
03882         //return target pseudoinstruction
03883         return tm_instr::create(INSTRUCTION_IDIV__21,in_operands,out_operands,lstring("idiv $TYPE_I_3 $I_3"), props,versions,0,einfo);
03884 }
03885 
03886 ptr<tm_instr> tm_instr_create_INSTRUCTION_IDIV__3() {
03887         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03888         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03889         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03890         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03891         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03892         ptr<execution_info> einfo;
03893         ptr<set<ulint> > versions;
03894         
03895         //input operands
03896         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03897         dt_list_I_1->insert(DT_INT_32S);
03898         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03899         reg_list_I_1->insert(R_EDX);
03900         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03901         op_I_1->destroyed_by_get()->push_back(O_2);
03902         in_operands->push_back(op_I_1);
03903         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03904         dt_list_I_2->insert(DT_INT_32S);
03905         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
03906         reg_list_I_2->insert(R_EAX);
03907         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
03908         op_I_2->destroyed_by_get()->push_back(O_1);
03909         in_operands->push_back(op_I_2);
03910         ptr<set<tm_data_type_base::id_type> > dt_list_I_3 = set<tm_data_type_base::id_type>::create();
03911         dt_list_I_3->insert(DT_INT_32S);
03912         ptr<set<tm_register_base::id_type> > reg_list_I_3 = set<tm_register_base::id_type>::create();
03913         reg_list_I_3->insert(R_EAX);
03914         reg_list_I_3->insert(R_EBX);
03915         reg_list_I_3->insert(R_ECX);
03916         reg_list_I_3->insert(R_EDX);
03917         reg_list_I_3->insert(R_EDI);
03918         reg_list_I_3->insert(R_ESI);
03919         reg_list_I_3->erase(R_EDX);
03920         ptr<tm_instr_op_reg> op_I_3 = tm_instr_op_reg::create(I_3, dt_list_I_3, reg_list_I_3);
03921         in_operands->push_back(op_I_3);
03922 
03923         //output operands
03924         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03925         dt_list_O_1->insert(DT_INT_32S);
03926         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03927         reg_list_O_1->insert(R_EAX);
03928         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03929         op_O_1->destroys_set(I_2);
03930         out_operands->push_back(op_O_1);
03931         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
03932         dt_list_O_2->insert(DT_INT_32S);
03933         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
03934         reg_list_O_2->insert(R_EDX);
03935         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
03936         op_O_2->destroys_set(I_1);
03937         out_operands->push_back(op_O_2);
03938         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
03939         dt_list_O_3->insert(DT_COND);
03940         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
03941         reg_list_O_3->insert(R_COND);
03942         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
03943         out_operands->push_back(op_O_3);
03944 
03945         //execution info
03946         einfo = execution_info::create(700);
03947 
03948         //properties
03949 
03950         //versions
03951         versions = set<ulint>::create();
03952         versions->insert(INSTRUCTION_IDIV__1);
03953         versions->insert(INSTRUCTION_IDIV__11);
03954         versions->insert(INSTRUCTION_IDIV__2);
03955         versions->insert(INSTRUCTION_IDIV__21);
03956         versions->insert(INSTRUCTION_IDIV__31);
03957 
03958 
03959         //return target pseudoinstruction
03960         return tm_instr::create(INSTRUCTION_IDIV__3,in_operands,out_operands,lstring("idiv $I_3"), props,versions,0,einfo);
03961 }
03962 
03963 ptr<tm_instr> tm_instr_create_INSTRUCTION_IDIV__31() {
03964         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
03965         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
03966         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
03967         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
03968         ptr<set<tm_data_type_base::id_type> > allowed_types; 
03969         ptr<execution_info> einfo;
03970         ptr<set<ulint> > versions;
03971         
03972         //input operands
03973         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
03974         dt_list_I_1->insert(DT_INT_32S);
03975         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
03976         reg_list_I_1->insert(R_EDX);
03977         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
03978         op_I_1->destroyed_by_get()->push_back(O_2);
03979         in_operands->push_back(op_I_1);
03980         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
03981         dt_list_I_2->insert(DT_INT_32S);
03982         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
03983         reg_list_I_2->insert(R_EAX);
03984         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
03985         op_I_2->destroyed_by_get()->push_back(O_1);
03986         in_operands->push_back(op_I_2);
03987         ptr<set<tm_data_type_base::id_type> > dt_list_I_3 = set<tm_data_type_base::id_type>::create();
03988         dt_list_I_3->insert(DT_INT_32S);
03989         ptr<tm_instr_op_mem> op_I_3 = tm_instr_op_mem::create(I_3, dt_list_I_3);
03990         in_operands->push_back(op_I_3);
03991 
03992         //output operands
03993         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
03994         dt_list_O_1->insert(DT_INT_32S);
03995         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
03996         reg_list_O_1->insert(R_EAX);
03997         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
03998         op_O_1->destroys_set(I_2);
03999         out_operands->push_back(op_O_1);
04000         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
04001         dt_list_O_2->insert(DT_INT_32S);
04002         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
04003         reg_list_O_2->insert(R_EDX);
04004         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
04005         op_O_2->destroys_set(I_1);
04006         out_operands->push_back(op_O_2);
04007         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
04008         dt_list_O_3->insert(DT_COND);
04009         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
04010         reg_list_O_3->insert(R_COND);
04011         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
04012         out_operands->push_back(op_O_3);
04013 
04014         //execution info
04015         einfo = execution_info::create(720);
04016 
04017         //properties
04018 
04019         //versions
04020         versions = set<ulint>::create();
04021         versions->insert(INSTRUCTION_IDIV__1);
04022         versions->insert(INSTRUCTION_IDIV__11);
04023         versions->insert(INSTRUCTION_IDIV__2);
04024         versions->insert(INSTRUCTION_IDIV__21);
04025         versions->insert(INSTRUCTION_IDIV__3);
04026 
04027 
04028         //return target pseudoinstruction
04029         return tm_instr::create(INSTRUCTION_IDIV__31,in_operands,out_operands,lstring("idiv $TYPE_I_3 $I_3"), props,versions,0,einfo);
04030 }
04031 
04032 ptr<tm_instr> tm_instr_create_INSTRUCTION_NEG__1() {
04033         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
04034         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
04035         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
04036         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
04037         ptr<set<tm_data_type_base::id_type> > allowed_types; 
04038         ptr<execution_info> einfo;
04039         ptr<set<ulint> > versions;
04040         
04041         //input operands
04042         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
04043         dt_list_I_1->insert(DT_INT_8P);
04044         dt_list_I_1->insert(DT_INT_8U);
04045         dt_list_I_1->insert(DT_INT_8S);
04046         dt_list_I_1->insert(DT_INT_16U);
04047         dt_list_I_1->insert(DT_INT_16S);
04048         dt_list_I_1->insert(DT_INT_32U);
04049         dt_list_I_1->insert(DT_INT_32S);
04050         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
04051         reg_list_I_1->insert(R_EAX);
04052         reg_list_I_1->insert(R_EBX);
04053         reg_list_I_1->insert(R_ECX);
04054         reg_list_I_1->insert(R_EDX);
04055         reg_list_I_1->insert(R_EDI);
04056         reg_list_I_1->insert(R_ESI);
04057         reg_list_I_1->insert(R_AX);
04058         reg_list_I_1->insert(R_BX);
04059         reg_list_I_1->insert(R_CX);
04060         reg_list_I_1->insert(R_DX);
04061         reg_list_I_1->insert(R_DI);
04062         reg_list_I_1->insert(R_SI);
04063         reg_list_I_1->insert(R_AL);
04064         reg_list_I_1->insert(R_AH);
04065         reg_list_I_1->insert(R_BL);
04066         reg_list_I_1->insert(R_BH);
04067         reg_list_I_1->insert(R_CL);
04068         reg_list_I_1->insert(R_CH);
04069         reg_list_I_1->insert(R_DL);
04070         reg_list_I_1->insert(R_DH);
04071         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
04072         op_I_1->destroyed_by_get()->push_back(O_1);
04073         in_operands->push_back(op_I_1);
04074 
04075         //output operands
04076         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
04077         dt_list_O_1->insert(DT_INT_8P);
04078         dt_list_O_1->insert(DT_INT_8U);
04079         dt_list_O_1->insert(DT_INT_8S);
04080         dt_list_O_1->insert(DT_INT_16U);
04081         dt_list_O_1->insert(DT_INT_16S);
04082         dt_list_O_1->insert(DT_INT_32U);
04083         dt_list_O_1->insert(DT_INT_32S);
04084         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
04085         reg_list_O_1->insert(R_EAX);
04086         reg_list_O_1->insert(R_EBX);
04087         reg_list_O_1->insert(R_ECX);
04088         reg_list_O_1->insert(R_EDX);
04089         reg_list_O_1->insert(R_EDI);
04090         reg_list_O_1->insert(R_ESI);
04091         reg_list_O_1->insert(R_AX);
04092         reg_list_O_1->insert(R_BX);
04093         reg_list_O_1->insert(R_CX);
04094         reg_list_O_1->insert(R_DX);
04095         reg_list_O_1->insert(R_DI);
04096         reg_list_O_1->insert(R_SI);
04097         reg_list_O_1->insert(R_AL);
04098         reg_list_O_1->insert(R_AH);
04099         reg_list_O_1->insert(R_BL);
04100         reg_list_O_1->insert(R_BH);
04101         reg_list_O_1->insert(R_CL);
04102         reg_list_O_1->insert(R_CH);
04103         reg_list_O_1->insert(R_DL);
04104         reg_list_O_1->insert(R_DH);
04105         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
04106         op_O_1->destroys_set(I_1);
04107         out_operands->push_back(op_O_1);
04108         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
04109         dt_list_O_2->insert(DT_COND);
04110         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
04111         reg_list_O_2->insert(R_COND);
04112         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
04113         out_operands->push_back(op_O_2);
04114 
04115         //execution info
04116         einfo = execution_info::create(10);
04117 
04118         //properties
04119 
04120         //versions
04121 
04122 
04123         //return target pseudoinstruction
04124         return tm_instr::create(INSTRUCTION_NEG__1,in_operands,out_operands,lstring("neg $I_1"), props,versions,0,einfo);
04125 }
04126 
04127 ptr<tm_instr> tm_instr_create_INSTRUCTION_SHL__1() {
04128         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
04129         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
04130         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
04131         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
04132         ptr<set<tm_data_type_base::id_type> > allowed_types; 
04133         ptr<execution_info> einfo;
04134         ptr<set<ulint> > versions;
04135         
04136         //input operands
04137         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
04138         dt_list_I_1->insert(DT_INT_8P);
04139         dt_list_I_1->insert(DT_INT_8U);
04140         dt_list_I_1->insert(DT_INT_8S);
04141         dt_list_I_1->insert(DT_INT_16U);
04142         dt_list_I_1->insert(DT_INT_16S);
04143         dt_list_I_1->insert(DT_INT_32U);
04144         dt_list_I_1->insert(DT_INT_32S);
04145         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
04146         reg_list_I_1->insert(R_EAX);
04147         reg_list_I_1->insert(R_EBX);
04148         reg_list_I_1->insert(R_ECX);
04149         reg_list_I_1->insert(R_EDX);
04150         reg_list_I_1->insert(R_EDI);
04151         reg_list_I_1->insert(R_ESI);
04152         reg_list_I_1->insert(R_AX);
04153         reg_list_I_1->insert(R_BX);
04154         reg_list_I_1->insert(R_CX);
04155         reg_list_I_1->insert(R_DX);
04156         reg_list_I_1->insert(R_DI);
04157         reg_list_I_1->insert(R_SI);
04158         reg_list_I_1->insert(R_AL);
04159         reg_list_I_1->insert(R_AH);
04160         reg_list_I_1->insert(R_BL);
04161         reg_list_I_1->insert(R_BH);
04162         reg_list_I_1->insert(R_CL);
04163         reg_list_I_1->insert(R_CH);
04164         reg_list_I_1->insert(R_DL);
04165         reg_list_I_1->insert(R_DH);
04166         reg_list_I_1->erase(R_CL);
04167         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
04168         op_I_1->destroyed_by_get()->push_back(O_1);
04169         in_operands->push_back(op_I_1);
04170         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
04171         dt_list_I_2->insert(DT_INT_8P);
04172         dt_list_I_2->insert(DT_INT_8U);
04173         dt_list_I_2->insert(DT_INT_8S);
04174         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
04175         reg_list_I_2->insert(R_CL);
04176         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
04177         in_operands->push_back(op_I_2);
04178 
04179         //output operands
04180         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
04181         dt_list_O_1->insert(DT_INT_8P);
04182         dt_list_O_1->insert(DT_INT_8U);
04183         dt_list_O_1->insert(DT_INT_8S);
04184         dt_list_O_1->insert(DT_INT_16U);
04185         dt_list_O_1->insert(DT_INT_16S);
04186         dt_list_O_1->insert(DT_INT_32U);
04187         dt_list_O_1->insert(DT_INT_32S);
04188         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
04189         reg_list_O_1->insert(R_EAX);
04190         reg_list_O_1->insert(R_EBX);
04191         reg_list_O_1->insert(R_ECX);
04192         reg_list_O_1->insert(R_EDX);
04193         reg_list_O_1->insert(R_EDI);
04194         reg_list_O_1->insert(R_ESI);
04195         reg_list_O_1->insert(R_AX);
04196         reg_list_O_1->insert(R_BX);
04197         reg_list_O_1->insert(R_CX);
04198         reg_list_O_1->insert(R_DX);
04199         reg_list_O_1->insert(R_DI);
04200         reg_list_O_1->insert(R_SI);
04201         reg_list_O_1->insert(R_AL);
04202         reg_list_O_1->insert(R_AH);
04203         reg_list_O_1->insert(R_BL);
04204         reg_list_O_1->insert(R_BH);
04205         reg_list_O_1->insert(R_CL);
04206         reg_list_O_1->insert(R_CH);
04207         reg_list_O_1->insert(R_DL);
04208         reg_list_O_1->insert(R_DH);
04209         reg_list_O_1->erase(R_CL);
04210         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
04211         op_O_1->destroys_set(I_1);
04212         out_operands->push_back(op_O_1);
04213         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
04214         dt_list_O_2->insert(DT_COND);
04215         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
04216         reg_list_O_2->insert(R_COND);
04217         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
04218         out_operands->push_back(op_O_2);
04219 
04220         //execution info
04221         einfo = execution_info::create(10);
04222 
04223         //properties
04224 
04225         //versions
04226 
04227 
04228         //return target pseudoinstruction
04229         return tm_instr::create(INSTRUCTION_SHL__1,in_operands,out_operands,lstring("shl $I_1, $I_2"), props,versions,0,einfo);
04230 }
04231 
04232 ptr<tm_instr> tm_instr_create_INSTRUCTION_SHR__1() {
04233         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
04234         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
04235         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
04236         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
04237         ptr<set<tm_data_type_base::id_type> > allowed_types; 
04238         ptr<execution_info> einfo;
04239         ptr<set<ulint> > versions;
04240         
04241         //input operands
04242         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
04243         dt_list_I_1->insert(DT_INT_8P);
04244         dt_list_I_1->insert(DT_INT_8U);
04245         dt_list_I_1->insert(DT_INT_8S);
04246         dt_list_I_1->insert(DT_INT_16U);
04247         dt_list_I_1->insert(DT_INT_16S);
04248         dt_list_I_1->insert(DT_INT_32U);
04249         dt_list_I_1->insert(DT_INT_32S);
04250         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
04251         reg_list_I_1->insert(R_EAX);
04252         reg_list_I_1->insert(R_EBX);
04253         reg_list_I_1->insert(R_ECX);
04254         reg_list_I_1->insert(R_EDX);
04255         reg_list_I_1->insert(R_EDI);
04256         reg_list_I_1->insert(R_ESI);
04257         reg_list_I_1->insert(R_AX);
04258         reg_list_I_1->insert(R_BX);
04259         reg_list_I_1->insert(R_CX);
04260         reg_list_I_1->insert(R_DX);
04261         reg_list_I_1->insert(R_DI);
04262         reg_list_I_1->insert(R_SI);
04263         reg_list_I_1->insert(R_AL);
04264         reg_list_I_1->insert(R_AH);
04265         reg_list_I_1->insert(R_BL);
04266         reg_list_I_1->insert(R_BH);
04267         reg_list_I_1->insert(R_CL);
04268         reg_list_I_1->insert(R_CH);
04269         reg_list_I_1->insert(R_DL);
04270         reg_list_I_1->insert(R_DH);
04271         reg_list_I_1->erase(R_CL);
04272         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
04273         op_I_1->destroyed_by_get()->push_back(O_1);
04274         in_operands->push_back(op_I_1);
04275         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
04276         dt_list_I_2->insert(DT_INT_8P);
04277         dt_list_I_2->insert(DT_INT_8U);
04278         dt_list_I_2->insert(DT_INT_8S);
04279         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
04280         reg_list_I_2->insert(R_CL);
04281         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
04282         in_operands->push_back(op_I_2);
04283 
04284         //output operands
04285         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
04286         dt_list_O_1->insert(DT_INT_8P);
04287         dt_list_O_1->insert(DT_INT_8U);
04288         dt_list_O_1->insert(DT_INT_8S);
04289         dt_list_O_1->insert(DT_INT_16U);
04290         dt_list_O_1->insert(DT_INT_16S);
04291         dt_list_O_1->insert(DT_INT_32U);
04292         dt_list_O_1->insert(DT_INT_32S);
04293         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
04294         reg_list_O_1->insert(R_EAX);
04295         reg_list_O_1->insert(R_EBX);
04296         reg_list_O_1->insert(R_ECX);
04297         reg_list_O_1->insert(R_EDX);
04298         reg_list_O_1->insert(R_EDI);
04299         reg_list_O_1->insert(R_ESI);
04300         reg_list_O_1->insert(R_AX);
04301         reg_list_O_1->insert(R_BX);
04302         reg_list_O_1->insert(R_CX);
04303         reg_list_O_1->insert(R_DX);
04304         reg_list_O_1->insert(R_DI);
04305         reg_list_O_1->insert(R_SI);
04306         reg_list_O_1->insert(R_AL);
04307         reg_list_O_1->insert(R_AH);
04308         reg_list_O_1->insert(R_BL);
04309         reg_list_O_1->insert(R_BH);
04310         reg_list_O_1->insert(R_CL);
04311         reg_list_O_1->insert(R_CH);
04312         reg_list_O_1->insert(R_DL);
04313         reg_list_O_1->insert(R_DH);
04314         reg_list_O_1->erase(R_CL);
04315         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
04316         op_O_1->destroys_set(I_1);
04317         out_operands->push_back(op_O_1);
04318         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
04319         dt_list_O_2->insert(DT_COND);
04320         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
04321         reg_list_O_2->insert(R_COND);
04322         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
04323         out_operands->push_back(op_O_2);
04324 
04325         //execution info
04326         einfo = execution_info::create(10);
04327 
04328         //properties
04329 
04330         //versions
04331 
04332 
04333         //return target pseudoinstruction
04334         return tm_instr::create(INSTRUCTION_SHR__1,in_operands,out_operands,lstring("shr $I_1, $I_2"), props,versions,0,einfo);
04335 }
04336 
04337 ptr<tm_instr> tm_instr_create_INSTRUCTION_SAL__1() {
04338         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
04339         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
04340         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
04341         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
04342         ptr<set<tm_data_type_base::id_type> > allowed_types; 
04343         ptr<execution_info> einfo;
04344         ptr<set<ulint> > versions;
04345         
04346         //input operands
04347         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
04348         dt_list_I_1->insert(DT_INT_8P);
04349         dt_list_I_1->insert(DT_INT_8U);
04350         dt_list_I_1->insert(DT_INT_8S);
04351         dt_list_I_1->insert(DT_INT_16U);
04352         dt_list_I_1->insert(DT_INT_16S);
04353         dt_list_I_1->insert(DT_INT_32U);
04354         dt_list_I_1->insert(DT_INT_32S);
04355         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
04356         reg_list_I_1->insert(R_EAX);
04357         reg_list_I_1->insert(R_EBX);
04358         reg_list_I_1->insert(R_ECX);
04359         reg_list_I_1->insert(R_EDX);
04360         reg_list_I_1->insert(R_EDI);
04361         reg_list_I_1->insert(R_ESI);
04362         reg_list_I_1->insert(R_AX);
04363         reg_list_I_1->insert(R_BX);
04364         reg_list_I_1->insert(R_CX);
04365         reg_list_I_1->insert(R_DX);
04366         reg_list_I_1->insert(R_DI);
04367         reg_list_I_1->insert(R_SI);
04368         reg_list_I_1->insert(R_AL);
04369         reg_list_I_1->insert(R_AH);
04370         reg_list_I_1->insert(R_BL);
04371         reg_list_I_1->insert(R_BH);
04372         reg_list_I_1->insert(R_CL);
04373         reg_list_I_1->insert(R_CH);
04374         reg_list_I_1->insert(R_DL);
04375         reg_list_I_1->insert(R_DH);
04376         reg_list_I_1->erase(R_CL);
04377         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
04378         op_I_1->destroyed_by_get()->push_back(O_1);
04379         in_operands->push_back(op_I_1);
04380         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
04381         dt_list_I_2->insert(DT_INT_8P);
04382         dt_list_I_2->insert(DT_INT_8U);
04383         dt_list_I_2->insert(DT_INT_8S);
04384         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
04385         reg_list_I_2->insert(R_CL);
04386         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
04387         in_operands->push_back(op_I_2);
04388 
04389         //output operands
04390         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
04391         dt_list_O_1->insert(DT_INT_8P);
04392         dt_list_O_1->insert(DT_INT_8U);
04393         dt_list_O_1->insert(DT_INT_8S);
04394         dt_list_O_1->insert(DT_INT_16U);
04395         dt_list_O_1->insert(DT_INT_16S);
04396         dt_list_O_1->insert(DT_INT_32U);
04397         dt_list_O_1->insert(DT_INT_32S);
04398         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
04399         reg_list_O_1->insert(R_EAX);
04400         reg_list_O_1->insert(R_EBX);
04401         reg_list_O_1->insert(R_ECX);
04402         reg_list_O_1->insert(R_EDX);
04403         reg_list_O_1->insert(R_EDI);
04404         reg_list_O_1->insert(R_ESI);
04405         reg_list_O_1->insert(R_AX);
04406         reg_list_O_1->insert(R_BX);
04407         reg_list_O_1->insert(R_CX);
04408         reg_list_O_1->insert(R_DX);
04409         reg_list_O_1->insert(R_DI);
04410         reg_list_O_1->insert(R_SI);
04411         reg_list_O_1->insert(R_AL);
04412         reg_list_O_1->insert(R_AH);
04413         reg_list_O_1->insert(R_BL);
04414         reg_list_O_1->insert(R_BH);
04415         reg_list_O_1->insert(R_CL);
04416         reg_list_O_1->insert(R_CH);
04417         reg_list_O_1->insert(R_DL);
04418         reg_list_O_1->insert(R_DH);
04419         reg_list_O_1->erase(R_CL);
04420         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
04421         op_O_1->destroys_set(I_1);
04422         out_operands->push_back(op_O_1);
04423         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
04424         dt_list_O_2->insert(DT_COND);
04425         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
04426         reg_list_O_2->insert(R_COND);
04427         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
04428         out_operands->push_back(op_O_2);
04429 
04430         //execution info
04431         einfo = execution_info::create(10);
04432 
04433         //properties
04434 
04435         //versions
04436 
04437 
04438         //return target pseudoinstruction
04439         return tm_instr::create(INSTRUCTION_SAL__1,in_operands,out_operands,lstring("sal $I_1, $I_2"), props,versions,0,einfo);
04440 }
04441 
04442 ptr<tm_instr> tm_instr_create_INSTRUCTION_SAR__1() {
04443         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
04444         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
04445         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
04446         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
04447         ptr<set<tm_data_type_base::id_type> > allowed_types; 
04448         ptr<execution_info> einfo;
04449         ptr<set<ulint> > versions;
04450         
04451         //input operands
04452         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
04453         dt_list_I_1->insert(DT_INT_8P);
04454         dt_list_I_1->insert(DT_INT_8U);
04455         dt_list_I_1->insert(DT_INT_8S);
04456         dt_list_I_1->insert(DT_INT_16U);
04457         dt_list_I_1->insert(DT_INT_16S);
04458         dt_list_I_1->insert(DT_INT_32U);
04459         dt_list_I_1->insert(DT_INT_32S);
04460         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
04461         reg_list_I_1->insert(R_EAX);
04462         reg_list_I_1->insert(R_EBX);
04463         reg_list_I_1->insert(R_ECX);
04464         reg_list_I_1->insert(R_EDX);
04465         reg_list_I_1->insert(R_EDI);
04466         reg_list_I_1->insert(R_ESI);
04467         reg_list_I_1->insert(R_AX);
04468         reg_list_I_1->insert(R_BX);
04469         reg_list_I_1->insert(R_CX);
04470         reg_list_I_1->insert(R_DX);
04471         reg_list_I_1->insert(R_DI);
04472         reg_list_I_1->insert(R_SI);
04473         reg_list_I_1->insert(R_AL);
04474         reg_list_I_1->insert(R_AH);
04475         reg_list_I_1->insert(R_BL);
04476         reg_list_I_1->insert(R_BH);
04477         reg_list_I_1->insert(R_CL);
04478         reg_list_I_1->insert(R_CH);
04479         reg_list_I_1->insert(R_DL);
04480         reg_list_I_1->insert(R_DH);
04481         reg_list_I_1->erase(R_CL);
04482         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
04483         op_I_1->destroyed_by_get()->push_back(O_1);
04484         in_operands->push_back(op_I_1);
04485         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
04486         dt_list_I_2->insert(DT_INT_8P);
04487         dt_list_I_2->insert(DT_INT_8U);
04488         dt_list_I_2->insert(DT_INT_8S);
04489         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
04490         reg_list_I_2->insert(R_CL);
04491         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
04492         in_operands->push_back(op_I_2);
04493 
04494         //output operands
04495         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
04496         dt_list_O_1->insert(DT_INT_8P);
04497         dt_list_O_1->insert(DT_INT_8U);
04498         dt_list_O_1->insert(DT_INT_8S);
04499         dt_list_O_1->insert(DT_INT_16U);
04500         dt_list_O_1->insert(DT_INT_16S);
04501         dt_list_O_1->insert(DT_INT_32U);
04502         dt_list_O_1->insert(DT_INT_32S);
04503         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
04504         reg_list_O_1->insert(R_EAX);
04505         reg_list_O_1->insert(R_EBX);
04506         reg_list_O_1->insert(R_ECX);
04507         reg_list_O_1->insert(R_EDX);
04508         reg_list_O_1->insert(R_EDI);
04509         reg_list_O_1->insert(R_ESI);
04510         reg_list_O_1->insert(R_AX);
04511         reg_list_O_1->insert(R_BX);
04512         reg_list_O_1->insert(R_CX);
04513         reg_list_O_1->insert(R_DX);
04514         reg_list_O_1->insert(R_DI);
04515         reg_list_O_1->insert(R_SI);
04516         reg_list_O_1->insert(R_AL);
04517         reg_list_O_1->insert(R_AH);
04518         reg_list_O_1->insert(R_BL);
04519         reg_list_O_1->insert(R_BH);
04520         reg_list_O_1->insert(R_CL);
04521         reg_list_O_1->insert(R_CH);
04522         reg_list_O_1->insert(R_DL);
04523         reg_list_O_1->insert(R_DH);
04524         reg_list_O_1->erase(R_CL);
04525         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
04526         op_O_1->destroys_set(I_1);
04527         out_operands->push_back(op_O_1);
04528         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
04529         dt_list_O_2->insert(DT_COND);
04530         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
04531         reg_list_O_2->insert(R_COND);
04532         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
04533         out_operands->push_back(op_O_2);
04534 
04535         //execution info
04536         einfo = execution_info::create(10);
04537 
04538         //properties
04539 
04540         //versions
04541 
04542 
04543         //return target pseudoinstruction
04544         return tm_instr::create(INSTRUCTION_SAR__1,in_operands,out_operands,lstring("sar $I_1, $I_2"), props,versions,0,einfo);
04545 }
04546 
04547 ptr<tm_instr> tm_instr_create_INSTRUCTION_AND__1() {
04548         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
04549         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
04550         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
04551         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
04552         ptr<set<tm_data_type_base::id_type> > allowed_types; 
04553         ptr<execution_info> einfo;
04554         ptr<set<ulint> > versions;
04555         
04556         //input operands
04557         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
04558         dt_list_I_1->insert(DT_INT_8P);
04559         dt_list_I_1->insert(DT_INT_8U);
04560         dt_list_I_1->insert(DT_INT_8S);
04561         dt_list_I_1->insert(DT_INT_16U);
04562         dt_list_I_1->insert(DT_INT_16S);
04563         dt_list_I_1->insert(DT_INT_32U);
04564         dt_list_I_1->insert(DT_INT_32S);
04565         dt_list_I_1->insert(DT_BOOL);
04566         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
04567         reg_list_I_1->insert(R_EAX);
04568         reg_list_I_1->insert(R_EBX);
04569         reg_list_I_1->insert(R_ECX);
04570         reg_list_I_1->insert(R_EDX);
04571         reg_list_I_1->insert(R_EDI);
04572         reg_list_I_1->insert(R_ESI);
04573         reg_list_I_1->insert(R_AX);
04574         reg_list_I_1->insert(R_BX);
04575         reg_list_I_1->insert(R_CX);
04576         reg_list_I_1->insert(R_DX);
04577         reg_list_I_1->insert(R_DI);
04578         reg_list_I_1->insert(R_SI);
04579         reg_list_I_1->insert(R_AL);
04580         reg_list_I_1->insert(R_AH);
04581         reg_list_I_1->insert(R_BL);
04582         reg_list_I_1->insert(R_BH);
04583         reg_list_I_1->insert(R_CL);
04584         reg_list_I_1->insert(R_CH);
04585         reg_list_I_1->insert(R_DL);
04586         reg_list_I_1->insert(R_DH);
04587         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
04588         op_I_1->destroyed_by_get()->push_back(O_1);
04589         in_operands->push_back(op_I_1);
04590         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
04591         dt_list_I_2->insert(DT_INT_8P);
04592         dt_list_I_2->insert(DT_INT_8U);
04593         dt_list_I_2->insert(DT_INT_8S);
04594         dt_list_I_2->insert(DT_INT_16U);
04595         dt_list_I_2->insert(DT_INT_16S);
04596         dt_list_I_2->insert(DT_INT_32U);
04597         dt_list_I_2->insert(DT_INT_32S);
04598         dt_list_I_2->insert(DT_BOOL);
04599         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
04600         reg_list_I_2->insert(R_EAX);
04601         reg_list_I_2->insert(R_EBX);
04602         reg_list_I_2->insert(R_ECX);
04603         reg_list_I_2->insert(R_EDX);
04604         reg_list_I_2->insert(R_EDI);
04605         reg_list_I_2->insert(R_ESI);
04606         reg_list_I_2->insert(R_AX);
04607         reg_list_I_2->insert(R_BX);
04608         reg_list_I_2->insert(R_CX);
04609         reg_list_I_2->insert(R_DX);
04610         reg_list_I_2->insert(R_DI);
04611         reg_list_I_2->insert(R_SI);
04612         reg_list_I_2->insert(R_AL);
04613         reg_list_I_2->insert(R_AH);
04614         reg_list_I_2->insert(R_BL);
04615         reg_list_I_2->insert(R_BH);
04616         reg_list_I_2->insert(R_CL);
04617         reg_list_I_2->insert(R_CH);
04618         reg_list_I_2->insert(R_DL);
04619         reg_list_I_2->insert(R_DH);
04620         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
04621         in_operands->push_back(op_I_2);
04622 
04623         //output operands
04624         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
04625         dt_list_O_1->insert(DT_INT_8P);
04626         dt_list_O_1->insert(DT_INT_8U);
04627         dt_list_O_1->insert(DT_INT_8S);
04628         dt_list_O_1->insert(DT_INT_16U);
04629         dt_list_O_1->insert(DT_INT_16S);
04630         dt_list_O_1->insert(DT_INT_32U);
04631         dt_list_O_1->insert(DT_INT_32S);
04632         dt_list_O_1->insert(DT_BOOL);
04633         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
04634         reg_list_O_1->insert(R_EAX);
04635         reg_list_O_1->insert(R_EBX);
04636         reg_list_O_1->insert(R_ECX);
04637         reg_list_O_1->insert(R_EDX);
04638         reg_list_O_1->insert(R_EDI);
04639         reg_list_O_1->insert(R_ESI);
04640         reg_list_O_1->insert(R_AX);
04641         reg_list_O_1->insert(R_BX);
04642         reg_list_O_1->insert(R_CX);
04643         reg_list_O_1->insert(R_DX);
04644         reg_list_O_1->insert(R_DI);
04645         reg_list_O_1->insert(R_SI);
04646         reg_list_O_1->insert(R_AL);
04647         reg_list_O_1->insert(R_AH);
04648         reg_list_O_1->insert(R_BL);
04649         reg_list_O_1->insert(R_BH);
04650         reg_list_O_1->insert(R_CL);
04651         reg_list_O_1->insert(R_CH);
04652         reg_list_O_1->insert(R_DL);
04653         reg_list_O_1->insert(R_DH);
04654         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
04655         op_O_1->destroys_set(I_1);
04656         out_operands->push_back(op_O_1);
04657         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
04658         dt_list_O_2->insert(DT_COND);
04659         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
04660         reg_list_O_2->insert(R_COND);
04661         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
04662         out_operands->push_back(op_O_2);
04663 
04664         //execution info
04665         einfo = execution_info::create(10);
04666 
04667         //properties
04668 
04669         //versions
04670         versions = set<ulint>::create();
04671         versions->insert(INSTRUCTION_AND__11);
04672         versions->insert(INSTRUCTION_AND__12);
04673         versions->insert(INSTRUCTION_AND__13);
04674         versions->insert(INSTRUCTION_AND__14);
04675         versions->insert(INSTRUCTION_AND__2);
04676 
04677 
04678         //return target pseudoinstruction
04679         return tm_instr::create(INSTRUCTION_AND__1,in_operands,out_operands,lstring("and $O_1, $I_2"), props,versions,0,einfo);
04680 }
04681 
04682 ptr<tm_instr> tm_instr_create_INSTRUCTION_AND__11() {
04683         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
04684         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
04685         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
04686         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
04687         ptr<set<tm_data_type_base::id_type> > allowed_types; 
04688         ptr<execution_info> einfo;
04689         ptr<set<ulint> > versions;
04690         
04691         //input operands
04692         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
04693         dt_list_I_1->insert(DT_INT_8P);
04694         dt_list_I_1->insert(DT_INT_8U);
04695         dt_list_I_1->insert(DT_INT_8S);
04696         dt_list_I_1->insert(DT_INT_16U);
04697         dt_list_I_1->insert(DT_INT_16S);
04698         dt_list_I_1->insert(DT_INT_32U);
04699         dt_list_I_1->insert(DT_INT_32S);
04700         dt_list_I_1->insert(DT_BOOL);
04701         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
04702         reg_list_I_1->insert(R_EAX);
04703         reg_list_I_1->insert(R_EBX);
04704         reg_list_I_1->insert(R_ECX);
04705         reg_list_I_1->insert(R_EDX);
04706         reg_list_I_1->insert(R_EDI);
04707         reg_list_I_1->insert(R_ESI);
04708         reg_list_I_1->insert(R_AX);
04709         reg_list_I_1->insert(R_BX);
04710         reg_list_I_1->insert(R_CX);
04711         reg_list_I_1->insert(R_DX);
04712         reg_list_I_1->insert(R_DI);
04713         reg_list_I_1->insert(R_SI);
04714         reg_list_I_1->insert(R_AL);
04715         reg_list_I_1->insert(R_AH);
04716         reg_list_I_1->insert(R_BL);
04717         reg_list_I_1->insert(R_BH);
04718         reg_list_I_1->insert(R_CL);
04719         reg_list_I_1->insert(R_CH);
04720         reg_list_I_1->insert(R_DL);
04721         reg_list_I_1->insert(R_DH);
04722         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
04723         op_I_1->destroyed_by_get()->push_back(O_1);
04724         in_operands->push_back(op_I_1);
04725         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
04726         dt_list_I_2->insert(DT_INT_8P);
04727         dt_list_I_2->insert(DT_INT_8U);
04728         dt_list_I_2->insert(DT_INT_8S);
04729         dt_list_I_2->insert(DT_INT_16U);
04730         dt_list_I_2->insert(DT_INT_16S);
04731         dt_list_I_2->insert(DT_INT_32U);
04732         dt_list_I_2->insert(DT_INT_32S);
04733         dt_list_I_2->insert(DT_BOOL);
04734         ptr<tm_instr_op_imm> op_I_2 = tm_instr_op_imm::create(I_2, dt_list_I_2);
04735         in_operands->push_back(op_I_2);
04736 
04737         //output operands
04738         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
04739         dt_list_O_1->insert(DT_INT_8P);
04740         dt_list_O_1->insert(DT_INT_8U);
04741         dt_list_O_1->insert(DT_INT_8S);
04742         dt_list_O_1->insert(DT_INT_16U);
04743         dt_list_O_1->insert(DT_INT_16S);
04744         dt_list_O_1->insert(DT_INT_32U);
04745         dt_list_O_1->insert(DT_INT_32S);
04746         dt_list_O_1->insert(DT_BOOL);
04747         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
04748         reg_list_O_1->insert(R_EAX);
04749         reg_list_O_1->insert(R_EBX);
04750         reg_list_O_1->insert(R_ECX);
04751         reg_list_O_1->insert(R_EDX);
04752         reg_list_O_1->insert(R_EDI);
04753         reg_list_O_1->insert(R_ESI);
04754         reg_list_O_1->insert(R_AX);
04755         reg_list_O_1->insert(R_BX);
04756         reg_list_O_1->insert(R_CX);
04757         reg_list_O_1->insert(R_DX);
04758         reg_list_O_1->insert(R_DI);
04759         reg_list_O_1->insert(R_SI);
04760         reg_list_O_1->insert(R_AL);
04761         reg_list_O_1->insert(R_AH);
04762         reg_list_O_1->insert(R_BL);
04763         reg_list_O_1->insert(R_BH);
04764         reg_list_O_1->insert(R_CL);
04765         reg_list_O_1->insert(R_CH);
04766         reg_list_O_1->insert(R_DL);
04767         reg_list_O_1->insert(R_DH);
04768         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
04769         op_O_1->destroys_set(I_1);
04770         out_operands->push_back(op_O_1);
04771         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
04772         dt_list_O_2->insert(DT_COND);
04773         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
04774         reg_list_O_2->insert(R_COND);
04775         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
04776         out_operands->push_back(op_O_2);
04777 
04778         //execution info
04779         einfo = execution_info::create(10);
04780 
04781         //properties
04782 
04783         //versions
04784         versions = set<ulint>::create();
04785         versions->insert(INSTRUCTION_AND__1);
04786         versions->insert(INSTRUCTION_AND__12);
04787         versions->insert(INSTRUCTION_AND__13);
04788         versions->insert(INSTRUCTION_AND__14);
04789         versions->insert(INSTRUCTION_AND__2);
04790 
04791 
04792         //return target pseudoinstruction
04793         return tm_instr::create(INSTRUCTION_AND__11,in_operands,out_operands,lstring("and $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
04794 }
04795 
04796 ptr<tm_instr> tm_instr_create_INSTRUCTION_AND__12() {
04797         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
04798         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
04799         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
04800         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
04801         ptr<set<tm_data_type_base::id_type> > allowed_types; 
04802         ptr<execution_info> einfo;
04803         ptr<set<ulint> > versions;
04804         
04805         //input operands
04806         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
04807         dt_list_I_1->insert(DT_INT_8P);
04808         dt_list_I_1->insert(DT_INT_8U);
04809         dt_list_I_1->insert(DT_INT_8S);
04810         dt_list_I_1->insert(DT_INT_16U);
04811         dt_list_I_1->insert(DT_INT_16S);
04812         dt_list_I_1->insert(DT_INT_32U);
04813         dt_list_I_1->insert(DT_INT_32S);
04814         dt_list_I_1->insert(DT_BOOL);
04815         ptr<tm_instr_op_imm> op_I_1 = tm_instr_op_imm::create(I_1, dt_list_I_1);
04816         in_operands->push_back(op_I_1);
04817         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
04818         dt_list_I_2->insert(DT_INT_8P);
04819         dt_list_I_2->insert(DT_INT_8U);
04820         dt_list_I_2->insert(DT_INT_8S);
04821         dt_list_I_2->insert(DT_INT_16U);
04822         dt_list_I_2->insert(DT_INT_16S);
04823         dt_list_I_2->insert(DT_INT_32U);
04824         dt_list_I_2->insert(DT_INT_32S);
04825         dt_list_I_2->insert(DT_BOOL);
04826         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
04827         reg_list_I_2->insert(R_EAX);
04828         reg_list_I_2->insert(R_EBX);
04829         reg_list_I_2->insert(R_ECX);
04830         reg_list_I_2->insert(R_EDX);
04831         reg_list_I_2->insert(R_EDI);
04832         reg_list_I_2->insert(R_ESI);
04833         reg_list_I_2->insert(R_AX);
04834         reg_list_I_2->insert(R_BX);
04835         reg_list_I_2->insert(R_CX);
04836         reg_list_I_2->insert(R_DX);
04837         reg_list_I_2->insert(R_DI);
04838         reg_list_I_2->insert(R_SI);
04839         reg_list_I_2->insert(R_AL);
04840         reg_list_I_2->insert(R_AH);
04841         reg_list_I_2->insert(R_BL);
04842         reg_list_I_2->insert(R_BH);
04843         reg_list_I_2->insert(R_CL);
04844         reg_list_I_2->insert(R_CH);
04845         reg_list_I_2->insert(R_DL);
04846         reg_list_I_2->insert(R_DH);
04847         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
04848         op_I_2->destroyed_by_get()->push_back(O_1);
04849         in_operands->push_back(op_I_2);
04850 
04851         //output operands
04852         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
04853         dt_list_O_1->insert(DT_INT_8P);
04854         dt_list_O_1->insert(DT_INT_8U);
04855         dt_list_O_1->insert(DT_INT_8S);
04856         dt_list_O_1->insert(DT_INT_16U);
04857         dt_list_O_1->insert(DT_INT_16S);
04858         dt_list_O_1->insert(DT_INT_32U);
04859         dt_list_O_1->insert(DT_INT_32S);
04860         dt_list_O_1->insert(DT_BOOL);
04861         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
04862         reg_list_O_1->insert(R_EAX);
04863         reg_list_O_1->insert(R_EBX);
04864         reg_list_O_1->insert(R_ECX);
04865         reg_list_O_1->insert(R_EDX);
04866         reg_list_O_1->insert(R_EDI);
04867         reg_list_O_1->insert(R_ESI);
04868         reg_list_O_1->insert(R_AX);
04869         reg_list_O_1->insert(R_BX);
04870         reg_list_O_1->insert(R_CX);
04871         reg_list_O_1->insert(R_DX);
04872         reg_list_O_1->insert(R_DI);
04873         reg_list_O_1->insert(R_SI);
04874         reg_list_O_1->insert(R_AL);
04875         reg_list_O_1->insert(R_AH);
04876         reg_list_O_1->insert(R_BL);
04877         reg_list_O_1->insert(R_BH);
04878         reg_list_O_1->insert(R_CL);
04879         reg_list_O_1->insert(R_CH);
04880         reg_list_O_1->insert(R_DL);
04881         reg_list_O_1->insert(R_DH);
04882         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
04883         op_O_1->destroys_set(I_2);
04884         out_operands->push_back(op_O_1);
04885         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
04886         dt_list_O_2->insert(DT_COND);
04887         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
04888         reg_list_O_2->insert(R_COND);
04889         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
04890         out_operands->push_back(op_O_2);
04891 
04892         //execution info
04893         einfo = execution_info::create(10);
04894 
04895         //properties
04896 
04897         //versions
04898         versions = set<ulint>::create();
04899         versions->insert(INSTRUCTION_AND__1);
04900         versions->insert(INSTRUCTION_AND__11);
04901         versions->insert(INSTRUCTION_AND__13);
04902         versions->insert(INSTRUCTION_AND__14);
04903         versions->insert(INSTRUCTION_AND__2);
04904 
04905 
04906         //return target pseudoinstruction
04907         return tm_instr::create(INSTRUCTION_AND__12,in_operands,out_operands,lstring("and $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
04908 }
04909 
04910 ptr<tm_instr> tm_instr_create_INSTRUCTION_AND__13() {
04911         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
04912         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
04913         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
04914         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
04915         ptr<set<tm_data_type_base::id_type> > allowed_types; 
04916         ptr<execution_info> einfo;
04917         ptr<set<ulint> > versions;
04918         
04919         //input operands
04920         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
04921         dt_list_I_1->insert(DT_INT_8P);
04922         dt_list_I_1->insert(DT_INT_8U);
04923         dt_list_I_1->insert(DT_INT_8S);
04924         dt_list_I_1->insert(DT_INT_16U);
04925         dt_list_I_1->insert(DT_INT_16S);
04926         dt_list_I_1->insert(DT_INT_32U);
04927         dt_list_I_1->insert(DT_INT_32S);
04928         dt_list_I_1->insert(DT_BOOL);
04929         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
04930         reg_list_I_1->insert(R_EAX);
04931         reg_list_I_1->insert(R_EBX);
04932         reg_list_I_1->insert(R_ECX);
04933         reg_list_I_1->insert(R_EDX);
04934         reg_list_I_1->insert(R_EDI);
04935         reg_list_I_1->insert(R_ESI);
04936         reg_list_I_1->insert(R_AX);
04937         reg_list_I_1->insert(R_BX);
04938         reg_list_I_1->insert(R_CX);
04939         reg_list_I_1->insert(R_DX);
04940         reg_list_I_1->insert(R_DI);
04941         reg_list_I_1->insert(R_SI);
04942         reg_list_I_1->insert(R_AL);
04943         reg_list_I_1->insert(R_AH);
04944         reg_list_I_1->insert(R_BL);
04945         reg_list_I_1->insert(R_BH);
04946         reg_list_I_1->insert(R_CL);
04947         reg_list_I_1->insert(R_CH);
04948         reg_list_I_1->insert(R_DL);
04949         reg_list_I_1->insert(R_DH);
04950         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
04951         op_I_1->destroyed_by_get()->push_back(O_1);
04952         in_operands->push_back(op_I_1);
04953         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
04954         dt_list_I_2->insert(DT_INT_8P);
04955         dt_list_I_2->insert(DT_INT_8U);
04956         dt_list_I_2->insert(DT_INT_8S);
04957         dt_list_I_2->insert(DT_INT_16U);
04958         dt_list_I_2->insert(DT_INT_16S);
04959         dt_list_I_2->insert(DT_INT_32U);
04960         dt_list_I_2->insert(DT_INT_32S);
04961         dt_list_I_2->insert(DT_BOOL);
04962         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
04963         in_operands->push_back(op_I_2);
04964 
04965         //output operands
04966         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
04967         dt_list_O_1->insert(DT_INT_8P);
04968         dt_list_O_1->insert(DT_INT_8U);
04969         dt_list_O_1->insert(DT_INT_8S);
04970         dt_list_O_1->insert(DT_INT_16U);
04971         dt_list_O_1->insert(DT_INT_16S);
04972         dt_list_O_1->insert(DT_INT_32U);
04973         dt_list_O_1->insert(DT_INT_32S);
04974         dt_list_O_1->insert(DT_BOOL);
04975         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
04976         reg_list_O_1->insert(R_EAX);
04977         reg_list_O_1->insert(R_EBX);
04978         reg_list_O_1->insert(R_ECX);
04979         reg_list_O_1->insert(R_EDX);
04980         reg_list_O_1->insert(R_EDI);
04981         reg_list_O_1->insert(R_ESI);
04982         reg_list_O_1->insert(R_AX);
04983         reg_list_O_1->insert(R_BX);
04984         reg_list_O_1->insert(R_CX);
04985         reg_list_O_1->insert(R_DX);
04986         reg_list_O_1->insert(R_DI);
04987         reg_list_O_1->insert(R_SI);
04988         reg_list_O_1->insert(R_AL);
04989         reg_list_O_1->insert(R_AH);
04990         reg_list_O_1->insert(R_BL);
04991         reg_list_O_1->insert(R_BH);
04992         reg_list_O_1->insert(R_CL);
04993         reg_list_O_1->insert(R_CH);
04994         reg_list_O_1->insert(R_DL);
04995         reg_list_O_1->insert(R_DH);
04996         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
04997         op_O_1->destroys_set(I_1);
04998         out_operands->push_back(op_O_1);
04999         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
05000         dt_list_O_2->insert(DT_COND);
05001         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
05002         reg_list_O_2->insert(R_COND);
05003         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
05004         out_operands->push_back(op_O_2);
05005 
05006         //execution info
05007         einfo = execution_info::create(30);
05008 
05009         //properties
05010 
05011         //versions
05012         versions = set<ulint>::create();
05013         versions->insert(INSTRUCTION_AND__1);
05014         versions->insert(INSTRUCTION_AND__11);
05015         versions->insert(INSTRUCTION_AND__12);
05016         versions->insert(INSTRUCTION_AND__14);
05017         versions->insert(INSTRUCTION_AND__2);
05018 
05019 
05020         //return target pseudoinstruction
05021         return tm_instr::create(INSTRUCTION_AND__13,in_operands,out_operands,lstring("and $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
05022 }
05023 
05024 ptr<tm_instr> tm_instr_create_INSTRUCTION_AND__14() {
05025         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
05026         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
05027         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
05028         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
05029         ptr<set<tm_data_type_base::id_type> > allowed_types; 
05030         ptr<execution_info> einfo;
05031         ptr<set<ulint> > versions;
05032         
05033         //input operands
05034         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
05035         dt_list_I_1->insert(DT_INT_8P);
05036         dt_list_I_1->insert(DT_INT_8U);
05037         dt_list_I_1->insert(DT_INT_8S);
05038         dt_list_I_1->insert(DT_INT_16U);
05039         dt_list_I_1->insert(DT_INT_16S);
05040         dt_list_I_1->insert(DT_INT_32U);
05041         dt_list_I_1->insert(DT_INT_32S);
05042         dt_list_I_1->insert(DT_BOOL);
05043         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
05044         in_operands->push_back(op_I_1);
05045         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
05046         dt_list_I_2->insert(DT_INT_8P);
05047         dt_list_I_2->insert(DT_INT_8U);
05048         dt_list_I_2->insert(DT_INT_8S);
05049         dt_list_I_2->insert(DT_INT_16U);
05050         dt_list_I_2->insert(DT_INT_16S);
05051         dt_list_I_2->insert(DT_INT_32U);
05052         dt_list_I_2->insert(DT_INT_32S);
05053         dt_list_I_2->insert(DT_BOOL);
05054         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
05055         reg_list_I_2->insert(R_EAX);
05056         reg_list_I_2->insert(R_EBX);
05057         reg_list_I_2->insert(R_ECX);
05058         reg_list_I_2->insert(R_EDX);
05059         reg_list_I_2->insert(R_EDI);
05060         reg_list_I_2->insert(R_ESI);
05061         reg_list_I_2->insert(R_AX);
05062         reg_list_I_2->insert(R_BX);
05063         reg_list_I_2->insert(R_CX);
05064         reg_list_I_2->insert(R_DX);
05065         reg_list_I_2->insert(R_DI);
05066         reg_list_I_2->insert(R_SI);
05067         reg_list_I_2->insert(R_AL);
05068         reg_list_I_2->insert(R_AH);
05069         reg_list_I_2->insert(R_BL);
05070         reg_list_I_2->insert(R_BH);
05071         reg_list_I_2->insert(R_CL);
05072         reg_list_I_2->insert(R_CH);
05073         reg_list_I_2->insert(R_DL);
05074         reg_list_I_2->insert(R_DH);
05075         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
05076         op_I_2->destroyed_by_get()->push_back(O_1);
05077         in_operands->push_back(op_I_2);
05078 
05079         //output operands
05080         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
05081         dt_list_O_1->insert(DT_INT_8P);
05082         dt_list_O_1->insert(DT_INT_8U);
05083         dt_list_O_1->insert(DT_INT_8S);
05084         dt_list_O_1->insert(DT_INT_16U);
05085         dt_list_O_1->insert(DT_INT_16S);
05086         dt_list_O_1->insert(DT_INT_32U);
05087         dt_list_O_1->insert(DT_INT_32S);
05088         dt_list_O_1->insert(DT_BOOL);
05089         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
05090         reg_list_O_1->insert(R_EAX);
05091         reg_list_O_1->insert(R_EBX);
05092         reg_list_O_1->insert(R_ECX);
05093         reg_list_O_1->insert(R_EDX);
05094         reg_list_O_1->insert(R_EDI);
05095         reg_list_O_1->insert(R_ESI);
05096         reg_list_O_1->insert(R_AX);
05097         reg_list_O_1->insert(R_BX);
05098         reg_list_O_1->insert(R_CX);
05099         reg_list_O_1->insert(R_DX);
05100         reg_list_O_1->insert(R_DI);
05101         reg_list_O_1->insert(R_SI);
05102         reg_list_O_1->insert(R_AL);
05103         reg_list_O_1->insert(R_AH);
05104         reg_list_O_1->insert(R_BL);
05105         reg_list_O_1->insert(R_BH);
05106         reg_list_O_1->insert(R_CL);
05107         reg_list_O_1->insert(R_CH);
05108         reg_list_O_1->insert(R_DL);
05109         reg_list_O_1->insert(R_DH);
05110         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
05111         op_O_1->destroys_set(I_2);
05112         out_operands->push_back(op_O_1);
05113         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
05114         dt_list_O_2->insert(DT_COND);
05115         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
05116         reg_list_O_2->insert(R_COND);
05117         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
05118         out_operands->push_back(op_O_2);
05119 
05120         //execution info
05121         einfo = execution_info::create(30);
05122 
05123         //properties
05124 
05125         //versions
05126         versions = set<ulint>::create();
05127         versions->insert(INSTRUCTION_AND__1);
05128         versions->insert(INSTRUCTION_AND__11);
05129         versions->insert(INSTRUCTION_AND__12);
05130         versions->insert(INSTRUCTION_AND__13);
05131         versions->insert(INSTRUCTION_AND__2);
05132 
05133 
05134         //return target pseudoinstruction
05135         return tm_instr::create(INSTRUCTION_AND__14,in_operands,out_operands,lstring("and $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
05136 }
05137 
05138 ptr<tm_instr> tm_instr_create_INSTRUCTION_AND__2() {
05139         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
05140         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
05141         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
05142         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
05143         ptr<set<tm_data_type_base::id_type> > allowed_types; 
05144         ptr<execution_info> einfo;
05145         ptr<set<ulint> > versions;
05146         
05147         //input operands
05148         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
05149         dt_list_I_1->insert(DT_BOOL);
05150         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
05151         reg_list_I_1->insert(R_AL);
05152         reg_list_I_1->insert(R_AH);
05153         reg_list_I_1->insert(R_BL);
05154         reg_list_I_1->insert(R_BH);
05155         reg_list_I_1->insert(R_CL);
05156         reg_list_I_1->insert(R_CH);
05157         reg_list_I_1->insert(R_DL);
05158         reg_list_I_1->insert(R_DH);
05159         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
05160         op_I_1->destroyed_by_get()->push_back(O_1);
05161         in_operands->push_back(op_I_1);
05162 
05163         //output operands
05164         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
05165         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
05166         reg_list_O_1->insert(R_EAX);
05167         reg_list_O_1->insert(R_EBX);
05168         reg_list_O_1->insert(R_ECX);
05169         reg_list_O_1->insert(R_EDX);
05170         reg_list_O_1->insert(R_EDI);
05171         reg_list_O_1->insert(R_ESI);
05172         reg_list_O_1->insert(R_AX);
05173         reg_list_O_1->insert(R_BX);
05174         reg_list_O_1->insert(R_CX);
05175         reg_list_O_1->insert(R_DX);
05176         reg_list_O_1->insert(R_DI);
05177         reg_list_O_1->insert(R_SI);
05178         reg_list_O_1->insert(R_AL);
05179         reg_list_O_1->insert(R_AH);
05180         reg_list_O_1->insert(R_BL);
05181         reg_list_O_1->insert(R_BH);
05182         reg_list_O_1->insert(R_CL);
05183         reg_list_O_1->insert(R_CH);
05184         reg_list_O_1->insert(R_DL);
05185         reg_list_O_1->insert(R_DH);
05186         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
05187         op_O_1->destroys_set(I_1);
05188         out_operands->push_back(op_O_1);
05189         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
05190         dt_list_O_2->insert(DT_COND);
05191         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
05192         reg_list_O_2->insert(R_COND);
05193         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
05194         out_operands->push_back(op_O_2);
05195 
05196         //execution info
05197         einfo = execution_info::create(10);
05198 
05199         //properties
05200 
05201         //versions
05202         versions = set<ulint>::create();
05203         versions->insert(INSTRUCTION_AND__1);
05204         versions->insert(INSTRUCTION_AND__11);
05205         versions->insert(INSTRUCTION_AND__12);
05206         versions->insert(INSTRUCTION_AND__13);
05207         versions->insert(INSTRUCTION_AND__14);
05208 
05209 
05210         //return target pseudoinstruction
05211         return tm_instr::create(INSTRUCTION_AND__2,in_operands,out_operands,lstring("and $O_1, 0x1"), props,versions,0,einfo);
05212 }
05213 
05214 ptr<tm_instr> tm_instr_create_INSTRUCTION_OR__1() {
05215         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
05216         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
05217         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
05218         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
05219         ptr<set<tm_data_type_base::id_type> > allowed_types; 
05220         ptr<execution_info> einfo;
05221         ptr<set<ulint> > versions;
05222         
05223         //input operands
05224         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
05225         dt_list_I_1->insert(DT_INT_8P);
05226         dt_list_I_1->insert(DT_INT_8U);
05227         dt_list_I_1->insert(DT_INT_8S);
05228         dt_list_I_1->insert(DT_INT_16U);
05229         dt_list_I_1->insert(DT_INT_16S);
05230         dt_list_I_1->insert(DT_INT_32U);
05231         dt_list_I_1->insert(DT_INT_32S);
05232         dt_list_I_1->insert(DT_BOOL);
05233         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
05234         reg_list_I_1->insert(R_EAX);
05235         reg_list_I_1->insert(R_EBX);
05236         reg_list_I_1->insert(R_ECX);
05237         reg_list_I_1->insert(R_EDX);
05238         reg_list_I_1->insert(R_EDI);
05239         reg_list_I_1->insert(R_ESI);
05240         reg_list_I_1->insert(R_AX);
05241         reg_list_I_1->insert(R_BX);
05242         reg_list_I_1->insert(R_CX);
05243         reg_list_I_1->insert(R_DX);
05244         reg_list_I_1->insert(R_DI);
05245         reg_list_I_1->insert(R_SI);
05246         reg_list_I_1->insert(R_AL);
05247         reg_list_I_1->insert(R_AH);
05248         reg_list_I_1->insert(R_BL);
05249         reg_list_I_1->insert(R_BH);
05250         reg_list_I_1->insert(R_CL);
05251         reg_list_I_1->insert(R_CH);
05252         reg_list_I_1->insert(R_DL);
05253         reg_list_I_1->insert(R_DH);
05254         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
05255         op_I_1->destroyed_by_get()->push_back(O_1);
05256         in_operands->push_back(op_I_1);
05257         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
05258         dt_list_I_2->insert(DT_INT_8P);
05259         dt_list_I_2->insert(DT_INT_8U);
05260         dt_list_I_2->insert(DT_INT_8S);
05261         dt_list_I_2->insert(DT_INT_16U);
05262         dt_list_I_2->insert(DT_INT_16S);
05263         dt_list_I_2->insert(DT_INT_32U);
05264         dt_list_I_2->insert(DT_INT_32S);
05265         dt_list_I_2->insert(DT_BOOL);
05266         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
05267         reg_list_I_2->insert(R_EAX);
05268         reg_list_I_2->insert(R_EBX);
05269         reg_list_I_2->insert(R_ECX);
05270         reg_list_I_2->insert(R_EDX);
05271         reg_list_I_2->insert(R_EDI);
05272         reg_list_I_2->insert(R_ESI);
05273         reg_list_I_2->insert(R_AX);
05274         reg_list_I_2->insert(R_BX);
05275         reg_list_I_2->insert(R_CX);
05276         reg_list_I_2->insert(R_DX);
05277         reg_list_I_2->insert(R_DI);
05278         reg_list_I_2->insert(R_SI);
05279         reg_list_I_2->insert(R_AL);
05280         reg_list_I_2->insert(R_AH);
05281         reg_list_I_2->insert(R_BL);
05282         reg_list_I_2->insert(R_BH);
05283         reg_list_I_2->insert(R_CL);
05284         reg_list_I_2->insert(R_CH);
05285         reg_list_I_2->insert(R_DL);
05286         reg_list_I_2->insert(R_DH);
05287         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
05288         in_operands->push_back(op_I_2);
05289 
05290         //output operands
05291         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
05292         dt_list_O_1->insert(DT_INT_8P);
05293         dt_list_O_1->insert(DT_INT_8U);
05294         dt_list_O_1->insert(DT_INT_8S);
05295         dt_list_O_1->insert(DT_INT_16U);
05296         dt_list_O_1->insert(DT_INT_16S);
05297         dt_list_O_1->insert(DT_INT_32U);
05298         dt_list_O_1->insert(DT_INT_32S);
05299         dt_list_O_1->insert(DT_BOOL);
05300         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
05301         reg_list_O_1->insert(R_EAX);
05302         reg_list_O_1->insert(R_EBX);
05303         reg_list_O_1->insert(R_ECX);
05304         reg_list_O_1->insert(R_EDX);
05305         reg_list_O_1->insert(R_EDI);
05306         reg_list_O_1->insert(R_ESI);
05307         reg_list_O_1->insert(R_AX);
05308         reg_list_O_1->insert(R_BX);
05309         reg_list_O_1->insert(R_CX);
05310         reg_list_O_1->insert(R_DX);
05311         reg_list_O_1->insert(R_DI);
05312         reg_list_O_1->insert(R_SI);
05313         reg_list_O_1->insert(R_AL);
05314         reg_list_O_1->insert(R_AH);
05315         reg_list_O_1->insert(R_BL);
05316         reg_list_O_1->insert(R_BH);
05317         reg_list_O_1->insert(R_CL);
05318         reg_list_O_1->insert(R_CH);
05319         reg_list_O_1->insert(R_DL);
05320         reg_list_O_1->insert(R_DH);
05321         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
05322         op_O_1->destroys_set(I_1);
05323         out_operands->push_back(op_O_1);
05324         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
05325         dt_list_O_2->insert(DT_COND);
05326         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
05327         reg_list_O_2->insert(R_COND);
05328         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
05329         out_operands->push_back(op_O_2);
05330 
05331         //execution info
05332         einfo = execution_info::create(10);
05333 
05334         //properties
05335 
05336         //versions
05337         versions = set<ulint>::create();
05338         versions->insert(INSTRUCTION_OR__11);
05339         versions->insert(INSTRUCTION_OR__12);
05340         versions->insert(INSTRUCTION_OR__13);
05341         versions->insert(INSTRUCTION_OR__14);
05342 
05343 
05344         //return target pseudoinstruction
05345         return tm_instr::create(INSTRUCTION_OR__1,in_operands,out_operands,lstring("or $O_1, $I_2"), props,versions,0,einfo);
05346 }
05347 
05348 ptr<tm_instr> tm_instr_create_INSTRUCTION_OR__11() {
05349         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
05350         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
05351         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
05352         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
05353         ptr<set<tm_data_type_base::id_type> > allowed_types; 
05354         ptr<execution_info> einfo;
05355         ptr<set<ulint> > versions;
05356         
05357         //input operands
05358         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
05359         dt_list_I_1->insert(DT_INT_8P);
05360         dt_list_I_1->insert(DT_INT_8U);
05361         dt_list_I_1->insert(DT_INT_8S);
05362         dt_list_I_1->insert(DT_INT_16U);
05363         dt_list_I_1->insert(DT_INT_16S);
05364         dt_list_I_1->insert(DT_INT_32U);
05365         dt_list_I_1->insert(DT_INT_32S);
05366         dt_list_I_1->insert(DT_BOOL);
05367         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
05368         reg_list_I_1->insert(R_EAX);
05369         reg_list_I_1->insert(R_EBX);
05370         reg_list_I_1->insert(R_ECX);
05371         reg_list_I_1->insert(R_EDX);
05372         reg_list_I_1->insert(R_EDI);
05373         reg_list_I_1->insert(R_ESI);
05374         reg_list_I_1->insert(R_AX);
05375         reg_list_I_1->insert(R_BX);
05376         reg_list_I_1->insert(R_CX);
05377         reg_list_I_1->insert(R_DX);
05378         reg_list_I_1->insert(R_DI);
05379         reg_list_I_1->insert(R_SI);
05380         reg_list_I_1->insert(R_AL);
05381         reg_list_I_1->insert(R_AH);
05382         reg_list_I_1->insert(R_BL);
05383         reg_list_I_1->insert(R_BH);
05384         reg_list_I_1->insert(R_CL);
05385         reg_list_I_1->insert(R_CH);
05386         reg_list_I_1->insert(R_DL);
05387         reg_list_I_1->insert(R_DH);
05388         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
05389         op_I_1->destroyed_by_get()->push_back(O_1);
05390         in_operands->push_back(op_I_1);
05391         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
05392         dt_list_I_2->insert(DT_INT_8P);
05393         dt_list_I_2->insert(DT_INT_8U);
05394         dt_list_I_2->insert(DT_INT_8S);
05395         dt_list_I_2->insert(DT_INT_16U);
05396         dt_list_I_2->insert(DT_INT_16S);
05397         dt_list_I_2->insert(DT_INT_32U);
05398         dt_list_I_2->insert(DT_INT_32S);
05399         dt_list_I_2->insert(DT_BOOL);
05400         ptr<tm_instr_op_imm> op_I_2 = tm_instr_op_imm::create(I_2, dt_list_I_2);
05401         in_operands->push_back(op_I_2);
05402 
05403         //output operands
05404         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
05405         dt_list_O_1->insert(DT_INT_8P);
05406         dt_list_O_1->insert(DT_INT_8U);
05407         dt_list_O_1->insert(DT_INT_8S);
05408         dt_list_O_1->insert(DT_INT_16U);
05409         dt_list_O_1->insert(DT_INT_16S);
05410         dt_list_O_1->insert(DT_INT_32U);
05411         dt_list_O_1->insert(DT_INT_32S);
05412         dt_list_O_1->insert(DT_BOOL);
05413         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
05414         reg_list_O_1->insert(R_EAX);
05415         reg_list_O_1->insert(R_EBX);
05416         reg_list_O_1->insert(R_ECX);
05417         reg_list_O_1->insert(R_EDX);
05418         reg_list_O_1->insert(R_EDI);
05419         reg_list_O_1->insert(R_ESI);
05420         reg_list_O_1->insert(R_AX);
05421         reg_list_O_1->insert(R_BX);
05422         reg_list_O_1->insert(R_CX);
05423         reg_list_O_1->insert(R_DX);
05424         reg_list_O_1->insert(R_DI);
05425         reg_list_O_1->insert(R_SI);
05426         reg_list_O_1->insert(R_AL);
05427         reg_list_O_1->insert(R_AH);
05428         reg_list_O_1->insert(R_BL);
05429         reg_list_O_1->insert(R_BH);
05430         reg_list_O_1->insert(R_CL);
05431         reg_list_O_1->insert(R_CH);
05432         reg_list_O_1->insert(R_DL);
05433         reg_list_O_1->insert(R_DH);
05434         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
05435         op_O_1->destroys_set(I_1);
05436         out_operands->push_back(op_O_1);
05437         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
05438         dt_list_O_2->insert(DT_COND);
05439         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
05440         reg_list_O_2->insert(R_COND);
05441         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
05442         out_operands->push_back(op_O_2);
05443 
05444         //execution info
05445         einfo = execution_info::create(10);
05446 
05447         //properties
05448 
05449         //versions
05450         versions = set<ulint>::create();
05451         versions->insert(INSTRUCTION_OR__1);
05452         versions->insert(INSTRUCTION_OR__12);
05453         versions->insert(INSTRUCTION_OR__13);
05454         versions->insert(INSTRUCTION_OR__14);
05455 
05456 
05457         //return target pseudoinstruction
05458         return tm_instr::create(INSTRUCTION_OR__11,in_operands,out_operands,lstring("or $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
05459 }
05460 
05461 ptr<tm_instr> tm_instr_create_INSTRUCTION_OR__12() {
05462         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
05463         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
05464         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
05465         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
05466         ptr<set<tm_data_type_base::id_type> > allowed_types; 
05467         ptr<execution_info> einfo;
05468         ptr<set<ulint> > versions;
05469         
05470         //input operands
05471         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
05472         dt_list_I_1->insert(DT_INT_8P);
05473         dt_list_I_1->insert(DT_INT_8U);
05474         dt_list_I_1->insert(DT_INT_8S);
05475         dt_list_I_1->insert(DT_INT_16U);
05476         dt_list_I_1->insert(DT_INT_16S);
05477         dt_list_I_1->insert(DT_INT_32U);
05478         dt_list_I_1->insert(DT_INT_32S);
05479         dt_list_I_1->insert(DT_BOOL);
05480         ptr<tm_instr_op_imm> op_I_1 = tm_instr_op_imm::create(I_1, dt_list_I_1);
05481         in_operands->push_back(op_I_1);
05482         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
05483         dt_list_I_2->insert(DT_INT_8P);
05484         dt_list_I_2->insert(DT_INT_8U);
05485         dt_list_I_2->insert(DT_INT_8S);
05486         dt_list_I_2->insert(DT_INT_16U);
05487         dt_list_I_2->insert(DT_INT_16S);
05488         dt_list_I_2->insert(DT_INT_32U);
05489         dt_list_I_2->insert(DT_INT_32S);
05490         dt_list_I_2->insert(DT_BOOL);
05491         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
05492         reg_list_I_2->insert(R_EAX);
05493         reg_list_I_2->insert(R_EBX);
05494         reg_list_I_2->insert(R_ECX);
05495         reg_list_I_2->insert(R_EDX);
05496         reg_list_I_2->insert(R_EDI);
05497         reg_list_I_2->insert(R_ESI);
05498         reg_list_I_2->insert(R_AX);
05499         reg_list_I_2->insert(R_BX);
05500         reg_list_I_2->insert(R_CX);
05501         reg_list_I_2->insert(R_DX);
05502         reg_list_I_2->insert(R_DI);
05503         reg_list_I_2->insert(R_SI);
05504         reg_list_I_2->insert(R_AL);
05505         reg_list_I_2->insert(R_AH);
05506         reg_list_I_2->insert(R_BL);
05507         reg_list_I_2->insert(R_BH);
05508         reg_list_I_2->insert(R_CL);
05509         reg_list_I_2->insert(R_CH);
05510         reg_list_I_2->insert(R_DL);
05511         reg_list_I_2->insert(R_DH);
05512         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
05513         op_I_2->destroyed_by_get()->push_back(O_1);
05514         in_operands->push_back(op_I_2);
05515 
05516         //output operands
05517         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
05518         dt_list_O_1->insert(DT_INT_8P);
05519         dt_list_O_1->insert(DT_INT_8U);
05520         dt_list_O_1->insert(DT_INT_8S);
05521         dt_list_O_1->insert(DT_INT_16U);
05522         dt_list_O_1->insert(DT_INT_16S);
05523         dt_list_O_1->insert(DT_INT_32U);
05524         dt_list_O_1->insert(DT_INT_32S);
05525         dt_list_O_1->insert(DT_BOOL);
05526         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
05527         reg_list_O_1->insert(R_EAX);
05528         reg_list_O_1->insert(R_EBX);
05529         reg_list_O_1->insert(R_ECX);
05530         reg_list_O_1->insert(R_EDX);
05531         reg_list_O_1->insert(R_EDI);
05532         reg_list_O_1->insert(R_ESI);
05533         reg_list_O_1->insert(R_AX);
05534         reg_list_O_1->insert(R_BX);
05535         reg_list_O_1->insert(R_CX);
05536         reg_list_O_1->insert(R_DX);
05537         reg_list_O_1->insert(R_DI);
05538         reg_list_O_1->insert(R_SI);
05539         reg_list_O_1->insert(R_AL);
05540         reg_list_O_1->insert(R_AH);
05541         reg_list_O_1->insert(R_BL);
05542         reg_list_O_1->insert(R_BH);
05543         reg_list_O_1->insert(R_CL);
05544         reg_list_O_1->insert(R_CH);
05545         reg_list_O_1->insert(R_DL);
05546         reg_list_O_1->insert(R_DH);
05547         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
05548         op_O_1->destroys_set(I_2);
05549         out_operands->push_back(op_O_1);
05550         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
05551         dt_list_O_2->insert(DT_COND);
05552         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
05553         reg_list_O_2->insert(R_COND);
05554         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
05555         out_operands->push_back(op_O_2);
05556 
05557         //execution info
05558         einfo = execution_info::create(10);
05559 
05560         //properties
05561 
05562         //versions
05563         versions = set<ulint>::create();
05564         versions->insert(INSTRUCTION_OR__1);
05565         versions->insert(INSTRUCTION_OR__11);
05566         versions->insert(INSTRUCTION_OR__13);
05567         versions->insert(INSTRUCTION_OR__14);
05568 
05569 
05570         //return target pseudoinstruction
05571         return tm_instr::create(INSTRUCTION_OR__12,in_operands,out_operands,lstring("or $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
05572 }
05573 
05574 ptr<tm_instr> tm_instr_create_INSTRUCTION_OR__13() {
05575         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
05576         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
05577         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
05578         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
05579         ptr<set<tm_data_type_base::id_type> > allowed_types; 
05580         ptr<execution_info> einfo;
05581         ptr<set<ulint> > versions;
05582         
05583         //input operands
05584         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
05585         dt_list_I_1->insert(DT_INT_8P);
05586         dt_list_I_1->insert(DT_INT_8U);
05587         dt_list_I_1->insert(DT_INT_8S);
05588         dt_list_I_1->insert(DT_INT_16U);
05589         dt_list_I_1->insert(DT_INT_16S);
05590         dt_list_I_1->insert(DT_INT_32U);
05591         dt_list_I_1->insert(DT_INT_32S);
05592         dt_list_I_1->insert(DT_BOOL);
05593         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
05594         reg_list_I_1->insert(R_EAX);
05595         reg_list_I_1->insert(R_EBX);
05596         reg_list_I_1->insert(R_ECX);
05597         reg_list_I_1->insert(R_EDX);
05598         reg_list_I_1->insert(R_EDI);
05599         reg_list_I_1->insert(R_ESI);
05600         reg_list_I_1->insert(R_AX);
05601         reg_list_I_1->insert(R_BX);
05602         reg_list_I_1->insert(R_CX);
05603         reg_list_I_1->insert(R_DX);
05604         reg_list_I_1->insert(R_DI);
05605         reg_list_I_1->insert(R_SI);
05606         reg_list_I_1->insert(R_AL);
05607         reg_list_I_1->insert(R_AH);
05608         reg_list_I_1->insert(R_BL);
05609         reg_list_I_1->insert(R_BH);
05610         reg_list_I_1->insert(R_CL);
05611         reg_list_I_1->insert(R_CH);
05612         reg_list_I_1->insert(R_DL);
05613         reg_list_I_1->insert(R_DH);
05614         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
05615         op_I_1->destroyed_by_get()->push_back(O_1);
05616         in_operands->push_back(op_I_1);
05617         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
05618         dt_list_I_2->insert(DT_INT_8P);
05619         dt_list_I_2->insert(DT_INT_8U);
05620         dt_list_I_2->insert(DT_INT_8S);
05621         dt_list_I_2->insert(DT_INT_16U);
05622         dt_list_I_2->insert(DT_INT_16S);
05623         dt_list_I_2->insert(DT_INT_32U);
05624         dt_list_I_2->insert(DT_INT_32S);
05625         dt_list_I_2->insert(DT_BOOL);
05626         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
05627         in_operands->push_back(op_I_2);
05628 
05629         //output operands
05630         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
05631         dt_list_O_1->insert(DT_INT_8P);
05632         dt_list_O_1->insert(DT_INT_8U);
05633         dt_list_O_1->insert(DT_INT_8S);
05634         dt_list_O_1->insert(DT_INT_16U);
05635         dt_list_O_1->insert(DT_INT_16S);
05636         dt_list_O_1->insert(DT_INT_32U);
05637         dt_list_O_1->insert(DT_INT_32S);
05638         dt_list_O_1->insert(DT_BOOL);
05639         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
05640         reg_list_O_1->insert(R_EAX);
05641         reg_list_O_1->insert(R_EBX);
05642         reg_list_O_1->insert(R_ECX);
05643         reg_list_O_1->insert(R_EDX);
05644         reg_list_O_1->insert(R_EDI);
05645         reg_list_O_1->insert(R_ESI);
05646         reg_list_O_1->insert(R_AX);
05647         reg_list_O_1->insert(R_BX);
05648         reg_list_O_1->insert(R_CX);
05649         reg_list_O_1->insert(R_DX);
05650         reg_list_O_1->insert(R_DI);
05651         reg_list_O_1->insert(R_SI);
05652         reg_list_O_1->insert(R_AL);
05653         reg_list_O_1->insert(R_AH);
05654         reg_list_O_1->insert(R_BL);
05655         reg_list_O_1->insert(R_BH);
05656         reg_list_O_1->insert(R_CL);
05657         reg_list_O_1->insert(R_CH);
05658         reg_list_O_1->insert(R_DL);
05659         reg_list_O_1->insert(R_DH);
05660         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
05661         op_O_1->destroys_set(I_1);
05662         out_operands->push_back(op_O_1);
05663         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
05664         dt_list_O_2->insert(DT_COND);
05665         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
05666         reg_list_O_2->insert(R_COND);
05667         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
05668         out_operands->push_back(op_O_2);
05669 
05670         //execution info
05671         einfo = execution_info::create(30);
05672 
05673         //properties
05674 
05675         //versions
05676         versions = set<ulint>::create();
05677         versions->insert(INSTRUCTION_OR__1);
05678         versions->insert(INSTRUCTION_OR__11);
05679         versions->insert(INSTRUCTION_OR__12);
05680         versions->insert(INSTRUCTION_OR__14);
05681 
05682 
05683         //return target pseudoinstruction
05684         return tm_instr::create(INSTRUCTION_OR__13,in_operands,out_operands,lstring("or $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
05685 }
05686 
05687 ptr<tm_instr> tm_instr_create_INSTRUCTION_OR__14() {
05688         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
05689         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
05690         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
05691         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
05692         ptr<set<tm_data_type_base::id_type> > allowed_types; 
05693         ptr<execution_info> einfo;
05694         ptr<set<ulint> > versions;
05695         
05696         //input operands
05697         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
05698         dt_list_I_1->insert(DT_INT_8P);
05699         dt_list_I_1->insert(DT_INT_8U);
05700         dt_list_I_1->insert(DT_INT_8S);
05701         dt_list_I_1->insert(DT_INT_16U);
05702         dt_list_I_1->insert(DT_INT_16S);
05703         dt_list_I_1->insert(DT_INT_32U);
05704         dt_list_I_1->insert(DT_INT_32S);
05705         dt_list_I_1->insert(DT_BOOL);
05706         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
05707         in_operands->push_back(op_I_1);
05708         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
05709         dt_list_I_2->insert(DT_INT_8P);
05710         dt_list_I_2->insert(DT_INT_8U);
05711         dt_list_I_2->insert(DT_INT_8S);
05712         dt_list_I_2->insert(DT_INT_16U);
05713         dt_list_I_2->insert(DT_INT_16S);
05714         dt_list_I_2->insert(DT_INT_32U);
05715         dt_list_I_2->insert(DT_INT_32S);
05716         dt_list_I_2->insert(DT_BOOL);
05717         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
05718         reg_list_I_2->insert(R_EAX);
05719         reg_list_I_2->insert(R_EBX);
05720         reg_list_I_2->insert(R_ECX);
05721         reg_list_I_2->insert(R_EDX);
05722         reg_list_I_2->insert(R_EDI);
05723         reg_list_I_2->insert(R_ESI);
05724         reg_list_I_2->insert(R_AX);
05725         reg_list_I_2->insert(R_BX);
05726         reg_list_I_2->insert(R_CX);
05727         reg_list_I_2->insert(R_DX);
05728         reg_list_I_2->insert(R_DI);
05729         reg_list_I_2->insert(R_SI);
05730         reg_list_I_2->insert(R_AL);
05731         reg_list_I_2->insert(R_AH);
05732         reg_list_I_2->insert(R_BL);
05733         reg_list_I_2->insert(R_BH);
05734         reg_list_I_2->insert(R_CL);
05735         reg_list_I_2->insert(R_CH);
05736         reg_list_I_2->insert(R_DL);
05737         reg_list_I_2->insert(R_DH);
05738         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
05739         op_I_2->destroyed_by_get()->push_back(O_1);
05740         in_operands->push_back(op_I_2);
05741 
05742         //output operands
05743         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
05744         dt_list_O_1->insert(DT_INT_8P);
05745         dt_list_O_1->insert(DT_INT_8U);
05746         dt_list_O_1->insert(DT_INT_8S);
05747         dt_list_O_1->insert(DT_INT_16U);
05748         dt_list_O_1->insert(DT_INT_16S);
05749         dt_list_O_1->insert(DT_INT_32U);
05750         dt_list_O_1->insert(DT_INT_32S);
05751         dt_list_O_1->insert(DT_BOOL);
05752         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
05753         reg_list_O_1->insert(R_EAX);
05754         reg_list_O_1->insert(R_EBX);
05755         reg_list_O_1->insert(R_ECX);
05756         reg_list_O_1->insert(R_EDX);
05757         reg_list_O_1->insert(R_EDI);
05758         reg_list_O_1->insert(R_ESI);
05759         reg_list_O_1->insert(R_AX);
05760         reg_list_O_1->insert(R_BX);
05761         reg_list_O_1->insert(R_CX);
05762         reg_list_O_1->insert(R_DX);
05763         reg_list_O_1->insert(R_DI);
05764         reg_list_O_1->insert(R_SI);
05765         reg_list_O_1->insert(R_AL);
05766         reg_list_O_1->insert(R_AH);
05767         reg_list_O_1->insert(R_BL);
05768         reg_list_O_1->insert(R_BH);
05769         reg_list_O_1->insert(R_CL);
05770         reg_list_O_1->insert(R_CH);
05771         reg_list_O_1->insert(R_DL);
05772         reg_list_O_1->insert(R_DH);
05773         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
05774         op_O_1->destroys_set(I_2);
05775         out_operands->push_back(op_O_1);
05776         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
05777         dt_list_O_2->insert(DT_COND);
05778         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
05779         reg_list_O_2->insert(R_COND);
05780         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
05781         out_operands->push_back(op_O_2);
05782 
05783         //execution info
05784         einfo = execution_info::create(30);
05785 
05786         //properties
05787 
05788         //versions
05789         versions = set<ulint>::create();
05790         versions->insert(INSTRUCTION_OR__1);
05791         versions->insert(INSTRUCTION_OR__11);
05792         versions->insert(INSTRUCTION_OR__12);
05793         versions->insert(INSTRUCTION_OR__13);
05794 
05795 
05796         //return target pseudoinstruction
05797         return tm_instr::create(INSTRUCTION_OR__14,in_operands,out_operands,lstring("or $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
05798 }
05799 
05800 ptr<tm_instr> tm_instr_create_INSTRUCTION_XOR__1() {
05801         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
05802         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
05803         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
05804         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
05805         ptr<set<tm_data_type_base::id_type> > allowed_types; 
05806         ptr<execution_info> einfo;
05807         ptr<set<ulint> > versions;
05808         
05809         //input operands
05810         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
05811         dt_list_I_1->insert(DT_INT_8P);
05812         dt_list_I_1->insert(DT_INT_8U);
05813         dt_list_I_1->insert(DT_INT_8S);
05814         dt_list_I_1->insert(DT_INT_16U);
05815         dt_list_I_1->insert(DT_INT_16S);
05816         dt_list_I_1->insert(DT_INT_32U);
05817         dt_list_I_1->insert(DT_INT_32S);
05818         dt_list_I_1->insert(DT_BOOL);
05819         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
05820         reg_list_I_1->insert(R_EAX);
05821         reg_list_I_1->insert(R_EBX);
05822         reg_list_I_1->insert(R_ECX);
05823         reg_list_I_1->insert(R_EDX);
05824         reg_list_I_1->insert(R_EDI);
05825         reg_list_I_1->insert(R_ESI);
05826         reg_list_I_1->insert(R_AX);
05827         reg_list_I_1->insert(R_BX);
05828         reg_list_I_1->insert(R_CX);
05829         reg_list_I_1->insert(R_DX);
05830         reg_list_I_1->insert(R_DI);
05831         reg_list_I_1->insert(R_SI);
05832         reg_list_I_1->insert(R_AL);
05833         reg_list_I_1->insert(R_AH);
05834         reg_list_I_1->insert(R_BL);
05835         reg_list_I_1->insert(R_BH);
05836         reg_list_I_1->insert(R_CL);
05837         reg_list_I_1->insert(R_CH);
05838         reg_list_I_1->insert(R_DL);
05839         reg_list_I_1->insert(R_DH);
05840         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
05841         op_I_1->destroyed_by_get()->push_back(O_1);
05842         in_operands->push_back(op_I_1);
05843         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
05844         dt_list_I_2->insert(DT_INT_8P);
05845         dt_list_I_2->insert(DT_INT_8U);
05846         dt_list_I_2->insert(DT_INT_8S);
05847         dt_list_I_2->insert(DT_INT_16U);
05848         dt_list_I_2->insert(DT_INT_16S);
05849         dt_list_I_2->insert(DT_INT_32U);
05850         dt_list_I_2->insert(DT_INT_32S);
05851         dt_list_I_2->insert(DT_BOOL);
05852         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
05853         reg_list_I_2->insert(R_EAX);
05854         reg_list_I_2->insert(R_EBX);
05855         reg_list_I_2->insert(R_ECX);
05856         reg_list_I_2->insert(R_EDX);
05857         reg_list_I_2->insert(R_EDI);
05858         reg_list_I_2->insert(R_ESI);
05859         reg_list_I_2->insert(R_AX);
05860         reg_list_I_2->insert(R_BX);
05861         reg_list_I_2->insert(R_CX);
05862         reg_list_I_2->insert(R_DX);
05863         reg_list_I_2->insert(R_DI);
05864         reg_list_I_2->insert(R_SI);
05865         reg_list_I_2->insert(R_AL);
05866         reg_list_I_2->insert(R_AH);
05867         reg_list_I_2->insert(R_BL);
05868         reg_list_I_2->insert(R_BH);
05869         reg_list_I_2->insert(R_CL);
05870         reg_list_I_2->insert(R_CH);
05871         reg_list_I_2->insert(R_DL);
05872         reg_list_I_2->insert(R_DH);
05873         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
05874         in_operands->push_back(op_I_2);
05875 
05876         //output operands
05877         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
05878         dt_list_O_1->insert(DT_INT_8P);
05879         dt_list_O_1->insert(DT_INT_8U);
05880         dt_list_O_1->insert(DT_INT_8S);
05881         dt_list_O_1->insert(DT_INT_16U);
05882         dt_list_O_1->insert(DT_INT_16S);
05883         dt_list_O_1->insert(DT_INT_32U);
05884         dt_list_O_1->insert(DT_INT_32S);
05885         dt_list_O_1->insert(DT_BOOL);
05886         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
05887         reg_list_O_1->insert(R_EAX);
05888         reg_list_O_1->insert(R_EBX);
05889         reg_list_O_1->insert(R_ECX);
05890         reg_list_O_1->insert(R_EDX);
05891         reg_list_O_1->insert(R_EDI);
05892         reg_list_O_1->insert(R_ESI);
05893         reg_list_O_1->insert(R_AX);
05894         reg_list_O_1->insert(R_BX);
05895         reg_list_O_1->insert(R_CX);
05896         reg_list_O_1->insert(R_DX);
05897         reg_list_O_1->insert(R_DI);
05898         reg_list_O_1->insert(R_SI);
05899         reg_list_O_1->insert(R_AL);
05900         reg_list_O_1->insert(R_AH);
05901         reg_list_O_1->insert(R_BL);
05902         reg_list_O_1->insert(R_BH);
05903         reg_list_O_1->insert(R_CL);
05904         reg_list_O_1->insert(R_CH);
05905         reg_list_O_1->insert(R_DL);
05906         reg_list_O_1->insert(R_DH);
05907         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
05908         op_O_1->destroys_set(I_1);
05909         out_operands->push_back(op_O_1);
05910         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
05911         dt_list_O_2->insert(DT_COND);
05912         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
05913         reg_list_O_2->insert(R_COND);
05914         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
05915         out_operands->push_back(op_O_2);
05916 
05917         //execution info
05918         einfo = execution_info::create(10);
05919 
05920         //properties
05921 
05922         //versions
05923         versions = set<ulint>::create();
05924         versions->insert(INSTRUCTION_XOR__11);
05925         versions->insert(INSTRUCTION_XOR__12);
05926         versions->insert(INSTRUCTION_XOR__13);
05927         versions->insert(INSTRUCTION_XOR__14);
05928         versions->insert(INSTRUCTION_XOR__2);
05929 
05930 
05931         //return target pseudoinstruction
05932         return tm_instr::create(INSTRUCTION_XOR__1,in_operands,out_operands,lstring("xor $O_1, $I_2"), props,versions,0,einfo);
05933 }
05934 
05935 ptr<tm_instr> tm_instr_create_INSTRUCTION_XOR__11() {
05936         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
05937         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
05938         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
05939         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
05940         ptr<set<tm_data_type_base::id_type> > allowed_types; 
05941         ptr<execution_info> einfo;
05942         ptr<set<ulint> > versions;
05943         
05944         //input operands
05945         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
05946         dt_list_I_1->insert(DT_INT_8P);
05947         dt_list_I_1->insert(DT_INT_8U);
05948         dt_list_I_1->insert(DT_INT_8S);
05949         dt_list_I_1->insert(DT_INT_16U);
05950         dt_list_I_1->insert(DT_INT_16S);
05951         dt_list_I_1->insert(DT_INT_32U);
05952         dt_list_I_1->insert(DT_INT_32S);
05953         dt_list_I_1->insert(DT_BOOL);
05954         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
05955         reg_list_I_1->insert(R_EAX);
05956         reg_list_I_1->insert(R_EBX);
05957         reg_list_I_1->insert(R_ECX);
05958         reg_list_I_1->insert(R_EDX);
05959         reg_list_I_1->insert(R_EDI);
05960         reg_list_I_1->insert(R_ESI);
05961         reg_list_I_1->insert(R_AX);
05962         reg_list_I_1->insert(R_BX);
05963         reg_list_I_1->insert(R_CX);
05964         reg_list_I_1->insert(R_DX);
05965         reg_list_I_1->insert(R_DI);
05966         reg_list_I_1->insert(R_SI);
05967         reg_list_I_1->insert(R_AL);
05968         reg_list_I_1->insert(R_AH);
05969         reg_list_I_1->insert(R_BL);
05970         reg_list_I_1->insert(R_BH);
05971         reg_list_I_1->insert(R_CL);
05972         reg_list_I_1->insert(R_CH);
05973         reg_list_I_1->insert(R_DL);
05974         reg_list_I_1->insert(R_DH);
05975         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
05976         op_I_1->destroyed_by_get()->push_back(O_1);
05977         in_operands->push_back(op_I_1);
05978         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
05979         dt_list_I_2->insert(DT_INT_8P);
05980         dt_list_I_2->insert(DT_INT_8U);
05981         dt_list_I_2->insert(DT_INT_8S);
05982         dt_list_I_2->insert(DT_INT_16U);
05983         dt_list_I_2->insert(DT_INT_16S);
05984         dt_list_I_2->insert(DT_INT_32U);
05985         dt_list_I_2->insert(DT_INT_32S);
05986         dt_list_I_2->insert(DT_BOOL);
05987         ptr<tm_instr_op_imm> op_I_2 = tm_instr_op_imm::create(I_2, dt_list_I_2);
05988         in_operands->push_back(op_I_2);
05989 
05990         //output operands
05991         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
05992         dt_list_O_1->insert(DT_INT_8P);
05993         dt_list_O_1->insert(DT_INT_8U);
05994         dt_list_O_1->insert(DT_INT_8S);
05995         dt_list_O_1->insert(DT_INT_16U);
05996         dt_list_O_1->insert(DT_INT_16S);
05997         dt_list_O_1->insert(DT_INT_32U);
05998         dt_list_O_1->insert(DT_INT_32S);
05999         dt_list_O_1->insert(DT_BOOL);
06000         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06001         reg_list_O_1->insert(R_EAX);
06002         reg_list_O_1->insert(R_EBX);
06003         reg_list_O_1->insert(R_ECX);
06004         reg_list_O_1->insert(R_EDX);
06005         reg_list_O_1->insert(R_EDI);
06006         reg_list_O_1->insert(R_ESI);
06007         reg_list_O_1->insert(R_AX);
06008         reg_list_O_1->insert(R_BX);
06009         reg_list_O_1->insert(R_CX);
06010         reg_list_O_1->insert(R_DX);
06011         reg_list_O_1->insert(R_DI);
06012         reg_list_O_1->insert(R_SI);
06013         reg_list_O_1->insert(R_AL);
06014         reg_list_O_1->insert(R_AH);
06015         reg_list_O_1->insert(R_BL);
06016         reg_list_O_1->insert(R_BH);
06017         reg_list_O_1->insert(R_CL);
06018         reg_list_O_1->insert(R_CH);
06019         reg_list_O_1->insert(R_DL);
06020         reg_list_O_1->insert(R_DH);
06021         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06022         op_O_1->destroys_set(I_1);
06023         out_operands->push_back(op_O_1);
06024         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
06025         dt_list_O_2->insert(DT_COND);
06026         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
06027         reg_list_O_2->insert(R_COND);
06028         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
06029         out_operands->push_back(op_O_2);
06030 
06031         //execution info
06032         einfo = execution_info::create(10);
06033 
06034         //properties
06035 
06036         //versions
06037         versions = set<ulint>::create();
06038         versions->insert(INSTRUCTION_XOR__1);
06039         versions->insert(INSTRUCTION_XOR__12);
06040         versions->insert(INSTRUCTION_XOR__13);
06041         versions->insert(INSTRUCTION_XOR__14);
06042         versions->insert(INSTRUCTION_XOR__2);
06043 
06044 
06045         //return target pseudoinstruction
06046         return tm_instr::create(INSTRUCTION_XOR__11,in_operands,out_operands,lstring("xor $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
06047 }
06048 
06049 ptr<tm_instr> tm_instr_create_INSTRUCTION_XOR__12() {
06050         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06051         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06052         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06053         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06054         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06055         ptr<execution_info> einfo;
06056         ptr<set<ulint> > versions;
06057         
06058         //input operands
06059         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06060         dt_list_I_1->insert(DT_INT_8P);
06061         dt_list_I_1->insert(DT_INT_8U);
06062         dt_list_I_1->insert(DT_INT_8S);
06063         dt_list_I_1->insert(DT_INT_16U);
06064         dt_list_I_1->insert(DT_INT_16S);
06065         dt_list_I_1->insert(DT_INT_32U);
06066         dt_list_I_1->insert(DT_INT_32S);
06067         dt_list_I_1->insert(DT_BOOL);
06068         ptr<tm_instr_op_imm> op_I_1 = tm_instr_op_imm::create(I_1, dt_list_I_1);
06069         in_operands->push_back(op_I_1);
06070         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
06071         dt_list_I_2->insert(DT_INT_8P);
06072         dt_list_I_2->insert(DT_INT_8U);
06073         dt_list_I_2->insert(DT_INT_8S);
06074         dt_list_I_2->insert(DT_INT_16U);
06075         dt_list_I_2->insert(DT_INT_16S);
06076         dt_list_I_2->insert(DT_INT_32U);
06077         dt_list_I_2->insert(DT_INT_32S);
06078         dt_list_I_2->insert(DT_BOOL);
06079         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
06080         reg_list_I_2->insert(R_EAX);
06081         reg_list_I_2->insert(R_EBX);
06082         reg_list_I_2->insert(R_ECX);
06083         reg_list_I_2->insert(R_EDX);
06084         reg_list_I_2->insert(R_EDI);
06085         reg_list_I_2->insert(R_ESI);
06086         reg_list_I_2->insert(R_AX);
06087         reg_list_I_2->insert(R_BX);
06088         reg_list_I_2->insert(R_CX);
06089         reg_list_I_2->insert(R_DX);
06090         reg_list_I_2->insert(R_DI);
06091         reg_list_I_2->insert(R_SI);
06092         reg_list_I_2->insert(R_AL);
06093         reg_list_I_2->insert(R_AH);
06094         reg_list_I_2->insert(R_BL);
06095         reg_list_I_2->insert(R_BH);
06096         reg_list_I_2->insert(R_CL);
06097         reg_list_I_2->insert(R_CH);
06098         reg_list_I_2->insert(R_DL);
06099         reg_list_I_2->insert(R_DH);
06100         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
06101         op_I_2->destroyed_by_get()->push_back(O_1);
06102         in_operands->push_back(op_I_2);
06103 
06104         //output operands
06105         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06106         dt_list_O_1->insert(DT_INT_8P);
06107         dt_list_O_1->insert(DT_INT_8U);
06108         dt_list_O_1->insert(DT_INT_8S);
06109         dt_list_O_1->insert(DT_INT_16U);
06110         dt_list_O_1->insert(DT_INT_16S);
06111         dt_list_O_1->insert(DT_INT_32U);
06112         dt_list_O_1->insert(DT_INT_32S);
06113         dt_list_O_1->insert(DT_BOOL);
06114         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06115         reg_list_O_1->insert(R_EAX);
06116         reg_list_O_1->insert(R_EBX);
06117         reg_list_O_1->insert(R_ECX);
06118         reg_list_O_1->insert(R_EDX);
06119         reg_list_O_1->insert(R_EDI);
06120         reg_list_O_1->insert(R_ESI);
06121         reg_list_O_1->insert(R_AX);
06122         reg_list_O_1->insert(R_BX);
06123         reg_list_O_1->insert(R_CX);
06124         reg_list_O_1->insert(R_DX);
06125         reg_list_O_1->insert(R_DI);
06126         reg_list_O_1->insert(R_SI);
06127         reg_list_O_1->insert(R_AL);
06128         reg_list_O_1->insert(R_AH);
06129         reg_list_O_1->insert(R_BL);
06130         reg_list_O_1->insert(R_BH);
06131         reg_list_O_1->insert(R_CL);
06132         reg_list_O_1->insert(R_CH);
06133         reg_list_O_1->insert(R_DL);
06134         reg_list_O_1->insert(R_DH);
06135         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06136         op_O_1->destroys_set(I_2);
06137         out_operands->push_back(op_O_1);
06138         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
06139         dt_list_O_2->insert(DT_COND);
06140         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
06141         reg_list_O_2->insert(R_COND);
06142         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
06143         out_operands->push_back(op_O_2);
06144 
06145         //execution info
06146         einfo = execution_info::create(10);
06147 
06148         //properties
06149 
06150         //versions
06151         versions = set<ulint>::create();
06152         versions->insert(INSTRUCTION_XOR__1);
06153         versions->insert(INSTRUCTION_XOR__11);
06154         versions->insert(INSTRUCTION_XOR__13);
06155         versions->insert(INSTRUCTION_XOR__14);
06156         versions->insert(INSTRUCTION_XOR__2);
06157 
06158 
06159         //return target pseudoinstruction
06160         return tm_instr::create(INSTRUCTION_XOR__12,in_operands,out_operands,lstring("xor $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
06161 }
06162 
06163 ptr<tm_instr> tm_instr_create_INSTRUCTION_XOR__13() {
06164         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06165         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06166         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06167         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06168         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06169         ptr<execution_info> einfo;
06170         ptr<set<ulint> > versions;
06171         
06172         //input operands
06173         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06174         dt_list_I_1->insert(DT_INT_8P);
06175         dt_list_I_1->insert(DT_INT_8U);
06176         dt_list_I_1->insert(DT_INT_8S);
06177         dt_list_I_1->insert(DT_INT_16U);
06178         dt_list_I_1->insert(DT_INT_16S);
06179         dt_list_I_1->insert(DT_INT_32U);
06180         dt_list_I_1->insert(DT_INT_32S);
06181         dt_list_I_1->insert(DT_BOOL);
06182         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
06183         reg_list_I_1->insert(R_EAX);
06184         reg_list_I_1->insert(R_EBX);
06185         reg_list_I_1->insert(R_ECX);
06186         reg_list_I_1->insert(R_EDX);
06187         reg_list_I_1->insert(R_EDI);
06188         reg_list_I_1->insert(R_ESI);
06189         reg_list_I_1->insert(R_AX);
06190         reg_list_I_1->insert(R_BX);
06191         reg_list_I_1->insert(R_CX);
06192         reg_list_I_1->insert(R_DX);
06193         reg_list_I_1->insert(R_DI);
06194         reg_list_I_1->insert(R_SI);
06195         reg_list_I_1->insert(R_AL);
06196         reg_list_I_1->insert(R_AH);
06197         reg_list_I_1->insert(R_BL);
06198         reg_list_I_1->insert(R_BH);
06199         reg_list_I_1->insert(R_CL);
06200         reg_list_I_1->insert(R_CH);
06201         reg_list_I_1->insert(R_DL);
06202         reg_list_I_1->insert(R_DH);
06203         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
06204         op_I_1->destroyed_by_get()->push_back(O_1);
06205         in_operands->push_back(op_I_1);
06206         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
06207         dt_list_I_2->insert(DT_INT_8P);
06208         dt_list_I_2->insert(DT_INT_8U);
06209         dt_list_I_2->insert(DT_INT_8S);
06210         dt_list_I_2->insert(DT_INT_16U);
06211         dt_list_I_2->insert(DT_INT_16S);
06212         dt_list_I_2->insert(DT_INT_32U);
06213         dt_list_I_2->insert(DT_INT_32S);
06214         dt_list_I_2->insert(DT_BOOL);
06215         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
06216         in_operands->push_back(op_I_2);
06217 
06218         //output operands
06219         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06220         dt_list_O_1->insert(DT_INT_8P);
06221         dt_list_O_1->insert(DT_INT_8U);
06222         dt_list_O_1->insert(DT_INT_8S);
06223         dt_list_O_1->insert(DT_INT_16U);
06224         dt_list_O_1->insert(DT_INT_16S);
06225         dt_list_O_1->insert(DT_INT_32U);
06226         dt_list_O_1->insert(DT_INT_32S);
06227         dt_list_O_1->insert(DT_BOOL);
06228         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06229         reg_list_O_1->insert(R_EAX);
06230         reg_list_O_1->insert(R_EBX);
06231         reg_list_O_1->insert(R_ECX);
06232         reg_list_O_1->insert(R_EDX);
06233         reg_list_O_1->insert(R_EDI);
06234         reg_list_O_1->insert(R_ESI);
06235         reg_list_O_1->insert(R_AX);
06236         reg_list_O_1->insert(R_BX);
06237         reg_list_O_1->insert(R_CX);
06238         reg_list_O_1->insert(R_DX);
06239         reg_list_O_1->insert(R_DI);
06240         reg_list_O_1->insert(R_SI);
06241         reg_list_O_1->insert(R_AL);
06242         reg_list_O_1->insert(R_AH);
06243         reg_list_O_1->insert(R_BL);
06244         reg_list_O_1->insert(R_BH);
06245         reg_list_O_1->insert(R_CL);
06246         reg_list_O_1->insert(R_CH);
06247         reg_list_O_1->insert(R_DL);
06248         reg_list_O_1->insert(R_DH);
06249         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06250         op_O_1->destroys_set(I_1);
06251         out_operands->push_back(op_O_1);
06252         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
06253         dt_list_O_2->insert(DT_COND);
06254         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
06255         reg_list_O_2->insert(R_COND);
06256         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
06257         out_operands->push_back(op_O_2);
06258 
06259         //execution info
06260         einfo = execution_info::create(30);
06261 
06262         //properties
06263 
06264         //versions
06265         versions = set<ulint>::create();
06266         versions->insert(INSTRUCTION_XOR__1);
06267         versions->insert(INSTRUCTION_XOR__11);
06268         versions->insert(INSTRUCTION_XOR__12);
06269         versions->insert(INSTRUCTION_XOR__14);
06270         versions->insert(INSTRUCTION_XOR__2);
06271 
06272 
06273         //return target pseudoinstruction
06274         return tm_instr::create(INSTRUCTION_XOR__13,in_operands,out_operands,lstring("xor $O_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
06275 }
06276 
06277 ptr<tm_instr> tm_instr_create_INSTRUCTION_XOR__14() {
06278         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06279         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06280         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06281         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06282         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06283         ptr<execution_info> einfo;
06284         ptr<set<ulint> > versions;
06285         
06286         //input operands
06287         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06288         dt_list_I_1->insert(DT_INT_8P);
06289         dt_list_I_1->insert(DT_INT_8U);
06290         dt_list_I_1->insert(DT_INT_8S);
06291         dt_list_I_1->insert(DT_INT_16U);
06292         dt_list_I_1->insert(DT_INT_16S);
06293         dt_list_I_1->insert(DT_INT_32U);
06294         dt_list_I_1->insert(DT_INT_32S);
06295         dt_list_I_1->insert(DT_BOOL);
06296         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
06297         in_operands->push_back(op_I_1);
06298         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
06299         dt_list_I_2->insert(DT_INT_8P);
06300         dt_list_I_2->insert(DT_INT_8U);
06301         dt_list_I_2->insert(DT_INT_8S);
06302         dt_list_I_2->insert(DT_INT_16U);
06303         dt_list_I_2->insert(DT_INT_16S);
06304         dt_list_I_2->insert(DT_INT_32U);
06305         dt_list_I_2->insert(DT_INT_32S);
06306         dt_list_I_2->insert(DT_BOOL);
06307         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
06308         reg_list_I_2->insert(R_EAX);
06309         reg_list_I_2->insert(R_EBX);
06310         reg_list_I_2->insert(R_ECX);
06311         reg_list_I_2->insert(R_EDX);
06312         reg_list_I_2->insert(R_EDI);
06313         reg_list_I_2->insert(R_ESI);
06314         reg_list_I_2->insert(R_AX);
06315         reg_list_I_2->insert(R_BX);
06316         reg_list_I_2->insert(R_CX);
06317         reg_list_I_2->insert(R_DX);
06318         reg_list_I_2->insert(R_DI);
06319         reg_list_I_2->insert(R_SI);
06320         reg_list_I_2->insert(R_AL);
06321         reg_list_I_2->insert(R_AH);
06322         reg_list_I_2->insert(R_BL);
06323         reg_list_I_2->insert(R_BH);
06324         reg_list_I_2->insert(R_CL);
06325         reg_list_I_2->insert(R_CH);
06326         reg_list_I_2->insert(R_DL);
06327         reg_list_I_2->insert(R_DH);
06328         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
06329         op_I_2->destroyed_by_get()->push_back(O_1);
06330         in_operands->push_back(op_I_2);
06331 
06332         //output operands
06333         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06334         dt_list_O_1->insert(DT_INT_8P);
06335         dt_list_O_1->insert(DT_INT_8U);
06336         dt_list_O_1->insert(DT_INT_8S);
06337         dt_list_O_1->insert(DT_INT_16U);
06338         dt_list_O_1->insert(DT_INT_16S);
06339         dt_list_O_1->insert(DT_INT_32U);
06340         dt_list_O_1->insert(DT_INT_32S);
06341         dt_list_O_1->insert(DT_BOOL);
06342         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06343         reg_list_O_1->insert(R_EAX);
06344         reg_list_O_1->insert(R_EBX);
06345         reg_list_O_1->insert(R_ECX);
06346         reg_list_O_1->insert(R_EDX);
06347         reg_list_O_1->insert(R_EDI);
06348         reg_list_O_1->insert(R_ESI);
06349         reg_list_O_1->insert(R_AX);
06350         reg_list_O_1->insert(R_BX);
06351         reg_list_O_1->insert(R_CX);
06352         reg_list_O_1->insert(R_DX);
06353         reg_list_O_1->insert(R_DI);
06354         reg_list_O_1->insert(R_SI);
06355         reg_list_O_1->insert(R_AL);
06356         reg_list_O_1->insert(R_AH);
06357         reg_list_O_1->insert(R_BL);
06358         reg_list_O_1->insert(R_BH);
06359         reg_list_O_1->insert(R_CL);
06360         reg_list_O_1->insert(R_CH);
06361         reg_list_O_1->insert(R_DL);
06362         reg_list_O_1->insert(R_DH);
06363         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06364         op_O_1->destroys_set(I_2);
06365         out_operands->push_back(op_O_1);
06366         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
06367         dt_list_O_2->insert(DT_COND);
06368         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
06369         reg_list_O_2->insert(R_COND);
06370         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
06371         out_operands->push_back(op_O_2);
06372 
06373         //execution info
06374         einfo = execution_info::create(30);
06375 
06376         //properties
06377 
06378         //versions
06379         versions = set<ulint>::create();
06380         versions->insert(INSTRUCTION_XOR__1);
06381         versions->insert(INSTRUCTION_XOR__11);
06382         versions->insert(INSTRUCTION_XOR__12);
06383         versions->insert(INSTRUCTION_XOR__13);
06384         versions->insert(INSTRUCTION_XOR__2);
06385 
06386 
06387         //return target pseudoinstruction
06388         return tm_instr::create(INSTRUCTION_XOR__14,in_operands,out_operands,lstring("xor $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
06389 }
06390 
06391 ptr<tm_instr> tm_instr_create_INSTRUCTION_XOR__2() {
06392         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06393         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06394         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06395         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06396         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06397         ptr<execution_info> einfo;
06398         ptr<set<ulint> > versions;
06399         
06400         //input operands
06401         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06402         dt_list_I_1->insert(DT_INT_8P);
06403         dt_list_I_1->insert(DT_INT_8U);
06404         dt_list_I_1->insert(DT_INT_8S);
06405         dt_list_I_1->insert(DT_INT_16U);
06406         dt_list_I_1->insert(DT_INT_16S);
06407         dt_list_I_1->insert(DT_INT_32U);
06408         dt_list_I_1->insert(DT_INT_32S);
06409         dt_list_I_1->insert(DT_BOOL);
06410         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
06411         reg_list_I_1->insert(R_EAX);
06412         reg_list_I_1->insert(R_EBX);
06413         reg_list_I_1->insert(R_ECX);
06414         reg_list_I_1->insert(R_EDX);
06415         reg_list_I_1->insert(R_EDI);
06416         reg_list_I_1->insert(R_ESI);
06417         reg_list_I_1->insert(R_AX);
06418         reg_list_I_1->insert(R_BX);
06419         reg_list_I_1->insert(R_CX);
06420         reg_list_I_1->insert(R_DX);
06421         reg_list_I_1->insert(R_DI);
06422         reg_list_I_1->insert(R_SI);
06423         reg_list_I_1->insert(R_AL);
06424         reg_list_I_1->insert(R_AH);
06425         reg_list_I_1->insert(R_BL);
06426         reg_list_I_1->insert(R_BH);
06427         reg_list_I_1->insert(R_CL);
06428         reg_list_I_1->insert(R_CH);
06429         reg_list_I_1->insert(R_DL);
06430         reg_list_I_1->insert(R_DH);
06431         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
06432         op_I_1->destroyed_by_get()->push_back(O_1);
06433         in_operands->push_back(op_I_1);
06434 
06435         //output operands
06436         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06437         dt_list_O_1->insert(DT_INT_8P);
06438         dt_list_O_1->insert(DT_INT_8U);
06439         dt_list_O_1->insert(DT_INT_8S);
06440         dt_list_O_1->insert(DT_INT_16U);
06441         dt_list_O_1->insert(DT_INT_16S);
06442         dt_list_O_1->insert(DT_INT_32U);
06443         dt_list_O_1->insert(DT_INT_32S);
06444         dt_list_O_1->insert(DT_BOOL);
06445         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06446         reg_list_O_1->insert(R_EAX);
06447         reg_list_O_1->insert(R_EBX);
06448         reg_list_O_1->insert(R_ECX);
06449         reg_list_O_1->insert(R_EDX);
06450         reg_list_O_1->insert(R_EDI);
06451         reg_list_O_1->insert(R_ESI);
06452         reg_list_O_1->insert(R_AX);
06453         reg_list_O_1->insert(R_BX);
06454         reg_list_O_1->insert(R_CX);
06455         reg_list_O_1->insert(R_DX);
06456         reg_list_O_1->insert(R_DI);
06457         reg_list_O_1->insert(R_SI);
06458         reg_list_O_1->insert(R_AL);
06459         reg_list_O_1->insert(R_AH);
06460         reg_list_O_1->insert(R_BL);
06461         reg_list_O_1->insert(R_BH);
06462         reg_list_O_1->insert(R_CL);
06463         reg_list_O_1->insert(R_CH);
06464         reg_list_O_1->insert(R_DL);
06465         reg_list_O_1->insert(R_DH);
06466         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06467         op_O_1->destroys_set(I_1);
06468         out_operands->push_back(op_O_1);
06469         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
06470         dt_list_O_2->insert(DT_COND);
06471         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
06472         reg_list_O_2->insert(R_COND);
06473         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
06474         out_operands->push_back(op_O_2);
06475 
06476         //execution info
06477         einfo = execution_info::create(10);
06478 
06479         //properties
06480 
06481         //versions
06482         versions = set<ulint>::create();
06483         versions->insert(INSTRUCTION_XOR__1);
06484         versions->insert(INSTRUCTION_XOR__11);
06485         versions->insert(INSTRUCTION_XOR__12);
06486         versions->insert(INSTRUCTION_XOR__13);
06487         versions->insert(INSTRUCTION_XOR__14);
06488 
06489 
06490         //return target pseudoinstruction
06491         return tm_instr::create(INSTRUCTION_XOR__2,in_operands,out_operands,lstring("xor $O_1, 0x1"), props,versions,0,einfo);
06492 }
06493 
06494 ptr<tm_instr> tm_instr_create_INSTRUCTION_NOT__1() {
06495         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06496         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06497         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06498         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06499         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06500         ptr<execution_info> einfo;
06501         ptr<set<ulint> > versions;
06502         
06503         //input operands
06504         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06505         dt_list_I_1->insert(DT_INT_8P);
06506         dt_list_I_1->insert(DT_INT_8U);
06507         dt_list_I_1->insert(DT_INT_8S);
06508         dt_list_I_1->insert(DT_INT_16U);
06509         dt_list_I_1->insert(DT_INT_16S);
06510         dt_list_I_1->insert(DT_INT_32U);
06511         dt_list_I_1->insert(DT_INT_32S);
06512         dt_list_I_1->insert(DT_BOOL);
06513         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
06514         reg_list_I_1->insert(R_EAX);
06515         reg_list_I_1->insert(R_EBX);
06516         reg_list_I_1->insert(R_ECX);
06517         reg_list_I_1->insert(R_EDX);
06518         reg_list_I_1->insert(R_EDI);
06519         reg_list_I_1->insert(R_ESI);
06520         reg_list_I_1->insert(R_AX);
06521         reg_list_I_1->insert(R_BX);
06522         reg_list_I_1->insert(R_CX);
06523         reg_list_I_1->insert(R_DX);
06524         reg_list_I_1->insert(R_DI);
06525         reg_list_I_1->insert(R_SI);
06526         reg_list_I_1->insert(R_AL);
06527         reg_list_I_1->insert(R_AH);
06528         reg_list_I_1->insert(R_BL);
06529         reg_list_I_1->insert(R_BH);
06530         reg_list_I_1->insert(R_CL);
06531         reg_list_I_1->insert(R_CH);
06532         reg_list_I_1->insert(R_DL);
06533         reg_list_I_1->insert(R_DH);
06534         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
06535         op_I_1->destroyed_by_get()->push_back(O_1);
06536         in_operands->push_back(op_I_1);
06537 
06538         //output operands
06539         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06540         dt_list_O_1->insert(DT_INT_8P);
06541         dt_list_O_1->insert(DT_INT_8U);
06542         dt_list_O_1->insert(DT_INT_8S);
06543         dt_list_O_1->insert(DT_INT_16U);
06544         dt_list_O_1->insert(DT_INT_16S);
06545         dt_list_O_1->insert(DT_INT_32U);
06546         dt_list_O_1->insert(DT_INT_32S);
06547         dt_list_O_1->insert(DT_BOOL);
06548         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06549         reg_list_O_1->insert(R_EAX);
06550         reg_list_O_1->insert(R_EBX);
06551         reg_list_O_1->insert(R_ECX);
06552         reg_list_O_1->insert(R_EDX);
06553         reg_list_O_1->insert(R_EDI);
06554         reg_list_O_1->insert(R_ESI);
06555         reg_list_O_1->insert(R_AX);
06556         reg_list_O_1->insert(R_BX);
06557         reg_list_O_1->insert(R_CX);
06558         reg_list_O_1->insert(R_DX);
06559         reg_list_O_1->insert(R_DI);
06560         reg_list_O_1->insert(R_SI);
06561         reg_list_O_1->insert(R_AL);
06562         reg_list_O_1->insert(R_AH);
06563         reg_list_O_1->insert(R_BL);
06564         reg_list_O_1->insert(R_BH);
06565         reg_list_O_1->insert(R_CL);
06566         reg_list_O_1->insert(R_CH);
06567         reg_list_O_1->insert(R_DL);
06568         reg_list_O_1->insert(R_DH);
06569         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06570         op_O_1->destroys_set(I_1);
06571         out_operands->push_back(op_O_1);
06572 
06573         //execution info
06574         einfo = execution_info::create(10);
06575 
06576         //properties
06577 
06578         //versions
06579 
06580 
06581         //return target pseudoinstruction
06582         return tm_instr::create(INSTRUCTION_NOT__1,in_operands,out_operands,lstring("not $O_1"), props,versions,0,einfo);
06583 }
06584 
06585 ptr<tm_instr> tm_instr_create_INSTRUCTION_CONVERT__1() {
06586         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06587         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06588         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06589         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06590         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06591         ptr<execution_info> einfo;
06592         ptr<set<ulint> > versions;
06593         
06594         //input operands
06595         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06596         dt_list_I_1->insert(DT_INT_8P);
06597         dt_list_I_1->insert(DT_INT_8U);
06598         dt_list_I_1->insert(DT_INT_8S);
06599         dt_list_I_1->insert(DT_INT_16U);
06600         dt_list_I_1->insert(DT_INT_16S);
06601         dt_list_I_1->insert(DT_INT_32U);
06602         dt_list_I_1->insert(DT_INT_32S);
06603         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
06604         reg_list_I_1->insert(R_EAX);
06605         reg_list_I_1->insert(R_EBX);
06606         reg_list_I_1->insert(R_ECX);
06607         reg_list_I_1->insert(R_EDX);
06608         reg_list_I_1->insert(R_EDI);
06609         reg_list_I_1->insert(R_ESI);
06610         reg_list_I_1->insert(R_AX);
06611         reg_list_I_1->insert(R_BX);
06612         reg_list_I_1->insert(R_CX);
06613         reg_list_I_1->insert(R_DX);
06614         reg_list_I_1->insert(R_DI);
06615         reg_list_I_1->insert(R_SI);
06616         reg_list_I_1->insert(R_AL);
06617         reg_list_I_1->insert(R_AH);
06618         reg_list_I_1->insert(R_BL);
06619         reg_list_I_1->insert(R_BH);
06620         reg_list_I_1->insert(R_CL);
06621         reg_list_I_1->insert(R_CH);
06622         reg_list_I_1->insert(R_DL);
06623         reg_list_I_1->insert(R_DH);
06624         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
06625         op_I_1->destroyed_by_get()->push_back(O_1);
06626         in_operands->push_back(op_I_1);
06627 
06628         //output operands
06629         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06630         dt_list_O_1->insert(DT_INT_8U);
06631         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06632         reg_list_O_1->insert(R_AL);
06633         reg_list_O_1->insert(R_AH);
06634         reg_list_O_1->insert(R_BL);
06635         reg_list_O_1->insert(R_BH);
06636         reg_list_O_1->insert(R_CL);
06637         reg_list_O_1->insert(R_CH);
06638         reg_list_O_1->insert(R_DL);
06639         reg_list_O_1->insert(R_DH);
06640         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06641         op_O_1->destroys_set(I_1);
06642         out_operands->push_back(op_O_1);
06643 
06644         //execution info
06645         einfo = execution_info::create(0);
06646 
06647         //properties
06648 
06649         //versions
06650         versions = set<ulint>::create();
06651         versions->insert(INSTRUCTION_CONVERT__5);
06652         versions->insert(INSTRUCTION_CONVERT__2);
06653         versions->insert(INSTRUCTION_CONVERT__3);
06654 
06655 
06656         //return target pseudoinstruction
06657         return tm_instr::create(INSTRUCTION_CONVERT__1,in_operands,out_operands,lstring(""), props,versions,0,einfo);
06658 }
06659 
06660 ptr<tm_instr> tm_instr_create_INSTRUCTION_CONVERT__5() {
06661         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06662         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06663         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06664         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06665         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06666         ptr<execution_info> einfo;
06667         ptr<set<ulint> > versions;
06668         
06669         //input operands
06670         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06671         dt_list_I_1->insert(DT_INT_8P);
06672         dt_list_I_1->insert(DT_INT_8U);
06673         dt_list_I_1->insert(DT_INT_8S);
06674         dt_list_I_1->insert(DT_INT_16U);
06675         dt_list_I_1->insert(DT_INT_16S);
06676         dt_list_I_1->insert(DT_INT_32U);
06677         dt_list_I_1->insert(DT_INT_32S);
06678         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
06679         reg_list_I_1->insert(R_EAX);
06680         reg_list_I_1->insert(R_EBX);
06681         reg_list_I_1->insert(R_ECX);
06682         reg_list_I_1->insert(R_EDX);
06683         reg_list_I_1->insert(R_EDI);
06684         reg_list_I_1->insert(R_ESI);
06685         reg_list_I_1->insert(R_AX);
06686         reg_list_I_1->insert(R_BX);
06687         reg_list_I_1->insert(R_CX);
06688         reg_list_I_1->insert(R_DX);
06689         reg_list_I_1->insert(R_DI);
06690         reg_list_I_1->insert(R_SI);
06691         reg_list_I_1->insert(R_AL);
06692         reg_list_I_1->insert(R_AH);
06693         reg_list_I_1->insert(R_BL);
06694         reg_list_I_1->insert(R_BH);
06695         reg_list_I_1->insert(R_CL);
06696         reg_list_I_1->insert(R_CH);
06697         reg_list_I_1->insert(R_DL);
06698         reg_list_I_1->insert(R_DH);
06699         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
06700         op_I_1->destroyed_by_get()->push_back(O_1);
06701         in_operands->push_back(op_I_1);
06702 
06703         //output operands
06704         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06705         dt_list_O_1->insert(DT_INT_8P);
06706         dt_list_O_1->insert(DT_INT_8U);
06707         dt_list_O_1->insert(DT_INT_8S);
06708         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06709         reg_list_O_1->insert(R_AL);
06710         reg_list_O_1->insert(R_AH);
06711         reg_list_O_1->insert(R_BL);
06712         reg_list_O_1->insert(R_BH);
06713         reg_list_O_1->insert(R_CL);
06714         reg_list_O_1->insert(R_CH);
06715         reg_list_O_1->insert(R_DL);
06716         reg_list_O_1->insert(R_DH);
06717         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06718         op_O_1->destroys_set(I_1);
06719         out_operands->push_back(op_O_1);
06720 
06721         //execution info
06722         einfo = execution_info::create(0);
06723 
06724         //properties
06725 
06726         //versions
06727         versions = set<ulint>::create();
06728         versions->insert(INSTRUCTION_CONVERT__1);
06729         versions->insert(INSTRUCTION_CONVERT__2);
06730         versions->insert(INSTRUCTION_CONVERT__3);
06731 
06732 
06733         //return target pseudoinstruction
06734         return tm_instr::create(INSTRUCTION_CONVERT__5,in_operands,out_operands,lstring(""), props,versions,0,einfo);
06735 }
06736 
06737 ptr<tm_instr> tm_instr_create_INSTRUCTION_CONVERT__2() {
06738         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06739         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06740         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06741         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06742         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06743         ptr<execution_info> einfo;
06744         ptr<set<ulint> > versions;
06745         
06746         //input operands
06747         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06748         dt_list_I_1->insert(DT_INT_32U);
06749         dt_list_I_1->insert(DT_INT_32S);
06750         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
06751         reg_list_I_1->insert(R_EAX);
06752         reg_list_I_1->insert(R_EBX);
06753         reg_list_I_1->insert(R_ECX);
06754         reg_list_I_1->insert(R_EDX);
06755         reg_list_I_1->insert(R_EDI);
06756         reg_list_I_1->insert(R_ESI);
06757         reg_list_I_1->insert(R_AX);
06758         reg_list_I_1->insert(R_BX);
06759         reg_list_I_1->insert(R_CX);
06760         reg_list_I_1->insert(R_DX);
06761         reg_list_I_1->insert(R_DI);
06762         reg_list_I_1->insert(R_SI);
06763         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
06764         op_I_1->destroyed_by_get()->push_back(O_1);
06765         in_operands->push_back(op_I_1);
06766 
06767         //output operands
06768         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06769         dt_list_O_1->insert(DT_INT_16U);
06770         dt_list_O_1->insert(DT_INT_16S);
06771         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06772         reg_list_O_1->insert(R_AX);
06773         reg_list_O_1->insert(R_BX);
06774         reg_list_O_1->insert(R_CX);
06775         reg_list_O_1->insert(R_DX);
06776         reg_list_O_1->insert(R_DI);
06777         reg_list_O_1->insert(R_SI);
06778         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06779         op_O_1->destroys_set(I_1);
06780         out_operands->push_back(op_O_1);
06781 
06782         //execution info
06783         einfo = execution_info::create(0);
06784 
06785         //properties
06786 
06787         //versions
06788         versions = set<ulint>::create();
06789         versions->insert(INSTRUCTION_CONVERT__1);
06790         versions->insert(INSTRUCTION_CONVERT__5);
06791         versions->insert(INSTRUCTION_CONVERT__3);
06792 
06793 
06794         //return target pseudoinstruction
06795         return tm_instr::create(INSTRUCTION_CONVERT__2,in_operands,out_operands,lstring(""), props,versions,0,einfo);
06796 }
06797 
06798 ptr<tm_instr> tm_instr_create_INSTRUCTION_CONVERT__3() {
06799         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06800         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06801         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06802         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06803         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06804         ptr<execution_info> einfo;
06805         ptr<set<ulint> > versions;
06806         
06807         //input operands
06808         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06809         dt_list_I_1->insert(DT_INT_32U);
06810         dt_list_I_1->insert(DT_INT_32S);
06811         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
06812         reg_list_I_1->insert(R_EAX);
06813         reg_list_I_1->insert(R_EBX);
06814         reg_list_I_1->insert(R_ECX);
06815         reg_list_I_1->insert(R_EDX);
06816         reg_list_I_1->insert(R_EDI);
06817         reg_list_I_1->insert(R_ESI);
06818         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
06819         op_I_1->destroyed_by_get()->push_back(O_1);
06820         in_operands->push_back(op_I_1);
06821 
06822         //output operands
06823         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06824         dt_list_O_1->insert(DT_INT_32U);
06825         dt_list_O_1->insert(DT_INT_32S);
06826         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06827         reg_list_O_1->insert(R_EAX);
06828         reg_list_O_1->insert(R_EBX);
06829         reg_list_O_1->insert(R_ECX);
06830         reg_list_O_1->insert(R_EDX);
06831         reg_list_O_1->insert(R_EDI);
06832         reg_list_O_1->insert(R_ESI);
06833         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06834         op_O_1->destroys_set(I_1);
06835         out_operands->push_back(op_O_1);
06836 
06837         //execution info
06838         einfo = execution_info::create(0);
06839 
06840         //properties
06841 
06842         //versions
06843         versions = set<ulint>::create();
06844         versions->insert(INSTRUCTION_CONVERT__1);
06845         versions->insert(INSTRUCTION_CONVERT__5);
06846         versions->insert(INSTRUCTION_CONVERT__2);
06847 
06848 
06849         //return target pseudoinstruction
06850         return tm_instr::create(INSTRUCTION_CONVERT__3,in_operands,out_operands,lstring(""), props,versions,0,einfo);
06851 }
06852 
06853 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOVZX__1() {
06854         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06855         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06856         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06857         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06858         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06859         ptr<execution_info> einfo;
06860         ptr<set<ulint> > versions;
06861         
06862         //input operands
06863         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06864         dt_list_I_1->insert(DT_INT_8P);
06865         dt_list_I_1->insert(DT_INT_8U);
06866         dt_list_I_1->insert(DT_INT_8S);
06867         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
06868         reg_list_I_1->insert(R_AL);
06869         reg_list_I_1->insert(R_AH);
06870         reg_list_I_1->insert(R_BL);
06871         reg_list_I_1->insert(R_BH);
06872         reg_list_I_1->insert(R_CL);
06873         reg_list_I_1->insert(R_CH);
06874         reg_list_I_1->insert(R_DL);
06875         reg_list_I_1->insert(R_DH);
06876         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
06877         in_operands->push_back(op_I_1);
06878 
06879         //output operands
06880         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06881         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06882         reg_list_O_1->insert(R_EAX);
06883         reg_list_O_1->insert(R_EBX);
06884         reg_list_O_1->insert(R_ECX);
06885         reg_list_O_1->insert(R_EDX);
06886         reg_list_O_1->insert(R_EDI);
06887         reg_list_O_1->insert(R_ESI);
06888         reg_list_O_1->insert(R_AX);
06889         reg_list_O_1->insert(R_BX);
06890         reg_list_O_1->insert(R_CX);
06891         reg_list_O_1->insert(R_DX);
06892         reg_list_O_1->insert(R_DI);
06893         reg_list_O_1->insert(R_SI);
06894         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06895         out_operands->push_back(op_O_1);
06896 
06897         //execution info
06898         einfo = execution_info::create(10);
06899 
06900         //properties
06901 
06902         //versions
06903         versions = set<ulint>::create();
06904         versions->insert(INSTRUCTION_MOVZX__2);
06905         versions->insert(INSTRUCTION_MOVZX__3);
06906         versions->insert(INSTRUCTION_MOVZX__4);
06907         versions->insert(INSTRUCTION_MOVZX__5);
06908         versions->insert(INSTRUCTION_MOVZX__6);
06909 
06910 
06911         //return target pseudoinstruction
06912         return tm_instr::create(INSTRUCTION_MOVZX__1,in_operands,out_operands,lstring("movzx $O_1, $I_1"), props,versions,0,einfo);
06913 }
06914 
06915 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOVZX__2() {
06916         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06917         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06918         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06919         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06920         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06921         ptr<execution_info> einfo;
06922         ptr<set<ulint> > versions;
06923         
06924         //input operands
06925         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06926         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
06927         reg_list_I_1->insert(R_AX);
06928         reg_list_I_1->insert(R_BX);
06929         reg_list_I_1->insert(R_CX);
06930         reg_list_I_1->insert(R_DX);
06931         reg_list_I_1->insert(R_DI);
06932         reg_list_I_1->insert(R_SI);
06933         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
06934         in_operands->push_back(op_I_1);
06935 
06936         //output operands
06937         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06938         dt_list_O_1->insert(DT_INT_32U);
06939         dt_list_O_1->insert(DT_INT_32S);
06940         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
06941         reg_list_O_1->insert(R_EAX);
06942         reg_list_O_1->insert(R_EBX);
06943         reg_list_O_1->insert(R_ECX);
06944         reg_list_O_1->insert(R_EDX);
06945         reg_list_O_1->insert(R_EDI);
06946         reg_list_O_1->insert(R_ESI);
06947         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
06948         out_operands->push_back(op_O_1);
06949 
06950         //execution info
06951         einfo = execution_info::create(10);
06952 
06953         //properties
06954 
06955         //versions
06956         versions = set<ulint>::create();
06957         versions->insert(INSTRUCTION_MOVZX__1);
06958         versions->insert(INSTRUCTION_MOVZX__3);
06959         versions->insert(INSTRUCTION_MOVZX__4);
06960         versions->insert(INSTRUCTION_MOVZX__5);
06961         versions->insert(INSTRUCTION_MOVZX__6);
06962 
06963 
06964         //return target pseudoinstruction
06965         return tm_instr::create(INSTRUCTION_MOVZX__2,in_operands,out_operands,lstring("movzx $O_1, $I_1"), props,versions,0,einfo);
06966 }
06967 
06968 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOVZX__3() {
06969         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
06970         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
06971         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
06972         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
06973         ptr<set<tm_data_type_base::id_type> > allowed_types; 
06974         ptr<execution_info> einfo;
06975         ptr<set<ulint> > versions;
06976         
06977         //input operands
06978         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
06979         dt_list_I_1->insert(DT_BOOL);
06980         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
06981         reg_list_I_1->insert(R_AL);
06982         reg_list_I_1->insert(R_AH);
06983         reg_list_I_1->insert(R_BL);
06984         reg_list_I_1->insert(R_BH);
06985         reg_list_I_1->insert(R_CL);
06986         reg_list_I_1->insert(R_CH);
06987         reg_list_I_1->insert(R_DL);
06988         reg_list_I_1->insert(R_DH);
06989         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
06990         in_operands->push_back(op_I_1);
06991 
06992         //output operands
06993         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
06994         dt_list_O_1->insert(DT_INT_8P);
06995         dt_list_O_1->insert(DT_INT_8U);
06996         dt_list_O_1->insert(DT_INT_8S);
06997         dt_list_O_1->insert(DT_INT_16U);
06998         dt_list_O_1->insert(DT_INT_16S);
06999         dt_list_O_1->insert(DT_INT_32U);
07000         dt_list_O_1->insert(DT_INT_32S);
07001         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07002         reg_list_O_1->insert(R_EAX);
07003         reg_list_O_1->insert(R_EBX);
07004         reg_list_O_1->insert(R_ECX);
07005         reg_list_O_1->insert(R_EDX);
07006         reg_list_O_1->insert(R_EDI);
07007         reg_list_O_1->insert(R_ESI);
07008         reg_list_O_1->insert(R_AX);
07009         reg_list_O_1->insert(R_BX);
07010         reg_list_O_1->insert(R_CX);
07011         reg_list_O_1->insert(R_DX);
07012         reg_list_O_1->insert(R_DI);
07013         reg_list_O_1->insert(R_SI);
07014         reg_list_O_1->insert(R_AL);
07015         reg_list_O_1->insert(R_AH);
07016         reg_list_O_1->insert(R_BL);
07017         reg_list_O_1->insert(R_BH);
07018         reg_list_O_1->insert(R_CL);
07019         reg_list_O_1->insert(R_CH);
07020         reg_list_O_1->insert(R_DL);
07021         reg_list_O_1->insert(R_DH);
07022         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07023         out_operands->push_back(op_O_1);
07024 
07025         //execution info
07026         einfo = execution_info::create(10);
07027 
07028         //properties
07029 
07030         //versions
07031         versions = set<ulint>::create();
07032         versions->insert(INSTRUCTION_MOVZX__1);
07033         versions->insert(INSTRUCTION_MOVZX__2);
07034         versions->insert(INSTRUCTION_MOVZX__4);
07035         versions->insert(INSTRUCTION_MOVZX__5);
07036         versions->insert(INSTRUCTION_MOVZX__6);
07037 
07038 
07039         //return target pseudoinstruction
07040         return tm_instr::create(INSTRUCTION_MOVZX__3,in_operands,out_operands,lstring("movzx $O_1, $I_1"), props,versions,0,einfo);
07041 }
07042 
07043 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOVZX__4() {
07044         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07045         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07046         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07047         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07048         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07049         ptr<execution_info> einfo;
07050         ptr<set<ulint> > versions;
07051         
07052         //input operands
07053         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07054         dt_list_I_1->insert(DT_BOOL);
07055         dt_list_I_1->insert(DT_INT_8P);
07056         dt_list_I_1->insert(DT_INT_8U);
07057         dt_list_I_1->insert(DT_INT_8S);
07058         dt_list_I_1->insert(DT_INT_16U);
07059         dt_list_I_1->insert(DT_INT_16S);
07060         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
07061         reg_list_I_1->insert(R_AL);
07062         reg_list_I_1->insert(R_AH);
07063         reg_list_I_1->insert(R_BL);
07064         reg_list_I_1->insert(R_BH);
07065         reg_list_I_1->insert(R_CL);
07066         reg_list_I_1->insert(R_CH);
07067         reg_list_I_1->insert(R_DL);
07068         reg_list_I_1->insert(R_DH);
07069         reg_list_I_1->insert(R_AX);
07070         reg_list_I_1->insert(R_BX);
07071         reg_list_I_1->insert(R_CX);
07072         reg_list_I_1->insert(R_DX);
07073         reg_list_I_1->insert(R_DI);
07074         reg_list_I_1->insert(R_SI);
07075         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
07076         in_operands->push_back(op_I_1);
07077 
07078         //output operands
07079         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07080         dt_list_O_1->insert(DT_INT_32U);
07081         dt_list_O_1->insert(DT_INT_32S);
07082         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07083         reg_list_O_1->insert(R_EAX);
07084         reg_list_O_1->insert(R_EBX);
07085         reg_list_O_1->insert(R_ECX);
07086         reg_list_O_1->insert(R_EDX);
07087         reg_list_O_1->insert(R_EDI);
07088         reg_list_O_1->insert(R_ESI);
07089         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07090         out_operands->push_back(op_O_1);
07091 
07092         //execution info
07093         einfo = execution_info::create(10);
07094 
07095         //properties
07096 
07097         //versions
07098         versions = set<ulint>::create();
07099         versions->insert(INSTRUCTION_MOVZX__1);
07100         versions->insert(INSTRUCTION_MOVZX__2);
07101         versions->insert(INSTRUCTION_MOVZX__3);
07102         versions->insert(INSTRUCTION_MOVZX__5);
07103         versions->insert(INSTRUCTION_MOVZX__6);
07104 
07105 
07106         //return target pseudoinstruction
07107         return tm_instr::create(INSTRUCTION_MOVZX__4,in_operands,out_operands,lstring("movzx $O_1, $I_1"), props,versions,0,einfo);
07108 }
07109 
07110 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOVZX__5() {
07111         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07112         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07113         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07114         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07115         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07116         ptr<execution_info> einfo;
07117         ptr<set<ulint> > versions;
07118         
07119         //input operands
07120         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07121         dt_list_I_1->insert(DT_BOOL);
07122         dt_list_I_1->insert(DT_INT_8P);
07123         dt_list_I_1->insert(DT_INT_8U);
07124         dt_list_I_1->insert(DT_INT_8S);
07125         dt_list_I_1->insert(DT_INT_16U);
07126         dt_list_I_1->insert(DT_INT_16S);
07127         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
07128         in_operands->push_back(op_I_1);
07129 
07130         //output operands
07131         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07132         dt_list_O_1->insert(DT_INT_32U);
07133         dt_list_O_1->insert(DT_INT_32S);
07134         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07135         reg_list_O_1->insert(R_EAX);
07136         reg_list_O_1->insert(R_EBX);
07137         reg_list_O_1->insert(R_ECX);
07138         reg_list_O_1->insert(R_EDX);
07139         reg_list_O_1->insert(R_EDI);
07140         reg_list_O_1->insert(R_ESI);
07141         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07142         out_operands->push_back(op_O_1);
07143 
07144         //execution info
07145         einfo = execution_info::create(30);
07146 
07147         //properties
07148 
07149         //versions
07150         versions = set<ulint>::create();
07151         versions->insert(INSTRUCTION_MOVZX__1);
07152         versions->insert(INSTRUCTION_MOVZX__2);
07153         versions->insert(INSTRUCTION_MOVZX__3);
07154         versions->insert(INSTRUCTION_MOVZX__4);
07155         versions->insert(INSTRUCTION_MOVZX__6);
07156 
07157 
07158         //return target pseudoinstruction
07159         return tm_instr::create(INSTRUCTION_MOVZX__5,in_operands,out_operands,lstring("movzx $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
07160 }
07161 
07162 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOVZX__6() {
07163         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07164         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07165         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07166         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07167         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07168         ptr<execution_info> einfo;
07169         ptr<set<ulint> > versions;
07170         
07171         //input operands
07172         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07173         dt_list_I_1->insert(DT_BOOL);
07174         dt_list_I_1->insert(DT_INT_8P);
07175         dt_list_I_1->insert(DT_INT_8U);
07176         dt_list_I_1->insert(DT_INT_8S);
07177         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
07178         in_operands->push_back(op_I_1);
07179 
07180         //output operands
07181         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07182         dt_list_O_1->insert(DT_INT_16U);
07183         dt_list_O_1->insert(DT_INT_16S);
07184         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07185         reg_list_O_1->insert(R_AX);
07186         reg_list_O_1->insert(R_BX);
07187         reg_list_O_1->insert(R_CX);
07188         reg_list_O_1->insert(R_DX);
07189         reg_list_O_1->insert(R_DI);
07190         reg_list_O_1->insert(R_SI);
07191         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07192         out_operands->push_back(op_O_1);
07193 
07194         //execution info
07195         einfo = execution_info::create(30);
07196 
07197         //properties
07198 
07199         //versions
07200         versions = set<ulint>::create();
07201         versions->insert(INSTRUCTION_MOVZX__1);
07202         versions->insert(INSTRUCTION_MOVZX__2);
07203         versions->insert(INSTRUCTION_MOVZX__3);
07204         versions->insert(INSTRUCTION_MOVZX__4);
07205         versions->insert(INSTRUCTION_MOVZX__5);
07206 
07207 
07208         //return target pseudoinstruction
07209         return tm_instr::create(INSTRUCTION_MOVZX__6,in_operands,out_operands,lstring("movzx $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
07210 }
07211 
07212 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOVSX__1() {
07213         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07214         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07215         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07216         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07217         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07218         ptr<execution_info> einfo;
07219         ptr<set<ulint> > versions;
07220         
07221         //input operands
07222         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07223         dt_list_I_1->insert(DT_INT_8P);
07224         dt_list_I_1->insert(DT_INT_8U);
07225         dt_list_I_1->insert(DT_INT_8S);
07226         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
07227         reg_list_I_1->insert(R_AL);
07228         reg_list_I_1->insert(R_AH);
07229         reg_list_I_1->insert(R_BL);
07230         reg_list_I_1->insert(R_BH);
07231         reg_list_I_1->insert(R_CL);
07232         reg_list_I_1->insert(R_CH);
07233         reg_list_I_1->insert(R_DL);
07234         reg_list_I_1->insert(R_DH);
07235         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
07236         in_operands->push_back(op_I_1);
07237 
07238         //output operands
07239         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07240         dt_list_O_1->insert(DT_INT_32S);
07241         dt_list_O_1->insert(DT_INT_16S);
07242         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07243         reg_list_O_1->insert(R_EAX);
07244         reg_list_O_1->insert(R_EBX);
07245         reg_list_O_1->insert(R_ECX);
07246         reg_list_O_1->insert(R_EDX);
07247         reg_list_O_1->insert(R_EDI);
07248         reg_list_O_1->insert(R_ESI);
07249         reg_list_O_1->insert(R_AX);
07250         reg_list_O_1->insert(R_BX);
07251         reg_list_O_1->insert(R_CX);
07252         reg_list_O_1->insert(R_DX);
07253         reg_list_O_1->insert(R_DI);
07254         reg_list_O_1->insert(R_SI);
07255         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07256         out_operands->push_back(op_O_1);
07257 
07258         //execution info
07259         einfo = execution_info::create(10);
07260 
07261         //properties
07262 
07263         //versions
07264         versions = set<ulint>::create();
07265         versions->insert(INSTRUCTION_MOVSX__11);
07266         versions->insert(INSTRUCTION_MOVSX__2);
07267         versions->insert(INSTRUCTION_MOVSX__21);
07268 
07269 
07270         //return target pseudoinstruction
07271         return tm_instr::create(INSTRUCTION_MOVSX__1,in_operands,out_operands,lstring("movsx $O_1, $I_1"), props,versions,0,einfo);
07272 }
07273 
07274 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOVSX__11() {
07275         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07276         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07277         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07278         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07279         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07280         ptr<execution_info> einfo;
07281         ptr<set<ulint> > versions;
07282         
07283         //input operands
07284         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07285         dt_list_I_1->insert(DT_INT_8P);
07286         dt_list_I_1->insert(DT_INT_8U);
07287         dt_list_I_1->insert(DT_INT_8S);
07288         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
07289         in_operands->push_back(op_I_1);
07290 
07291         //output operands
07292         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07293         dt_list_O_1->insert(DT_INT_32S);
07294         dt_list_O_1->insert(DT_INT_16S);
07295         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07296         reg_list_O_1->insert(R_EAX);
07297         reg_list_O_1->insert(R_EBX);
07298         reg_list_O_1->insert(R_ECX);
07299         reg_list_O_1->insert(R_EDX);
07300         reg_list_O_1->insert(R_EDI);
07301         reg_list_O_1->insert(R_ESI);
07302         reg_list_O_1->insert(R_AX);
07303         reg_list_O_1->insert(R_BX);
07304         reg_list_O_1->insert(R_CX);
07305         reg_list_O_1->insert(R_DX);
07306         reg_list_O_1->insert(R_DI);
07307         reg_list_O_1->insert(R_SI);
07308         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07309         out_operands->push_back(op_O_1);
07310 
07311         //execution info
07312         einfo = execution_info::create(30);
07313 
07314         //properties
07315 
07316         //versions
07317         versions = set<ulint>::create();
07318         versions->insert(INSTRUCTION_MOVSX__1);
07319         versions->insert(INSTRUCTION_MOVSX__2);
07320         versions->insert(INSTRUCTION_MOVSX__21);
07321 
07322 
07323         //return target pseudoinstruction
07324         return tm_instr::create(INSTRUCTION_MOVSX__11,in_operands,out_operands,lstring("movsx $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
07325 }
07326 
07327 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOVSX__2() {
07328         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07329         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07330         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07331         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07332         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07333         ptr<execution_info> einfo;
07334         ptr<set<ulint> > versions;
07335         
07336         //input operands
07337         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07338         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
07339         reg_list_I_1->insert(R_AX);
07340         reg_list_I_1->insert(R_BX);
07341         reg_list_I_1->insert(R_CX);
07342         reg_list_I_1->insert(R_DX);
07343         reg_list_I_1->insert(R_DI);
07344         reg_list_I_1->insert(R_SI);
07345         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
07346         in_operands->push_back(op_I_1);
07347 
07348         //output operands
07349         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07350         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07351         reg_list_O_1->insert(R_EAX);
07352         reg_list_O_1->insert(R_EBX);
07353         reg_list_O_1->insert(R_ECX);
07354         reg_list_O_1->insert(R_EDX);
07355         reg_list_O_1->insert(R_EDI);
07356         reg_list_O_1->insert(R_ESI);
07357         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07358         out_operands->push_back(op_O_1);
07359 
07360         //execution info
07361         einfo = execution_info::create(10);
07362 
07363         //properties
07364 
07365         //versions
07366         versions = set<ulint>::create();
07367         versions->insert(INSTRUCTION_MOVSX__1);
07368         versions->insert(INSTRUCTION_MOVSX__11);
07369         versions->insert(INSTRUCTION_MOVSX__21);
07370 
07371 
07372         //return target pseudoinstruction
07373         return tm_instr::create(INSTRUCTION_MOVSX__2,in_operands,out_operands,lstring("movsx $O_1, $I_1"), props,versions,0,einfo);
07374 }
07375 
07376 ptr<tm_instr> tm_instr_create_INSTRUCTION_MOVSX__21() {
07377         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07378         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07379         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07380         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07381         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07382         ptr<execution_info> einfo;
07383         ptr<set<ulint> > versions;
07384         
07385         //input operands
07386         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07387         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
07388         in_operands->push_back(op_I_1);
07389 
07390         //output operands
07391         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07392         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07393         reg_list_O_1->insert(R_EAX);
07394         reg_list_O_1->insert(R_EBX);
07395         reg_list_O_1->insert(R_ECX);
07396         reg_list_O_1->insert(R_EDX);
07397         reg_list_O_1->insert(R_EDI);
07398         reg_list_O_1->insert(R_ESI);
07399         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07400         out_operands->push_back(op_O_1);
07401 
07402         //execution info
07403         einfo = execution_info::create(30);
07404 
07405         //properties
07406 
07407         //versions
07408         versions = set<ulint>::create();
07409         versions->insert(INSTRUCTION_MOVSX__1);
07410         versions->insert(INSTRUCTION_MOVSX__11);
07411         versions->insert(INSTRUCTION_MOVSX__2);
07412 
07413 
07414         //return target pseudoinstruction
07415         return tm_instr::create(INSTRUCTION_MOVSX__21,in_operands,out_operands,lstring("movsx $O_1, $TYPE_I_1 $I_1"), props,versions,0,einfo);
07416 }
07417 
07418 ptr<tm_instr> tm_instr_create_INSTRUCTION_LEA__1() {
07419         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07420         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07421         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07422         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07423         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07424         ptr<execution_info> einfo;
07425         ptr<set<ulint> > versions;
07426         
07427         //input operands
07428         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07429         dt_list_I_1->insert(DT_INT_8P);
07430         dt_list_I_1->insert(DT_INT_8U);
07431         dt_list_I_1->insert(DT_INT_8S);
07432         dt_list_I_1->insert(DT_INT_16U);
07433         dt_list_I_1->insert(DT_INT_16S);
07434         dt_list_I_1->insert(DT_INT_32U);
07435         dt_list_I_1->insert(DT_INT_32S);
07436         dt_list_I_1->insert(DT_COND);
07437         dt_list_I_1->insert(DT_BOOL);
07438         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
07439         in_operands->push_back(op_I_1);
07440 
07441         //output operands
07442         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07443         dt_list_O_1->insert(DT_INT_32U);
07444         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07445         reg_list_O_1->insert(R_EAX);
07446         reg_list_O_1->insert(R_EBX);
07447         reg_list_O_1->insert(R_ECX);
07448         reg_list_O_1->insert(R_EDX);
07449         reg_list_O_1->insert(R_EDI);
07450         reg_list_O_1->insert(R_ESI);
07451         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07452         out_operands->push_back(op_O_1);
07453 
07454         //execution info
07455         einfo = execution_info::create(10);
07456 
07457         //properties
07458 
07459         //versions
07460         versions = set<ulint>::create();
07461         versions->insert(INSTRUCTION_LEAVE__1);
07462 
07463 
07464         //return target pseudoinstruction
07465         return tm_instr::create(INSTRUCTION_LEA__1,in_operands,out_operands,lstring("lea $O_1, $I_1"), props,versions,0,einfo);
07466 }
07467 
07468 ptr<tm_instr> tm_instr_create_INSTRUCTION_CMP__1() {
07469         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07470         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07471         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07472         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07473         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07474         ptr<execution_info> einfo;
07475         ptr<set<ulint> > versions;
07476         
07477         //input operands
07478         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07479         dt_list_I_1->insert(DT_INT_8P);
07480         dt_list_I_1->insert(DT_INT_8U);
07481         dt_list_I_1->insert(DT_INT_8S);
07482         dt_list_I_1->insert(DT_INT_16U);
07483         dt_list_I_1->insert(DT_INT_16S);
07484         dt_list_I_1->insert(DT_INT_32U);
07485         dt_list_I_1->insert(DT_INT_32S);
07486         dt_list_I_1->insert(DT_BOOL);
07487         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
07488         reg_list_I_1->insert(R_EAX);
07489         reg_list_I_1->insert(R_EBX);
07490         reg_list_I_1->insert(R_ECX);
07491         reg_list_I_1->insert(R_EDX);
07492         reg_list_I_1->insert(R_EDI);
07493         reg_list_I_1->insert(R_ESI);
07494         reg_list_I_1->insert(R_AX);
07495         reg_list_I_1->insert(R_BX);
07496         reg_list_I_1->insert(R_CX);
07497         reg_list_I_1->insert(R_DX);
07498         reg_list_I_1->insert(R_DI);
07499         reg_list_I_1->insert(R_SI);
07500         reg_list_I_1->insert(R_AL);
07501         reg_list_I_1->insert(R_AH);
07502         reg_list_I_1->insert(R_BL);
07503         reg_list_I_1->insert(R_BH);
07504         reg_list_I_1->insert(R_CL);
07505         reg_list_I_1->insert(R_CH);
07506         reg_list_I_1->insert(R_DL);
07507         reg_list_I_1->insert(R_DH);
07508         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
07509         in_operands->push_back(op_I_1);
07510 
07511         //output operands
07512         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07513         dt_list_O_1->insert(DT_COND);
07514         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07515         reg_list_O_1->insert(R_COND);
07516         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07517         out_operands->push_back(op_O_1);
07518 
07519         //execution info
07520         einfo = execution_info::create(10);
07521 
07522         //properties
07523 
07524         //versions
07525         versions = set<ulint>::create();
07526         versions->insert(INSTRUCTION_CMP__2);
07527         versions->insert(INSTRUCTION_CMP__21);
07528         versions->insert(INSTRUCTION_CMP__22);
07529         versions->insert(INSTRUCTION_CMP__23);
07530         versions->insert(INSTRUCTION_CMP__24);
07531 
07532 
07533         //return target pseudoinstruction
07534         return tm_instr::create(INSTRUCTION_CMP__1,in_operands,out_operands,lstring("cmp $I_1, 0"), props,versions,0,einfo);
07535 }
07536 
07537 ptr<tm_instr> tm_instr_create_INSTRUCTION_CMP__2() {
07538         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07539         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07540         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07541         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07542         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07543         ptr<execution_info> einfo;
07544         ptr<set<ulint> > versions;
07545         
07546         //input operands
07547         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07548         dt_list_I_1->insert(DT_INT_8P);
07549         dt_list_I_1->insert(DT_INT_8U);
07550         dt_list_I_1->insert(DT_INT_8S);
07551         dt_list_I_1->insert(DT_INT_16U);
07552         dt_list_I_1->insert(DT_INT_16S);
07553         dt_list_I_1->insert(DT_INT_32U);
07554         dt_list_I_1->insert(DT_INT_32S);
07555         dt_list_I_1->insert(DT_BOOL);
07556         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
07557         reg_list_I_1->insert(R_EAX);
07558         reg_list_I_1->insert(R_EBX);
07559         reg_list_I_1->insert(R_ECX);
07560         reg_list_I_1->insert(R_EDX);
07561         reg_list_I_1->insert(R_EDI);
07562         reg_list_I_1->insert(R_ESI);
07563         reg_list_I_1->insert(R_AX);
07564         reg_list_I_1->insert(R_BX);
07565         reg_list_I_1->insert(R_CX);
07566         reg_list_I_1->insert(R_DX);
07567         reg_list_I_1->insert(R_DI);
07568         reg_list_I_1->insert(R_SI);
07569         reg_list_I_1->insert(R_AL);
07570         reg_list_I_1->insert(R_AH);
07571         reg_list_I_1->insert(R_BL);
07572         reg_list_I_1->insert(R_BH);
07573         reg_list_I_1->insert(R_CL);
07574         reg_list_I_1->insert(R_CH);
07575         reg_list_I_1->insert(R_DL);
07576         reg_list_I_1->insert(R_DH);
07577         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
07578         in_operands->push_back(op_I_1);
07579         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
07580         dt_list_I_2->insert(DT_INT_8P);
07581         dt_list_I_2->insert(DT_INT_8U);
07582         dt_list_I_2->insert(DT_INT_8S);
07583         dt_list_I_2->insert(DT_INT_16U);
07584         dt_list_I_2->insert(DT_INT_16S);
07585         dt_list_I_2->insert(DT_INT_32U);
07586         dt_list_I_2->insert(DT_INT_32S);
07587         dt_list_I_2->insert(DT_BOOL);
07588         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
07589         reg_list_I_2->insert(R_EAX);
07590         reg_list_I_2->insert(R_EBX);
07591         reg_list_I_2->insert(R_ECX);
07592         reg_list_I_2->insert(R_EDX);
07593         reg_list_I_2->insert(R_EDI);
07594         reg_list_I_2->insert(R_ESI);
07595         reg_list_I_2->insert(R_AX);
07596         reg_list_I_2->insert(R_BX);
07597         reg_list_I_2->insert(R_CX);
07598         reg_list_I_2->insert(R_DX);
07599         reg_list_I_2->insert(R_DI);
07600         reg_list_I_2->insert(R_SI);
07601         reg_list_I_2->insert(R_AL);
07602         reg_list_I_2->insert(R_AH);
07603         reg_list_I_2->insert(R_BL);
07604         reg_list_I_2->insert(R_BH);
07605         reg_list_I_2->insert(R_CL);
07606         reg_list_I_2->insert(R_CH);
07607         reg_list_I_2->insert(R_DL);
07608         reg_list_I_2->insert(R_DH);
07609         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
07610         in_operands->push_back(op_I_2);
07611 
07612         //output operands
07613         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07614         dt_list_O_1->insert(DT_COND);
07615         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07616         reg_list_O_1->insert(R_COND);
07617         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07618         out_operands->push_back(op_O_1);
07619 
07620         //execution info
07621         einfo = execution_info::create(10);
07622 
07623         //properties
07624 
07625         //versions
07626         versions = set<ulint>::create();
07627         versions->insert(INSTRUCTION_CMP__1);
07628         versions->insert(INSTRUCTION_CMP__21);
07629         versions->insert(INSTRUCTION_CMP__22);
07630         versions->insert(INSTRUCTION_CMP__23);
07631         versions->insert(INSTRUCTION_CMP__24);
07632 
07633 
07634         //return target pseudoinstruction
07635         return tm_instr::create(INSTRUCTION_CMP__2,in_operands,out_operands,lstring("cmp $I_1, $I_2"), props,versions,0,einfo);
07636 }
07637 
07638 ptr<tm_instr> tm_instr_create_INSTRUCTION_CMP__21() {
07639         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07640         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07641         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07642         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07643         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07644         ptr<execution_info> einfo;
07645         ptr<set<ulint> > versions;
07646         
07647         //input operands
07648         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07649         dt_list_I_1->insert(DT_INT_8P);
07650         dt_list_I_1->insert(DT_INT_8U);
07651         dt_list_I_1->insert(DT_INT_8S);
07652         dt_list_I_1->insert(DT_INT_16U);
07653         dt_list_I_1->insert(DT_INT_16S);
07654         dt_list_I_1->insert(DT_INT_32U);
07655         dt_list_I_1->insert(DT_INT_32S);
07656         dt_list_I_1->insert(DT_BOOL);
07657         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
07658         reg_list_I_1->insert(R_EAX);
07659         reg_list_I_1->insert(R_EBX);
07660         reg_list_I_1->insert(R_ECX);
07661         reg_list_I_1->insert(R_EDX);
07662         reg_list_I_1->insert(R_EDI);
07663         reg_list_I_1->insert(R_ESI);
07664         reg_list_I_1->insert(R_AX);
07665         reg_list_I_1->insert(R_BX);
07666         reg_list_I_1->insert(R_CX);
07667         reg_list_I_1->insert(R_DX);
07668         reg_list_I_1->insert(R_DI);
07669         reg_list_I_1->insert(R_SI);
07670         reg_list_I_1->insert(R_AL);
07671         reg_list_I_1->insert(R_AH);
07672         reg_list_I_1->insert(R_BL);
07673         reg_list_I_1->insert(R_BH);
07674         reg_list_I_1->insert(R_CL);
07675         reg_list_I_1->insert(R_CH);
07676         reg_list_I_1->insert(R_DL);
07677         reg_list_I_1->insert(R_DH);
07678         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
07679         in_operands->push_back(op_I_1);
07680         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
07681         dt_list_I_2->insert(DT_INT_8P);
07682         dt_list_I_2->insert(DT_INT_8U);
07683         dt_list_I_2->insert(DT_INT_8S);
07684         dt_list_I_2->insert(DT_INT_16U);
07685         dt_list_I_2->insert(DT_INT_16S);
07686         dt_list_I_2->insert(DT_INT_32U);
07687         dt_list_I_2->insert(DT_INT_32S);
07688         dt_list_I_2->insert(DT_BOOL);
07689         ptr<tm_instr_op_imm> op_I_2 = tm_instr_op_imm::create(I_2, dt_list_I_2);
07690         in_operands->push_back(op_I_2);
07691 
07692         //output operands
07693         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07694         dt_list_O_1->insert(DT_COND);
07695         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07696         reg_list_O_1->insert(R_COND);
07697         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07698         out_operands->push_back(op_O_1);
07699 
07700         //execution info
07701         einfo = execution_info::create(10);
07702 
07703         //properties
07704 
07705         //versions
07706         versions = set<ulint>::create();
07707         versions->insert(INSTRUCTION_CMP__1);
07708         versions->insert(INSTRUCTION_CMP__2);
07709         versions->insert(INSTRUCTION_CMP__22);
07710         versions->insert(INSTRUCTION_CMP__23);
07711         versions->insert(INSTRUCTION_CMP__24);
07712 
07713 
07714         //return target pseudoinstruction
07715         return tm_instr::create(INSTRUCTION_CMP__21,in_operands,out_operands,lstring("cmp $I_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
07716 }
07717 
07718 ptr<tm_instr> tm_instr_create_INSTRUCTION_CMP__22() {
07719         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07720         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07721         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07722         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07723         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07724         ptr<execution_info> einfo;
07725         ptr<set<ulint> > versions;
07726         
07727         //input operands
07728         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07729         dt_list_I_1->insert(DT_INT_8P);
07730         dt_list_I_1->insert(DT_INT_8U);
07731         dt_list_I_1->insert(DT_INT_8S);
07732         dt_list_I_1->insert(DT_INT_16U);
07733         dt_list_I_1->insert(DT_INT_16S);
07734         dt_list_I_1->insert(DT_INT_32U);
07735         dt_list_I_1->insert(DT_INT_32S);
07736         dt_list_I_1->insert(DT_BOOL);
07737         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
07738         reg_list_I_1->insert(R_EAX);
07739         reg_list_I_1->insert(R_EBX);
07740         reg_list_I_1->insert(R_ECX);
07741         reg_list_I_1->insert(R_EDX);
07742         reg_list_I_1->insert(R_EDI);
07743         reg_list_I_1->insert(R_ESI);
07744         reg_list_I_1->insert(R_AX);
07745         reg_list_I_1->insert(R_BX);
07746         reg_list_I_1->insert(R_CX);
07747         reg_list_I_1->insert(R_DX);
07748         reg_list_I_1->insert(R_DI);
07749         reg_list_I_1->insert(R_SI);
07750         reg_list_I_1->insert(R_AL);
07751         reg_list_I_1->insert(R_AH);
07752         reg_list_I_1->insert(R_BL);
07753         reg_list_I_1->insert(R_BH);
07754         reg_list_I_1->insert(R_CL);
07755         reg_list_I_1->insert(R_CH);
07756         reg_list_I_1->insert(R_DL);
07757         reg_list_I_1->insert(R_DH);
07758         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
07759         in_operands->push_back(op_I_1);
07760         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
07761         dt_list_I_2->insert(DT_INT_8P);
07762         dt_list_I_2->insert(DT_INT_8U);
07763         dt_list_I_2->insert(DT_INT_8S);
07764         dt_list_I_2->insert(DT_INT_16U);
07765         dt_list_I_2->insert(DT_INT_16S);
07766         dt_list_I_2->insert(DT_INT_32U);
07767         dt_list_I_2->insert(DT_INT_32S);
07768         dt_list_I_2->insert(DT_BOOL);
07769         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
07770         in_operands->push_back(op_I_2);
07771 
07772         //output operands
07773         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07774         dt_list_O_1->insert(DT_COND);
07775         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07776         reg_list_O_1->insert(R_COND);
07777         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07778         out_operands->push_back(op_O_1);
07779 
07780         //execution info
07781         einfo = execution_info::create(30);
07782 
07783         //properties
07784 
07785         //versions
07786         versions = set<ulint>::create();
07787         versions->insert(INSTRUCTION_CMP__1);
07788         versions->insert(INSTRUCTION_CMP__2);
07789         versions->insert(INSTRUCTION_CMP__21);
07790         versions->insert(INSTRUCTION_CMP__23);
07791         versions->insert(INSTRUCTION_CMP__24);
07792 
07793 
07794         //return target pseudoinstruction
07795         return tm_instr::create(INSTRUCTION_CMP__22,in_operands,out_operands,lstring("cmp $I_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
07796 }
07797 
07798 ptr<tm_instr> tm_instr_create_INSTRUCTION_CMP__23() {
07799         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07800         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07801         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07802         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07803         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07804         ptr<execution_info> einfo;
07805         ptr<set<ulint> > versions;
07806         
07807         //input operands
07808         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07809         dt_list_I_1->insert(DT_INT_8P);
07810         dt_list_I_1->insert(DT_INT_8U);
07811         dt_list_I_1->insert(DT_INT_8S);
07812         dt_list_I_1->insert(DT_INT_16U);
07813         dt_list_I_1->insert(DT_INT_16S);
07814         dt_list_I_1->insert(DT_INT_32U);
07815         dt_list_I_1->insert(DT_INT_32S);
07816         dt_list_I_1->insert(DT_BOOL);
07817         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
07818         in_operands->push_back(op_I_1);
07819         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
07820         dt_list_I_2->insert(DT_INT_8P);
07821         dt_list_I_2->insert(DT_INT_8U);
07822         dt_list_I_2->insert(DT_INT_8S);
07823         dt_list_I_2->insert(DT_INT_16U);
07824         dt_list_I_2->insert(DT_INT_16S);
07825         dt_list_I_2->insert(DT_INT_32U);
07826         dt_list_I_2->insert(DT_INT_32S);
07827         dt_list_I_2->insert(DT_BOOL);
07828         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
07829         reg_list_I_2->insert(R_EAX);
07830         reg_list_I_2->insert(R_EBX);
07831         reg_list_I_2->insert(R_ECX);
07832         reg_list_I_2->insert(R_EDX);
07833         reg_list_I_2->insert(R_EDI);
07834         reg_list_I_2->insert(R_ESI);
07835         reg_list_I_2->insert(R_AX);
07836         reg_list_I_2->insert(R_BX);
07837         reg_list_I_2->insert(R_CX);
07838         reg_list_I_2->insert(R_DX);
07839         reg_list_I_2->insert(R_DI);
07840         reg_list_I_2->insert(R_SI);
07841         reg_list_I_2->insert(R_AL);
07842         reg_list_I_2->insert(R_AH);
07843         reg_list_I_2->insert(R_BL);
07844         reg_list_I_2->insert(R_BH);
07845         reg_list_I_2->insert(R_CL);
07846         reg_list_I_2->insert(R_CH);
07847         reg_list_I_2->insert(R_DL);
07848         reg_list_I_2->insert(R_DH);
07849         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
07850         in_operands->push_back(op_I_2);
07851 
07852         //output operands
07853         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07854         dt_list_O_1->insert(DT_COND);
07855         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07856         reg_list_O_1->insert(R_COND);
07857         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07858         out_operands->push_back(op_O_1);
07859 
07860         //execution info
07861         einfo = execution_info::create(30);
07862 
07863         //properties
07864 
07865         //versions
07866         versions = set<ulint>::create();
07867         versions->insert(INSTRUCTION_CMP__1);
07868         versions->insert(INSTRUCTION_CMP__2);
07869         versions->insert(INSTRUCTION_CMP__21);
07870         versions->insert(INSTRUCTION_CMP__22);
07871         versions->insert(INSTRUCTION_CMP__24);
07872 
07873 
07874         //return target pseudoinstruction
07875         return tm_instr::create(INSTRUCTION_CMP__23,in_operands,out_operands,lstring("cmp $I_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
07876 }
07877 
07878 ptr<tm_instr> tm_instr_create_INSTRUCTION_CMP__24() {
07879         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07880         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07881         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07882         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07883         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07884         ptr<execution_info> einfo;
07885         ptr<set<ulint> > versions;
07886         
07887         //input operands
07888         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07889         dt_list_I_1->insert(DT_INT_8P);
07890         dt_list_I_1->insert(DT_INT_8U);
07891         dt_list_I_1->insert(DT_INT_8S);
07892         dt_list_I_1->insert(DT_INT_16U);
07893         dt_list_I_1->insert(DT_INT_16S);
07894         dt_list_I_1->insert(DT_INT_32U);
07895         dt_list_I_1->insert(DT_INT_32S);
07896         dt_list_I_1->insert(DT_BOOL);
07897         ptr<tm_instr_op_mem> op_I_1 = tm_instr_op_mem::create(I_1, dt_list_I_1);
07898         in_operands->push_back(op_I_1);
07899         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
07900         dt_list_I_2->insert(DT_INT_8P);
07901         dt_list_I_2->insert(DT_INT_8U);
07902         dt_list_I_2->insert(DT_INT_8S);
07903         dt_list_I_2->insert(DT_INT_16U);
07904         dt_list_I_2->insert(DT_INT_16S);
07905         dt_list_I_2->insert(DT_INT_32U);
07906         dt_list_I_2->insert(DT_INT_32S);
07907         dt_list_I_2->insert(DT_BOOL);
07908         ptr<tm_instr_op_imm> op_I_2 = tm_instr_op_imm::create(I_2, dt_list_I_2);
07909         in_operands->push_back(op_I_2);
07910 
07911         //output operands
07912         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
07913         dt_list_O_1->insert(DT_COND);
07914         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
07915         reg_list_O_1->insert(R_COND);
07916         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
07917         out_operands->push_back(op_O_1);
07918 
07919         //execution info
07920         einfo = execution_info::create(30);
07921 
07922         //properties
07923 
07924         //versions
07925         versions = set<ulint>::create();
07926         versions->insert(INSTRUCTION_CMP__1);
07927         versions->insert(INSTRUCTION_CMP__2);
07928         versions->insert(INSTRUCTION_CMP__21);
07929         versions->insert(INSTRUCTION_CMP__22);
07930         versions->insert(INSTRUCTION_CMP__23);
07931 
07932 
07933         //return target pseudoinstruction
07934         return tm_instr::create(INSTRUCTION_CMP__24,in_operands,out_operands,lstring("cmp $TYPE_I_1 $I_1, $TYPE_I_2 $I_2"), props,versions,0,einfo);
07935 }
07936 
07937 ptr<tm_instr> tm_instr_create_INSTRUCTION_JMP__1() {
07938         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07939         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07940         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07941         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07942         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07943         ptr<execution_info> einfo;
07944         ptr<set<ulint> > versions;
07945         
07946         //input operands
07947 
07948         //output operands
07949 
07950         //execution info
07951         einfo = execution_info::create(10);
07952 
07953         //properties
07954 
07955         //versions
07956 
07957 
07958         //return target pseudoinstruction
07959         return tm_instr::create(INSTRUCTION_JMP__1,in_operands,out_operands,lstring("jmp NEAR $label_1"), props,versions,IF_JUMP,einfo);
07960 }
07961 
07962 ptr<tm_instr> tm_instr_create_INSTRUCTION_JA__1() {
07963         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07964         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07965         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07966         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07967         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07968         ptr<execution_info> einfo;
07969         ptr<set<ulint> > versions;
07970         
07971         //input operands
07972         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
07973         dt_list_I_1->insert(DT_COND);
07974         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
07975         reg_list_I_1->insert(R_COND);
07976         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
07977         in_operands->push_back(op_I_1);
07978 
07979         //output operands
07980 
07981         //execution info
07982         einfo = execution_info::create(10);
07983 
07984         //properties
07985 
07986         //versions
07987 
07988 
07989         //return target pseudoinstruction
07990         return tm_instr::create(INSTRUCTION_JA__1,in_operands,out_operands,lstring("ja NEAR $label_1"), props,versions,IF_JUMP,einfo);
07991 }
07992 
07993 ptr<tm_instr> tm_instr_create_INSTRUCTION_JZ__1() {
07994         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
07995         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
07996         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
07997         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
07998         ptr<set<tm_data_type_base::id_type> > allowed_types; 
07999         ptr<execution_info> einfo;
08000         ptr<set<ulint> > versions;
08001         
08002         //input operands
08003         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08004         dt_list_I_1->insert(DT_COND);
08005         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08006         reg_list_I_1->insert(R_COND);
08007         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08008         in_operands->push_back(op_I_1);
08009 
08010         //output operands
08011 
08012         //execution info
08013         einfo = execution_info::create(10);
08014 
08015         //properties
08016 
08017         //versions
08018 
08019 
08020         //return target pseudoinstruction
08021         return tm_instr::create(INSTRUCTION_JZ__1,in_operands,out_operands,lstring("jz NEAR $label_1"), props,versions,IF_JUMP,einfo);
08022 }
08023 
08024 ptr<tm_instr> tm_instr_create_INSTRUCTION_JG__1() {
08025         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08026         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08027         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08028         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08029         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08030         ptr<execution_info> einfo;
08031         ptr<set<ulint> > versions;
08032         
08033         //input operands
08034         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08035         dt_list_I_1->insert(DT_COND);
08036         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08037         reg_list_I_1->insert(R_COND);
08038         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08039         in_operands->push_back(op_I_1);
08040 
08041         //output operands
08042 
08043         //execution info
08044         einfo = execution_info::create(10);
08045 
08046         //properties
08047         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"true"));
08048 
08049         //versions
08050 
08051 
08052         //return target pseudoinstruction
08053         return tm_instr::create(INSTRUCTION_JG__1,in_operands,out_operands,lstring("jg NEAR $label_1"), props,versions,IF_JUMP,einfo);
08054 }
08055 
08056 ptr<tm_instr> tm_instr_create_INSTRUCTION_JL__1() {
08057         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08058         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08059         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08060         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08061         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08062         ptr<execution_info> einfo;
08063         ptr<set<ulint> > versions;
08064         
08065         //input operands
08066         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08067         dt_list_I_1->insert(DT_COND);
08068         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08069         reg_list_I_1->insert(R_COND);
08070         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08071         in_operands->push_back(op_I_1);
08072 
08073         //output operands
08074 
08075         //execution info
08076         einfo = execution_info::create(10);
08077 
08078         //properties
08079         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"true"));
08080 
08081         //versions
08082 
08083 
08084         //return target pseudoinstruction
08085         return tm_instr::create(INSTRUCTION_JL__1,in_operands,out_operands,lstring("jl NEAR $label_1"), props,versions,IF_JUMP,einfo);
08086 }
08087 
08088 ptr<tm_instr> tm_instr_create_INSTRUCTION_JB__1() {
08089         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08090         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08091         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08092         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08093         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08094         ptr<execution_info> einfo;
08095         ptr<set<ulint> > versions;
08096         
08097         //input operands
08098         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08099         dt_list_I_1->insert(DT_COND);
08100         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08101         reg_list_I_1->insert(R_COND);
08102         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08103         in_operands->push_back(op_I_1);
08104 
08105         //output operands
08106 
08107         //execution info
08108         einfo = execution_info::create(10);
08109 
08110         //properties
08111         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"false"));
08112 
08113         //versions
08114 
08115 
08116         //return target pseudoinstruction
08117         return tm_instr::create(INSTRUCTION_JB__1,in_operands,out_operands,lstring("jb NEAR $label_1"), props,versions,IF_JUMP,einfo);
08118 }
08119 
08120 ptr<tm_instr> tm_instr_create_INSTRUCTION_JE__1() {
08121         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08122         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08123         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08124         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08125         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08126         ptr<execution_info> einfo;
08127         ptr<set<ulint> > versions;
08128         
08129         //input operands
08130         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08131         dt_list_I_1->insert(DT_COND);
08132         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08133         reg_list_I_1->insert(R_COND);
08134         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08135         in_operands->push_back(op_I_1);
08136 
08137         //output operands
08138 
08139         //execution info
08140         einfo = execution_info::create(10);
08141 
08142         //properties
08143 
08144         //versions
08145 
08146 
08147         //return target pseudoinstruction
08148         return tm_instr::create(INSTRUCTION_JE__1,in_operands,out_operands,lstring("je NEAR $label_1"), props,versions,IF_JUMP,einfo);
08149 }
08150 
08151 ptr<tm_instr> tm_instr_create_INSTRUCTION_JNG__1() {
08152         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08153         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08154         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08155         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08156         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08157         ptr<execution_info> einfo;
08158         ptr<set<ulint> > versions;
08159         
08160         //input operands
08161         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08162         dt_list_I_1->insert(DT_COND);
08163         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08164         reg_list_I_1->insert(R_COND);
08165         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08166         in_operands->push_back(op_I_1);
08167 
08168         //output operands
08169 
08170         //execution info
08171         einfo = execution_info::create(10);
08172 
08173         //properties
08174         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"true"));
08175 
08176         //versions
08177 
08178 
08179         //return target pseudoinstruction
08180         return tm_instr::create(INSTRUCTION_JNG__1,in_operands,out_operands,lstring("jng NEAR $label_1"), props,versions,IF_JUMP,einfo);
08181 }
08182 
08183 ptr<tm_instr> tm_instr_create_INSTRUCTION_JNA__1() {
08184         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08185         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08186         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08187         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08188         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08189         ptr<execution_info> einfo;
08190         ptr<set<ulint> > versions;
08191         
08192         //input operands
08193         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08194         dt_list_I_1->insert(DT_COND);
08195         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08196         reg_list_I_1->insert(R_COND);
08197         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08198         in_operands->push_back(op_I_1);
08199 
08200         //output operands
08201 
08202         //execution info
08203         einfo = execution_info::create(10);
08204 
08205         //properties
08206         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"false"));
08207 
08208         //versions
08209 
08210 
08211         //return target pseudoinstruction
08212         return tm_instr::create(INSTRUCTION_JNA__1,in_operands,out_operands,lstring("jna NEAR $label_1"), props,versions,IF_JUMP,einfo);
08213 }
08214 
08215 ptr<tm_instr> tm_instr_create_INSTRUCTION_JNL__1() {
08216         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08217         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08218         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08219         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08220         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08221         ptr<execution_info> einfo;
08222         ptr<set<ulint> > versions;
08223         
08224         //input operands
08225         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08226         dt_list_I_1->insert(DT_COND);
08227         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08228         reg_list_I_1->insert(R_COND);
08229         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08230         in_operands->push_back(op_I_1);
08231 
08232         //output operands
08233 
08234         //execution info
08235         einfo = execution_info::create(10);
08236 
08237         //properties
08238         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"true"));
08239 
08240         //versions
08241 
08242 
08243         //return target pseudoinstruction
08244         return tm_instr::create(INSTRUCTION_JNL__1,in_operands,out_operands,lstring("jnl NEAR $label_1"), props,versions,IF_JUMP,einfo);
08245 }
08246 
08247 ptr<tm_instr> tm_instr_create_INSTRUCTION_JNB__1() {
08248         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08249         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08250         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08251         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08252         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08253         ptr<execution_info> einfo;
08254         ptr<set<ulint> > versions;
08255         
08256         //input operands
08257         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08258         dt_list_I_1->insert(DT_COND);
08259         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08260         reg_list_I_1->insert(R_COND);
08261         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08262         in_operands->push_back(op_I_1);
08263 
08264         //output operands
08265 
08266         //execution info
08267         einfo = execution_info::create(10);
08268 
08269         //properties
08270         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"false"));
08271 
08272         //versions
08273 
08274 
08275         //return target pseudoinstruction
08276         return tm_instr::create(INSTRUCTION_JNB__1,in_operands,out_operands,lstring("jnb NEAR $label_1"), props,versions,IF_JUMP,einfo);
08277 }
08278 
08279 ptr<tm_instr> tm_instr_create_INSTRUCTION_JNE__1() {
08280         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08281         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08282         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08283         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08284         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08285         ptr<execution_info> einfo;
08286         ptr<set<ulint> > versions;
08287         
08288         //input operands
08289         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08290         dt_list_I_1->insert(DT_COND);
08291         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08292         reg_list_I_1->insert(R_COND);
08293         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08294         in_operands->push_back(op_I_1);
08295 
08296         //output operands
08297 
08298         //execution info
08299         einfo = execution_info::create(10);
08300 
08301         //properties
08302 
08303         //versions
08304 
08305 
08306         //return target pseudoinstruction
08307         return tm_instr::create(INSTRUCTION_JNE__1,in_operands,out_operands,lstring("jne NEAR $label_1"), props,versions,IF_JUMP,einfo);
08308 }
08309 
08310 ptr<tm_instr> tm_instr_create_INSTRUCTION_SETG__1() {
08311         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08312         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08313         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08314         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08315         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08316         ptr<execution_info> einfo;
08317         ptr<set<ulint> > versions;
08318         
08319         //input operands
08320         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08321         dt_list_I_1->insert(DT_COND);
08322         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08323         reg_list_I_1->insert(R_COND);
08324         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08325         in_operands->push_back(op_I_1);
08326 
08327         //output operands
08328         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08329         dt_list_O_1->insert(DT_BOOL);
08330         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08331         reg_list_O_1->insert(R_AL);
08332         reg_list_O_1->insert(R_AH);
08333         reg_list_O_1->insert(R_BL);
08334         reg_list_O_1->insert(R_BH);
08335         reg_list_O_1->insert(R_CL);
08336         reg_list_O_1->insert(R_CH);
08337         reg_list_O_1->insert(R_DL);
08338         reg_list_O_1->insert(R_DH);
08339         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08340         out_operands->push_back(op_O_1);
08341 
08342         //execution info
08343         einfo = execution_info::create(50);
08344 
08345         //properties
08346         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"true"));
08347 
08348         //versions
08349 
08350 
08351         //return target pseudoinstruction
08352         return tm_instr::create(INSTRUCTION_SETG__1,in_operands,out_operands,lstring("setg $O_1"), props,versions,0,einfo);
08353 }
08354 
08355 ptr<tm_instr> tm_instr_create_INSTRUCTION_SETA__1() {
08356         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08357         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08358         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08359         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08360         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08361         ptr<execution_info> einfo;
08362         ptr<set<ulint> > versions;
08363         
08364         //input operands
08365         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08366         dt_list_I_1->insert(DT_COND);
08367         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08368         reg_list_I_1->insert(R_COND);
08369         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08370         in_operands->push_back(op_I_1);
08371 
08372         //output operands
08373         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08374         dt_list_O_1->insert(DT_BOOL);
08375         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08376         reg_list_O_1->insert(R_AL);
08377         reg_list_O_1->insert(R_AH);
08378         reg_list_O_1->insert(R_BL);
08379         reg_list_O_1->insert(R_BH);
08380         reg_list_O_1->insert(R_CL);
08381         reg_list_O_1->insert(R_CH);
08382         reg_list_O_1->insert(R_DL);
08383         reg_list_O_1->insert(R_DH);
08384         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08385         out_operands->push_back(op_O_1);
08386 
08387         //execution info
08388         einfo = execution_info::create(50);
08389 
08390         //properties
08391         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"false"));
08392 
08393         //versions
08394 
08395 
08396         //return target pseudoinstruction
08397         return tm_instr::create(INSTRUCTION_SETA__1,in_operands,out_operands,lstring("seta $O_1"), props,versions,0,einfo);
08398 }
08399 
08400 ptr<tm_instr> tm_instr_create_INSTRUCTION_SETL__1() {
08401         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08402         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08403         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08404         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08405         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08406         ptr<execution_info> einfo;
08407         ptr<set<ulint> > versions;
08408         
08409         //input operands
08410         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08411         dt_list_I_1->insert(DT_COND);
08412         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08413         reg_list_I_1->insert(R_COND);
08414         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08415         in_operands->push_back(op_I_1);
08416 
08417         //output operands
08418         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08419         dt_list_O_1->insert(DT_BOOL);
08420         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08421         reg_list_O_1->insert(R_AL);
08422         reg_list_O_1->insert(R_AH);
08423         reg_list_O_1->insert(R_BL);
08424         reg_list_O_1->insert(R_BH);
08425         reg_list_O_1->insert(R_CL);
08426         reg_list_O_1->insert(R_CH);
08427         reg_list_O_1->insert(R_DL);
08428         reg_list_O_1->insert(R_DH);
08429         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08430         out_operands->push_back(op_O_1);
08431 
08432         //execution info
08433         einfo = execution_info::create(50);
08434 
08435         //properties
08436         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"true"));
08437 
08438         //versions
08439 
08440 
08441         //return target pseudoinstruction
08442         return tm_instr::create(INSTRUCTION_SETL__1,in_operands,out_operands,lstring("setl $O_1"), props,versions,0,einfo);
08443 }
08444 
08445 ptr<tm_instr> tm_instr_create_INSTRUCTION_SETB__1() {
08446         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08447         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08448         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08449         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08450         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08451         ptr<execution_info> einfo;
08452         ptr<set<ulint> > versions;
08453         
08454         //input operands
08455         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08456         dt_list_I_1->insert(DT_COND);
08457         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08458         reg_list_I_1->insert(R_COND);
08459         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08460         in_operands->push_back(op_I_1);
08461 
08462         //output operands
08463         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08464         dt_list_O_1->insert(DT_BOOL);
08465         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08466         reg_list_O_1->insert(R_AL);
08467         reg_list_O_1->insert(R_AH);
08468         reg_list_O_1->insert(R_BL);
08469         reg_list_O_1->insert(R_BH);
08470         reg_list_O_1->insert(R_CL);
08471         reg_list_O_1->insert(R_CH);
08472         reg_list_O_1->insert(R_DL);
08473         reg_list_O_1->insert(R_DH);
08474         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08475         out_operands->push_back(op_O_1);
08476 
08477         //execution info
08478         einfo = execution_info::create(50);
08479 
08480         //properties
08481         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"false"));
08482 
08483         //versions
08484 
08485 
08486         //return target pseudoinstruction
08487         return tm_instr::create(INSTRUCTION_SETB__1,in_operands,out_operands,lstring("setb $O_1"), props,versions,0,einfo);
08488 }
08489 
08490 ptr<tm_instr> tm_instr_create_INSTRUCTION_SETE__1() {
08491         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08492         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08493         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08494         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08495         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08496         ptr<execution_info> einfo;
08497         ptr<set<ulint> > versions;
08498         
08499         //input operands
08500         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08501         dt_list_I_1->insert(DT_COND);
08502         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08503         reg_list_I_1->insert(R_COND);
08504         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08505         in_operands->push_back(op_I_1);
08506 
08507         //output operands
08508         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08509         dt_list_O_1->insert(DT_BOOL);
08510         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08511         reg_list_O_1->insert(R_AL);
08512         reg_list_O_1->insert(R_AH);
08513         reg_list_O_1->insert(R_BL);
08514         reg_list_O_1->insert(R_BH);
08515         reg_list_O_1->insert(R_CL);
08516         reg_list_O_1->insert(R_CH);
08517         reg_list_O_1->insert(R_DL);
08518         reg_list_O_1->insert(R_DH);
08519         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08520         out_operands->push_back(op_O_1);
08521 
08522         //execution info
08523         einfo = execution_info::create(50);
08524 
08525         //properties
08526 
08527         //versions
08528 
08529 
08530         //return target pseudoinstruction
08531         return tm_instr::create(INSTRUCTION_SETE__1,in_operands,out_operands,lstring("sete $O_1"), props,versions,0,einfo);
08532 }
08533 
08534 ptr<tm_instr> tm_instr_create_INSTRUCTION_SETNG__1() {
08535         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08536         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08537         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08538         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08539         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08540         ptr<execution_info> einfo;
08541         ptr<set<ulint> > versions;
08542         
08543         //input operands
08544         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08545         dt_list_I_1->insert(DT_COND);
08546         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08547         reg_list_I_1->insert(R_COND);
08548         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08549         in_operands->push_back(op_I_1);
08550 
08551         //output operands
08552         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08553         dt_list_O_1->insert(DT_BOOL);
08554         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08555         reg_list_O_1->insert(R_AL);
08556         reg_list_O_1->insert(R_AH);
08557         reg_list_O_1->insert(R_BL);
08558         reg_list_O_1->insert(R_BH);
08559         reg_list_O_1->insert(R_CL);
08560         reg_list_O_1->insert(R_CH);
08561         reg_list_O_1->insert(R_DL);
08562         reg_list_O_1->insert(R_DH);
08563         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08564         out_operands->push_back(op_O_1);
08565 
08566         //execution info
08567         einfo = execution_info::create(50);
08568 
08569         //properties
08570         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"true"));
08571 
08572         //versions
08573 
08574 
08575         //return target pseudoinstruction
08576         return tm_instr::create(INSTRUCTION_SETNG__1,in_operands,out_operands,lstring("setng $O_1"), props,versions,0,einfo);
08577 }
08578 
08579 ptr<tm_instr> tm_instr_create_INSTRUCTION_SETNA__1() {
08580         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08581         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08582         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08583         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08584         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08585         ptr<execution_info> einfo;
08586         ptr<set<ulint> > versions;
08587         
08588         //input operands
08589         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08590         dt_list_I_1->insert(DT_COND);
08591         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08592         reg_list_I_1->insert(R_COND);
08593         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08594         in_operands->push_back(op_I_1);
08595 
08596         //output operands
08597         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08598         dt_list_O_1->insert(DT_BOOL);
08599         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08600         reg_list_O_1->insert(R_AL);
08601         reg_list_O_1->insert(R_AH);
08602         reg_list_O_1->insert(R_BL);
08603         reg_list_O_1->insert(R_BH);
08604         reg_list_O_1->insert(R_CL);
08605         reg_list_O_1->insert(R_CH);
08606         reg_list_O_1->insert(R_DL);
08607         reg_list_O_1->insert(R_DH);
08608         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08609         out_operands->push_back(op_O_1);
08610 
08611         //execution info
08612         einfo = execution_info::create(50);
08613 
08614         //properties
08615         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"false"));
08616 
08617         //versions
08618 
08619 
08620         //return target pseudoinstruction
08621         return tm_instr::create(INSTRUCTION_SETNA__1,in_operands,out_operands,lstring("setna $O_1"), props,versions,0,einfo);
08622 }
08623 
08624 ptr<tm_instr> tm_instr_create_INSTRUCTION_SETNL__1() {
08625         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08626         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08627         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08628         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08629         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08630         ptr<execution_info> einfo;
08631         ptr<set<ulint> > versions;
08632         
08633         //input operands
08634         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08635         dt_list_I_1->insert(DT_COND);
08636         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08637         reg_list_I_1->insert(R_COND);
08638         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08639         in_operands->push_back(op_I_1);
08640 
08641         //output operands
08642         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08643         dt_list_O_1->insert(DT_BOOL);
08644         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08645         reg_list_O_1->insert(R_AL);
08646         reg_list_O_1->insert(R_AH);
08647         reg_list_O_1->insert(R_BL);
08648         reg_list_O_1->insert(R_BH);
08649         reg_list_O_1->insert(R_CL);
08650         reg_list_O_1->insert(R_CH);
08651         reg_list_O_1->insert(R_DL);
08652         reg_list_O_1->insert(R_DH);
08653         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08654         out_operands->push_back(op_O_1);
08655 
08656         //execution info
08657         einfo = execution_info::create(50);
08658 
08659         //properties
08660         props->insert(::std::pair<ulint, lstring>(PROPERTY_TEST_SIGNED,"true"));
08661 
08662         //versions
08663 
08664 
08665         //return target pseudoinstruction
08666         return tm_instr::create(INSTRUCTION_SETNL__1,in_operands,out_operands,lstring("setnl $O_1"), props,versions,0,einfo);
08667 }
08668 
08669 ptr<tm_instr> tm_instr_create_INSTRUCTION_SETNB__1() {
08670         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08671         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08672         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08673         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08674         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08675         ptr<execution_info> einfo;
08676         ptr<set<ulint> > versions;
08677         
08678         //input operands
08679         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08680         dt_list_I_1->insert(DT_COND);
08681         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08682         reg_list_I_1->insert(R_COND);
08683         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08684         in_operands->push_back(op_I_1);
08685 
08686         //output operands
08687         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08688         dt_list_O_1->insert(DT_BOOL);
08689         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08690         reg_list_O_1->insert(R_AL);
08691         reg_list_O_1->insert(R_AH);
08692         reg_list_O_1->insert(R_BL);
08693         reg_list_O_1->insert(R_BH);
08694         reg_list_O_1->insert(R_CL);
08695         reg_list_O_1->insert(R_CH);
08696         reg_list_O_1->insert(R_DL);
08697         reg_list_O_1->insert(R_DH);
08698         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08699         out_operands->push_back(op_O_1);
08700 
08701         //execution info
08702         einfo = execution_info::create(50);
08703 
08704         //properties
08705 
08706         //versions
08707 
08708 
08709         //return target pseudoinstruction
08710         return tm_instr::create(INSTRUCTION_SETNB__1,in_operands,out_operands,lstring("setnb $O_1"), props,versions,0,einfo);
08711 }
08712 
08713 ptr<tm_instr> tm_instr_create_INSTRUCTION_SETNE__1() {
08714         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08715         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08716         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08717         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08718         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08719         ptr<execution_info> einfo;
08720         ptr<set<ulint> > versions;
08721         
08722         //input operands
08723         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08724         dt_list_I_1->insert(DT_COND);
08725         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08726         reg_list_I_1->insert(R_COND);
08727         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08728         in_operands->push_back(op_I_1);
08729 
08730         //output operands
08731         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08732         dt_list_O_1->insert(DT_BOOL);
08733         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08734         reg_list_O_1->insert(R_AL);
08735         reg_list_O_1->insert(R_AH);
08736         reg_list_O_1->insert(R_BL);
08737         reg_list_O_1->insert(R_BH);
08738         reg_list_O_1->insert(R_CL);
08739         reg_list_O_1->insert(R_CH);
08740         reg_list_O_1->insert(R_DL);
08741         reg_list_O_1->insert(R_DH);
08742         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08743         out_operands->push_back(op_O_1);
08744 
08745         //execution info
08746         einfo = execution_info::create(50);
08747 
08748         //properties
08749 
08750         //versions
08751 
08752 
08753         //return target pseudoinstruction
08754         return tm_instr::create(INSTRUCTION_SETNE__1,in_operands,out_operands,lstring("setne $O_1"), props,versions,0,einfo);
08755 }
08756 
08757 ptr<tm_instr> tm_instr_create_INSTRUCTION_SETNZ__1() {
08758         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08759         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08760         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08761         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08762         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08763         ptr<execution_info> einfo;
08764         ptr<set<ulint> > versions;
08765         
08766         //input operands
08767         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08768         dt_list_I_1->insert(DT_COND);
08769         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08770         reg_list_I_1->insert(R_COND);
08771         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08772         in_operands->push_back(op_I_1);
08773 
08774         //output operands
08775         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08776         dt_list_O_1->insert(DT_BOOL);
08777         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08778         reg_list_O_1->insert(R_AL);
08779         reg_list_O_1->insert(R_AH);
08780         reg_list_O_1->insert(R_BL);
08781         reg_list_O_1->insert(R_BH);
08782         reg_list_O_1->insert(R_CL);
08783         reg_list_O_1->insert(R_CH);
08784         reg_list_O_1->insert(R_DL);
08785         reg_list_O_1->insert(R_DH);
08786         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08787         out_operands->push_back(op_O_1);
08788 
08789         //execution info
08790         einfo = execution_info::create(50);
08791 
08792         //properties
08793 
08794         //versions
08795 
08796 
08797         //return target pseudoinstruction
08798         return tm_instr::create(INSTRUCTION_SETNZ__1,in_operands,out_operands,lstring("setnz $O_1"), props,versions,0,einfo);
08799 }
08800 
08801 ptr<tm_instr> tm_instr_create_INSTRUCTION_PUSH__1() {
08802         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08803         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08804         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08805         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08806         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08807         ptr<execution_info> einfo;
08808         ptr<set<ulint> > versions;
08809         
08810         //input operands
08811         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08812         dt_list_I_1->insert(DT_INT_32U);
08813         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08814         reg_list_I_1->insert(R_ESP);
08815         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08816         op_I_1->destroyed_by_get()->push_back(O_1);
08817         in_operands->push_back(op_I_1);
08818         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
08819         dt_list_I_2->insert(DT_INT_32U);
08820         dt_list_I_2->insert(DT_INT_32S);
08821         ptr<tm_instr_op_mem> op_I_2 = tm_instr_op_mem::create(I_2, dt_list_I_2);
08822         in_operands->push_back(op_I_2);
08823 
08824         //output operands
08825         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08826         dt_list_O_1->insert(DT_INT_32U);
08827         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08828         reg_list_O_1->insert(R_ESP);
08829         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08830         op_O_1->destroys_set(I_1);
08831         out_operands->push_back(op_O_1);
08832 
08833         //execution info
08834         einfo = execution_info::create(15);
08835 
08836         //properties
08837 
08838         //versions
08839         versions = set<ulint>::create();
08840         versions->insert(INSTRUCTION_PUSH__2);
08841         versions->insert(INSTRUCTION_PUSH__3);
08842 
08843 
08844         //return target pseudoinstruction
08845         return tm_instr::create(INSTRUCTION_PUSH__1,in_operands,out_operands,lstring("push $TYPE_I_2 $I_2"), props,versions,IF_STORE | IF_SYS,einfo);
08846 }
08847 
08848 ptr<tm_instr> tm_instr_create_INSTRUCTION_PUSH__2() {
08849         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08850         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08851         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08852         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08853         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08854         ptr<execution_info> einfo;
08855         ptr<set<ulint> > versions;
08856         
08857         //input operands
08858         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08859         dt_list_I_1->insert(DT_INT_32U);
08860         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08861         reg_list_I_1->insert(R_ESP);
08862         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08863         op_I_1->destroyed_by_get()->push_back(O_1);
08864         in_operands->push_back(op_I_1);
08865         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
08866         dt_list_I_2->insert(DT_INT_32U);
08867         dt_list_I_2->insert(DT_INT_32S);
08868         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
08869         reg_list_I_2->insert(R_EAX);
08870         reg_list_I_2->insert(R_EBX);
08871         reg_list_I_2->insert(R_ECX);
08872         reg_list_I_2->insert(R_EDX);
08873         reg_list_I_2->insert(R_EDI);
08874         reg_list_I_2->insert(R_ESI);
08875         reg_list_I_2->insert(R_AX);
08876         reg_list_I_2->insert(R_BX);
08877         reg_list_I_2->insert(R_CX);
08878         reg_list_I_2->insert(R_DX);
08879         reg_list_I_2->insert(R_DI);
08880         reg_list_I_2->insert(R_SI);
08881         reg_list_I_2->insert(R_AL);
08882         reg_list_I_2->insert(R_AH);
08883         reg_list_I_2->insert(R_BL);
08884         reg_list_I_2->insert(R_BH);
08885         reg_list_I_2->insert(R_CL);
08886         reg_list_I_2->insert(R_CH);
08887         reg_list_I_2->insert(R_DL);
08888         reg_list_I_2->insert(R_DH);
08889         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
08890         in_operands->push_back(op_I_2);
08891 
08892         //output operands
08893         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08894         dt_list_O_1->insert(DT_INT_32U);
08895         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08896         reg_list_O_1->insert(R_ESP);
08897         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08898         op_O_1->destroys_set(I_1);
08899         out_operands->push_back(op_O_1);
08900 
08901         //execution info
08902         einfo = execution_info::create(15);
08903 
08904         //properties
08905 
08906         //versions
08907         versions = set<ulint>::create();
08908         versions->insert(INSTRUCTION_PUSH__1);
08909         versions->insert(INSTRUCTION_PUSH__3);
08910 
08911 
08912         //return target pseudoinstruction
08913         return tm_instr::create(INSTRUCTION_PUSH__2,in_operands,out_operands,lstring("push $I_2"), props,versions,IF_STORE | IF_SYS,einfo);
08914 }
08915 
08916 ptr<tm_instr> tm_instr_create_INSTRUCTION_PUSH__3() {
08917         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08918         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08919         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08920         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08921         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08922         ptr<execution_info> einfo;
08923         ptr<set<ulint> > versions;
08924         
08925         //input operands
08926         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08927         dt_list_I_1->insert(DT_INT_32U);
08928         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08929         reg_list_I_1->insert(R_ESP);
08930         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08931         op_I_1->destroyed_by_get()->push_back(O_1);
08932         in_operands->push_back(op_I_1);
08933         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
08934         dt_list_I_2->insert(DT_INT_8P);
08935         dt_list_I_2->insert(DT_INT_8U);
08936         dt_list_I_2->insert(DT_INT_8S);
08937         dt_list_I_2->insert(DT_INT_16U);
08938         dt_list_I_2->insert(DT_INT_16S);
08939         dt_list_I_2->insert(DT_INT_32U);
08940         dt_list_I_2->insert(DT_INT_32S);
08941         dt_list_I_2->insert(DT_BOOL);
08942         ptr<tm_instr_op_imm> op_I_2 = tm_instr_op_imm::create(I_2, dt_list_I_2);
08943         in_operands->push_back(op_I_2);
08944 
08945         //output operands
08946         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08947         dt_list_O_1->insert(DT_INT_32U);
08948         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08949         reg_list_O_1->insert(R_ESP);
08950         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08951         op_O_1->destroys_set(I_1);
08952         out_operands->push_back(op_O_1);
08953 
08954         //execution info
08955         einfo = execution_info::create(15);
08956 
08957         //properties
08958 
08959         //versions
08960         versions = set<ulint>::create();
08961         versions->insert(INSTRUCTION_PUSH__1);
08962         versions->insert(INSTRUCTION_PUSH__2);
08963 
08964 
08965         //return target pseudoinstruction
08966         return tm_instr::create(INSTRUCTION_PUSH__3,in_operands,out_operands,lstring("push DWORD $I_2"), props,versions,IF_STORE | IF_SYS,einfo);
08967 }
08968 
08969 ptr<tm_instr> tm_instr_create_INSTRUCTION_POP__1() {
08970         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
08971         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
08972         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
08973         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
08974         ptr<set<tm_data_type_base::id_type> > allowed_types; 
08975         ptr<execution_info> einfo;
08976         ptr<set<ulint> > versions;
08977         
08978         //input operands
08979         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
08980         dt_list_I_1->insert(DT_INT_32U);
08981         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
08982         reg_list_I_1->insert(R_ESP);
08983         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
08984         op_I_1->destroyed_by_get()->push_back(O_1);
08985         in_operands->push_back(op_I_1);
08986 
08987         //output operands
08988         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
08989         dt_list_O_1->insert(DT_INT_32U);
08990         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
08991         reg_list_O_1->insert(R_ESP);
08992         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
08993         op_O_1->destroys_set(I_1);
08994         out_operands->push_back(op_O_1);
08995         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
08996         dt_list_O_2->insert(DT_INT_8P);
08997         dt_list_O_2->insert(DT_INT_8U);
08998         dt_list_O_2->insert(DT_INT_8S);
08999         dt_list_O_2->insert(DT_INT_16U);
09000         dt_list_O_2->insert(DT_INT_16S);
09001         dt_list_O_2->insert(DT_INT_32U);
09002         dt_list_O_2->insert(DT_INT_32S);
09003         dt_list_O_2->insert(DT_COND);
09004         dt_list_O_2->insert(DT_BOOL);
09005         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
09006         reg_list_O_2->insert(R_EAX);
09007         reg_list_O_2->insert(R_EBX);
09008         reg_list_O_2->insert(R_ECX);
09009         reg_list_O_2->insert(R_EDX);
09010         reg_list_O_2->insert(R_EDI);
09011         reg_list_O_2->insert(R_ESI);
09012         reg_list_O_2->insert(R_AX);
09013         reg_list_O_2->insert(R_BX);
09014         reg_list_O_2->insert(R_CX);
09015         reg_list_O_2->insert(R_DX);
09016         reg_list_O_2->insert(R_DI);
09017         reg_list_O_2->insert(R_SI);
09018         reg_list_O_2->insert(R_AL);
09019         reg_list_O_2->insert(R_AH);
09020         reg_list_O_2->insert(R_BL);
09021         reg_list_O_2->insert(R_BH);
09022         reg_list_O_2->insert(R_CL);
09023         reg_list_O_2->insert(R_CH);
09024         reg_list_O_2->insert(R_DL);
09025         reg_list_O_2->insert(R_DH);
09026         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
09027         out_operands->push_back(op_O_2);
09028 
09029         //execution info
09030         einfo = execution_info::create(15);
09031 
09032         //properties
09033 
09034         //versions
09035 
09036 
09037         //return target pseudoinstruction
09038         return tm_instr::create(INSTRUCTION_POP__1,in_operands,out_operands,lstring("pop $O_2"), props,versions,IF_SYS,einfo);
09039 }
09040 
09041 ptr<tm_instr> tm_instr_create_INSTRUCTION_NOP__1() {
09042         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
09043         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
09044         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
09045         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
09046         ptr<set<tm_data_type_base::id_type> > allowed_types; 
09047         ptr<execution_info> einfo;
09048         ptr<set<ulint> > versions;
09049         
09050         //input operands
09051 
09052         //output operands
09053 
09054         //execution info
09055         einfo = execution_info::create(10);
09056 
09057         //properties
09058 
09059         //versions
09060 
09061 
09062         //return target pseudoinstruction
09063         return tm_instr::create(INSTRUCTION_NOP__1,in_operands,out_operands,lstring("nop"), props,versions,IF_SYS,einfo);
09064 }
09065 
09066 ptr<tm_instr> tm_instr_create_INSTRUCTION_ESPADD__1() {
09067         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
09068         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
09069         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
09070         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
09071         ptr<set<tm_data_type_base::id_type> > allowed_types; 
09072         ptr<execution_info> einfo;
09073         ptr<set<ulint> > versions;
09074         
09075         //input operands
09076         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
09077         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
09078         reg_list_I_1->insert(R_ESP);
09079         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
09080         op_I_1->destroyed_by_get()->push_back(O_1);
09081         in_operands->push_back(op_I_1);
09082         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
09083         dt_list_I_2->insert(DT_INT_8P);
09084         dt_list_I_2->insert(DT_INT_8U);
09085         dt_list_I_2->insert(DT_INT_8S);
09086         dt_list_I_2->insert(DT_INT_16U);
09087         dt_list_I_2->insert(DT_INT_16S);
09088         dt_list_I_2->insert(DT_INT_32U);
09089         dt_list_I_2->insert(DT_INT_32S);
09090         ptr<tm_instr_op_imm> op_I_2 = tm_instr_op_imm::create(I_2, dt_list_I_2);
09091         in_operands->push_back(op_I_2);
09092 
09093         //output operands
09094         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
09095         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
09096         reg_list_O_1->insert(R_ESP);
09097         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
09098         op_O_1->destroys_set(I_1);
09099         out_operands->push_back(op_O_1);
09100         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
09101         dt_list_O_2->insert(DT_COND);
09102         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
09103         reg_list_O_2->insert(R_COND);
09104         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
09105         out_operands->push_back(op_O_2);
09106 
09107         //execution info
09108         einfo = execution_info::create(10);
09109 
09110         //properties
09111 
09112         //versions
09113 
09114 
09115         //return target pseudoinstruction
09116         return tm_instr::create(INSTRUCTION_ESPADD__1,in_operands,out_operands,lstring("add $O_1, $TYPE_I_2 $I_2"), props,versions,IF_SYS,einfo);
09117 }
09118 
09119 ptr<tm_instr> tm_instr_create_INSTRUCTION_BACKUPESP__1() {
09120         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
09121         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
09122         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
09123         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
09124         ptr<set<tm_data_type_base::id_type> > allowed_types; 
09125         ptr<execution_info> einfo;
09126         ptr<set<ulint> > versions;
09127         
09128         //input operands
09129         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
09130         dt_list_I_1->insert(DT_INT_32U);
09131         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
09132         reg_list_I_1->insert(R_ESP);
09133         reg_list_I_1->insert(R_EBP);
09134         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
09135         in_operands->push_back(op_I_1);
09136 
09137         //output operands
09138         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
09139         dt_list_O_1->insert(DT_INT_32U);
09140         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
09141         reg_list_O_1->insert(R_ESP);
09142         reg_list_O_1->insert(R_EBP);
09143         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
09144         out_operands->push_back(op_O_1);
09145 
09146         //execution info
09147         einfo = execution_info::create(10);
09148 
09149         //properties
09150 
09151         //versions
09152 
09153 
09154         //return target pseudoinstruction
09155         return tm_instr::create(INSTRUCTION_BACKUPESP__1,in_operands,out_operands,lstring("mov $O_1, $I_1"), props,versions,IF_SYS,einfo);
09156 }
09157 
09158 ptr<tm_instr> tm_instr_create_INSTRUCTION_CALL__1() {
09159         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
09160         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
09161         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
09162         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
09163         ptr<set<tm_data_type_base::id_type> > allowed_types; 
09164         ptr<execution_info> einfo;
09165         ptr<set<ulint> > versions;
09166         
09167         //input operands
09168 
09169         //output operands
09170         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
09171         dt_list_O_1->insert(DT_INT_8P);
09172         dt_list_O_1->insert(DT_INT_8U);
09173         dt_list_O_1->insert(DT_INT_8S);
09174         dt_list_O_1->insert(DT_INT_16U);
09175         dt_list_O_1->insert(DT_INT_16S);
09176         dt_list_O_1->insert(DT_INT_32U);
09177         dt_list_O_1->insert(DT_INT_32S);
09178         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
09179         reg_list_O_1->insert(R_EAX);
09180         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
09181         out_operands->push_back(op_O_1);
09182         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
09183         dt_list_O_2->insert(DT_INT_8P);
09184         dt_list_O_2->insert(DT_INT_8U);
09185         dt_list_O_2->insert(DT_INT_8S);
09186         dt_list_O_2->insert(DT_INT_16U);
09187         dt_list_O_2->insert(DT_INT_16S);
09188         dt_list_O_2->insert(DT_INT_32U);
09189         dt_list_O_2->insert(DT_INT_32S);
09190         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
09191         reg_list_O_2->insert(R_ECX);
09192         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
09193         out_operands->push_back(op_O_2);
09194         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
09195         dt_list_O_3->insert(DT_INT_8P);
09196         dt_list_O_3->insert(DT_INT_8U);
09197         dt_list_O_3->insert(DT_INT_8S);
09198         dt_list_O_3->insert(DT_INT_16U);
09199         dt_list_O_3->insert(DT_INT_16S);
09200         dt_list_O_3->insert(DT_INT_32U);
09201         dt_list_O_3->insert(DT_INT_32S);
09202         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
09203         reg_list_O_3->insert(R_EDX);
09204         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
09205         out_operands->push_back(op_O_3);
09206 
09207         //execution info
09208         einfo = execution_info::create(50);
09209 
09210         //properties
09211 
09212         //versions
09213 
09214 
09215         //return target pseudoinstruction
09216         return tm_instr::create(INSTRUCTION_CALL__1,in_operands,out_operands,lstring("call $name"), props,versions,IF_SYS,einfo);
09217 }
09218 
09219 ptr<tm_instr> tm_instr_create_INSTRUCTION_PROLOGUE__1() {
09220         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
09221         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
09222         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
09223         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
09224         ptr<set<tm_data_type_base::id_type> > allowed_types; 
09225         ptr<execution_info> einfo;
09226         ptr<set<ulint> > versions;
09227         
09228         //input operands
09229 
09230         //output operands
09231         ptr<set<tm_data_type_base::id_type> > dt_list_O_1 = set<tm_data_type_base::id_type>::create();
09232         dt_list_O_1->insert(DT_INT_8P);
09233         dt_list_O_1->insert(DT_INT_8U);
09234         dt_list_O_1->insert(DT_INT_8S);
09235         dt_list_O_1->insert(DT_INT_16U);
09236         dt_list_O_1->insert(DT_INT_16S);
09237         dt_list_O_1->insert(DT_INT_32U);
09238         dt_list_O_1->insert(DT_INT_32S);
09239         ptr<set<tm_register_base::id_type> > reg_list_O_1 = set<tm_register_base::id_type>::create();
09240         reg_list_O_1->insert(R_EDI);
09241         ptr<tm_instr_op_reg> op_O_1 = tm_instr_op_reg::create(O_1, dt_list_O_1, reg_list_O_1);
09242         out_operands->push_back(op_O_1);
09243         ptr<set<tm_data_type_base::id_type> > dt_list_O_2 = set<tm_data_type_base::id_type>::create();
09244         dt_list_O_2->insert(DT_INT_8P);
09245         dt_list_O_2->insert(DT_INT_8U);
09246         dt_list_O_2->insert(DT_INT_8S);
09247         dt_list_O_2->insert(DT_INT_16U);
09248         dt_list_O_2->insert(DT_INT_16S);
09249         dt_list_O_2->insert(DT_INT_32U);
09250         dt_list_O_2->insert(DT_INT_32S);
09251         ptr<set<tm_register_base::id_type> > reg_list_O_2 = set<tm_register_base::id_type>::create();
09252         reg_list_O_2->insert(R_ESI);
09253         ptr<tm_instr_op_reg> op_O_2 = tm_instr_op_reg::create(O_2, dt_list_O_2, reg_list_O_2);
09254         out_operands->push_back(op_O_2);
09255         ptr<set<tm_data_type_base::id_type> > dt_list_O_3 = set<tm_data_type_base::id_type>::create();
09256         dt_list_O_3->insert(DT_INT_8P);
09257         dt_list_O_3->insert(DT_INT_8U);
09258         dt_list_O_3->insert(DT_INT_8S);
09259         dt_list_O_3->insert(DT_INT_16U);
09260         dt_list_O_3->insert(DT_INT_16S);
09261         dt_list_O_3->insert(DT_INT_32U);
09262         dt_list_O_3->insert(DT_INT_32S);
09263         ptr<set<tm_register_base::id_type> > reg_list_O_3 = set<tm_register_base::id_type>::create();
09264         reg_list_O_3->insert(R_EBX);
09265         ptr<tm_instr_op_reg> op_O_3 = tm_instr_op_reg::create(O_3, dt_list_O_3, reg_list_O_3);
09266         out_operands->push_back(op_O_3);
09267 
09268         //execution info
09269         einfo = execution_info::create(0);
09270 
09271         //properties
09272 
09273         //versions
09274 
09275 
09276         //return target pseudoinstruction
09277         return tm_instr::create(INSTRUCTION_PROLOGUE__1,in_operands,out_operands,lstring(""), props,versions,IF_SYS,einfo);
09278 }
09279 
09280 ptr<tm_instr> tm_instr_create_INSTRUCTION_EPILOGUE__1() {
09281         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
09282         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
09283         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
09284         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
09285         ptr<set<tm_data_type_base::id_type> > allowed_types; 
09286         ptr<execution_info> einfo;
09287         ptr<set<ulint> > versions;
09288         
09289         //input operands
09290         ptr<set<tm_data_type_base::id_type> > dt_list_I_1 = set<tm_data_type_base::id_type>::create();
09291         dt_list_I_1->insert(DT_INT_8P);
09292         dt_list_I_1->insert(DT_INT_8U);
09293         dt_list_I_1->insert(DT_INT_8S);
09294         dt_list_I_1->insert(DT_INT_16U);
09295         dt_list_I_1->insert(DT_INT_16S);
09296         dt_list_I_1->insert(DT_INT_32U);
09297         dt_list_I_1->insert(DT_INT_32S);
09298         ptr<set<tm_register_base::id_type> > reg_list_I_1 = set<tm_register_base::id_type>::create();
09299         reg_list_I_1->insert(R_EDI);
09300         ptr<tm_instr_op_reg> op_I_1 = tm_instr_op_reg::create(I_1, dt_list_I_1, reg_list_I_1);
09301         in_operands->push_back(op_I_1);
09302         ptr<set<tm_data_type_base::id_type> > dt_list_I_2 = set<tm_data_type_base::id_type>::create();
09303         dt_list_I_2->insert(DT_INT_8P);
09304         dt_list_I_2->insert(DT_INT_8U);
09305         dt_list_I_2->insert(DT_INT_8S);
09306         dt_list_I_2->insert(DT_INT_16U);
09307         dt_list_I_2->insert(DT_INT_16S);
09308         dt_list_I_2->insert(DT_INT_32U);
09309         dt_list_I_2->insert(DT_INT_32S);
09310         ptr<set<tm_register_base::id_type> > reg_list_I_2 = set<tm_register_base::id_type>::create();
09311         reg_list_I_2->insert(R_ESI);
09312         ptr<tm_instr_op_reg> op_I_2 = tm_instr_op_reg::create(I_2, dt_list_I_2, reg_list_I_2);
09313         in_operands->push_back(op_I_2);
09314         ptr<set<tm_data_type_base::id_type> > dt_list_I_3 = set<tm_data_type_base::id_type>::create();
09315         dt_list_I_3->insert(DT_INT_8P);
09316         dt_list_I_3->insert(DT_INT_8U);
09317         dt_list_I_3->insert(DT_INT_8S);
09318         dt_list_I_3->insert(DT_INT_16U);
09319         dt_list_I_3->insert(DT_INT_16S);
09320         dt_list_I_3->insert(DT_INT_32U);
09321         dt_list_I_3->insert(DT_INT_32S);
09322         ptr<set<tm_register_base::id_type> > reg_list_I_3 = set<tm_register_base::id_type>::create();
09323         reg_list_I_3->insert(R_EBX);
09324         ptr<tm_instr_op_reg> op_I_3 = tm_instr_op_reg::create(I_3, dt_list_I_3, reg_list_I_3);
09325         in_operands->push_back(op_I_3);
09326 
09327         //output operands
09328 
09329         //execution info
09330         einfo = execution_info::create(0);
09331 
09332         //properties
09333 
09334         //versions
09335 
09336 
09337         //return target pseudoinstruction
09338         return tm_instr::create(INSTRUCTION_EPILOGUE__1,in_operands,out_operands,lstring(""), props,versions,IF_SYS,einfo);
09339 }
09340 
09341 ptr<tm_instr> tm_instr_create_INSTRUCTION_LEAVE__1() {
09342         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
09343         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
09344         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
09345         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
09346         ptr<set<tm_data_type_base::id_type> > allowed_types; 
09347         ptr<execution_info> einfo;
09348         ptr<set<ulint> > versions;
09349         
09350         //input operands
09351 
09352         //output operands
09353 
09354         //execution info
09355         einfo = execution_info::create(10);
09356 
09357         //properties
09358 
09359         //versions
09360 
09361 
09362         //return target pseudoinstruction
09363         return tm_instr::create(INSTRUCTION_LEAVE__1,in_operands,out_operands,lstring("leave"), props,versions,IF_SYS,einfo);
09364 }
09365 
09366 ptr<tm_instr> tm_instr_create_INSTRUCTION_RET__1() {
09367         ptr<vector<srp<tm_instr_op_base> > > in_operands = vector<srp<tm_instr_op_base> >::create();
09368         ptr<vector<srp<tm_instr_op_base> > > out_operands = vector<srp<tm_instr_op_base> >::create();
09369         ptr<set<tm_register_base::id_type> > req_regs = set<tm_register_base::id_type>::create();
09370         ptr<map<ulint, lstring> > props = map<ulint, lstring>::create();
09371         ptr<set<tm_data_type_base::id_type> > allowed_types; 
09372         ptr<execution_info> einfo;
09373         ptr<set<ulint> > versions;
09374         
09375         //input operands
09376 
09377         //output operands
09378 
09379         //execution info
09380         einfo = execution_info::create(80);
09381 
09382         //properties
09383 
09384         //versions
09385 
09386 
09387         //return target pseudoinstruction
09388         return tm_instr::create(INSTRUCTION_RET__1,in_operands,out_operands,lstring("ret"), props,versions,IF_SYS,einfo);
09389 }
09390 
09391 ptr<tm_instr> tm_instr::instance(ulint id) {
09392         map<ulint,srp<tm_instr> >::iterator existing_instr = id_to_instance_get()->find(id);
09393 
09394         if ( existing_instr != id_to_instance_get()->end() ) {
09395                 return existing_instr->second;
09396         }
09397 
09398         ptr<tm_instr> new_instr = NULL;
09399         switch(id) {
09400 
09401                 case INSTRUCTION_MOV__1: {
09402                         new_instr = tm_instr_create_INSTRUCTION_MOV__1();
09403                 } break;
09404 
09405                 case INSTRUCTION_MOV__2: {
09406                         new_instr = tm_instr_create_INSTRUCTION_MOV__2();
09407                 } break;
09408 
09409                 case INSTRUCTION_MOV__3: {
09410                         new_instr = tm_instr_create_INSTRUCTION_MOV__3();
09411                 } break;
09412 
09413                 case INSTRUCTION_MOV__4: {
09414                         new_instr = tm_instr_create_INSTRUCTION_MOV__4();
09415                 } break;
09416 
09417                 case INSTRUCTION_MOV__5: {
09418                         new_instr = tm_instr_create_INSTRUCTION_MOV__5();
09419                 } break;
09420 
09421                 case INSTRUCTION_MOV__7: {
09422                         new_instr = tm_instr_create_INSTRUCTION_MOV__7();
09423                 } break;
09424 
09425                 case INSTRUCTION_MOV__71: {
09426                         new_instr = tm_instr_create_INSTRUCTION_MOV__71();
09427                 } break;
09428 
09429                 case INSTRUCTION_MOV__8: {
09430                         new_instr = tm_instr_create_INSTRUCTION_MOV__8();
09431                 } break;
09432 
09433                 case INSTRUCTION_SYSMOV__9: {
09434                         new_instr = tm_instr_create_INSTRUCTION_SYSMOV__9();
09435                 } break;
09436 
09437                 case INSTRUCTION_SYSMOV__10: {
09438                         new_instr = tm_instr_create_INSTRUCTION_SYSMOV__10();
09439                 } break;
09440 
09441                 case INSTRUCTION_SYSMOV__11: {
09442                         new_instr = tm_instr_create_INSTRUCTION_SYSMOV__11();
09443                 } break;
09444 
09445                 case INSTRUCTION_SAHF__1: {
09446                         new_instr = tm_instr_create_INSTRUCTION_SAHF__1();
09447                 } break;
09448 
09449                 case INSTRUCTION_LAHF__1: {
09450                         new_instr = tm_instr_create_INSTRUCTION_LAHF__1();
09451                 } break;
09452 
09453                 case INSTRUCTION_ADD__1: {
09454                         new_instr = tm_instr_create_INSTRUCTION_ADD__1();
09455                 } break;
09456 
09457                 case INSTRUCTION_ADD__11: {
09458                         new_instr = tm_instr_create_INSTRUCTION_ADD__11();
09459                 } break;
09460 
09461                 case INSTRUCTION_ADD__12: {
09462                         new_instr = tm_instr_create_INSTRUCTION_ADD__12();
09463                 } break;
09464 
09465                 case INSTRUCTION_ADD__13: {
09466                         new_instr = tm_instr_create_INSTRUCTION_ADD__13();
09467                 } break;
09468 
09469                 case INSTRUCTION_ADD__14: {
09470                         new_instr = tm_instr_create_INSTRUCTION_ADD__14();
09471                 } break;
09472 
09473                 case INSTRUCTION_SUB__1: {
09474                         new_instr = tm_instr_create_INSTRUCTION_SUB__1();
09475                 } break;
09476 
09477                 case INSTRUCTION_SUB__11: {
09478                         new_instr = tm_instr_create_INSTRUCTION_SUB__11();
09479                 } break;
09480 
09481                 case INSTRUCTION_SUB__12: {
09482                         new_instr = tm_instr_create_INSTRUCTION_SUB__12();
09483                 } break;
09484 
09485                 case INSTRUCTION_IMUL__1: {
09486                         new_instr = tm_instr_create_INSTRUCTION_IMUL__1();
09487                 } break;
09488 
09489                 case INSTRUCTION_IMUL__2: {
09490                         new_instr = tm_instr_create_INSTRUCTION_IMUL__2();
09491                 } break;
09492 
09493                 case INSTRUCTION_IMUL__21: {
09494                         new_instr = tm_instr_create_INSTRUCTION_IMUL__21();
09495                 } break;
09496 
09497                 case INSTRUCTION_IMUL__22: {
09498                         new_instr = tm_instr_create_INSTRUCTION_IMUL__22();
09499                 } break;
09500 
09501                 case INSTRUCTION_IMUL__23: {
09502                         new_instr = tm_instr_create_INSTRUCTION_IMUL__23();
09503                 } break;
09504 
09505                 case INSTRUCTION_IMUL__24: {
09506                         new_instr = tm_instr_create_INSTRUCTION_IMUL__24();
09507                 } break;
09508 
09509                 case INSTRUCTION_MUL__1: {
09510                         new_instr = tm_instr_create_INSTRUCTION_MUL__1();
09511                 } break;
09512 
09513                 case INSTRUCTION_MUL__11: {
09514                         new_instr = tm_instr_create_INSTRUCTION_MUL__11();
09515                 } break;
09516 
09517                 case INSTRUCTION_MUL__12: {
09518                         new_instr = tm_instr_create_INSTRUCTION_MUL__12();
09519                 } break;
09520 
09521                 case INSTRUCTION_MUL__2: {
09522                         new_instr = tm_instr_create_INSTRUCTION_MUL__2();
09523                 } break;
09524 
09525                 case INSTRUCTION_MUL__21: {
09526                         new_instr = tm_instr_create_INSTRUCTION_MUL__21();
09527                 } break;
09528 
09529                 case INSTRUCTION_MUL__22: {
09530                         new_instr = tm_instr_create_INSTRUCTION_MUL__22();
09531                 } break;
09532 
09533                 case INSTRUCTION_MUL__3: {
09534                         new_instr = tm_instr_create_INSTRUCTION_MUL__3();
09535                 } break;
09536 
09537                 case INSTRUCTION_MUL__31: {
09538                         new_instr = tm_instr_create_INSTRUCTION_MUL__31();
09539                 } break;
09540 
09541                 case INSTRUCTION_MUL__32: {
09542                         new_instr = tm_instr_create_INSTRUCTION_MUL__32();
09543                 } break;
09544 
09545                 case INSTRUCTION_CBW__1: {
09546                         new_instr = tm_instr_create_INSTRUCTION_CBW__1();
09547                 } break;
09548 
09549                 case INSTRUCTION_CWD__1: {
09550                         new_instr = tm_instr_create_INSTRUCTION_CWD__1();
09551                 } break;
09552 
09553                 case INSTRUCTION_CDQ__1: {
09554                         new_instr = tm_instr_create_INSTRUCTION_CDQ__1();
09555                 } break;
09556 
09557                 case INSTRUCTION_DIV__1: {
09558                         new_instr = tm_instr_create_INSTRUCTION_DIV__1();
09559                 } break;
09560 
09561                 case INSTRUCTION_DIV__11: {
09562                         new_instr = tm_instr_create_INSTRUCTION_DIV__11();
09563                 } break;
09564 
09565                 case INSTRUCTION_DIV__2: {
09566                         new_instr = tm_instr_create_INSTRUCTION_DIV__2();
09567                 } break;
09568 
09569                 case INSTRUCTION_DIV__21: {
09570                         new_instr = tm_instr_create_INSTRUCTION_DIV__21();
09571                 } break;
09572 
09573                 case INSTRUCTION_DIV__3: {
09574                         new_instr = tm_instr_create_INSTRUCTION_DIV__3();
09575                 } break;
09576 
09577                 case INSTRUCTION_DIV__31: {
09578                         new_instr = tm_instr_create_INSTRUCTION_DIV__31();
09579                 } break;
09580 
09581                 case INSTRUCTION_NULLAH__1: {
09582                         new_instr = tm_instr_create_INSTRUCTION_NULLAH__1();
09583                 } break;
09584 
09585                 case INSTRUCTION_NULLDX__1: {
09586                         new_instr = tm_instr_create_INSTRUCTION_NULLDX__1();
09587                 } break;
09588 
09589                 case INSTRUCTION_NULLEDX__1: {
09590                         new_instr = tm_instr_create_INSTRUCTION_NULLEDX__1();
09591                 } break;
09592 
09593                 case INSTRUCTION_IDIV__1: {
09594                         new_instr = tm_instr_create_INSTRUCTION_IDIV__1();
09595                 } break;
09596 
09597                 case INSTRUCTION_IDIV__11: {
09598                         new_instr = tm_instr_create_INSTRUCTION_IDIV__11();
09599                 } break;
09600 
09601                 case INSTRUCTION_IDIV__2: {
09602                         new_instr = tm_instr_create_INSTRUCTION_IDIV__2();
09603                 } break;
09604 
09605                 case INSTRUCTION_IDIV__21: {
09606                         new_instr = tm_instr_create_INSTRUCTION_IDIV__21();
09607                 } break;
09608 
09609                 case INSTRUCTION_IDIV__3: {
09610                         new_instr = tm_instr_create_INSTRUCTION_IDIV__3();
09611                 } break;
09612 
09613                 case INSTRUCTION_IDIV__31: {
09614                         new_instr = tm_instr_create_INSTRUCTION_IDIV__31();
09615                 } break;
09616 
09617                 case INSTRUCTION_NEG__1: {
09618                         new_instr = tm_instr_create_INSTRUCTION_NEG__1();
09619                 } break;
09620 
09621                 case INSTRUCTION_SHL__1: {
09622                         new_instr = tm_instr_create_INSTRUCTION_SHL__1();
09623                 } break;
09624 
09625                 case INSTRUCTION_SHR__1: {
09626                         new_instr = tm_instr_create_INSTRUCTION_SHR__1();
09627                 } break;
09628 
09629                 case INSTRUCTION_SAL__1: {
09630                         new_instr = tm_instr_create_INSTRUCTION_SAL__1();
09631                 } break;
09632 
09633                 case INSTRUCTION_SAR__1: {
09634                         new_instr = tm_instr_create_INSTRUCTION_SAR__1();
09635                 } break;
09636 
09637                 case INSTRUCTION_AND__1: {
09638                         new_instr = tm_instr_create_INSTRUCTION_AND__1();
09639                 } break;
09640 
09641                 case INSTRUCTION_AND__11: {
09642                         new_instr = tm_instr_create_INSTRUCTION_AND__11();
09643                 } break;
09644 
09645                 case INSTRUCTION_AND__12: {
09646                         new_instr = tm_instr_create_INSTRUCTION_AND__12();
09647                 } break;
09648 
09649                 case INSTRUCTION_AND__13: {
09650                         new_instr = tm_instr_create_INSTRUCTION_AND__13();
09651                 } break;
09652 
09653                 case INSTRUCTION_AND__14: {
09654                         new_instr = tm_instr_create_INSTRUCTION_AND__14();
09655                 } break;
09656 
09657                 case INSTRUCTION_AND__2: {
09658                         new_instr = tm_instr_create_INSTRUCTION_AND__2();
09659                 } break;
09660 
09661                 case INSTRUCTION_OR__1: {
09662                         new_instr = tm_instr_create_INSTRUCTION_OR__1();
09663                 } break;
09664 
09665                 case INSTRUCTION_OR__11: {
09666                         new_instr = tm_instr_create_INSTRUCTION_OR__11();
09667                 } break;
09668 
09669                 case INSTRUCTION_OR__12: {
09670                         new_instr = tm_instr_create_INSTRUCTION_OR__12();
09671                 } break;
09672 
09673                 case INSTRUCTION_OR__13: {
09674                         new_instr = tm_instr_create_INSTRUCTION_OR__13();
09675                 } break;
09676 
09677                 case INSTRUCTION_OR__14: {
09678                         new_instr = tm_instr_create_INSTRUCTION_OR__14();
09679                 } break;
09680 
09681                 case INSTRUCTION_XOR__1: {
09682                         new_instr = tm_instr_create_INSTRUCTION_XOR__1();
09683                 } break;
09684 
09685                 case INSTRUCTION_XOR__11: {
09686                         new_instr = tm_instr_create_INSTRUCTION_XOR__11();
09687                 } break;
09688 
09689                 case INSTRUCTION_XOR__12: {
09690                         new_instr = tm_instr_create_INSTRUCTION_XOR__12();
09691                 } break;
09692 
09693                 case INSTRUCTION_XOR__13: {
09694                         new_instr = tm_instr_create_INSTRUCTION_XOR__13();
09695                 } break;
09696 
09697                 case INSTRUCTION_XOR__14: {
09698                         new_instr = tm_instr_create_INSTRUCTION_XOR__14();
09699                 } break;
09700 
09701                 case INSTRUCTION_XOR__2: {
09702                         new_instr = tm_instr_create_INSTRUCTION_XOR__2();
09703                 } break;
09704 
09705                 case INSTRUCTION_NOT__1: {
09706                         new_instr = tm_instr_create_INSTRUCTION_NOT__1();
09707                 } break;
09708 
09709                 case INSTRUCTION_CONVERT__1: {
09710                         new_instr = tm_instr_create_INSTRUCTION_CONVERT__1();
09711                 } break;
09712 
09713                 case INSTRUCTION_CONVERT__5: {
09714                         new_instr = tm_instr_create_INSTRUCTION_CONVERT__5();
09715                 } break;
09716 
09717                 case INSTRUCTION_CONVERT__2: {
09718                         new_instr = tm_instr_create_INSTRUCTION_CONVERT__2();
09719                 } break;
09720 
09721                 case INSTRUCTION_CONVERT__3: {
09722                         new_instr = tm_instr_create_INSTRUCTION_CONVERT__3();
09723                 } break;
09724 
09725                 case INSTRUCTION_MOVZX__1: {
09726                         new_instr = tm_instr_create_INSTRUCTION_MOVZX__1();
09727                 } break;
09728 
09729                 case INSTRUCTION_MOVZX__2: {
09730                         new_instr = tm_instr_create_INSTRUCTION_MOVZX__2();
09731                 } break;
09732 
09733                 case INSTRUCTION_MOVZX__3: {
09734                         new_instr = tm_instr_create_INSTRUCTION_MOVZX__3();
09735                 } break;
09736 
09737                 case INSTRUCTION_MOVZX__4: {
09738                         new_instr = tm_instr_create_INSTRUCTION_MOVZX__4();
09739                 } break;
09740 
09741                 case INSTRUCTION_MOVZX__5: {
09742                         new_instr = tm_instr_create_INSTRUCTION_MOVZX__5();
09743                 } break;
09744 
09745                 case INSTRUCTION_MOVZX__6: {
09746                         new_instr = tm_instr_create_INSTRUCTION_MOVZX__6();
09747                 } break;
09748 
09749                 case INSTRUCTION_MOVSX__1: {
09750                         new_instr = tm_instr_create_INSTRUCTION_MOVSX__1();
09751                 } break;
09752 
09753                 case INSTRUCTION_MOVSX__11: {
09754                         new_instr = tm_instr_create_INSTRUCTION_MOVSX__11();
09755                 } break;
09756 
09757                 case INSTRUCTION_MOVSX__2: {
09758                         new_instr = tm_instr_create_INSTRUCTION_MOVSX__2();
09759                 } break;
09760 
09761                 case INSTRUCTION_MOVSX__21: {
09762                         new_instr = tm_instr_create_INSTRUCTION_MOVSX__21();
09763                 } break;
09764 
09765                 case INSTRUCTION_LEA__1: {
09766                         new_instr = tm_instr_create_INSTRUCTION_LEA__1();
09767                 } break;
09768 
09769                 case INSTRUCTION_CMP__1: {
09770                         new_instr = tm_instr_create_INSTRUCTION_CMP__1();
09771                 } break;
09772 
09773                 case INSTRUCTION_CMP__2: {
09774                         new_instr = tm_instr_create_INSTRUCTION_CMP__2();
09775                 } break;
09776 
09777                 case INSTRUCTION_CMP__21: {
09778                         new_instr = tm_instr_create_INSTRUCTION_CMP__21();
09779                 } break;
09780 
09781                 case INSTRUCTION_CMP__22: {
09782                         new_instr = tm_instr_create_INSTRUCTION_CMP__22();
09783                 } break;
09784 
09785                 case INSTRUCTION_CMP__23: {
09786                         new_instr = tm_instr_create_INSTRUCTION_CMP__23();
09787                 } break;
09788 
09789                 case INSTRUCTION_CMP__24: {
09790                         new_instr = tm_instr_create_INSTRUCTION_CMP__24();
09791                 } break;
09792 
09793                 case INSTRUCTION_JMP__1: {
09794                         new_instr = tm_instr_create_INSTRUCTION_JMP__1();
09795                 } break;
09796 
09797                 case INSTRUCTION_JA__1: {
09798                         new_instr = tm_instr_create_INSTRUCTION_JA__1();
09799                 } break;
09800 
09801                 case INSTRUCTION_JZ__1: {
09802                         new_instr = tm_instr_create_INSTRUCTION_JZ__1();
09803                 } break;
09804 
09805                 case INSTRUCTION_JG__1: {
09806                         new_instr = tm_instr_create_INSTRUCTION_JG__1();
09807                 } break;
09808 
09809                 case INSTRUCTION_JL__1: {
09810                         new_instr = tm_instr_create_INSTRUCTION_JL__1();
09811                 } break;
09812 
09813                 case INSTRUCTION_JB__1: {
09814                         new_instr = tm_instr_create_INSTRUCTION_JB__1();
09815                 } break;
09816 
09817                 case INSTRUCTION_JE__1: {
09818                         new_instr = tm_instr_create_INSTRUCTION_JE__1();
09819                 } break;
09820 
09821                 case INSTRUCTION_JNG__1: {
09822                         new_instr = tm_instr_create_INSTRUCTION_JNG__1();
09823                 } break;
09824 
09825                 case INSTRUCTION_JNA__1: {
09826                         new_instr = tm_instr_create_INSTRUCTION_JNA__1();
09827                 } break;
09828 
09829                 case INSTRUCTION_JNL__1: {
09830                         new_instr = tm_instr_create_INSTRUCTION_JNL__1();
09831                 } break;
09832 
09833                 case INSTRUCTION_JNB__1: {
09834                         new_instr = tm_instr_create_INSTRUCTION_JNB__1();
09835                 } break;
09836 
09837                 case INSTRUCTION_JNE__1: {
09838                         new_instr = tm_instr_create_INSTRUCTION_JNE__1();
09839                 } break;
09840 
09841                 case INSTRUCTION_SETG__1: {
09842                         new_instr = tm_instr_create_INSTRUCTION_SETG__1();
09843                 } break;
09844 
09845                 case INSTRUCTION_SETA__1: {
09846                         new_instr = tm_instr_create_INSTRUCTION_SETA__1();
09847                 } break;
09848 
09849                 case INSTRUCTION_SETL__1: {
09850                         new_instr = tm_instr_create_INSTRUCTION_SETL__1();
09851                 } break;
09852 
09853                 case INSTRUCTION_SETB__1: {
09854                         new_instr = tm_instr_create_INSTRUCTION_SETB__1();
09855                 } break;
09856 
09857                 case INSTRUCTION_SETE__1: {
09858                         new_instr = tm_instr_create_INSTRUCTION_SETE__1();
09859                 } break;
09860 
09861                 case INSTRUCTION_SETNG__1: {
09862                         new_instr = tm_instr_create_INSTRUCTION_SETNG__1();
09863                 } break;
09864 
09865                 case INSTRUCTION_SETNA__1: {
09866                         new_instr = tm_instr_create_INSTRUCTION_SETNA__1();
09867                 } break;
09868 
09869                 case INSTRUCTION_SETNL__1: {
09870                         new_instr = tm_instr_create_INSTRUCTION_SETNL__1();
09871                 } break;
09872 
09873                 case INSTRUCTION_SETNB__1: {
09874                         new_instr = tm_instr_create_INSTRUCTION_SETNB__1();
09875                 } break;
09876 
09877                 case INSTRUCTION_SETNE__1: {
09878                         new_instr = tm_instr_create_INSTRUCTION_SETNE__1();
09879                 } break;
09880 
09881                 case INSTRUCTION_SETNZ__1: {
09882                         new_instr = tm_instr_create_INSTRUCTION_SETNZ__1();
09883                 } break;
09884 
09885                 case INSTRUCTION_PUSH__1: {
09886                         new_instr = tm_instr_create_INSTRUCTION_PUSH__1();
09887                 } break;
09888 
09889                 case INSTRUCTION_PUSH__2: {
09890                         new_instr = tm_instr_create_INSTRUCTION_PUSH__2();
09891                 } break;
09892 
09893                 case INSTRUCTION_PUSH__3: {
09894                         new_instr = tm_instr_create_INSTRUCTION_PUSH__3();
09895                 } break;
09896 
09897                 case INSTRUCTION_POP__1: {
09898                         new_instr = tm_instr_create_INSTRUCTION_POP__1();
09899                 } break;
09900 
09901                 case INSTRUCTION_NOP__1: {
09902                         new_instr = tm_instr_create_INSTRUCTION_NOP__1();
09903                 } break;
09904 
09905                 case INSTRUCTION_ESPADD__1: {
09906                         new_instr = tm_instr_create_INSTRUCTION_ESPADD__1();
09907                 } break;
09908 
09909                 case INSTRUCTION_BACKUPESP__1: {
09910                         new_instr = tm_instr_create_INSTRUCTION_BACKUPESP__1();
09911                 } break;
09912 
09913                 case INSTRUCTION_CALL__1: {
09914                         new_instr = tm_instr_create_INSTRUCTION_CALL__1();
09915                 } break;
09916 
09917                 case INSTRUCTION_PROLOGUE__1: {
09918                         new_instr = tm_instr_create_INSTRUCTION_PROLOGUE__1();
09919                 } break;
09920 
09921                 case INSTRUCTION_EPILOGUE__1: {
09922                         new_instr = tm_instr_create_INSTRUCTION_EPILOGUE__1();
09923                 } break;
09924 
09925                 case INSTRUCTION_LEAVE__1: {
09926                         new_instr = tm_instr_create_INSTRUCTION_LEAVE__1();
09927                 } break;
09928 
09929                 case INSTRUCTION_RET__1: {
09930                         new_instr = tm_instr_create_INSTRUCTION_RET__1();
09931                 } break;
09932 
09933                 default: lassert(false);
09934         }
09935 
09936         lassert(new_instr);
09937         id_to_instance_get()->insert(::std::pair<ulint,srp<tm_instr> >(id, new_instr));
09938         return new_instr;
09939 }
09940 
09941 end_package(instructions);
09942 end_package(md);
09943 end_package(lestes);