S390: Implemented ALCR in S390 simulator.

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 1804 matching lines @@
       if (ALR == op) {
         alu_out = r1_val + r2_val;
         isOF = CheckOverflowForUIntAdd(r1_val, r2_val);
       } else if (SLR == op) {
         alu_out = r1_val - r2_val;
         isOF = CheckOverflowForUIntSub(r1_val, r2_val);
       } else {
         UNREACHABLE();
       }
       set_low_register(r1, alu_out);
-      SetS390ConditionCode<uint32_t>(alu_out, 0);
-      SetS390OverflowCode(isOF);
+      SetS390ConditionCodeCarry<uint32_t>(alu_out, isOF);
       break;
     }
     case LNR: {
       // Load Negative (32)
       RRInstruction* rrinst = reinterpret_cast<RRInstruction*>(instr);
       int r1 = rrinst->R1Value();
       int r2 = rrinst->R2Value();
       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);
@@ skipping 613 matching lines @@
       set_low_register(r1, alu_out >> 32);
       set_low_register(r1 + 1, alu_out & 0x00000000FFFFFFFF);
       SetS390ConditionCode<int32_t>(alu_out, 0);
       break;
     }
     default: { return DecodeFourByteArithmetic(instr); }
   }
   return true;
 }
 
-/**
- * Decodes and simulates four byte arithmetic instructions
- */
-bool Simulator::DecodeFourByteArithmetic(Instruction* instr) {
+bool Simulator::DecodeFourByteArithmetic64Bit(Instruction* instr) {
   Opcode op = instr->S390OpcodeValue();
 
-  // Pre-cast instruction to various types
   RRFInstruction* rrfInst = reinterpret_cast<RRFInstruction*>(instr);
   RREInstruction* rreInst = reinterpret_cast<RREInstruction*>(instr);
 
   switch (op) {
     case AGR:
     case SGR:
     case OGR:
     case NGR:
     case XGR: {
       int r1 = rreInst->R1Value();
@@ skipping 53 matching lines @@
       int64_t r1_val = get_register(r1);
       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);
       break;
     }
+    case AGRK:
+    case SGRK:
+    case NGRK:
+    case OGRK:
+    case XGRK: {
+      // 64-bit Non-clobbering arithmetics / bitwise ops.
+      int r1 = rrfInst->R1Value();
+      int r2 = rrfInst->R2Value();
+      int r3 = rrfInst->R3Value();
+      int64_t r2_val = get_register(r2);
+      int64_t r3_val = get_register(r3);
+      if (AGRK == op) {
+        bool isOF = CheckOverflowForIntAdd(r2_val, r3_val, int64_t);
+        SetS390ConditionCode<int64_t>(r2_val + r3_val, 0);
+        SetS390OverflowCode(isOF);
+        set_register(r1, r2_val + r3_val);
+      } else if (SGRK == op) {
+        bool isOF = CheckOverflowForIntSub(r2_val, r3_val, int64_t);
+        SetS390ConditionCode<int64_t>(r2_val - r3_val, 0);
+        SetS390OverflowCode(isOF);
+        set_register(r1, r2_val - r3_val);
+      } else {
+        // Assume bitwise operation here
+        uint64_t bitwise_result = 0;
+        if (NGRK == op) {
+          bitwise_result = r2_val & r3_val;
+        } else if (OGRK == op) {
+          bitwise_result = r2_val | r3_val;
+        } else if (XGRK == op) {
+          bitwise_result = r2_val ^ r3_val;
+        }
+        SetS390BitWiseConditionCode<uint64_t>(bitwise_result);
+        set_register(r1, bitwise_result);
+      }
+      break;
+    }
+    case ALGRK:
+    case SLGRK: {
+      // 64-bit Non-clobbering unsigned arithmetics
+      int r1 = rrfInst->R1Value();
+      int r2 = rrfInst->R2Value();
+      int r3 = rrfInst->R3Value();
+      uint64_t r2_val = get_register(r2);
+      uint64_t r3_val = get_register(r3);
+      if (ALGRK == op) {
+        bool isOF = CheckOverflowForUIntAdd(r2_val, r3_val);
+        SetS390ConditionCode<uint64_t>(r2_val + r3_val, 0);
+        SetS390OverflowCode(isOF);
+        set_register(r1, r2_val + r3_val);
+      } else if (SLGRK == op) {
+        bool isOF = CheckOverflowForUIntSub(r2_val, r3_val);
+        SetS390ConditionCode<uint64_t>(r2_val - r3_val, 0);
+        SetS390OverflowCode(isOF);
+        set_register(r1, r2_val - r3_val);
+      }
+    }
+    case AGHI:
+    case MGHI: {
+      RIInstruction* riinst = reinterpret_cast<RIInstruction*>(instr);
+      int32_t r1 = riinst->R1Value();
+      int64_t i = static_cast<int64_t>(riinst->I2Value());
+      int64_t r1_val = get_register(r1);
+      bool isOF = false;
+      switch (op) {
+        case AGHI:
+          isOF = CheckOverflowForIntAdd(r1_val, i, int64_t);
+          r1_val += i;
+          break;
+        case MGHI:
+          isOF = CheckOverflowForMul(r1_val, i);
+          r1_val *= i;
+          break;  // no overflow indication is given
+        default:
+          break;
+      }
+      set_register(r1, r1_val);
+      SetS390ConditionCode<int32_t>(r1_val, 0);
+      SetS390OverflowCode(isOF);
+      break;
+    }
+    default:
+      UNREACHABLE();
+  }
+  return true;
+}
+
+/**
+ * Decodes and simulates four byte arithmetic instructions
+ */
+bool Simulator::DecodeFourByteArithmetic(Instruction* instr) {
+  Opcode op = instr->S390OpcodeValue();
+
+  // Pre-cast instruction to various types
+  RRFInstruction* rrfInst = reinterpret_cast<RRFInstruction*>(instr);
+
+  switch (op) {
+    case AGR:
+    case SGR:
+    case OGR:
+    case NGR:
+    case XGR:
+    case AGFR:
+    case SGFR: {
+      DecodeFourByteArithmetic64Bit(instr);
+      break;
+    }
     case ARK:
     case SRK:
     case NRK:
     case ORK:
     case XRK: {
       // 32-bit Non-clobbering arithmetics / bitwise ops
       int r1 = rrfInst->R1Value();
       int r2 = rrfInst->R2Value();
       int r3 = rrfInst->R3Value();
       int32_t r2_val = get_low_register<int32_t>(r2);
@@ skipping 42 matching lines @@
         SetS390OverflowCode(isOF);
         set_low_register(r1, r2_val - r3_val);
       }
       break;
     }
     case AGRK:
     case SGRK:
     case NGRK:
     case OGRK:
     case XGRK: {
-      // 64-bit Non-clobbering arithmetics / bitwise ops.
-      int r1 = rrfInst->R1Value();
-      int r2 = rrfInst->R2Value();
-      int r3 = rrfInst->R3Value();
-      int64_t r2_val = get_register(r2);
-      int64_t r3_val = get_register(r3);
-      if (AGRK == op) {
-        bool isOF = CheckOverflowForIntAdd(r2_val, r3_val, int64_t);
-        SetS390ConditionCode<int64_t>(r2_val + r3_val, 0);
-        SetS390OverflowCode(isOF);
-        set_register(r1, r2_val + r3_val);
-      } else if (SGRK == op) {
-        bool isOF = CheckOverflowForIntSub(r2_val, r3_val, int64_t);
-        SetS390ConditionCode<int64_t>(r2_val - r3_val, 0);
-        SetS390OverflowCode(isOF);
-        set_register(r1, r2_val - r3_val);
-      } else {
-        // Assume bitwise operation here
-        uint64_t bitwise_result = 0;
-        if (NGRK == op) {
-          bitwise_result = r2_val & r3_val;
-        } else if (OGRK == op) {
-          bitwise_result = r2_val | r3_val;
-        } else if (XGRK == op) {
-          bitwise_result = r2_val ^ r3_val;
-        }
-        SetS390BitWiseConditionCode<uint64_t>(bitwise_result);
-        set_register(r1, bitwise_result);
-      }
+      DecodeFourByteArithmetic64Bit(instr);
       break;
     }
     case ALGRK:
     case SLGRK: {
-      // 64-bit Non-clobbering unsigned arithmetics
-      int r1 = rrfInst->R1Value();
-      int r2 = rrfInst->R2Value();
-      int r3 = rrfInst->R3Value();
-      uint64_t r2_val = get_register(r2);
-      uint64_t r3_val = get_register(r3);
-      if (ALGRK == op) {
-        bool isOF = CheckOverflowForUIntAdd(r2_val, r3_val);
-        SetS390ConditionCode<uint64_t>(r2_val + r3_val, 0);
-        SetS390OverflowCode(isOF);
-        set_register(r1, r2_val + r3_val);
-      } else if (SLGRK == op) {
-        bool isOF = CheckOverflowForUIntSub(r2_val, r3_val);
-        SetS390ConditionCode<uint64_t>(r2_val - r3_val, 0);
-        SetS390OverflowCode(isOF);
-        set_register(r1, r2_val - r3_val);
-      }
+      DecodeFourByteArithmetic64Bit(instr);
       break;
     }
     case AHI:
     case MHI: {
       RIInstruction* riinst = reinterpret_cast<RIInstruction*>(instr);
       int32_t r1 = riinst->R1Value();
       int32_t i = riinst->I2Value();
       int32_t r1_val = get_low_register<int32_t>(r1);
       bool isOF = false;
       switch (op) {
         case AHI:
           isOF = CheckOverflowForIntAdd(r1_val, i, int32_t);
           r1_val += i;
           break;
         case MHI:
           isOF = CheckOverflowForMul(r1_val, i);
           r1_val *= i;
           break;  // no overflow indication is given
         default:
           break;
       }
       set_low_register(r1, r1_val);
       SetS390ConditionCode<int32_t>(r1_val, 0);
       SetS390OverflowCode(isOF);
       break;
     }
     case AGHI:
     case MGHI: {
-      RIInstruction* riinst = reinterpret_cast<RIInstruction*>(instr);
-      int32_t r1 = riinst->R1Value();
-      int64_t i = static_cast<int64_t>(riinst->I2Value());
-      int64_t r1_val = get_register(r1);
-      bool isOF = false;
-      switch (op) {
-        case AGHI:
-          isOF = CheckOverflowForIntAdd(r1_val, i, int64_t);
-          r1_val += i;
-          break;
-        case MGHI:
-          isOF = CheckOverflowForMul(r1_val, i);
-          r1_val *= i;
-          break;  // no overflow indication is given
-        default:
-          break;
-      }
-      set_register(r1, r1_val);
-      SetS390ConditionCode<int32_t>(r1_val, 0);
-      SetS390OverflowCode(isOF);
+      DecodeFourByteArithmetic64Bit(instr);
       break;
     }
     case MLR: {
       RREInstruction* rreinst = reinterpret_cast<RREInstruction*>(instr);
       int r1 = rreinst->R1Value();
       int r2 = rreinst->R2Value();
       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);
@@ skipping 263 matching lines @@
       r2_val >>= 48;
       set_register(r1, r2_val);
 #else
       int32_t r2_val = get_low_register<int32_t>(r2);
       r2_val <<= 16;
       r2_val >>= 16;
       set_low_register(r1, r2_val);
 #endif
       break;
     }
+    case ALCR: {
+      RREInstruction* rrinst = reinterpret_cast<RREInstruction*>(instr);
+      int r1 = rrinst->R1Value();
+      int r2 = rrinst->R2Value();
+      uint32_t r1_val = get_low_register<uint32_t>(r1);
+      uint32_t r2_val = get_low_register<uint32_t>(r2);
+      uint32_t alu_out = 0;
+      bool isOF = false;
+
+      alu_out = r1_val + r2_val;
+      bool isOF_original = CheckOverflowForUIntAdd(r1_val, r2_val);
+      if (TestConditionCode((Condition)2) || TestConditionCode((Condition)3)) {
+        alu_out = alu_out + 1;
+        isOF = isOF_original || CheckOverflowForUIntAdd(alu_out, 1);
+      } else {
+        isOF = isOF_original;
+      }
+      set_low_register(r1, alu_out);
+      SetS390ConditionCodeCarry<uint32_t>(alu_out, isOF);
+      break;
+    }
     default: { return DecodeFourByteFloatingPoint(instr); }
   }
   return true;
 }
 
 void Simulator::DecodeFourByteFloatingPointIntConversion(Instruction* instr) {
   Opcode op = instr->S390OpcodeValue();
   switch (op) {
     case CDLFBR:
     case CDLGBR:
@@ skipping 2046 matching lines @@
   uintptr_t address = *stack_slot;
   set_register(sp, current_sp + sizeof(uintptr_t));
   return address;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // USE_SIMULATOR
 #endif  // V8_TARGET_ARCH_S390