DBC: Adds simdbc64 target, adds arm64 arithmetic overflow logic

runtime/vm/simulator_dbc.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <setjmp.h>  // NOLINT
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_DBC)
 
@@ skipping 88 matching lines @@
 
 DART_FORCE_INLINE static RawObject** FrameArguments(RawObject** FP,
                                                     intptr_t argc) {
   return FP - (kDartFrameFixedSize + argc);
 }
 
 
 class SimulatorHelpers {
  public:
   DART_FORCE_INLINE static RawSmi* GetClassIdAsSmi(RawObject* obj) {
-    return Smi::New(obj->IsHeapObject() ? obj->GetClassId() : kSmiCid);
+    return Smi::New(obj->IsHeapObject() ? obj->GetClassId()
+                                        : static_cast<intptr_t>(kSmiCid));
   }
 
   DART_FORCE_INLINE static intptr_t GetClassId(RawObject* obj) {
-    return obj->IsHeapObject() ? obj->GetClassId() : kSmiCid;
+    return obj->IsHeapObject() ? obj->GetClassId()
+                               : static_cast<intptr_t>(kSmiCid);
   }
 
   DART_FORCE_INLINE static void IncrementUsageCounter(RawICData* icdata) {
     reinterpret_cast<RawFunction*>(icdata->ptr()->owner_)
         ->ptr()
         ->usage_counter_++;
   }
 
   DART_FORCE_INLINE static bool IsStrictEqualWithNumberCheck(RawObject* lhs,
                                                              RawObject* rhs) {
@@ skipping 207 matching lines @@
                      uint32_t* pc) {
   frame[0] = Function::null();
   frame[1] = Code::null();
   frame[2] = reinterpret_cast<RawObject*>(pc);
   frame[3] = reinterpret_cast<RawObject*>(base);
   fp_ = sp_ = frame + kDartFrameFixedSize;
   thread->set_top_exit_frame_info(reinterpret_cast<uword>(sp_));
 }
 
 
-#if defined(__has_builtin)

[Vyacheslav Egorov (Google), 2016/04/22 06:22:04]

Where did this go?

Inline assembly is just a fall back, compiler intrinsics are the right thing to
rely on. 

I would expect that clang used to compile for ARM64 actually has support for
overflow intrinsics.

[zra, 2016/04/22 19:40:49]

I found the problem with the intrinsics. Their use here assumes that when there
is overflow, the output is not modified. That is what the inline assembly does.
But the intrinsics may/should modify the output, even when there is overflow:

https://gcc.gnu.org/onlinedocs/gcc/Integer-Overflow-Builtins.html.

Ivan has suggested that I keep the changes here, and add TODOs to investigate
using the intrinsics once we have something working.

[Vyacheslav Egorov (Google), 2016/04/23 18:58:35]

Good catch! Alternative would be to just rewrite SMI_FAST_PATH_TOS to not pass
stack slot directly but only commit it if intrinsic succeeds. 

[zra, 2016/04/25 15:42:56]

Assuming the intrinsic does a branch to decide the return value, we'd be adding
another branch to decide whether to commit. Maybe it doesn't matter because the
additional branch goes away after the compiler finishes inlining. We can
investigate that later. Right now, I'd like to land this CL to unblock wiring up
the interpreter for Flutter.

-#if __has_builtin(__builtin_smul_overflow)
-#define HAS_MUL_OVERFLOW
-#endif
-#if __has_builtin(__builtin_sadd_overflow)
-#define HAS_ADD_OVERFLOW
-#endif
-#if __has_builtin(__builtin_ssub_overflow)
-#define HAS_SUB_OVERFLOW
-#endif
-#endif
-
-
-DART_FORCE_INLINE static bool SignedAddWithOverflow(int32_t lhs,
-                                                    int32_t rhs,
+DART_FORCE_INLINE static bool SignedAddWithOverflow(intptr_t lhs,
+                                                    intptr_t rhs,
                                                     intptr_t* out) {
   int32_t res = 1;

[Vyacheslav Egorov (Google), 2016/04/22 06:22:04]

if you make this intptr_t then both ARM and ARM64 become the same code as far as
I see

[zra, 2016/04/22 19:40:49]

Done.

-#if defined(HAS_ADD_OVERFLOW)
-  res = static_cast<int32_t>(__builtin_sadd_overflow(
-      lhs, rhs, reinterpret_cast<int32_t*>(out)));
-#elif defined(__i386__)
+#if defined(HOST_ARCH_IA32) || defined(HOST_ARCH_X64)
   asm volatile(
       "add %2, %1\n"

[Ivan Posva, 2016/04/21 23:35:15]

Shouldn't this be at least an addq for HOST_ARCH_X64?

[zra, 2016/04/22 19:40:49]

The correct ops for the types of the provided operands are generated.

       "jo 1f;\n"
       "xor %0, %0\n"
       "mov %1, 0(%3)\n"
       "1: "
       : "+r"(res), "+r"(lhs)
       : "r"(rhs), "r"(out)
       : "cc");
-#elif defined(__arm__)
+#elif defined(HOST_ARCH_ARM)
   asm volatile(
       "adds %1, %1, %2;\n"
       "bvs 1f;\n"
       "mov %0, $0;\n"
       "str %1, [%3, #0]\n"
       "1:"
       : "+r"(res), "+r"(lhs)
       : "r"(rhs), "r"(out)
       : "cc", "r12");
+#elif defined(HOST_ARCH_ARM64)
+  asm volatile(
+      "adds %1, %1, %2;\n"
+      "bvs 1f;\n"
+      "mov %w0, #0;\n"
+      "str %1, [%3, #0]\n"
+      "1:"
+      : "+r"(res), "+r"(lhs)
+      : "r"(rhs), "r"(out)
+      : "cc");
 #else
 #error "Unsupported platform"
 #endif
   return (res != 0);
 }
 
 
-DART_FORCE_INLINE static bool SignedSubWithOverflow(int32_t lhs,
-                                                    int32_t rhs,
+DART_FORCE_INLINE static bool SignedSubWithOverflow(intptr_t lhs,
+                                                    intptr_t rhs,
                                                     intptr_t* out) {
   int32_t res = 1;
-#if defined(HAS_SUB_OVERFLOW)
-  res = static_cast<int32_t>(__builtin_ssub_overflow(
-      lhs, rhs, reinterpret_cast<int32_t*>(out)));
-#elif defined(__i386__)
+#if defined(HOST_ARCH_IA32) || defined(HOST_ARCH_X64)

[Ivan Posva, 2016/04/21 23:35:15]

dittoq

[zra, 2016/04/22 19:40:49]

Acknowledged.

   asm volatile(
       "sub %2, %1\n"
       "jo 1f;\n"
       "xor %0, %0\n"
       "mov %1, 0(%3)\n"
       "1: "
       : "+r"(res), "+r"(lhs)
       : "r"(rhs), "r"(out)
       : "cc");
-#elif defined(__arm__)
+#elif defined(HOST_ARCH_ARM)
   asm volatile(
       "subs %1, %1, %2;\n"
       "bvs 1f;\n"
       "mov %0, $0;\n"
       "str %1, [%3, #0]\n"
       "1:"
       : "+r"(res), "+r"(lhs)
       : "r"(rhs), "r"(out)
       : "cc", "r12");
+#elif defined(HOST_ARCH_ARM64)
+  asm volatile(
+      "subs %1, %1, %2;\n"
+      "bvs 1f;\n"
+      "mov %w0, #0;\n"
+      "str %1, [%3, #0]\n"
+      "1:"
+      : "+r"(res), "+r"(lhs)
+      : "r"(rhs), "r"(out)
+      : "cc");
 #else
 #error "Unsupported platform"
 #endif
   return (res != 0);
 }
 
 
-DART_FORCE_INLINE static bool SignedMulWithOverflow(int32_t lhs,
-                                                    int32_t rhs,
+DART_FORCE_INLINE static bool SignedMulWithOverflow(intptr_t lhs,
+                                                    intptr_t rhs,
                                                     intptr_t* out) {
   int32_t res = 1;
-#if defined(HAS_MUL_OVERFLOW)
-  res = static_cast<int32_t>(__builtin_smul_overflow(
-      lhs, rhs, reinterpret_cast<int32_t*>(out)));
-#elif defined(__i386__)
+#if defined(HOST_ARCH_IA32) || defined(HOST_ARCH_X64)

[Ivan Posva, 2016/04/21 23:35:15]

dittoq

[zra, 2016/04/22 19:40:49]

Acknowledged.

   asm volatile(
       "imul %2, %1\n"
       "jo 1f;\n"
       "xor %0, %0\n"
       "mov %1, 0(%3)\n"
       "1: "
       : "+r"(res), "+r"(lhs)
       : "r"(rhs), "r"(out)
       : "cc");
-#elif defined(__arm__)
+#elif defined(HOST_ARCH_ARM)
   asm volatile(
       "smull %1, ip, %1, %2;\n"
       "cmp ip, %1, ASR #31;\n"
       "bne 1f;\n"
       "mov %0, $0;\n"
       "str %1, [%3, #0]\n"
       "1:"
       : "+r"(res), "+r"(lhs)
       : "r"(rhs), "r"(out)
       : "cc", "r12");
+#elif defined(HOST_ARCH_ARM64)
+  int64_t prod_lo;
+  asm volatile(
+      "mul %1, %2, %3\n"
+      "smulh %2, %2, %3\n"
+      "cmp %2, %1, ASR #63;\n"
+      "bne 1f;\n"
+      "mov %w0, #0;\n"
+      "str %1, [%4, #0]\n"
+      "1:"
+      : "+r"(res), "+r"(prod_lo), "+r"(lhs)
+      : "r"(rhs), "r"(out)
+      : "cc");
 #else
 #error "Unsupported platform"
 #endif
   return (res != 0);
 }
 
 
 #define LIKELY(cond) __builtin_expect((cond), 1)
 
 
@@ skipping 1437 matching lines @@
   special_[kExceptionSpecialIndex] = raw_exception;
   special_[kStacktraceSpecialIndex] = raw_stacktrace;
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 
 #endif  // defined TARGET_ARCH_DBC