MIPS64: Unify and improve Word32 compares to use same instructions as Word64 compares.

test/cctest/compiler/call-tester.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.
 
 #ifndef V8_CCTEST_COMPILER_CALL_TESTER_H_
 #define V8_CCTEST_COMPILER_CALL_TESTER_H_
 
 #include "src/v8.h"
 
 #include "src/simulator.h"
@@ skipping 110 matching lines @@
 template <>
 struct ParameterTraits<int*> {
   static uintptr_t Cast(int* r) { return reinterpret_cast<uintptr_t>(r); }
 };
 
 template <typename T>
 struct ParameterTraits<T*> {
   static uintptr_t Cast(void* r) { return reinterpret_cast<uintptr_t>(r); }
 };
 
+#if V8_TARGET_ARCH_MIPS64

[titzer, 2015/03/24 14:37:22]

This should be good enough for all architectures, yes?

[dusmil.imgtec, 2015/03/24 18:41:12]

Yes, after all this only concerns simulated architectures where host code and
generated code are different.  Particularly this solves problem for mips64
simulator builds where transition from x64 code to mips64 generated code is
done.

[titzer, 2015/03/24 18:43:33]

If you remove the ifdef and it works on all platforms, I'll rubber-stamp it
tomorrow.

Sorry for the late comment, forgot to hit the button before it landed.

+// Additional template specialization required for mips64 to sign-extend
+// parameters defined by calling convention.
+template <>
+struct ParameterTraits<int32_t> {
+  static int64_t Cast(int32_t r) { return static_cast<int64_t>(r); }
+};
+
+template <>
+struct ParameterTraits<uint32_t> {
+  static int64_t Cast(uint32_t r) {
+    return static_cast<int64_t>(static_cast<int32_t>(r));
+  }
+};
+#endif
+
 class CallHelper {
  public:
   explicit CallHelper(Isolate* isolate, MachineSignature* machine_sig)
       : machine_sig_(machine_sig), isolate_(isolate) {
     USE(isolate_);
   }
   virtual ~CallHelper() {}
 
   static MachineSignature* MakeMachineSignature(
       Zone* zone, MachineType return_type, MachineType p0 = kMachNone,
@@ skipping 66 matching lines @@
         Simulator::CallArgument::End()};
     return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args));
   }
 #elif USE_SIMULATOR && (V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC64)
   uintptr_t CallSimulator(byte* f, int64_t p1 = 0, int64_t p2 = 0,
                           int64_t p3 = 0, int64_t p4 = 0) {
     Simulator* simulator = Simulator::current(isolate_);
     return static_cast<uintptr_t>(simulator->Call(f, 4, p1, p2, p3, p4));
   }
 
+
   template <typename R, typename F>
   R DoCall(F* f) {
     return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f)));
   }
   template <typename R, typename F, typename P1>
   R DoCall(F* f, P1 p1) {
     return ReturnValueTraits<R>::Cast(
         CallSimulator(FUNCTION_ADDR(f), ParameterTraits<P1>::Cast(p1)));
   }
   template <typename R, typename F, typename P1, typename P2>
@@ skipping 194 matching lines @@
 
  private:
   CallHelper* helper() { return static_cast<C*>(this); }
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CCTEST_COMPILER_CALL_TESTER_H_