S390: Implemented ALCR in S390 simulator.

src/s390/simulator-s390.h

 // 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.
 
 // Declares a Simulator for S390 instructions if we are not generating a native
 // S390 binary. This Simulator allows us to run and debug S390 code generation
 // on regular desktop machines.
 // V8 calls into generated code by "calling" the CALL_GENERATED_CODE macro,
 // which will start execution in the Simulator or forwards to the real entry
 // on a S390 hardware platform.
@@ skipping 291 matching lines @@
 
   inline int64_t ReadDW(intptr_t addr);
   inline double ReadDouble(intptr_t addr);
   inline void WriteDW(intptr_t addr, int64_t value);
 
   // S390
   void Trace(Instruction* instr);
   bool DecodeTwoByte(Instruction* instr);
   bool DecodeFourByte(Instruction* instr);
   bool DecodeFourByteArithmetic(Instruction* instr);
+  bool DecodeFourByteArithmetic64Bit(Instruction* instr);
   bool DecodeFourByteFloatingPoint(Instruction* instr);
   void DecodeFourByteFloatingPointIntConversion(Instruction* instr);
   void DecodeFourByteFloatingPointRound(Instruction* instr);
 
   bool DecodeSixByte(Instruction* instr);
   bool DecodeSixByteArithmetic(Instruction* instr);
   bool S390InstructionDecode(Instruction* instr);
   void DecodeSixByteBitShift(Instruction* instr);
 
   // Used by the CL**BR instructions.
@@ skipping 66 matching lines @@
     } else if (lhs > rhs) {
       condition_reg_ |= CC_GT;
     }
 
     // We get down here only for floating point
     // comparisons and the values are unordered
     // i.e. NaN
     if (condition_reg_ == 0) condition_reg_ = unordered;
   }
 
+  // Used by arithmetic operations that use carry.
+  template <typename T>

[JoranSiu, 2016/03/31 13:27:57]

Not sure if this needs to be a template function, given that result is only
being compared to zero.

[bcleung, 2016/03/31 19:12:39]

This function will be used with unsigned int inputs of multiple types (e.g.
uint32 and uint64), therefore it is necessary to make it a template function.

+  void SetS390ConditionCodeCarry(T result, bool overflow) {
+    condition_reg_ = 0;
+    bool zero_result = (result == static_cast<T>(0));
+    if (zero_result && !overflow) {
+      condition_reg_ |= 8;
+    } else if (!zero_result && !overflow) {
+      condition_reg_ |= 4;
+    } else if (zero_result && overflow) {
+      condition_reg_ |= 2;
+    } else if (!zero_result && overflow) {
+      condition_reg_ |= 1;
+    }
+
+    // We get down here only for floating point

[JoranSiu, 2016/03/31 13:27:57]

Are there any floating point operations that would set the carry flag?  If not,
it might be better to stick an ASSERT to ensure condition_reg_ is non-zero.   

[bcleung, 2016/03/31 19:12:39]

According to principles of operation, no floating-point operations set the carry
flag. This line has been replaced with a check that causes an UNREACHABLE()
error if condition_reg_ is zero.

+    // comparisons and the values are unordered
+    // i.e. NaN
+    if (condition_reg_ == 0) condition_reg_ = unordered;
+  }
+
   bool isNaN(double value) { return (value != value); }
 
   // Set the condition code for bitwise operations
   // CC0 is set if value == 0.
   // CC1 is set if value != 0.
   // CC2/CC3 are not set.
   template <typename T>
   void SetS390BitWiseConditionCode(T value) {
     condition_reg_ = 0;
 
@@ skipping 117 matching lines @@
   static inline void UnregisterCTryCatch(v8::internal::Isolate* isolate) {
     Simulator::current(isolate)->PopAddress();
   }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // !defined(USE_SIMULATOR)
 #endif  // V8_S390_SIMULATOR_S390_H_