S390: Added remaining generated instructions to S390 simulator EVALUATE code.

src/s390/simulator-s390.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdarg.h>
 #include <stdlib.h>
 #include <cmath>
 
 #if V8_TARGET_ARCH_S390
 
@@ skipping 5947 matching lines @@
   int b1 = AS(SIYInstruction)->B1Value();      \
   intptr_t d1 = AS(SIYInstruction)->D1Value(); \
   uint8_t i2 = AS(SIYInstruction)->I2Value();  \
   int length = 6;
 
 #define DECODE_RRE_INSTRUCTION(r1, r2)    \
   int r1 = AS(RREInstruction)->R1Value(); \
   int r2 = AS(RREInstruction)->R2Value(); \
   int length = 4;
 
+#define DECODE_RRE_INSTRUCTION_M3(r1, r2, m3) \
+  int r1 = AS(RREInstruction)->R1Value();     \
+  int r2 = AS(RREInstruction)->R2Value();     \
+  int m3 = AS(RREInstruction)->M3Value();     \
+  int length = 4;
+
 #define DECODE_RRE_INSTRUCTION_NO_R2(r1)  \
   int r1 = AS(RREInstruction)->R1Value(); \
   int length = 4;
 
 #define DECODE_RRD_INSTRUCTION(r1, r2, r3) \
   int r1 = AS(RRDInstruction)->R1Value();  \
   int r2 = AS(RRDInstruction)->R2Value();  \
   int r3 = AS(RRDInstruction)->R3Value();  \
   int length = 4;
 
@@ skipping 391 matching lines @@
 
 EVALUATE(BKPT) {
   DCHECK_OPCODE(BKPT);
   set_pc(get_pc() + 2);
   S390Debugger dbg(this);
   dbg.Debug();
   int length = 2;
   return length;
 }
 
-EVALUATE(SPM) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SPM) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BALR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BALR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BCTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BCTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(BCR) {
   DCHECK_OPCODE(BCR);
   DECODE_RR_INSTRUCTION(r1, r2);
   if (TestConditionCode(Condition(r1))) {
     intptr_t r2_val = get_register(r2);
 #if (!V8_TARGET_ARCH_S390X && V8_HOST_ARCH_S390)
     // On 31-bit, the top most bit may be 0 or 1, but is ignored by the
     // hardware.  Cleanse the top bit before jumping to it, unless it's one
     // of the special PCs
     if (r2_val != bad_lr && r2_val != end_sim_pc) r2_val &= 0x7FFFFFFF;
 #endif
     set_pc(r2_val);
   }
 
   return length;
 }
 
-EVALUATE(SVC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SVC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BSM) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BSM) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BASSM) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BASSM) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(BASR) {
   DCHECK_OPCODE(BASR);
   DECODE_RR_INSTRUCTION(r1, r2);
   intptr_t link_addr = get_pc() + 2;
   // If R2 is zero, the BASR does not branch.
   int64_t r2_val = (r2 == 0) ? link_addr : get_register(r2);
 #if (!V8_TARGET_ARCH_S390X && V8_HOST_ARCH_S390)
   // On 31-bit, the top most bit may be 0 or 1, which can cause issues
   // for stackwalker.  The top bit should either be cleanse before being
   // pushed onto the stack, or during stack walking when dereferenced.
   // For simulator, we'll take the worst case scenario and always tag
   // the high bit, to flush out more problems.
   link_addr |= 0x80000000;
 #endif
   set_register(r1, link_addr);
   set_pc(r2_val);
   return length;
 }
 
-EVALUATE(MVCL) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MVCL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CLCL) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CLCL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LPR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LPR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LNR) {
   DCHECK_OPCODE(LNR);
   // Load Negative (32)
   DECODE_RR_INSTRUCTION(r1, r2);
   int32_t r2_val = get_low_register<int32_t>(r2);
   r2_val = (r2_val >= 0) ? -r2_val : r2_val;  // If pos, then negate it.
   set_low_register(r1, r2_val);
   condition_reg_ = (r2_val == 0) ? CC_EQ : CC_LT;  // CC0 - result is zero
   // CC1 - result is negative
@@ skipping 153 matching lines @@
 }
 
 EVALUATE(LDR) {
   DCHECK_OPCODE(LDR);
   DECODE_RR_INSTRUCTION(r1, r2);
   int64_t r2_val = get_d_register(r2);
   set_d_register(r1, r2_val);
   return length;
 }
 
-EVALUATE(CDR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CDR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LER) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LER) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(STH) {
   DCHECK_OPCODE(STH);
   DECODE_RX_A_INSTRUCTION(x2, b2, r1, d2_val);
   int16_t r1_val = get_low_register<int32_t>(r1);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t mem_addr = b2_val + x2_val + d2_val;
   WriteH(mem_addr, r1_val, instr);
 
@@ skipping 15 matching lines @@
   // Store Character/Byte
   DECODE_RX_A_INSTRUCTION(x2, b2, r1, d2_val);
   uint8_t r1_val = get_low_register<int32_t>(r1);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t mem_addr = b2_val + x2_val + d2_val;
   WriteB(mem_addr, r1_val);
   return length;
 }
 
-EVALUATE(IC_z) { return DecodeInstructionOriginal(instr); }
+EVALUATE(IC_z) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(EX) {
   DCHECK_OPCODE(EX);
   DECODE_RX_A_INSTRUCTION(x2, b2, r1, d2_val);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int32_t r1_val = get_low_register<int32_t>(r1);
 
   SixByteInstr the_instr = Instruction::InstructionBits(
       reinterpret_cast<const byte*>(b2_val + x2_val + d2_val));
   int inst_length = Instruction::InstructionLength(
       reinterpret_cast<const byte*>(b2_val + x2_val + d2_val));
 
   char new_instr_buf[8];
   char* addr = reinterpret_cast<char*>(&new_instr_buf[0]);
   the_instr |= static_cast<SixByteInstr>(r1_val & 0xff)
                << (8 * inst_length - 16);
   Instruction::SetInstructionBits<SixByteInstr>(
       reinterpret_cast<byte*>(addr), static_cast<SixByteInstr>(the_instr));
   ExecuteInstruction(reinterpret_cast<Instruction*>(addr), false);
   return length;
 }
 
-EVALUATE(BAL) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BAL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BCT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BCT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LH) {
   DCHECK_OPCODE(LH);
   // Load Halfword
   DECODE_RX_A_INSTRUCTION(x2, b2, r1, d2_val);
 
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t mem_addr = x2_val + b2_val + d2_val;
 
   int32_t result = static_cast<int32_t>(ReadH(mem_addr, instr));
   set_low_register(r1, result);
   return length;
 }
 
-EVALUATE(CH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(AH) {
   DCHECK_OPCODE(AH);
   DECODE_RX_A_INSTRUCTION(x2, b2, r1, d2_val);
   int32_t r1_val = get_low_register<int32_t>(r1);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t addr = b2_val + x2_val + d2_val;
   int32_t mem_val = static_cast<int32_t>(ReadH(addr, instr));
   int32_t alu_out = 0;
@@ skipping 32 matching lines @@
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t addr = b2_val + x2_val + d2_val;
   int32_t mem_val = static_cast<int32_t>(ReadH(addr, instr));
   int32_t alu_out = 0;
   alu_out = r1_val * mem_val;
   set_low_register(r1, alu_out);
   return length;
 }
 
-EVALUATE(BAS) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BAS) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CVD) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CVD) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CVB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CVB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LAE) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LAE) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(N) {
   DCHECK_OPCODE(N);
   // 32-bit Reg-Mem instructions
   DECODE_RX_A_INSTRUCTION(x2, b2, r1, d2_val);
   int32_t r1_val = get_low_register<int32_t>(r1);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int32_t mem_val = ReadW(b2_val + x2_val + d2_val, instr);
   int32_t alu_out = 0;
@@ skipping 86 matching lines @@
   int32_t alu_out = 0;
   bool isOF = false;
   isOF = CheckOverflowForIntSub(r1_val, mem_val, int32_t);
   alu_out = r1_val - mem_val;
   SetS390ConditionCode<int32_t>(alu_out, 0);
   SetS390OverflowCode(isOF);
   set_low_register(r1, alu_out);
   return length;
 }
 
-EVALUATE(M) { return DecodeInstructionOriginal(instr); }
+EVALUATE(M) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(D) { return DecodeInstructionOriginal(instr); }
+EVALUATE(D) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(AL) { return DecodeInstructionOriginal(instr); }
+EVALUATE(AL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SL) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(STD) {
   DCHECK_OPCODE(STD);
   DECODE_RX_A_INSTRUCTION(x2, b2, r1, d2_val);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t addr = b2_val + x2_val + d2_val;
   int64_t frs_val = get_d_register(r1);
   WriteDW(addr, frs_val);
   return length;
 }
 
 EVALUATE(LD) {
   DCHECK_OPCODE(LD);
   DECODE_RX_A_INSTRUCTION(x2, b2, r1, d2_val);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t addr = b2_val + x2_val + d2_val;
   int64_t dbl_val = *reinterpret_cast<int64_t*>(addr);
   set_d_register(r1, dbl_val);
   return length;
 }
 
-EVALUATE(CD) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CD) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(STE) {
   DCHECK_OPCODE(STE);
   DECODE_RX_A_INSTRUCTION(x2, b2, r1, d2_val);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t addr = b2_val + x2_val + d2_val;
   int64_t frs_val = get_d_register(r1) >> 32;
   WriteW(addr, static_cast<int32_t>(frs_val), instr);
   return length;
@@ skipping 14 matching lines @@
   DCHECK_OPCODE(LE);
   DECODE_RX_A_INSTRUCTION(x2, b2, r1, d2_val);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t addr = b2_val + x2_val + d2_val;
   float float_val = *reinterpret_cast<float*>(addr);
   set_d_register_from_float32(r1, float_val);
   return length;
 }
 
-EVALUATE(BRXH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BRXH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BRXLE) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BRXLE) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(BXH) {
   DCHECK_OPCODE(BXH);
   DECODE_RS_A_INSTRUCTION(r1, r3, b2, d2);
 
   // r1_val is the first operand, r3_val is the increment
   int32_t r1_val = r1 == 0 ? 0 : get_register(r1);
   int32_t r3_val = r2 == 0 ? 0 : get_register(r3);
   intptr_t b2_val = b2 == 0 ? 0 : get_register(b2);
   intptr_t branch_address = b2_val + d2;
   // increment r1_val
   r1_val += r3_val;
 
   // if the increment is even, then it designates a pair of registers
   // and the contents of the even and odd registers of the pair are used as
   // the increment and compare value respectively. If the increment is odd,
   // the increment itself is used as both the increment and compare value
   int32_t compare_val = r3 % 2 == 0 ? get_register(r3 + 1) : r3_val;
   if (r1_val > compare_val) {
     // branch to address if r1_val is greater than compare value
     set_pc(branch_address);
   }
 
   // update contents of register in r1 with the new incremented value
   set_register(r1, r1_val);
 
   return length;
 }
 
-EVALUATE(BXLE) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BXLE) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(SRL) {
   DCHECK_OPCODE(SRL);
   DECODE_RS_A_INSTRUCTION_NO_R3(r1, b2, d2);
   // only takes rightmost 6bits
   int64_t b2_val = b2 == 0 ? 0 : get_register(b2);
   int shiftBits = (b2_val + d2) & 0x3F;
   uint32_t r1_val = get_low_register<uint32_t>(r1);
   uint32_t alu_out = 0;
   alu_out = r1_val >> shiftBits;
@@ skipping 92 matching lines @@
   int64_t opnd1 = static_cast<int64_t>(get_low_register<int32_t>(r1)) << 32;
   int64_t opnd2 = static_cast<uint64_t>(get_low_register<uint32_t>(r1 + 1));
   int64_t r1_val = opnd1 + opnd2;
   int64_t alu_out = r1_val >> shiftBits;
   set_low_register(r1, alu_out >> 32);
   set_low_register(r1 + 1, alu_out & 0x00000000FFFFFFFF);
   SetS390ConditionCode<int32_t>(alu_out, 0);
   return length;
 }
 
-EVALUATE(SLDA) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SLDA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(STM) {
   DCHECK_OPCODE(STM);
   DECODE_RS_A_INSTRUCTION(r1, r3, rb, d2);
   // Store Multiple 32-bits.
   int offset = d2;
   // Regs roll around if r3 is less than r1.
   // Artifically increase r3 by 16 so we can calculate
   // the number of regs stored properly.
   if (r3 < r1) r3 += 16;
@@ skipping 22 matching lines @@
   if (0 == selected_bits) {
     condition_reg_ = CC_EQ;  // CC0
   } else if (selected_bits == imm_val) {
     condition_reg_ = 0x1;  // CC3
   } else {
     condition_reg_ = 0x4;  // CC1
   }
   return length;
 }
 
-EVALUATE(MVI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MVI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TS) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TS) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(NI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(NI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(CLI) {
   DCHECK_OPCODE(CLI);
   // Compare Immediate (Mem - Imm) (8)
   DECODE_SI_INSTRUCTION_I_UINT8(b1, d1_val, imm_val)
   int64_t b1_val = (b1 == 0) ? 0 : get_register(b1);
   intptr_t addr = b1_val + d1_val;
   uint8_t mem_val = ReadB(addr);
   SetS390ConditionCode<uint8_t>(mem_val, imm_val);
   return length;
 }
 
-EVALUATE(OI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(OI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(XI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(XI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LM) {
   DCHECK_OPCODE(LM);
   DECODE_RS_A_INSTRUCTION(r1, r3, rb, d2);
   // Store Multiple 32-bits.
   int offset = d2;
   // Regs roll around if r3 is less than r1.
   // Artifically increase r3 by 16 so we can calculate
   // the number of regs stored properly.
   if (r3 < r1) r3 += 16;
 
   int32_t rb_val = (rb == 0) ? 0 : get_low_register<int32_t>(rb);
 
   // Store each register in ascending order.
   for (int i = 0; i <= r3 - r1; i++) {
     int32_t value = ReadW(rb_val + offset + 4 * i, instr);
     set_low_register((r1 + i) % 16, value);
   }
   return length;
 }
 
-EVALUATE(MVCLE) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MVCLE) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CLCLE) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CLCLE) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CDS) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CDS) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STCM) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STCM) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(ICM) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ICM) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BPRP) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BPRP) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BPP) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BPP) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TRTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TRTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MVN) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MVN) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(MVC) {
   DCHECK_OPCODE(MVC);
   // Move Character
   SSInstruction* ssInstr = reinterpret_cast<SSInstruction*>(instr);
   int b1 = ssInstr->B1Value();
   intptr_t d1 = ssInstr->D1Value();
   int b2 = ssInstr->B2Value();
   intptr_t d2 = ssInstr->D2Value();
   int length = ssInstr->Length();
   int64_t b1_val = (b1 == 0) ? 0 : get_register(b1);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t src_addr = b2_val + d2;
   intptr_t dst_addr = b1_val + d1;
   // remember that the length is the actual length - 1
   for (int i = 0; i < length + 1; ++i) {
     WriteB(dst_addr++, ReadB(src_addr++));
   }
   length = 6;
   return length;
 }
 
-EVALUATE(MVZ) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(NC) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CLC) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(OC) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(XC) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(MVCP) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(TR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(TRT) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(ED) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(EDMK) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(PKU) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(UNPKU) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(MVCIN) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(PKA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(UNPKA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(PLO) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LMD) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(SRP) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(MVO) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(PACK) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(UNPK) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(ZAP) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(AP) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(SP) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(MP) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(DP) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(UPT) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(PFPO) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(IIHH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(IIHL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(IILH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(IILL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(NIHH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(NIHL) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MVZ) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(NC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CLC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(OC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(XC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(MVCP) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(TR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(TRT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(ED) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(EDMK) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(PKU) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(UNPKU) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(MVCIN) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(PKA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(UNPKA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(PLO) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LMD) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(SRP) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(MVO) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(PACK) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(UNPK) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(ZAP) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(AP) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(SP) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(MP) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(DP) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(UPT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(PFPO) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(IIHH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(IIHL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(IILH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(IILL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(NIHH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(NIHL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(NILH) {
   DCHECK_OPCODE(NILH);
   DECODE_RI_A_INSTRUCTION(instr, r1, i);
   int32_t r1_val = get_low_register<int32_t>(r1);
   // CC is set based on the 16 bits that are AND'd
   SetS390BitWiseConditionCode<uint16_t>((r1_val >> 16) & i);
   i = (i << 16) | 0x0000FFFF;
   set_low_register(r1, r1_val & i);
   return length;
 }
 
 EVALUATE(NILL) {
   DCHECK_OPCODE(NILL);
   DECODE_RI_A_INSTRUCTION(instr, r1, i);
   int32_t r1_val = get_low_register<int32_t>(r1);
   // CC is set based on the 16 bits that are AND'd
   SetS390BitWiseConditionCode<uint16_t>(r1_val & i);
   i |= 0xFFFF0000;
   set_low_register(r1, r1_val & i);
   return length;
 }
 
-EVALUATE(OIHH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(OIHH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(OIHL) { return DecodeInstructionOriginal(instr); }
+EVALUATE(OIHL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(OILH) {
   DCHECK_OPCODE(OILH);
   DECODE_RI_A_INSTRUCTION(instr, r1, i);
   int32_t r1_val = get_low_register<int32_t>(r1);
   // CC is set based on the 16 bits that are AND'd
   SetS390BitWiseConditionCode<uint16_t>((r1_val >> 16) | i);
   i = i << 16;
   set_low_register(r1, r1_val | i);
   return length;
 }
 
 EVALUATE(OILL) {
   DCHECK_OPCODE(OILL);
   DECODE_RI_A_INSTRUCTION(instr, r1, i);
   int32_t r1_val = get_low_register<int32_t>(r1);
   // CC is set based on the 16 bits that are AND'd
   SetS390BitWiseConditionCode<uint16_t>(r1_val | i);
   set_low_register(r1, r1_val | i);
   return length;
 }
 
-EVALUATE(LLIHH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLIHH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LLIHL) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLIHL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LLILH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLILH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LLILL) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLILL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TMLH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TMLH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(TMLL) {
   DCHECK_OPCODE(TMLL);
   DECODE_RI_A_INSTRUCTION(instr, r1, i2);
   int mask = i2 & 0x0000FFFF;
   if (mask == 0) {
     condition_reg_ = 0x0;
     return length;
   }
   uint32_t r1_val = get_low_register<uint32_t>(r1);
@@ skipping 39 matching lines @@
       } else {
         // leftmost bit is zero
         condition_reg_ = 0x4;
       }
       return length;  // Done!
     }
   }
   return length;
 }
 
-EVALUATE(TMHH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TMHH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TMHL) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TMHL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(BRAS) {
   DCHECK_OPCODE(BRAS);
   // Branch Relative and Save
   DECODE_RI_B_INSTRUCTION(instr, r1, d2)
   intptr_t pc = get_pc();
   // Set PC of next instruction to register
   set_register(r1, pc + sizeof(FourByteInstr));
   // Update PC to branch target
   set_pc(pc + d2 * 2);
@@ skipping 88 matching lines @@
 }
 
 EVALUATE(LARL) {
   DCHECK_OPCODE(LARL);
   DECODE_RIL_B_INSTRUCTION(r1, i2);
   intptr_t offset = i2 * 2;
   set_register(r1, get_pc() + offset);
   return length;
 }
 
-EVALUATE(LGFI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LGFI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(BRASL) {
   DCHECK_OPCODE(BRASL);
   // Branch and Save Relative Long
   DECODE_RIL_B_INSTRUCTION(r1, i2);
   intptr_t d2 = i2;
   intptr_t pc = get_pc();
   set_register(r1, pc + 6);  // save next instruction to register
   set_pc(pc + d2 * 2);       // update register
   return length;
@@ skipping 210 matching lines @@
 }
 
 EVALUATE(CLFI) {
   DCHECK_OPCODE(CLFI);
   // Compare Logical with Immediate (32)
   DECODE_RIL_A_INSTRUCTION(r1, imm);
   SetS390ConditionCode<uint32_t>(get_low_register<uint32_t>(r1), imm);
   return length;
 }
 
-EVALUATE(LLHRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LGHRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LHRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LLGHRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(STHRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LGRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(STGRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LGFRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LLGFRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(STRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(EXRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(PFDRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CGHRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CHRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CGRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CGFRL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(ECTG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CSST) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LPD) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LPDG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(BRCTH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(AIH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(ALSIH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(ALSIHN) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CIH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(STCK) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CFC) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(IPM) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(HSCH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(MSCH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(SSCH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(STSCH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(TSCH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(TPI) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(SAL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(RSCH) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(STCRW) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(STCPS) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(RCHP) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(SCHM) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CKSM) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(SAR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(EAR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLHRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LGHRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LHRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LLGHRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(STHRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LGRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(STGRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LGFRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LLGFRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(STRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(EXRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(PFDRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CGHRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CHRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CGRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CGFRL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(ECTG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CSST) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LPD) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LPDG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(BRCTH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(AIH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(ALSIH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(ALSIHN) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CIH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(STCK) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CFC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(IPM) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(HSCH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(MSCH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(SSCH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(STSCH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(TSCH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(TPI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(SAL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(RSCH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(STCRW) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(STCPS) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(RCHP) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(SCHM) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CKSM) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(SAR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(EAR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(MSR) {
   DCHECK_OPCODE(MSR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   int32_t r1_val = get_low_register<int32_t>(r1);
   int32_t r2_val = get_low_register<int32_t>(r2);
   set_low_register(r1, r1_val * r2_val);
   return length;
 }
 
-EVALUATE(MVST) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MVST) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CUSE) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CUSE) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SRST) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SRST) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(XSCH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(XSCH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STCKE) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STCKE) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STCKF) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STCKF) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SRNM) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SRNM) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STFPC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STFPC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LFPC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LFPC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TRE) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TRE) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CUUTF) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CUUTF) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CUTFU) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CUTFU) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STFLE) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STFLE) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SRNMB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SRNMB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SRNMT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SRNMT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LFAS) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LFAS) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(PPA) { return DecodeInstructionOriginal(instr); }
+EVALUATE(PPA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(ETND) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ETND) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TEND) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TEND) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(NIAI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(NIAI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TABORT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TABORT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TRAP4) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TRAP4) {
+  DCHECK_OPCODE(TRAP4);
+  int length = 4;
+  // whack the space of the caller allocated stack
+  int64_t sp_addr = get_register(sp);
+  for (int i = 0; i < kCalleeRegisterSaveAreaSize / kPointerSize; ++i) {
+    // we dont want to whack the RA (r14)
+    if (i != 14) (reinterpret_cast<intptr_t*>(sp_addr))[i] = 0xdeadbabe;
+  }
+  SoftwareInterrupt(instr);
+  return length;
+}
 
 EVALUATE(LPEBR) {
   DCHECK_OPCODE(LPEBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   float fr1_val = get_float32_from_d_register(r1);
   float fr2_val = get_float32_from_d_register(r2);
   fr1_val = std::fabs(fr2_val);
   set_d_register_from_float32(r1, fr1_val);
   if (fr2_val != fr2_val) {  // input is NaN
     condition_reg_ = CC_OF;
   } else if (fr2_val == 0) {
     condition_reg_ = CC_EQ;
   } else {
     condition_reg_ = CC_GT;
   }
 
   return length;
 }
 
-EVALUATE(LNEBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LNEBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LTEBR) {
   DCHECK_OPCODE(LTEBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   int64_t r2_val = get_d_register(r2);
   float fr2_val = get_float32_from_d_register(r2);
   SetS390ConditionCode<float>(fr2_val, 0.0);
   set_d_register(r1, r2_val);
   return length;
 }
 
-EVALUATE(LCEBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LCEBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LDEBR) {
   DCHECK_OPCODE(LDEBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   float fp_val = get_float32_from_d_register(r2);
   double db_val = static_cast<double>(fp_val);
   set_d_register_from_double(r1, db_val);
   return length;
 }
 
-EVALUATE(LXDBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LXDBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LXEBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LXEBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MXDBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MXDBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(KEBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KEBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(CEBR) {
   DCHECK_OPCODE(CEBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   float fr1_val = get_float32_from_d_register(r1);
   float fr2_val = get_float32_from_d_register(r2);
   if (isNaN(fr1_val) || isNaN(fr2_val)) {
     condition_reg_ = CC_OF;
   } else {
     SetS390ConditionCode<float>(fr1_val, fr2_val);
@@ skipping 19 matching lines @@
   DECODE_RRE_INSTRUCTION(r1, r2);
   float fr1_val = get_float32_from_d_register(r1);
   float fr2_val = get_float32_from_d_register(r2);
   fr1_val -= fr2_val;
   set_d_register_from_float32(r1, fr1_val);
   SetS390ConditionCode<float>(fr1_val, 0);
 
   return length;
 }
 
-EVALUATE(MDEBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MDEBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(DEBR) {
   DCHECK_OPCODE(DEBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   float fr1_val = get_float32_from_d_register(r1);
   float fr2_val = get_float32_from_d_register(r2);
   fr1_val /= fr2_val;
   set_d_register_from_float32(r1, fr1_val);
   SetS390ConditionCode<float>(fr1_val, 0);
 
   return length;
 }
 
-EVALUATE(MAEBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MAEBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MSEBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MSEBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LPDBR) {
   DCHECK_OPCODE(LPDBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   double r1_val = get_double_from_d_register(r1);
   double r2_val = get_double_from_d_register(r2);
   r1_val = std::fabs(r2_val);
   set_d_register_from_double(r1, r1_val);
   if (r2_val != r2_val) {  // input is NaN
     condition_reg_ = CC_OF;
   } else if (r2_val == 0) {
     condition_reg_ = CC_EQ;
   } else {
     condition_reg_ = CC_GT;
   }
   return length;
 }
 
-EVALUATE(LNDBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LNDBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LTDBR) {
   DCHECK_OPCODE(LTDBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   int64_t r2_val = get_d_register(r2);
   SetS390ConditionCode<double>(bit_cast<double, int64_t>(r2_val), 0.0);
   set_d_register(r1, r2_val);
   return length;
 }
 
@@ skipping 29 matching lines @@
 EVALUATE(SQDBR) {
   DCHECK_OPCODE(SQDBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   double r1_val = get_double_from_d_register(r1);
   double r2_val = get_double_from_d_register(r2);
   r1_val = std::sqrt(r2_val);
   set_d_register_from_double(r1, r1_val);
   return length;
 }
 
-EVALUATE(SQXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SQXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(MEEBR) {
   DCHECK_OPCODE(MEEBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   float fr1_val = get_float32_from_d_register(r1);
   float fr2_val = get_float32_from_d_register(r2);
   fr1_val *= fr2_val;
   set_d_register_from_float32(r1, fr1_val);
   SetS390ConditionCode<float>(fr1_val, 0);
   return length;
 }
 
-EVALUATE(KDBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KDBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(CDBR) {
   DCHECK_OPCODE(CDBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   double r1_val = get_double_from_d_register(r1);
   double r2_val = get_double_from_d_register(r2);
   if (isNaN(r1_val) || isNaN(r2_val)) {
     condition_reg_ = CC_OF;
   } else {
     SetS390ConditionCode<double>(r1_val, r2_val);
@@ skipping 50 matching lines @@
   DECODE_RRD_INSTRUCTION(r1, r2, r3);
   double r1_val = get_double_from_d_register(r1);
   double r2_val = get_double_from_d_register(r2);
   double r3_val = get_double_from_d_register(r3);
   r1_val += r2_val * r3_val;
   set_d_register_from_double(r1, r1_val);
   SetS390ConditionCode<double>(r1_val, 0);
   return length;
 }
 
-EVALUATE(MSDBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MSDBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LPXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LPXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LNXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LNXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LTXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LTXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LCXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LCXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LEDBRA) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LEDBRA) {
+  DCHECK_OPCODE(LEDBRA);
+  DECODE_RRE_INSTRUCTION(r1, r2);
+  double r2_val = get_double_from_d_register(r2);
+  set_d_register_from_float32(r1, static_cast<float>(r2_val));
+  return length;
+}
 
-EVALUATE(LDXBRA) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LDXBRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LEXBRA) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LEXBRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(FIXBRA) { return DecodeInstructionOriginal(instr); }
+EVALUATE(FIXBRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(KXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(AXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(AXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(DXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(DXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TBEDR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TBEDR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TBDR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TBDR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(DIEBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(DIEBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(FIEBRA) {
   DCHECK_OPCODE(FIEBRA);
   DECODE_RRF_E_INSTRUCTION(r1, r2, m3, m4);
   float r2_val = get_float32_from_d_register(r2);
   CHECK(m4 == 0);
   switch (m3) {
     case Assembler::FIDBRA_ROUND_TO_NEAREST_AWAY_FROM_0:
       set_d_register_from_float32(r1, round(r2_val));
       break;
     case Assembler::FIDBRA_ROUND_TOWARD_0:
       set_d_register_from_float32(r1, trunc(r2_val));
       break;
     case Assembler::FIDBRA_ROUND_TOWARD_POS_INF:
       set_d_register_from_float32(r1, std::ceil(r2_val));
       break;
     case Assembler::FIDBRA_ROUND_TOWARD_NEG_INF:
       set_d_register_from_float32(r1, std::floor(r2_val));
       break;
     default:
       UNIMPLEMENTED();
       break;
   }
   return length;
 }
 
-EVALUATE(THDER) { return DecodeInstructionOriginal(instr); }
+EVALUATE(THDER) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(THDR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(THDR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(DIDBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(DIDBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(FIDBRA) {
   DCHECK_OPCODE(FIDBRA);
   DECODE_RRF_E_INSTRUCTION(r1, r2, m3, m4);
   double r2_val = get_double_from_d_register(r2);
   CHECK(m4 == 0);
   switch (m3) {
     case Assembler::FIDBRA_ROUND_TO_NEAREST_AWAY_FROM_0:
       set_d_register_from_double(r1, round(r2_val));
       break;
     case Assembler::FIDBRA_ROUND_TOWARD_0:
       set_d_register_from_double(r1, trunc(r2_val));
       break;
     case Assembler::FIDBRA_ROUND_TOWARD_POS_INF:
       set_d_register_from_double(r1, std::ceil(r2_val));
       break;
     case Assembler::FIDBRA_ROUND_TOWARD_NEG_INF:
       set_d_register_from_double(r1, std::floor(r2_val));
       break;
     default:
       UNIMPLEMENTED();
       break;
   }
   return length;
 }
 
-EVALUATE(LXR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LXR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LPDFR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LPDFR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LNDFR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LNDFR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LCDFR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LCDFR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LZER) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LZER) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LZDR) {
   DCHECK_OPCODE(LZDR);
   DECODE_RRE_INSTRUCTION_NO_R2(r1);
   set_d_register_from_double(r1, 0.0);
   return length;
 }
 
-EVALUATE(LZXR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LZXR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SFPC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SFPC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SFASR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SFASR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(EFPC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(EFPC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(CELFBR) {
   DCHECK_OPCODE(CELFBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   uint32_t r2_val = get_low_register<uint32_t>(r2);
   float r1_val = static_cast<float>(r2_val);
   set_d_register_from_float32(r1, r1_val);
   return length;
 }
 
 EVALUATE(CDLFBR) {
   DCHECK_OPCODE(CDLFBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   uint32_t r2_val = get_low_register<uint32_t>(r2);
   double r1_val = static_cast<double>(r2_val);
   set_d_register_from_double(r1, r1_val);
   return length;
 }
 
-EVALUATE(CXLFBR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CEFBRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CDFBRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CXFBRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CFEBRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CFDBRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CFXBRA) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CXLFBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CEFBRA) {
+  DCHECK_OPCODE(CEFBRA);
+  DECODE_RRE_INSTRUCTION(r1, r2);
+  int32_t fr2_val = get_low_register<int32_t>(r2);
+  float fr1_val = static_cast<float>(fr2_val);
+  set_d_register_from_float32(r1, fr1_val);
+  return length;
+}
+
+EVALUATE(CDFBRA) {
+  DCHECK_OPCODE(CDFBRA);
+  DECODE_RRE_INSTRUCTION(r1, r2);
+  int32_t r2_val = get_low_register<int32_t>(r2);
+  double r1_val = static_cast<double>(r2_val);
+  set_d_register_from_double(r1, r1_val);
+  return length;
+}
+
+EVALUATE(CXFBRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CFEBRA) {
+  DCHECK_OPCODE(CFEBRA);
+  DECODE_RRE_INSTRUCTION_M3(r1, r2, mask_val);
+  float r2_fval = get_float32_from_d_register(r2);
+  int32_t r1_val = 0;
+
+  SetS390RoundConditionCode(r2_fval, INT32_MAX, INT32_MIN);
+
+  switch (mask_val) {
+    case CURRENT_ROUNDING_MODE:
+    case ROUND_TO_PREPARE_FOR_SHORTER_PRECISION: {
+      r1_val = static_cast<int32_t>(r2_fval);
+      break;
+    }
+    case ROUND_TO_NEAREST_WITH_TIES_AWAY_FROM_0: {
+      float ceil_val = std::ceil(r2_fval);
+      float floor_val = std::floor(r2_fval);
+      float sub_val1 = std::fabs(r2_fval - floor_val);
+      float sub_val2 = std::fabs(r2_fval - ceil_val);
+      if (sub_val1 > sub_val2) {
+        r1_val = static_cast<int32_t>(ceil_val);
+      } else if (sub_val1 < sub_val2) {
+        r1_val = static_cast<int32_t>(floor_val);
+      } else {  // round away from zero:
+        if (r2_fval > 0.0) {
+          r1_val = static_cast<int32_t>(ceil_val);
+        } else {
+          r1_val = static_cast<int32_t>(floor_val);
+        }
+      }
+      break;
+    }
+    case ROUND_TO_NEAREST_WITH_TIES_TO_EVEN: {
+      float ceil_val = std::ceil(r2_fval);
+      float floor_val = std::floor(r2_fval);
+      float sub_val1 = std::fabs(r2_fval - floor_val);
+      float sub_val2 = std::fabs(r2_fval - ceil_val);
+      if (sub_val1 > sub_val2) {
+        r1_val = static_cast<int32_t>(ceil_val);
+      } else if (sub_val1 < sub_val2) {
+        r1_val = static_cast<int32_t>(floor_val);
+      } else {  // check which one is even:
+        int32_t c_v = static_cast<int32_t>(ceil_val);
+        int32_t f_v = static_cast<int32_t>(floor_val);
+        if (f_v % 2 == 0)
+          r1_val = f_v;
+        else
+          r1_val = c_v;
+      }
+      break;
+    }
+    case ROUND_TOWARD_0: {
+      // check for overflow, cast r2_fval to 64bit integer
+      // then check value within the range of INT_MIN and INT_MAX
+      // and set condition code accordingly
+      int64_t temp = static_cast<int64_t>(r2_fval);
+      if (temp < INT_MIN || temp > INT_MAX) {
+        condition_reg_ = CC_OF;
+      }
+      r1_val = static_cast<int32_t>(r2_fval);
+      break;
+    }
+    case ROUND_TOWARD_PLUS_INFINITE: {
+      r1_val = static_cast<int32_t>(std::ceil(r2_fval));
+      break;
+    }
+    case ROUND_TOWARD_MINUS_INFINITE: {
+      // check for overflow, cast r2_fval to 64bit integer
+      // then check value within the range of INT_MIN and INT_MAX
+      // and set condition code accordingly
+      int64_t temp = static_cast<int64_t>(std::floor(r2_fval));
+      if (temp < INT_MIN || temp > INT_MAX) {
+        condition_reg_ = CC_OF;
+      }
+      r1_val = static_cast<int32_t>(std::floor(r2_fval));
+      break;
+    }
+    default:
+      UNREACHABLE();
+  }
+  set_low_register(r1, r1_val);
+  return length;
+}
+
+EVALUATE(CFDBRA) {
+  DCHECK_OPCODE(CFDBRA);
+  DECODE_RRE_INSTRUCTION_M3(r1, r2, mask_val);
+  double r2_val = get_double_from_d_register(r2);
+  int32_t r1_val = 0;
+
+  SetS390RoundConditionCode(r2_val, INT32_MAX, INT32_MIN);
+
+  switch (mask_val) {
+    case CURRENT_ROUNDING_MODE:
+    case ROUND_TO_PREPARE_FOR_SHORTER_PRECISION: {
+      r1_val = static_cast<int32_t>(r2_val);
+      break;
+    }
+    case ROUND_TO_NEAREST_WITH_TIES_AWAY_FROM_0: {
+      double ceil_val = std::ceil(r2_val);
+      double floor_val = std::floor(r2_val);
+      double sub_val1 = std::fabs(r2_val - floor_val);
+      double sub_val2 = std::fabs(r2_val - ceil_val);
+      if (sub_val1 > sub_val2) {
+        r1_val = static_cast<int32_t>(ceil_val);
+      } else if (sub_val1 < sub_val2) {
+        r1_val = static_cast<int32_t>(floor_val);
+      } else {  // round away from zero:
+        if (r2_val > 0.0) {
+          r1_val = static_cast<int32_t>(ceil_val);
+        } else {
+          r1_val = static_cast<int32_t>(floor_val);
+        }
+      }
+      break;
+    }
+    case ROUND_TO_NEAREST_WITH_TIES_TO_EVEN: {
+      double ceil_val = std::ceil(r2_val);
+      double floor_val = std::floor(r2_val);
+      double sub_val1 = std::fabs(r2_val - floor_val);
+      double sub_val2 = std::fabs(r2_val - ceil_val);
+      if (sub_val1 > sub_val2) {
+        r1_val = static_cast<int32_t>(ceil_val);
+      } else if (sub_val1 < sub_val2) {
+        r1_val = static_cast<int32_t>(floor_val);
+      } else {  // check which one is even:
+        int32_t c_v = static_cast<int32_t>(ceil_val);
+        int32_t f_v = static_cast<int32_t>(floor_val);
+        if (f_v % 2 == 0)
+          r1_val = f_v;
+        else
+          r1_val = c_v;
+      }
+      break;
+    }
+    case ROUND_TOWARD_0: {
+      // check for overflow, cast r2_val to 64bit integer
+      // then check value within the range of INT_MIN and INT_MAX
+      // and set condition code accordingly
+      int64_t temp = static_cast<int64_t>(r2_val);
+      if (temp < INT_MIN || temp > INT_MAX) {
+        condition_reg_ = CC_OF;
+      }
+      r1_val = static_cast<int32_t>(r2_val);
+      break;
+    }
+    case ROUND_TOWARD_PLUS_INFINITE: {
+      r1_val = static_cast<int32_t>(std::ceil(r2_val));
+      break;
+    }
+    case ROUND_TOWARD_MINUS_INFINITE: {
+      // check for overflow, cast r2_val to 64bit integer
+      // then check value within the range of INT_MIN and INT_MAX
+      // and set condition code accordingly
+      int64_t temp = static_cast<int64_t>(std::floor(r2_val));
+      if (temp < INT_MIN || temp > INT_MAX) {
+        condition_reg_ = CC_OF;
+      }
+      r1_val = static_cast<int32_t>(std::floor(r2_val));
+      break;
+    }
+    default:
+      UNREACHABLE();
+  }
+  set_low_register(r1, r1_val);
+  return length;
+}
+
+EVALUATE(CFXBRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(CLFEBR) {
   DCHECK_OPCODE(CLFEBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   float r2_val = get_float32_from_d_register(r2);
   uint32_t r1_val = static_cast<uint32_t>(r2_val);
   set_low_register(r1, r1_val);
   SetS390ConvertConditionCode<double>(r2_val, r1_val, UINT32_MAX);
   return length;
 }
 
 EVALUATE(CLFDBR) {
   DCHECK_OPCODE(CLFDBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   double r2_val = get_double_from_d_register(r2);
   uint32_t r1_val = static_cast<uint32_t>(r2_val);
   set_low_register(r1, r1_val);
   SetS390ConvertConditionCode<double>(r2_val, r1_val, UINT32_MAX);
   return length;
 }
 
-EVALUATE(CLFXBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CLFXBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(CELGBR) {
   DCHECK_OPCODE(CELGBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   uint64_t r2_val = get_register(r2);
   float r1_val = static_cast<float>(r2_val);
   set_d_register_from_float32(r1, r1_val);
   return length;
 }
 
 EVALUATE(CDLGBR) {
   DCHECK_OPCODE(CDLGBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   uint64_t r2_val = get_register(r2);
   double r1_val = static_cast<double>(r2_val);
   set_d_register_from_double(r1, r1_val);
   return length;
 }
 
-EVALUATE(CXLGBR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CXLGBR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CEGBRA) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CEGBRA) {
+  DCHECK_OPCODE(CEGBRA);
+  DECODE_RRE_INSTRUCTION(r1, r2);
+  int64_t fr2_val = get_register(r2);
+  float fr1_val = static_cast<float>(fr2_val);
+  set_d_register_from_float32(r1, fr1_val);
+  return length;
+}
 
-EVALUATE(CDGBRA) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CDGBRA) {
+  DCHECK_OPCODE(CDGBRA);
+  DECODE_RRE_INSTRUCTION(r1, r2);
+  int64_t r2_val = get_register(r2);
+  double r1_val = static_cast<double>(r2_val);
+  set_d_register_from_double(r1, r1_val);
+  return length;
+}
 
-EVALUATE(CXGBRA) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CXGBRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CGEBRA) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CGEBRA) {
+  DCHECK_OPCODE(CGEBRA);
+  DECODE_RRE_INSTRUCTION_M3(r1, r2, mask_val);
+  float r2_fval = get_float32_from_d_register(r2);
+  int64_t r1_val = 0;
 
-EVALUATE(CGDBRA) { return DecodeInstructionOriginal(instr); }
+  SetS390RoundConditionCode(r2_fval, INT64_MAX, INT64_MIN);
 
-EVALUATE(CGXBRA) { return DecodeInstructionOriginal(instr); }
+  switch (mask_val) {
+    case CURRENT_ROUNDING_MODE:
+    case ROUND_TO_NEAREST_WITH_TIES_AWAY_FROM_0:
+    case ROUND_TO_PREPARE_FOR_SHORTER_PRECISION: {
+      UNIMPLEMENTED();
+      break;
+    }
+    case ROUND_TO_NEAREST_WITH_TIES_TO_EVEN: {
+      float ceil_val = std::ceil(r2_fval);
+      float floor_val = std::floor(r2_fval);
+      if (std::abs(r2_fval - floor_val) > std::abs(r2_fval - ceil_val)) {
+        r1_val = static_cast<int64_t>(ceil_val);
+      } else if (std::abs(r2_fval - floor_val) < std::abs(r2_fval - ceil_val)) {
+        r1_val = static_cast<int64_t>(floor_val);
+      } else {  // check which one is even:
+        int64_t c_v = static_cast<int64_t>(ceil_val);
+        int64_t f_v = static_cast<int64_t>(floor_val);
+        if (f_v % 2 == 0)
+          r1_val = f_v;
+        else
+          r1_val = c_v;
+      }
+      break;
+    }
+    case ROUND_TOWARD_0: {
+      r1_val = static_cast<int64_t>(r2_fval);
+      break;
+    }
+    case ROUND_TOWARD_PLUS_INFINITE: {
+      r1_val = static_cast<int64_t>(std::ceil(r2_fval));
+      break;
+    }
+    case ROUND_TOWARD_MINUS_INFINITE: {
+      r1_val = static_cast<int64_t>(std::floor(r2_fval));
+      break;
+    }
+    default:
+      UNREACHABLE();
+  }
+  set_register(r1, r1_val);
+  return length;
+}
+
+EVALUATE(CGDBRA) {
+  DCHECK_OPCODE(CGDBRA);
+  DECODE_RRE_INSTRUCTION_M3(r1, r2, mask_val);
+  double r2_val = get_double_from_d_register(r2);
+  int64_t r1_val = 0;
+
+  SetS390RoundConditionCode(r2_val, INT64_MAX, INT64_MIN);
+
+  switch (mask_val) {
+    case CURRENT_ROUNDING_MODE:
+    case ROUND_TO_NEAREST_WITH_TIES_AWAY_FROM_0:
+    case ROUND_TO_PREPARE_FOR_SHORTER_PRECISION: {
+      UNIMPLEMENTED();
+      break;
+    }
+    case ROUND_TO_NEAREST_WITH_TIES_TO_EVEN: {
+      double ceil_val = std::ceil(r2_val);
+      double floor_val = std::floor(r2_val);
+      if (std::abs(r2_val - floor_val) > std::abs(r2_val - ceil_val)) {
+        r1_val = static_cast<int64_t>(ceil_val);
+      } else if (std::abs(r2_val - floor_val) < std::abs(r2_val - ceil_val)) {
+        r1_val = static_cast<int64_t>(floor_val);
+      } else {  // check which one is even:
+        int64_t c_v = static_cast<int64_t>(ceil_val);
+        int64_t f_v = static_cast<int64_t>(floor_val);
+        if (f_v % 2 == 0)
+          r1_val = f_v;
+        else
+          r1_val = c_v;
+      }
+      break;
+    }
+    case ROUND_TOWARD_0: {
+      r1_val = static_cast<int64_t>(r2_val);
+      break;
+    }
+    case ROUND_TOWARD_PLUS_INFINITE: {
+      r1_val = static_cast<int64_t>(std::ceil(r2_val));
+      break;
+    }
+    case ROUND_TOWARD_MINUS_INFINITE: {
+      r1_val = static_cast<int64_t>(std::floor(r2_val));
+      break;
+    }
+    default:
+      UNREACHABLE();
+  }
+  set_register(r1, r1_val);
+  return length;
+}
+
+EVALUATE(CGXBRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(CLGEBR) {
   DCHECK_OPCODE(CLGEBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   float r2_val = get_float32_from_d_register(r2);
   uint64_t r1_val = static_cast<uint64_t>(r2_val);
   set_register(r1, r1_val);
   SetS390ConvertConditionCode<double>(r2_val, r1_val, UINT64_MAX);
   return length;
 }
 
 EVALUATE(CLGDBR) {
   DCHECK_OPCODE(CLGDBR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   double r2_val = get_double_from_d_register(r2);
   uint64_t r1_val = static_cast<uint64_t>(r2_val);
   set_register(r1, r1_val);
   SetS390ConvertConditionCode<double>(r2_val, r1_val, UINT64_MAX);
   return length;
 }
 
-EVALUATE(CFER) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CFER) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CFDR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CFDR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CFXR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CFXR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LDGR) {
   DCHECK_OPCODE(LDGR);
   // Load FPR from GPR (L <- 64)
   DECODE_RRE_INSTRUCTION(r1, r2);
   uint64_t int_val = get_register(r2);
   // double double_val = bit_cast<double, uint64_t>(int_val);
   // set_d_register_from_double(rreInst->R1Value(), double_val);
   set_d_register(r1, int_val);
   return length;
 }
 
-EVALUATE(CGER) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CGER) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CGDR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CGDR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CGXR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CGXR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LGDR) {
   DCHECK_OPCODE(LGDR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   // Load GPR from FPR (64 <- L)
   int64_t double_val = get_d_register(r2);
   set_register(r1, double_val);
   return length;
 }
 
-EVALUATE(MDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(MDTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(DDTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(ADTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(SDTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LDETR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LEDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LTDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(FIDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(MXTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(DXTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(AXTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(SXTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LXDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LDXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LTXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(FIXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(KDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CGDTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CUDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(EEDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(ESDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(KXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CGXTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CUXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CSXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(EEXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(ESXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CDGTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CDUTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CDSTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CEDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(QADTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(IEDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(RRDTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CXGTRA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CXUTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CXSTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CEXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(QAXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(IEXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(RRXTR) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LPGR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(MDTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(DDTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(ADTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(SDTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LDETR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LEDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LTDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(FIDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(MXTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(DXTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(AXTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(SXTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LXDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LDXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LTXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(FIXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(KDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CGDTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CUDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(EEDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(ESDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(KXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CGXTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CUXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CSXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(EEXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(ESXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CDGTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CDUTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CDSTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CEDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(QADTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(IEDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(RRDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CXGTRA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CXUTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CXSTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CEXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(QAXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(IEXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(RRXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LPGR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LNGR) {
   DCHECK_OPCODE(LNGR);
   // Load Negative (64)
   DECODE_RRE_INSTRUCTION(r1, r2);
   int64_t r2_val = get_register(r2);
   r2_val = (r2_val >= 0) ? -r2_val : r2_val;  // If pos, then negate it.
   set_register(r1, r2_val);
   condition_reg_ = (r2_val == 0) ? CC_EQ : CC_LT;  // CC0 - result is zero
   // CC1 - result is negative
@@ skipping 32 matching lines @@
   int64_t r2_val = get_register(r2);
   bool isOF = false;
   isOF = CheckOverflowForIntSub(r1_val, r2_val, int64_t);
   r1_val -= r2_val;
   SetS390ConditionCode<int64_t>(r1_val, 0);
   SetS390OverflowCode(isOF);
   set_register(r1, r1_val);
   return length;
 }
 
-EVALUATE(ALGR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ALGR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SLGR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SLGR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(MSGR) {
   DCHECK_OPCODE(MSGR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   int64_t r1_val = get_register(r1);
   int64_t r2_val = get_register(r2);
   set_register(r1, r1_val * r2_val);
   return length;
 }
 
 EVALUATE(DSGR) {
   DCHECK_OPCODE(DSGR);
   DECODE_RRE_INSTRUCTION(r1, r2);
 
   DCHECK(r1 % 2 == 0);
 
   int64_t dividend = get_register(r1 + 1);
   int64_t divisor = get_register(r2);
   set_register(r1, dividend % divisor);
   set_register(r1 + 1, dividend / divisor);
   return length;
 }
 
-EVALUATE(LRVGR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LRVGR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LPGFR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LPGFR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LNGFR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LNGFR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LTGFR) {
   DCHECK_OPCODE(LTGFR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   // Load and Test Register (64 <- 32)  (Sign Extends 32-bit val)
   // Load Register (64 <- 32)  (Sign Extends 32-bit val)
   int32_t r2_val = get_low_register<int32_t>(r2);
   int64_t result = static_cast<int64_t>(r2_val);
   set_register(r1, result);
   SetS390ConditionCode<int64_t>(result, 0);
   return length;
 }
 
 EVALUATE(LCGFR) {
   DCHECK_OPCODE(LCGFR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   // Load and Test Register (64 <- 32)  (Sign Extends 32-bit val)
   // Load Register (64 <- 32)  (Sign Extends 32-bit val)
   int32_t r2_val = get_low_register<int32_t>(r2);
   int64_t result = static_cast<int64_t>(r2_val);
   set_register(r1, result);
   return length;
 }
 
-EVALUATE(LLGFR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLGFR) {
+  DCHECK_OPCODE(LLGFR);
+  DECODE_RRE_INSTRUCTION(r1, r2);
+  int32_t r2_val = get_low_register<int32_t>(r2);
+  uint64_t r2_finalval = (static_cast<uint64_t>(r2_val) & 0x00000000ffffffff);
+  set_register(r1, r2_finalval);
+  return length;
+}
 
-EVALUATE(LLGTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLGTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(AGFR) {
   DCHECK_OPCODE(AGFR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   // Add Register (64 <- 32)  (Sign Extends 32-bit val)
   int64_t r1_val = get_register(r1);
   int64_t r2_val = static_cast<int64_t>(get_low_register<int32_t>(r2));
   bool isOF = CheckOverflowForIntAdd(r1_val, r2_val, int64_t);
   r1_val += r2_val;
   SetS390ConditionCode<int64_t>(r1_val, 0);
@@ skipping 10 matching lines @@
   int64_t r2_val = static_cast<int64_t>(get_low_register<int32_t>(r2));
   bool isOF = false;
   isOF = CheckOverflowForIntSub(r1_val, r2_val, int64_t);
   r1_val -= r2_val;
   SetS390ConditionCode<int64_t>(r1_val, 0);
   SetS390OverflowCode(isOF);
   set_register(r1, r1_val);
   return length;
 }
 
-EVALUATE(ALGFR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ALGFR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SLGFR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SLGFR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MSGFR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MSGFR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(DSGFR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(DSGFR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(KMAC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KMAC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LRVR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LRVR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(CGR) {
   DCHECK_OPCODE(CGR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   // Compare (64)
   int64_t r1_val = get_register(r1);
   int64_t r2_val = get_register(r2);
   SetS390ConditionCode<int64_t>(r1_val, r2_val);
   return length;
 }
 
 EVALUATE(CLGR) {
   DCHECK_OPCODE(CLGR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   // Compare Logical (64)
   uint64_t r1_val = static_cast<uint64_t>(get_register(r1));
   uint64_t r2_val = static_cast<uint64_t>(get_register(r2));
   SetS390ConditionCode<uint64_t>(r1_val, r2_val);
   return length;
 }
 
-EVALUATE(KMF) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KMF) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(KMO) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KMO) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(PCC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(PCC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(KMCTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KMCTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(KM) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KM) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(KMC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KMC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CGFR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CGFR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(KIMD) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KIMD) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(KLMD) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KLMD) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CFDTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CFDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CLGDTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CLGDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CLFDTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CLFDTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BCTGR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BCTGR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CFXTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CFXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CLFXTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CLFXTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CDFTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CDFTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CDLGTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CDLGTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CDLFTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CDLFTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CXFTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CXFTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CXLGTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CXLGTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CXLFTR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CXLFTR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CGRT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CGRT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(NGR) {
   DCHECK_OPCODE(NGR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   int64_t r1_val = get_register(r1);
   int64_t r2_val = get_register(r2);
   r1_val &= r2_val;
   SetS390BitWiseConditionCode<uint64_t>(r1_val);
   set_register(r1, r1_val);
   return length;
@@ skipping 36 matching lines @@
   }
 
   r2_val = get_register(r2);
 
   int64_t mask = ~(1 << (63 - i));
   set_register(r1, i);
   set_register(r1 + 1, r2_val & mask);
   return length;
 }
 
-EVALUATE(LLGCR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLGCR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LLGHR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLGHR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MLGR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MLGR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(DLGR) {
   DCHECK_OPCODE(DLGR);
 #ifdef V8_TARGET_ARCH_S390X
   DECODE_RRE_INSTRUCTION(r1, r2);
   uint64_t r1_val = get_register(r1);
   uint64_t r2_val = get_register(r2);
   DCHECK(r1 % 2 == 0);
   unsigned __int128 dividend = static_cast<unsigned __int128>(r1_val) << 64;
   dividend += get_register(r1 + 1);
   uint64_t remainder = dividend % r2_val;
   uint64_t quotient = dividend / r2_val;
   r1_val = remainder;
   set_register(r1, remainder);
   set_register(r1 + 1, quotient);
   return length;
 #else
   UNREACHABLE();
 #endif
 }
 
-EVALUATE(ALCGR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ALCGR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SLBGR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SLBGR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(EPSW) { return DecodeInstructionOriginal(instr); }
+EVALUATE(EPSW) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TRTT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TRTT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TRTO) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TRTO) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TROT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TROT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TROO) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TROO) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LLCR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLCR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LLHR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLHR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(MLR) {
   DCHECK_OPCODE(MLR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   DCHECK(r1 % 2 == 0);
 
   uint32_t r1_val = get_low_register<uint32_t>(r1 + 1);
   uint32_t r2_val = get_low_register<uint32_t>(r2);
   uint64_t product =
       static_cast<uint64_t>(r1_val) * static_cast<uint64_t>(r2_val);
@@ skipping 55 matching lines @@
     alu_out = alu_out - 1;
     isOF = isOF_original || CheckOverflowForUIntSub(alu_out, 1);
   } else {
     isOF = isOF_original;
   }
   set_low_register(r1, alu_out);
   SetS390ConditionCodeCarry<uint32_t>(alu_out, isOF);
   return length;
 }
 
-EVALUATE(CU14) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CU14) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CU24) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CU24) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CU41) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CU41) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CU42) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CU42) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TRTRE) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TRTRE) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SRSTU) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SRSTU) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TRTE) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TRTE) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(AHHHR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(AHHHR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SHHHR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SHHHR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(ALHHHR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ALHHHR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SLHHHR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SLHHHR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CHHR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CHHR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(AHHLR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(AHHLR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SHHLR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SHHLR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(ALHHLR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ALHHLR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SLHHLR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SLHHLR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CHLR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CHLR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(POPCNT_Z) { return DecodeInstructionOriginal(instr); }
+EVALUATE(POPCNT_Z) {
+  DCHECK_OPCODE(POPCNT_Z);
+  DECODE_RRE_INSTRUCTION(r1, r2);
+  int64_t r2_val = get_register(r2);
+  int64_t r1_val = 0;
 
-EVALUATE(LOCGR) { return DecodeInstructionOriginal(instr); }
+  uint8_t* r2_val_ptr = reinterpret_cast<uint8_t*>(&r2_val);
+  uint8_t* r1_val_ptr = reinterpret_cast<uint8_t*>(&r1_val);
+  for (int i = 0; i < 8; i++) {
+    uint32_t x = static_cast<uint32_t>(r2_val_ptr[i]);
+#if defined(__GNUC__)
+    r1_val_ptr[i] = __builtin_popcount(x);
+#else
+#error unsupport __builtin_popcount
+#endif
+  }
+  set_register(r1, static_cast<uint64_t>(r1_val));
+  return length;
+}
+
+EVALUATE(LOCGR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(NGRK) {
   DCHECK_OPCODE(NGRK);
   DECODE_RRF_A_INSTRUCTION(r1, r2, r3);
   // 64-bit Non-clobbering arithmetics / bitwise ops.
   int64_t r2_val = get_register(r2);
   int64_t r3_val = get_register(r3);
   uint64_t bitwise_result = 0;
   bitwise_result = r2_val & r3_val;
   SetS390BitWiseConditionCode<uint64_t>(bitwise_result);
@@ skipping 72 matching lines @@
   // 64-bit Non-clobbering unsigned arithmetics
   uint64_t r2_val = get_register(r2);
   uint64_t r3_val = get_register(r3);
   bool isOF = CheckOverflowForUIntSub(r2_val, r3_val);
   SetS390ConditionCode<uint64_t>(r2_val - r3_val, 0);
   SetS390OverflowCode(isOF);
   set_register(r1, r2_val - r3_val);
   return length;
 }
 
-EVALUATE(LOCR) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LOCR) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(NRK) {
   DCHECK_OPCODE(NRK);
   DECODE_RRF_A_INSTRUCTION(r1, r2, r3);
   // 32-bit Non-clobbering arithmetics / bitwise ops
   int32_t r2_val = get_low_register<int32_t>(r2);
   int32_t r3_val = get_low_register<int32_t>(r3);
   // Assume bitwise operation here
   uint32_t bitwise_result = 0;
   bitwise_result = r2_val & r3_val;
@@ skipping 87 matching lines @@
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t addr = x2_val + b2_val + d2;
   int64_t value = ReadDW(addr);
   set_register(r1, value);
   SetS390ConditionCode<int64_t>(value, 0);
   return length;
 }
 
-EVALUATE(CVBY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CVBY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(AG) {
   DCHECK_OPCODE(AG);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t alu_out = get_register(r1);
   int64_t mem_val = ReadDW(b2_val + x2_val + d2);
   alu_out += mem_val;
   SetS390ConditionCode<int32_t>(alu_out, 0);
@@ skipping 55 matching lines @@
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t d2_val = d2;
   int64_t mem_val = ReadDW(b2_val + d2_val + x2_val);
   int64_t r1_val = get_register(r1);
   set_register(r1, mem_val * r1_val);
   return length;
 }
 
-EVALUATE(DSG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(DSG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CVBG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CVBG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LRVG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LRVG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LT) {
   DCHECK_OPCODE(LT);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t addr = x2_val + b2_val + d2;
   int32_t value = ReadW(addr, instr);
   set_low_register(r1, value);
   SetS390ConditionCode<int32_t>(value, 0);
@@ skipping 17 matching lines @@
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   // Miscellaneous Loads and Stores
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t addr = x2_val + b2_val + d2;
   uint64_t mem_val = static_cast<uint64_t>(ReadWU(addr, instr));
   set_register(r1, mem_val);
   return length;
 }
 
-EVALUATE(LLGT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLGT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(AGF) {
   DCHECK_OPCODE(AGF);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   uint64_t r1_val = get_register(r1);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t d2_val = d2;
   uint64_t alu_out = r1_val;
   uint32_t mem_val = ReadW(b2_val + d2_val + x2_val, instr);
@@ skipping 11 matching lines @@
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t d2_val = d2;
   uint64_t alu_out = r1_val;
   uint32_t mem_val = ReadW(b2_val + d2_val + x2_val, instr);
   alu_out -= mem_val;
   SetS390ConditionCode<int64_t>(alu_out, 0);
   set_register(r1, alu_out);
   return length;
 }
 
-EVALUATE(ALGF) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ALGF) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SLGF) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SLGF) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MSGF) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MSGF) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(DSGF) { return DecodeInstructionOriginal(instr); }
+EVALUATE(DSGF) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LRV) {
   DCHECK_OPCODE(LRV);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t mem_addr = b2_val + x2_val + d2;
   int32_t mem_val = ReadW(mem_addr, instr);
   set_low_register(r1, ByteReverse(mem_val));
   return length;
@@ skipping 30 matching lines @@
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t alu_out = get_register(r1);
   int64_t mem_val = ReadDW(b2_val + x2_val + d2);
   SetS390ConditionCode<uint64_t>(alu_out, mem_val);
   set_register(r1, alu_out);
   return length;
 }
 
-EVALUATE(NTSTG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(NTSTG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CVDY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CVDY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CVDG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CVDG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STRVG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STRVG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CGF) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CGF) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CLGF) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CLGF) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LTGF) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LTGF) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CGH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CGH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(PFD) { return DecodeInstructionOriginal(instr); }
+EVALUATE(PFD) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(STRV) {
   DCHECK_OPCODE(STRV);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int32_t r1_val = get_low_register<int32_t>(r1);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t mem_addr = b2_val + x2_val + d2;
   WriteW(mem_addr, ByteReverse(r1_val), instr);
   return length;
 }
 
 EVALUATE(STRVH) {
   DCHECK_OPCODE(STRVH);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int32_t r1_val = get_low_register<int32_t>(r1);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t mem_addr = b2_val + x2_val + d2;
   int16_t result = static_cast<int16_t>(r1_val >> 16);
   WriteH(mem_addr, ByteReverse(result), instr);
   return length;
 }
 
-EVALUATE(BCTG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BCTG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(MSY) {
   DCHECK_OPCODE(MSY);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t d2_val = d2;
   int32_t mem_val = ReadW(b2_val + d2_val + x2_val, instr);
   int32_t r1_val = get_low_register<int32_t>(r1);
   set_low_register(r1, mem_val * r1_val);
@@ skipping 86 matching lines @@
   int32_t mem_val = ReadW(b2_val + x2_val + d2, instr);
   bool isOF = false;
   isOF = CheckOverflowForIntSub(alu_out, mem_val, int32_t);
   alu_out -= mem_val;
   SetS390ConditionCode<int32_t>(alu_out, 0);
   SetS390OverflowCode(isOF);
   set_low_register(r1, alu_out);
   return length;
 }
 
-EVALUATE(MFY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MFY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(ALY) {
   DCHECK_OPCODE(ALY);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   uint32_t alu_out = get_low_register<uint32_t>(r1);
   uint32_t mem_val = ReadWU(b2_val + x2_val + d2, instr);
   alu_out += mem_val;
   set_low_register(r1, alu_out);
@@ skipping 44 matching lines @@
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   // Miscellaneous Loads and Stores
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t addr = x2_val + b2_val + d2;
   uint8_t value = get_low_register<uint32_t>(r1);
   WriteB(addr, value);
   return length;
 }
 
-EVALUATE(ICY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ICY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LAEY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LAEY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LB) {
   DCHECK_OPCODE(LB);
   // Miscellaneous Loads and Stores
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t addr = x2_val + b2_val + d2;
   int32_t mem_val = ReadB(addr);
   set_low_register(r1, mem_val);
@@ skipping 17 matching lines @@
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   // Miscellaneous Loads and Stores
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t addr = x2_val + b2_val + d2;
   int32_t result = static_cast<int32_t>(ReadH(addr, instr));
   set_low_register(r1, result);
   return length;
 }
 
-EVALUATE(CHY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CHY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(AHY) {
   DCHECK_OPCODE(AHY);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int32_t r1_val = get_low_register<int32_t>(r1);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t d2_val = d2;
   int32_t mem_val =
       static_cast<int32_t>(ReadH(b2_val + d2_val + x2_val, instr));
@@ skipping 19 matching lines @@
   int32_t alu_out = 0;
   bool isOF = false;
   alu_out = r1_val - mem_val;
   isOF = CheckOverflowForIntSub(r1_val, mem_val, int64_t);
   set_low_register(r1, alu_out);
   SetS390ConditionCode<int32_t>(alu_out, 0);
   SetS390OverflowCode(isOF);
   return length;
 }
 
-EVALUATE(MHY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MHY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(NG) {
   DCHECK_OPCODE(NG);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t alu_out = get_register(r1);
   int64_t mem_val = ReadDW(b2_val + x2_val + d2);
   alu_out &= mem_val;
   SetS390BitWiseConditionCode<uint32_t>(alu_out);
@@ skipping 20 matching lines @@
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t alu_out = get_register(r1);
   int64_t mem_val = ReadDW(b2_val + x2_val + d2);
   alu_out ^= mem_val;
   SetS390BitWiseConditionCode<uint32_t>(alu_out);
   set_register(r1, alu_out);
   return length;
 }
 
-EVALUATE(LGAT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LGAT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MLG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MLG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(DLG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(DLG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(ALCG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ALCG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SLBG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SLBG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STPQ) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STPQ) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LPQ) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LPQ) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LLGH) {
   DCHECK_OPCODE(LLGH);
   // Load Logical Halfword
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t d2_val = d2;
   uint16_t mem_val = ReadHU(b2_val + d2_val + x2_val, instr);
   set_register(r1, mem_val);
   return length;
 }
 
 EVALUATE(LLH) {
   DCHECK_OPCODE(LLH);
   // Load Logical Halfword
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t d2_val = d2;
   uint16_t mem_val = ReadHU(b2_val + d2_val + x2_val, instr);
   set_low_register(r1, mem_val);
   return length;
 }
 
-EVALUATE(ML) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ML) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(DL) { return DecodeInstructionOriginal(instr); }
+EVALUATE(DL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(ALC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ALC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SLB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SLB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LLGTAT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLGTAT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LLGFAT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLGFAT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LAT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LAT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LBH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LBH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LLCH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLCH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STCH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STCH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LHH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LHH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LLHH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LLHH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STHH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STHH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LFHAT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LFHAT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LFH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LFH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STFH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STFH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CHF) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CHF) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MVCDK) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MVCDK) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MVHHI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MVHHI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(MVGHI) {
   DCHECK_OPCODE(MVGHI);
   // Move Integer (64)
   DECODE_SIL_INSTRUCTION(b1, d1, i2);
   int64_t b1_val = (b1 == 0) ? 0 : get_register(b1);
   intptr_t src_addr = b1_val + d1;
   WriteDW(src_addr, i2);
   return length;
 }
 
 EVALUATE(MVHI) {
   DCHECK_OPCODE(MVHI);
   // Move Integer (32)
   DECODE_SIL_INSTRUCTION(b1, d1, i2);
   int64_t b1_val = (b1 == 0) ? 0 : get_register(b1);
   intptr_t src_addr = b1_val + d1;
   WriteW(src_addr, i2, instr);
   return length;
 }
 
-EVALUATE(CHHSI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CHHSI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CGHSI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CGHSI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CHSI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CHSI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CLFHSI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CLFHSI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TBEGIN) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TBEGIN) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TBEGINC) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TBEGINC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LMG) {
   DCHECK_OPCODE(LMG);
   // Store Multiple 64-bits.
   DECODE_RSY_A_INSTRUCTION(r1, r3, b2, d2);
   int rb = b2;
   int offset = d2;
 
   // Regs roll around if r3 is less than r1.
   // Artifically increase r3 by 16 so we can calculate
@@ skipping 76 matching lines @@
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int shiftBits = (b2_val + d2) & 0x3F;
   // unsigned
   uint64_t r3_val = get_register(r3);
   uint64_t alu_out = 0;
   alu_out = r3_val << shiftBits;
   set_register(r1, alu_out);
   return length;
 }
 
-EVALUATE(CSY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CSY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(RLLG) {
   DCHECK_OPCODE(RLLG);
   // For SLLG/SRLG, the 64-bit third operand is shifted the number
   // of bits specified by the second-operand address, and the result is
   // placed at the first-operand location. Except for when the R1 and R3
   // fields designate the same register, the third operand remains
   // unchanged in general register R3.
   DECODE_RSY_A_INSTRUCTION(r1, r3, b2, d2);
   // only takes rightmost 6 bits
@@ skipping 22 matching lines @@
   int64_t rb_val = (rb == 0) ? 0 : get_register(rb);
 
   // Store each register in ascending order.
   for (int i = 0; i <= r3 - r1; i++) {
     int64_t value = get_register((r1 + i) % 16);
     WriteDW(rb_val + offset + 8 * i, value);
   }
   return length;
 }
 
-EVALUATE(STMH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STMH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STCMH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STCMH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(STCMY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(STCMY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CDSY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CDSY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CDSG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CDSG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BXHG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BXHG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(BXLEG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(BXLEG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(ECAG) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ECAG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(TMY) {
   DCHECK_OPCODE(TMY);
   // Test Under Mask (Mem - Imm) (8)
   DECODE_SIY_INSTRUCTION(b1, d1, i2);
   int64_t b1_val = (b1 == 0) ? 0 : get_register(b1);
   intptr_t d1_val = d1;
   intptr_t addr = b1_val + d1_val;
   uint8_t mem_val = ReadB(addr);
   uint8_t imm_val = i2;
   uint8_t selected_bits = mem_val & imm_val;
   // CC0: Selected bits are zero
   // CC1: Selected bits mixed zeros and ones
   // CC3: Selected bits all ones
   if (0 == selected_bits) {
     condition_reg_ = CC_EQ;  // CC0
   } else if (selected_bits == imm_val) {
     condition_reg_ = 0x1;  // CC3
   } else {
     condition_reg_ = 0x4;  // CC1
   }
   return length;
 }
 
-EVALUATE(MVIY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MVIY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(NIY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(NIY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(CLIY) {
   DCHECK_OPCODE(CLIY);
   DECODE_SIY_INSTRUCTION(b1, d1, i2);
   // Compare Immediate (Mem - Imm) (8)
   int64_t b1_val = (b1 == 0) ? 0 : get_register(b1);
   intptr_t d1_val = d1;
   intptr_t addr = b1_val + d1_val;
   uint8_t mem_val = ReadB(addr);
   uint8_t imm_val = i2;
   SetS390ConditionCode<uint8_t>(mem_val, imm_val);
   return length;
 }
 
-EVALUATE(OIY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(OIY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(XIY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(XIY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(ASI) {
   DCHECK_OPCODE(ASI);
   // TODO(bcleung): Change all fooInstr->I2Value() to template functions.
   // The below static cast to 8 bit and then to 32 bit is necessary
   // because siyInstr->I2Value() returns a uint8_t, which a direct
   // cast to int32_t could incorrectly interpret.
   DECODE_SIY_INSTRUCTION(b1, d1, i2_unsigned);
   int8_t i2_8bit = static_cast<int8_t>(i2_unsigned);
   int32_t i2 = static_cast<int32_t>(i2_8bit);
   intptr_t b1_val = (b1 == 0) ? 0 : get_register(b1);
 
   int d1_val = d1;
   intptr_t addr = b1_val + d1_val;
 
   int32_t mem_val = ReadW(addr, instr);
   bool isOF = CheckOverflowForIntAdd(mem_val, i2, int32_t);
   int32_t alu_out = mem_val + i2;
   SetS390ConditionCode<int32_t>(alu_out, 0);
   SetS390OverflowCode(isOF);
   WriteW(addr, alu_out, instr);
   return length;
 }
 
-EVALUATE(ALSI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ALSI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(AGSI) {
   DCHECK_OPCODE(AGSI);
   // TODO(bcleung): Change all fooInstr->I2Value() to template functions.
   // The below static cast to 8 bit and then to 32 bit is necessary
   // because siyInstr->I2Value() returns a uint8_t, which a direct
   // cast to int32_t could incorrectly interpret.
   DECODE_SIY_INSTRUCTION(b1, d1, i2_unsigned);
   int8_t i2_8bit = static_cast<int8_t>(i2_unsigned);
   int64_t i2 = static_cast<int64_t>(i2_8bit);
   intptr_t b1_val = (b1 == 0) ? 0 : get_register(b1);
 
   int d1_val = d1;
   intptr_t addr = b1_val + d1_val;
 
   int64_t mem_val = ReadDW(addr);
   int isOF = CheckOverflowForIntAdd(mem_val, i2, int64_t);
   int64_t alu_out = mem_val + i2;
   SetS390ConditionCode<uint64_t>(alu_out, 0);
   SetS390OverflowCode(isOF);
   WriteDW(addr, alu_out);
   return length;
 }
 
-EVALUATE(ALGSI) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ALGSI) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(ICMH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ICMH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(ICMY) { return DecodeInstructionOriginal(instr); }
+EVALUATE(ICMY) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MVCLU) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MVCLU) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CLCLU) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CLCLU) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(STMY) {
   DCHECK_OPCODE(STMY);
   DECODE_RSY_A_INSTRUCTION(r1, r3, b2, d2);
   // Load/Store Multiple (32)
   int offset = d2;
 
   // Regs roll around if r3 is less than r1.
   // Artifically increase r3 by 16 so we can calculate
   // the number of regs stored properly.
   if (r3 < r1) r3 += 16;
 
   int32_t b2_val = (b2 == 0) ? 0 : get_low_register<int32_t>(b2);
 
   // Store each register in ascending order.
   for (int i = 0; i <= r3 - r1; i++) {
     int32_t value = get_low_register<int32_t>((r1 + i) % 16);
     WriteW(b2_val + offset + 4 * i, value, instr);
   }
   return length;
 }
 
-EVALUATE(LMH) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LMH) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LMY) {
   DCHECK_OPCODE(LMY);
   DECODE_RSY_A_INSTRUCTION(r1, r3, b2, d2);
   // Load/Store Multiple (32)
   int offset = d2;
 
   // Regs roll around if r3 is less than r1.
   // Artifically increase r3 by 16 so we can calculate
   // the number of regs stored properly.
   if (r3 < r1) r3 += 16;
 
   int32_t b2_val = (b2 == 0) ? 0 : get_low_register<int32_t>(b2);
 
   // Store each register in ascending order.
   for (int i = 0; i <= r3 - r1; i++) {
     int32_t value = ReadW(b2_val + offset + 4 * i, instr);
     set_low_register((r1 + i) % 16, value);
   }
   return length;
 }
 
-EVALUATE(TP) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TP) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(SRAK) {
   DCHECK_OPCODE(SRAK);
   DECODE_RSY_A_INSTRUCTION(r1, r3, b2, d2);
   // 32-bit non-clobbering shift-left/right arithmetic
   // only takes rightmost 6 bits
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int shiftBits = (b2_val + d2) & 0x3F;
   int32_t r3_val = get_low_register<int32_t>(r3);
   int32_t alu_out = 0;
@@ skipping 54 matching lines @@
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int shiftBits = (b2_val + d2) & 0x3F;
   // unsigned
   uint32_t r3_val = get_low_register<uint32_t>(r3);
   uint32_t alu_out = 0;
   alu_out = r3_val << shiftBits;
   set_low_register(r1, alu_out);
   return length;
 }
 
-EVALUATE(LOCG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(STOCG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LANG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LAOG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LAXG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LAAG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LAALG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LOC) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(STOC) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LAN) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LAO) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LAX) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LAA) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(LAAL) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(BRXHG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(BRXLG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(RISBLG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(RNSBG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(ROSBG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(RXSBG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(RISBGN) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(RISBHG) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CGRJ) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CGIT) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CIT) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CLFIT) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CGIJ) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CIJ) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(ALHSIK) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(ALGHSIK) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CGRB) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CGIB) { return DecodeInstructionOriginal(instr); }
-
-EVALUATE(CIB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LOCG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(STOCG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LANG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LAOG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LAXG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LAAG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LAALG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LOC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(STOC) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LAN) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LAO) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LAX) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LAA) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(LAAL) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(BRXHG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(BRXLG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(RISBLG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(RNSBG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(ROSBG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(RXSBG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(RISBGN) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(RISBHG) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CGRJ) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CGIT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CIT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CLFIT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CGIJ) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CIJ) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(ALHSIK) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(ALGHSIK) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CGRB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CGIB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
+
+EVALUATE(CIB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LDEB) {
   DCHECK_OPCODE(LDEB);
   // Load Float
   DECODE_RXE_INSTRUCTION(r1, b2, x2, d2);
   int rb = b2;
   int rx = x2;
   int offset = d2;
   int64_t rb_val = (rb == 0) ? 0 : get_register(rb);
   int64_t rx_val = (rx == 0) ? 0 : get_register(rx);
   double ret =
       static_cast<double>(*reinterpret_cast<float*>(rx_val + rb_val + offset));
   set_d_register_from_double(r1, ret);
   return length;
 }
 
-EVALUATE(LXDB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LXDB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(LXEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(LXEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MXDB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MXDB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(KEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(AEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(AEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MDEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MDEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(DEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(DEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MAEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MAEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MSEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MSEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TCEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TCEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TCDB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TCDB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TCXB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TCXB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SQEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SQEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(SQDB) {
   DCHECK_OPCODE(SQDB);
   DECODE_RXE_INSTRUCTION(r1, b2, x2, d2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t d2_val = d2;
   double r1_val = get_double_from_d_register(r1);
   double dbl_val = ReadDouble(b2_val + x2_val + d2_val);
   r1_val = std::sqrt(dbl_val);
   set_d_register_from_double(r1, r1_val);
   return length;
 }
 
-EVALUATE(MEEB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MEEB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(KDB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(KDB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(CDB) {
   DCHECK_OPCODE(CDB);
 
   DECODE_RXE_INSTRUCTION(r1, b2, x2, d2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t d2_val = d2;
   double r1_val = get_double_from_d_register(r1);
   double dbl_val = ReadDouble(b2_val + x2_val + d2_val);
@@ skipping 51 matching lines @@
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   intptr_t d2_val = d2;
   double r1_val = get_double_from_d_register(r1);
   double dbl_val = ReadDouble(b2_val + x2_val + d2_val);
   r1_val /= dbl_val;
   set_d_register_from_double(r1, r1_val);
   SetS390ConditionCode<double>(r1_val, 0);
   return length;
 }
 
-EVALUATE(MADB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MADB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(MSDB) { return DecodeInstructionOriginal(instr); }
+EVALUATE(MSDB) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SLDT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SLDT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SRDT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SRDT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SLXT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SLXT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(SRXT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(SRXT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TDCET) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TDCET) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TDGET) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TDGET) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TDCDT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TDCDT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TDGDT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TDGDT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TDCXT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TDCXT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(TDGXT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(TDGXT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 EVALUATE(LEY) {
   DCHECK_OPCODE(LEY);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   // Miscellaneous Loads and Stores
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t addr = x2_val + b2_val + d2;
   float float_val = *reinterpret_cast<float*>(addr);
   set_d_register_from_float32(r1, float_val);
@@ skipping 29 matching lines @@
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   // Miscellaneous Loads and Stores
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t addr = x2_val + b2_val + d2;
   int64_t frs_val = get_d_register(r1);
   WriteDW(addr, frs_val);
   return length;
 }
 
-EVALUATE(CZDT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CZDT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CZXT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CZXT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CDZT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CDZT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
-EVALUATE(CXZT) { return DecodeInstructionOriginal(instr); }
+EVALUATE(CXZT) {
+  UNIMPLEMENTED();
+  USE(instr);
+  return 0;
+}
 
 #undef EVALUATE
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // USE_SIMULATOR
 #endif  // V8_TARGET_ARCH_S390