Add unboxed Mint for X64

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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 "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 45 matching lines @@
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
 
 static bool CanUnboxDouble() {
   return FlowGraphCompiler::SupportsUnboxedDoubles();
 }
 
 
+static bool ShouldInlineInt64ArrayOps() {
+#if defined(TARGET_ARCH_X64)
+  return true;
+#endif
+  return false;
+}
+
 static bool CanConvertUnboxedMintToDouble() {
 #if defined(TARGET_ARCH_IA32)
   return true;
 #else
   // ARM does not have a short instruction sequence for converting int64 to
   // double.
   // TODO(johnmccutchan): Investigate possibility on MIPS once
   // mints are implemented there.
   return false;
 #endif
@@ skipping 1090 matching lines @@
       return kTypedDataUint16ArrayCid;
 
     case MethodRecognizer::kInt32ArrayGetIndexed:
     case MethodRecognizer::kInt32ArraySetIndexed:
       return kTypedDataInt32ArrayCid;
 
     case MethodRecognizer::kUint32ArrayGetIndexed:
     case MethodRecognizer::kUint32ArraySetIndexed:
       return kTypedDataUint32ArrayCid;
 
+    case MethodRecognizer::kInt64ArrayGetIndexed:
+    case MethodRecognizer::kInt64ArraySetIndexed:
+      return kTypedDataInt64ArrayCid;
+
     case MethodRecognizer::kFloat32x4ArrayGetIndexed:
     case MethodRecognizer::kFloat32x4ArraySetIndexed:
       return kTypedDataFloat32x4ArrayCid;
 
     case MethodRecognizer::kInt32x4ArrayGetIndexed:
     case MethodRecognizer::kInt32x4ArraySetIndexed:
       return kTypedDataInt32x4ArrayCid;
 
     case MethodRecognizer::kFloat64x2ArrayGetIndexed:
     case MethodRecognizer::kFloat64x2ArraySetIndexed:
@@ skipping 104 matching lines @@
       }
       case kTypedDataInt8ArrayCid:
       case kTypedDataUint8ArrayCid:
       case kTypedDataUint8ClampedArrayCid:
       case kExternalTypedDataUint8ArrayCid:
       case kExternalTypedDataUint8ClampedArrayCid:
       case kTypedDataInt16ArrayCid:
       case kTypedDataUint16ArrayCid:
       case kTypedDataInt32ArrayCid:
       case kTypedDataUint32ArrayCid:
+      case kTypedDataInt64ArrayCid:
         ASSERT(value_type.IsIntType());
         // Fall through.
       case kTypedDataFloat32ArrayCid:
       case kTypedDataFloat64ArrayCid: {
         type_args = instantiator = flow_graph_->constant_null();
         ASSERT((array_cid != kTypedDataFloat32ArrayCid &&
                 array_cid != kTypedDataFloat64ArrayCid) ||
                value_type.IsDoubleType());
         ASSERT(value_type.IsInstantiated());
         break;
@@ skipping 135 matching lines @@
     case MethodRecognizer::kFloat64x2ArrayGetIndexed:
       if (!ShouldInlineSimd()) {
         return false;
       }
       return InlineGetIndexed(kind, call, receiver, ic_data, entry, last);
     case MethodRecognizer::kInt32ArrayGetIndexed:
     case MethodRecognizer::kUint32ArrayGetIndexed:
       if (!CanUnboxInt32()) return false;
       return InlineGetIndexed(kind, call, receiver, ic_data, entry, last);
 
+    case MethodRecognizer::kInt64ArrayGetIndexed:
+      if (!ShouldInlineInt64ArrayOps()) {
+        return false;
+      }
+      return InlineGetIndexed(kind, call, receiver, ic_data, entry, last);
     // Recognized []= operators.
     case MethodRecognizer::kObjectArraySetIndexed:
     case MethodRecognizer::kGrowableArraySetIndexed:
       if (ArgIsAlways(kSmiCid, ic_data, 2)) {
         value_check = ic_data.AsUnaryClassChecksForArgNr(2);
       }
       return InlineSetIndexed(kind, target, call, receiver, token_pos,
                               &ic_data, value_check, entry, last);
     case MethodRecognizer::kInt8ArraySetIndexed:
     case MethodRecognizer::kUint8ArraySetIndexed:
@@ skipping 11 matching lines @@
     case MethodRecognizer::kInt32ArraySetIndexed:
     case MethodRecognizer::kUint32ArraySetIndexed:
       // Check that value is always smi or mint. We use Int32/Uint32 unboxing
       // which can only deal unbox these values.
       value_check = ic_data.AsUnaryClassChecksForArgNr(2);
       if (!HasOnlySmiOrMint(value_check)) {
         return false;
       }
       return InlineSetIndexed(kind, target, call, receiver, token_pos,
                               &ic_data, value_check, entry, last);
+    case MethodRecognizer::kInt64ArraySetIndexed:
+      if (!ShouldInlineInt64ArrayOps()) {
+        return false;
+      }
+      return InlineSetIndexed(kind, target, call, receiver, token_pos,
+                              &ic_data, value_check, entry, last);
     case MethodRecognizer::kFloat32ArraySetIndexed:
     case MethodRecognizer::kFloat64ArraySetIndexed:
       if (!CanUnboxDouble()) {
         return false;
       }
       // Check that value is always double.
       if (!ArgIsAlways(kDoubleCid, ic_data, 2)) {
         return false;
       }
       value_check = ic_data.AsUnaryClassChecksForArgNr(2);
@@ skipping 8624 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart