S390: [simulator] Initial 2-level jump table implementation

The old switch-case instruction decode implementation results in a
sparse table, which is not resolved by a fast jump table routing.
Therefore, it is really slow in instruction decoding phase.

R=joransiu@ca.ibm.com, michael_dawson@ca.ibm.com, mbrandy@us.ibm.com
BUG=

Review URL: https://codereview.chromium.org/1873963002

Cr-Commit-Position: refs/heads/master@{#35589}

src/s390/simulator-s390.h

@@ -507,6 +507,742 @@ class Simulator {
   };
   StopCountAndDesc watched_stops_[kNumOfWatchedStops];
   void DebugStart();
+
+  int DecodeInstructionOriginal(Instruction* instr);
+  int DecodeInstruction(Instruction* instr);
+  int Evaluate_Unknown(Instruction* instr);
+#define MAX_NUM_OPCODES (1 << 16)
+  typedef int (Simulator::*EvaluateFuncType)(Instruction*);
+
+  static EvaluateFuncType EvalTable[MAX_NUM_OPCODES];
+  static void EvalTableInit();
+
+#define EVALUATE(name) int Evaluate_##name(Instruction* instr)
+  EVALUATE(BKPT);
+  EVALUATE(SPM);
+  EVALUATE(BALR);
+  EVALUATE(BCTR);
+  EVALUATE(BCR);
+  EVALUATE(SVC);
+  EVALUATE(BSM);
+  EVALUATE(BASSM);
+  EVALUATE(BASR);
+  EVALUATE(MVCL);
+  EVALUATE(CLCL);
+  EVALUATE(LPR);
+  EVALUATE(LNR);
+  EVALUATE(LTR);
+  EVALUATE(LCR);
+  EVALUATE(NR);
+  EVALUATE(CLR);
+  EVALUATE(OR);
+  EVALUATE(XR);
+  EVALUATE(LR);
+  EVALUATE(CR);
+  EVALUATE(AR);
+  EVALUATE(SR);
+  EVALUATE(MR);
+  EVALUATE(DR);
+  EVALUATE(ALR);
+  EVALUATE(SLR);
+  EVALUATE(LDR);
+  EVALUATE(CDR);
+  EVALUATE(LER);
+  EVALUATE(STH);
+  EVALUATE(LA);
+  EVALUATE(STC);
+  EVALUATE(IC_z);
+  EVALUATE(EX);
+  EVALUATE(BAL);
+  EVALUATE(BCT);
+  EVALUATE(BC);
+  EVALUATE(LH);
+  EVALUATE(CH);
+  EVALUATE(AH);
+  EVALUATE(SH);
+  EVALUATE(MH);
+  EVALUATE(BAS);
+  EVALUATE(CVD);
+  EVALUATE(CVB);
+  EVALUATE(ST);
+  EVALUATE(LAE);
+  EVALUATE(N);
+  EVALUATE(CL);
+  EVALUATE(O);
+  EVALUATE(X);
+  EVALUATE(L);
+  EVALUATE(C);
+  EVALUATE(A);
+  EVALUATE(S);
+  EVALUATE(M);
+  EVALUATE(D);
+  EVALUATE(AL);
+  EVALUATE(SL);
+  EVALUATE(STD);
+  EVALUATE(LD);
+  EVALUATE(CD);
+  EVALUATE(STE);
+  EVALUATE(MS);
+  EVALUATE(LE);
+  EVALUATE(BRXH);
+  EVALUATE(BRXLE);
+  EVALUATE(BXH);
+  EVALUATE(BXLE);
+  EVALUATE(SRL);
+  EVALUATE(SLL);
+  EVALUATE(SRA);
+  EVALUATE(SLA);
+  EVALUATE(SRDL);
+  EVALUATE(SLDL);
+  EVALUATE(SRDA);
+  EVALUATE(SLDA);
+  EVALUATE(STM);
+  EVALUATE(TM);
+  EVALUATE(MVI);
+  EVALUATE(TS);
+  EVALUATE(NI);
+  EVALUATE(CLI);
+  EVALUATE(OI);
+  EVALUATE(XI);
+  EVALUATE(LM);
+  EVALUATE(MVCLE);
+  EVALUATE(CLCLE);
+  EVALUATE(MC);
+  EVALUATE(CDS);
+  EVALUATE(STCM);
+  EVALUATE(ICM);
+  EVALUATE(BPRP);
+  EVALUATE(BPP);
+  EVALUATE(TRTR);
+  EVALUATE(MVN);
+  EVALUATE(MVC);
+  EVALUATE(MVZ);
+  EVALUATE(NC);
+  EVALUATE(CLC);
+  EVALUATE(OC);
+  EVALUATE(XC);
+  EVALUATE(MVCP);
+  EVALUATE(TR);
+  EVALUATE(TRT);
+  EVALUATE(ED);
+  EVALUATE(EDMK);
+  EVALUATE(PKU);
+  EVALUATE(UNPKU);
+  EVALUATE(MVCIN);
+  EVALUATE(PKA);
+  EVALUATE(UNPKA);
+  EVALUATE(PLO);
+  EVALUATE(LMD);
+  EVALUATE(SRP);
+  EVALUATE(MVO);
+  EVALUATE(PACK);
+  EVALUATE(UNPK);
+  EVALUATE(ZAP);
+  EVALUATE(AP);
+  EVALUATE(SP);
+  EVALUATE(MP);
+  EVALUATE(DP);
+  EVALUATE(UPT);
+  EVALUATE(PFPO);
+  EVALUATE(IIHH);
+  EVALUATE(IIHL);
+  EVALUATE(IILH);
+  EVALUATE(IILL);
+  EVALUATE(NIHH);
+  EVALUATE(NIHL);
+  EVALUATE(NILH);
+  EVALUATE(NILL);
+  EVALUATE(OIHH);
+  EVALUATE(OIHL);
+  EVALUATE(OILH);
+  EVALUATE(OILL);
+  EVALUATE(LLIHH);
+  EVALUATE(LLIHL);
+  EVALUATE(LLILH);
+  EVALUATE(LLILL);
+  EVALUATE(TMLH);
+  EVALUATE(TMLL);
+  EVALUATE(TMHH);
+  EVALUATE(TMHL);
+  EVALUATE(BRC);
+  EVALUATE(BRAS);
+  EVALUATE(BRCT);
+  EVALUATE(BRCTG);
+  EVALUATE(LHI);
+  EVALUATE(LGHI);
+  EVALUATE(AHI);
+  EVALUATE(AGHI);
+  EVALUATE(MHI);
+  EVALUATE(MGHI);
+  EVALUATE(CHI);
+  EVALUATE(CGHI);
+  EVALUATE(LARL);
+  EVALUATE(LGFI);
+  EVALUATE(BRCL);
+  EVALUATE(BRASL);
+  EVALUATE(XIHF);
+  EVALUATE(XILF);
+  EVALUATE(IIHF);
+  EVALUATE(IILF);
+  EVALUATE(NIHF);
+  EVALUATE(NILF);
+  EVALUATE(OIHF);
+  EVALUATE(OILF);
+  EVALUATE(LLIHF);
+  EVALUATE(LLILF);
+  EVALUATE(MSGFI);
+  EVALUATE(MSFI);
+  EVALUATE(SLGFI);
+  EVALUATE(SLFI);
+  EVALUATE(AGFI);
+  EVALUATE(AFI);
+  EVALUATE(ALGFI);
+  EVALUATE(ALFI);
+  EVALUATE(CGFI);
+  EVALUATE(CFI);
+  EVALUATE(CLGFI);
+  EVALUATE(CLFI);
+  EVALUATE(LLHRL);
+  EVALUATE(LGHRL);
+  EVALUATE(LHRL);
+  EVALUATE(LLGHRL);
+  EVALUATE(STHRL);
+  EVALUATE(LGRL);
+  EVALUATE(STGRL);
+  EVALUATE(LGFRL);
+  EVALUATE(LRL);
+  EVALUATE(LLGFRL);
+  EVALUATE(STRL);
+  EVALUATE(EXRL);
+  EVALUATE(PFDRL);
+  EVALUATE(CGHRL);
+  EVALUATE(CHRL);
+  EVALUATE(CGRL);
+  EVALUATE(CGFRL);
+  EVALUATE(ECTG);
+  EVALUATE(CSST);
+  EVALUATE(LPD);
+  EVALUATE(LPDG);
+  EVALUATE(BRCTH);
+  EVALUATE(AIH);
+  EVALUATE(ALSIH);
+  EVALUATE(ALSIHN);
+  EVALUATE(CIH);
+  EVALUATE(STCK);
+  EVALUATE(CFC);
+  EVALUATE(IPM);
+  EVALUATE(HSCH);
+  EVALUATE(MSCH);
+  EVALUATE(SSCH);
+  EVALUATE(STSCH);
+  EVALUATE(TSCH);
+  EVALUATE(TPI);
+  EVALUATE(SAL);
+  EVALUATE(RSCH);
+  EVALUATE(STCRW);
+  EVALUATE(STCPS);
+  EVALUATE(RCHP);
+  EVALUATE(SCHM);
+  EVALUATE(CKSM);
+  EVALUATE(SAR);
+  EVALUATE(EAR);
+  EVALUATE(MSR);
+  EVALUATE(MVST);
+  EVALUATE(CUSE);
+  EVALUATE(SRST);
+  EVALUATE(XSCH);
+  EVALUATE(STCKE);
+  EVALUATE(STCKF);
+  EVALUATE(SRNM);
+  EVALUATE(STFPC);
+  EVALUATE(LFPC);
+  EVALUATE(TRE);
+  EVALUATE(CUUTF);
+  EVALUATE(CUTFU);
+  EVALUATE(STFLE);
+  EVALUATE(SRNMB);
+  EVALUATE(SRNMT);
+  EVALUATE(LFAS);
+  EVALUATE(PPA);
+  EVALUATE(ETND);
+  EVALUATE(TEND);
+  EVALUATE(NIAI);
+  EVALUATE(TABORT);
+  EVALUATE(TRAP4);
+  EVALUATE(LPEBR);
+  EVALUATE(LNEBR);
+  EVALUATE(LTEBR);
+  EVALUATE(LCEBR);
+  EVALUATE(LDEBR);
+  EVALUATE(LXDBR);
+  EVALUATE(LXEBR);
+  EVALUATE(MXDBR);
+  EVALUATE(KEBR);
+  EVALUATE(CEBR);
+  EVALUATE(AEBR);
+  EVALUATE(SEBR);
+  EVALUATE(MDEBR);
+  EVALUATE(DEBR);
+  EVALUATE(MAEBR);
+  EVALUATE(MSEBR);
+  EVALUATE(LPDBR);
+  EVALUATE(LNDBR);
+  EVALUATE(LTDBR);
+  EVALUATE(LCDBR);
+  EVALUATE(SQEBR);
+  EVALUATE(SQDBR);
+  EVALUATE(SQXBR);
+  EVALUATE(MEEBR);
+  EVALUATE(KDBR);
+  EVALUATE(CDBR);
+  EVALUATE(ADBR);
+  EVALUATE(SDBR);
+  EVALUATE(MDBR);
+  EVALUATE(DDBR);
+  EVALUATE(MADBR);
+  EVALUATE(MSDBR);
+  EVALUATE(LPXBR);
+  EVALUATE(LNXBR);
+  EVALUATE(LTXBR);
+  EVALUATE(LCXBR);
+  EVALUATE(LEDBRA);
+  EVALUATE(LDXBRA);
+  EVALUATE(LEXBRA);
+  EVALUATE(FIXBRA);
+  EVALUATE(KXBR);
+  EVALUATE(CXBR);
+  EVALUATE(AXBR);
+  EVALUATE(SXBR);
+  EVALUATE(MXBR);
+  EVALUATE(DXBR);
+  EVALUATE(TBEDR);
+  EVALUATE(TBDR);
+  EVALUATE(DIEBR);
+  EVALUATE(FIEBRA);
+  EVALUATE(THDER);
+  EVALUATE(THDR);
+  EVALUATE(DIDBR);
+  EVALUATE(FIDBRA);
+  EVALUATE(LXR);
+  EVALUATE(LPDFR);
+  EVALUATE(LNDFR);
+  EVALUATE(LCDFR);
+  EVALUATE(LZER);
+  EVALUATE(LZDR);
+  EVALUATE(LZXR);
+  EVALUATE(SFPC);
+  EVALUATE(SFASR);
+  EVALUATE(EFPC);
+  EVALUATE(CELFBR);
+  EVALUATE(CDLFBR);
+  EVALUATE(CXLFBR);
+  EVALUATE(CEFBRA);
+  EVALUATE(CDFBRA);
+  EVALUATE(CXFBRA);
+  EVALUATE(CFEBRA);
+  EVALUATE(CFDBRA);
+  EVALUATE(CFXBRA);
+  EVALUATE(CLFEBR);
+  EVALUATE(CLFDBR);
+  EVALUATE(CLFXBR);
+  EVALUATE(CELGBR);
+  EVALUATE(CDLGBR);
+  EVALUATE(CXLGBR);
+  EVALUATE(CEGBRA);
+  EVALUATE(CDGBRA);
+  EVALUATE(CXGBRA);
+  EVALUATE(CGEBRA);
+  EVALUATE(CGDBRA);
+  EVALUATE(CGXBRA);
+  EVALUATE(CLGEBR);
+  EVALUATE(CLGDBR);
+  EVALUATE(CFER);
+  EVALUATE(CFDR);
+  EVALUATE(CFXR);
+  EVALUATE(LDGR);
+  EVALUATE(CGER);
+  EVALUATE(CGDR);
+  EVALUATE(CGXR);
+  EVALUATE(LGDR);
+  EVALUATE(MDTR);
+  EVALUATE(MDTRA);
+  EVALUATE(DDTRA);
+  EVALUATE(ADTRA);
+  EVALUATE(SDTRA);
+  EVALUATE(LDETR);
+  EVALUATE(LEDTR);
+  EVALUATE(LTDTR);
+  EVALUATE(FIDTR);
+  EVALUATE(MXTRA);
+  EVALUATE(DXTRA);
+  EVALUATE(AXTRA);
+  EVALUATE(SXTRA);
+  EVALUATE(LXDTR);
+  EVALUATE(LDXTR);
+  EVALUATE(LTXTR);
+  EVALUATE(FIXTR);
+  EVALUATE(KDTR);
+  EVALUATE(CGDTRA);
+  EVALUATE(CUDTR);
+  EVALUATE(CDTR);
+  EVALUATE(EEDTR);
+  EVALUATE(ESDTR);
+  EVALUATE(KXTR);
+  EVALUATE(CGXTRA);
+  EVALUATE(CUXTR);
+  EVALUATE(CSXTR);
+  EVALUATE(CXTR);
+  EVALUATE(EEXTR);
+  EVALUATE(ESXTR);
+  EVALUATE(CDGTRA);
+  EVALUATE(CDUTR);
+  EVALUATE(CDSTR);
+  EVALUATE(CEDTR);
+  EVALUATE(QADTR);
+  EVALUATE(IEDTR);
+  EVALUATE(RRDTR);
+  EVALUATE(CXGTRA);
+  EVALUATE(CXUTR);
+  EVALUATE(CXSTR);
+  EVALUATE(CEXTR);
+  EVALUATE(QAXTR);
+  EVALUATE(IEXTR);
+  EVALUATE(RRXTR);
+  EVALUATE(LPGR);
+  EVALUATE(LNGR);
+  EVALUATE(LTGR);
+  EVALUATE(LCGR);
+  EVALUATE(LGR);
+  EVALUATE(LGBR);
+  EVALUATE(LGHR);
+  EVALUATE(AGR);
+  EVALUATE(SGR);
+  EVALUATE(ALGR);
+  EVALUATE(SLGR);
+  EVALUATE(MSGR);
+  EVALUATE(DSGR);
+  EVALUATE(LRVGR);
+  EVALUATE(LPGFR);
+  EVALUATE(LNGFR);
+  EVALUATE(LTGFR);
+  EVALUATE(LCGFR);
+  EVALUATE(LGFR);
+  EVALUATE(LLGFR);
+  EVALUATE(LLGTR);
+  EVALUATE(AGFR);
+  EVALUATE(SGFR);
+  EVALUATE(ALGFR);
+  EVALUATE(SLGFR);
+  EVALUATE(MSGFR);
+  EVALUATE(DSGFR);
+  EVALUATE(KMAC);
+  EVALUATE(LRVR);
+  EVALUATE(CGR);
+  EVALUATE(CLGR);
+  EVALUATE(LBR);
+  EVALUATE(LHR);
+  EVALUATE(KMF);
+  EVALUATE(KMO);
+  EVALUATE(PCC);
+  EVALUATE(KMCTR);
+  EVALUATE(KM);
+  EVALUATE(KMC);
+  EVALUATE(CGFR);
+  EVALUATE(KIMD);
+  EVALUATE(KLMD);
+  EVALUATE(CFDTR);
+  EVALUATE(CLGDTR);
+  EVALUATE(CLFDTR);
+  EVALUATE(BCTGR);
+  EVALUATE(CFXTR);
+  EVALUATE(CLFXTR);
+  EVALUATE(CDFTR);
+  EVALUATE(CDLGTR);
+  EVALUATE(CDLFTR);
+  EVALUATE(CXFTR);
+  EVALUATE(CXLGTR);
+  EVALUATE(CXLFTR);
+  EVALUATE(CGRT);
+  EVALUATE(NGR);
+  EVALUATE(OGR);
+  EVALUATE(XGR);
+  EVALUATE(FLOGR);
+  EVALUATE(LLGCR);
+  EVALUATE(LLGHR);
+  EVALUATE(MLGR);
+  EVALUATE(DLGR);
+  EVALUATE(ALCGR);
+  EVALUATE(SLBGR);
+  EVALUATE(EPSW);
+  EVALUATE(TRTT);
+  EVALUATE(TRTO);
+  EVALUATE(TROT);
+  EVALUATE(TROO);
+  EVALUATE(LLCR);
+  EVALUATE(LLHR);
+  EVALUATE(MLR);
+  EVALUATE(DLR);
+  EVALUATE(ALCR);
+  EVALUATE(SLBR);
+  EVALUATE(CU14);
+  EVALUATE(CU24);
+  EVALUATE(CU41);
+  EVALUATE(CU42);
+  EVALUATE(TRTRE);
+  EVALUATE(SRSTU);
+  EVALUATE(TRTE);
+  EVALUATE(AHHHR);
+  EVALUATE(SHHHR);
+  EVALUATE(ALHHHR);
+  EVALUATE(SLHHHR);
+  EVALUATE(CHHR);
+  EVALUATE(AHHLR);
+  EVALUATE(SHHLR);
+  EVALUATE(ALHHLR);
+  EVALUATE(SLHHLR);
+  EVALUATE(CHLR);
+  EVALUATE(POPCNT_Z);
+  EVALUATE(LOCGR);
+  EVALUATE(NGRK);
+  EVALUATE(OGRK);
+  EVALUATE(XGRK);
+  EVALUATE(AGRK);
+  EVALUATE(SGRK);
+  EVALUATE(ALGRK);
+  EVALUATE(SLGRK);
+  EVALUATE(LOCR);
+  EVALUATE(NRK);
+  EVALUATE(ORK);
+  EVALUATE(XRK);
+  EVALUATE(ARK);
+  EVALUATE(SRK);
+  EVALUATE(ALRK);
+  EVALUATE(SLRK);
+  EVALUATE(LTG);
+  EVALUATE(LG);
+  EVALUATE(CVBY);
+  EVALUATE(AG);
+  EVALUATE(SG);
+  EVALUATE(ALG);
+  EVALUATE(SLG);
+  EVALUATE(MSG);
+  EVALUATE(DSG);
+  EVALUATE(CVBG);
+  EVALUATE(LRVG);
+  EVALUATE(LT);
+  EVALUATE(LGF);
+  EVALUATE(LGH);
+  EVALUATE(LLGF);
+  EVALUATE(LLGT);
+  EVALUATE(AGF);
+  EVALUATE(SGF);
+  EVALUATE(ALGF);
+  EVALUATE(SLGF);
+  EVALUATE(MSGF);
+  EVALUATE(DSGF);
+  EVALUATE(LRV);
+  EVALUATE(LRVH);
+  EVALUATE(CG);
+  EVALUATE(CLG);
+  EVALUATE(STG);
+  EVALUATE(NTSTG);
+  EVALUATE(CVDY);
+  EVALUATE(CVDG);
+  EVALUATE(STRVG);
+  EVALUATE(CGF);
+  EVALUATE(CLGF);
+  EVALUATE(LTGF);
+  EVALUATE(CGH);
+  EVALUATE(PFD);
+  EVALUATE(STRV);
+  EVALUATE(STRVH);
+  EVALUATE(BCTG);
+  EVALUATE(STY);
+  EVALUATE(MSY);
+  EVALUATE(NY);
+  EVALUATE(CLY);
+  EVALUATE(OY);
+  EVALUATE(XY);
+  EVALUATE(LY);
+  EVALUATE(CY);
+  EVALUATE(AY);
+  EVALUATE(SY);
+  EVALUATE(MFY);
+  EVALUATE(ALY);
+  EVALUATE(SLY);
+  EVALUATE(STHY);
+  EVALUATE(LAY);
+  EVALUATE(STCY);
+  EVALUATE(ICY);
+  EVALUATE(LAEY);
+  EVALUATE(LB);
+  EVALUATE(LGB);
+  EVALUATE(LHY);
+  EVALUATE(CHY);
+  EVALUATE(AHY);
+  EVALUATE(SHY);
+  EVALUATE(MHY);
+  EVALUATE(NG);
+  EVALUATE(OG);
+  EVALUATE(XG);
+  EVALUATE(LGAT);
+  EVALUATE(MLG);
+  EVALUATE(DLG);
+  EVALUATE(ALCG);
+  EVALUATE(SLBG);
+  EVALUATE(STPQ);
+  EVALUATE(LPQ);
+  EVALUATE(LLGC);
+  EVALUATE(LLGH);
+  EVALUATE(LLC);
+  EVALUATE(LLH);
+  EVALUATE(ML);
+  EVALUATE(DL);
+  EVALUATE(ALC);
+  EVALUATE(SLB);
+  EVALUATE(LLGTAT);
+  EVALUATE(LLGFAT);
+  EVALUATE(LAT);
+  EVALUATE(LBH);
+  EVALUATE(LLCH);
+  EVALUATE(STCH);
+  EVALUATE(LHH);
+  EVALUATE(LLHH);
+  EVALUATE(STHH);
+  EVALUATE(LFHAT);
+  EVALUATE(LFH);
+  EVALUATE(STFH);
+  EVALUATE(CHF);
+  EVALUATE(MVCDK);
+  EVALUATE(MVHHI);
+  EVALUATE(MVGHI);
+  EVALUATE(MVHI);
+  EVALUATE(CHHSI);
+  EVALUATE(CGHSI);
+  EVALUATE(CHSI);
+  EVALUATE(CLFHSI);
+  EVALUATE(TBEGIN);
+  EVALUATE(TBEGINC);
+  EVALUATE(LMG);
+  EVALUATE(SRAG);
+  EVALUATE(SLAG);
+  EVALUATE(SRLG);
+  EVALUATE(SLLG);
+  EVALUATE(CSY);
+  EVALUATE(RLLG);
+  EVALUATE(RLL);
+  EVALUATE(STMG);
+  EVALUATE(STMH);
+  EVALUATE(STCMH);
+  EVALUATE(STCMY);
+  EVALUATE(CDSY);
+  EVALUATE(CDSG);
+  EVALUATE(BXHG);
+  EVALUATE(BXLEG);
+  EVALUATE(ECAG);
+  EVALUATE(TMY);
+  EVALUATE(MVIY);
+  EVALUATE(NIY);
+  EVALUATE(CLIY);
+  EVALUATE(OIY);
+  EVALUATE(XIY);
+  EVALUATE(ASI);
+  EVALUATE(ALSI);
+  EVALUATE(AGSI);
+  EVALUATE(ALGSI);
+  EVALUATE(ICMH);
+  EVALUATE(ICMY);
+  EVALUATE(MVCLU);
+  EVALUATE(CLCLU);
+  EVALUATE(STMY);
+  EVALUATE(LMH);
+  EVALUATE(LMY);
+  EVALUATE(TP);
+  EVALUATE(SRAK);
+  EVALUATE(SLAK);
+  EVALUATE(SRLK);
+  EVALUATE(SLLK);
+  EVALUATE(LOCG);
+  EVALUATE(STOCG);
+  EVALUATE(LANG);
+  EVALUATE(LAOG);
+  EVALUATE(LAXG);
+  EVALUATE(LAAG);
+  EVALUATE(LAALG);
+  EVALUATE(LOC);
+  EVALUATE(STOC);
+  EVALUATE(LAN);
+  EVALUATE(LAO);
+  EVALUATE(LAX);
+  EVALUATE(LAA);
+  EVALUATE(LAAL);
+  EVALUATE(BRXHG);
+  EVALUATE(BRXLG);
+  EVALUATE(RISBLG);
+  EVALUATE(RNSBG);
+  EVALUATE(RISBG);
+  EVALUATE(ROSBG);
+  EVALUATE(RXSBG);
+  EVALUATE(RISBGN);
+  EVALUATE(RISBHG);
+  EVALUATE(CGRJ);
+  EVALUATE(CGIT);
+  EVALUATE(CIT);
+  EVALUATE(CLFIT);
+  EVALUATE(CGIJ);
+  EVALUATE(CIJ);
+  EVALUATE(AHIK);
+  EVALUATE(AGHIK);
+  EVALUATE(ALHSIK);
+  EVALUATE(ALGHSIK);
+  EVALUATE(CGRB);
+  EVALUATE(CGIB);
+  EVALUATE(CIB);
+  EVALUATE(LDEB);
+  EVALUATE(LXDB);
+  EVALUATE(LXEB);
+  EVALUATE(MXDB);
+  EVALUATE(KEB);
+  EVALUATE(CEB);
+  EVALUATE(AEB);
+  EVALUATE(SEB);
+  EVALUATE(MDEB);
+  EVALUATE(DEB);
+  EVALUATE(MAEB);
+  EVALUATE(MSEB);
+  EVALUATE(TCEB);
+  EVALUATE(TCDB);
+  EVALUATE(TCXB);
+  EVALUATE(SQEB);
+  EVALUATE(SQDB);
+  EVALUATE(MEEB);
+  EVALUATE(KDB);
+  EVALUATE(CDB);
+  EVALUATE(ADB);
+  EVALUATE(SDB);
+  EVALUATE(MDB);
+  EVALUATE(DDB);
+  EVALUATE(MADB);
+  EVALUATE(MSDB);
+  EVALUATE(SLDT);
+  EVALUATE(SRDT);
+  EVALUATE(SLXT);
+  EVALUATE(SRXT);
+  EVALUATE(TDCET);
+  EVALUATE(TDGET);
+  EVALUATE(TDCDT);
+  EVALUATE(TDGDT);
+  EVALUATE(TDCXT);
+  EVALUATE(TDGXT);
+  EVALUATE(LEY);
+  EVALUATE(LDY);
+  EVALUATE(STEY);
+  EVALUATE(STDY);
+  EVALUATE(CZDT);
+  EVALUATE(CZXT);
+  EVALUATE(CDZT);
+  EVALUATE(CXZT);
+#undef EVALUATE
 };
 
 // When running with the simulator transition into simulated execution at this