DBC: More Load/Store Indexed variants, A few more math instructions.

runtime/vm/intermediate_language_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 "vm/globals.h"  // Needed here to get TARGET_ARCH_DBC.
 #if defined(TARGET_ARCH_DBC)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/cpu.h"
@@ skipping 22 matching lines @@
   M(LoadCodeUnits)                                                             \
   M(LoadUntagged)                                                              \
   M(AllocateUninitializedContext)                                              \
   M(BinaryInt32Op)                                                             \
   M(Int32ToDouble)                                                             \
   M(DoubleToInteger)                                                           \
   M(DoubleToDouble)                                                            \
   M(DoubleToFloat)                                                             \
   M(FloatToDouble)                                                             \
   M(BoxInt64)                                                                  \
-  M(InvokeMathCFunction)                                                       \
   M(MergedMath)                                                                \
   M(GuardFieldClass)                                                           \
   M(GuardFieldLength)                                                          \
   M(IfThenElse)                                                                \
   M(ExtractNthOutput)                                                          \
   M(BinaryUint32Op)                                                            \
   M(ShiftUint32Op)                                                             \
   M(UnaryUint32Op)                                                             \
   M(UnboxedIntConverter)                                                       \
   M(BoxInteger32)                                                              \
@@ skipping 46 matching lines @@
   M(Float64x2ZeroArg)                                                          \
   M(Float64x2OneArg)                                                           \
   M(CheckedSmiOp)                                                              \
 
 // Location summaries actually are not used by the unoptimizing DBC compiler
 // because we don't allocate any registers.
 static LocationSummary* CreateLocationSummary(
     Zone* zone,
     intptr_t num_inputs,
     Location output = Location::NoLocation(),
-    LocationSummary::ContainsCall contains_call = LocationSummary::kNoCall) {
-  const intptr_t kNumTemps = 0;
+    LocationSummary::ContainsCall contains_call = LocationSummary::kNoCall,
+    intptr_t num_temps = 0) {
   LocationSummary* locs = new(zone) LocationSummary(
-      zone, num_inputs, kNumTemps, contains_call);
+      zone, num_inputs, num_temps, contains_call);
   for (intptr_t i = 0; i < num_inputs; i++) {
     locs->set_in(i, (contains_call == LocationSummary::kNoCall) ?
         Location::RequiresRegister() : Location::RegisterLocation(i));
   }
+  for (intptr_t i = 0; i < num_temps; i++) {
+    locs->set_temp(i, Location::RequiresRegister());
+  }
   if (!output.IsInvalid()) {
     // For instructions that call we default to returning result in R0.
     locs->set_out(0, output);
   }
   return locs;
 }
 
 
 #define DEFINE_MAKE_LOCATION_SUMMARY(Name, ...)                                \
   LocationSummary* Name##Instr::MakeLocationSummary(Zone* zone, bool opt)      \
@@ skipping 538 matching lines @@
     __ Push(locs()->in(1).reg());
   }
   __ CreateArrayTOS();
   compiler->RecordSafepoint(locs());
   if (compiler->is_optimizing()) {
     __ PopLocal(locs()->out(0).reg());
   }
 }
 
 
-EMIT_NATIVE_CODE(StoreIndexed, 3) {
+EMIT_NATIVE_CODE(StoreIndexed, 3, Location::NoLocation(),
+    LocationSummary::kNoCall, 1) {
   if (compiler->is_optimizing()) {
-    if (class_id() != kArrayCid) {
+    if (IsExternal()) {
       Unsupported(compiler);
       UNREACHABLE();
     }
-    __ StoreIndexed(locs()->in(kArrayPos).reg(),
-                    locs()->in(kIndexPos).reg(),
-                    locs()->in(kValuePos).reg());
+    const Register array = locs()->in(kArrayPos).reg();
+    const Register index = locs()->in(kIndexPos).reg();
+    const Register value = locs()->in(kValuePos).reg();
+    const Register temp = locs()->temp(0).reg();
+    switch (class_id()) {
+      case kArrayCid:
+        __ StoreIndexed(array, index, value);
+        break;
+      case kTypedDataFloat64ArrayCid:
+        if ((index_scale() != 8) && (index_scale() != 1)) {
+          Unsupported(compiler);
+          UNREACHABLE();
+        }
+        if (index_scale() == 1) {
+          __ LoadConstant(temp, Smi::Handle(Smi::New(3)));
+          __ Shr(temp, index, temp);
+          __ Nop(0);
+        } else {
+          __ Move(temp, index);
+        }
+        __ StoreFloat64Indexed(array, temp, value);
+        break;
+      default:
+        Unsupported(compiler);
+        UNREACHABLE();
+        break;
+    }
   } else {
     ASSERT(class_id() == kArrayCid);
     __ StoreIndexedTOS();
   }
 }
 
 
 EMIT_NATIVE_CODE(LoadIndexed, 2, Location::RequiresRegister()) {
   ASSERT(compiler->is_optimizing());
-  if (class_id() != kArrayCid) {
+  if (IsExternal()) {
     Unsupported(compiler);
     UNREACHABLE();
   }
   const Register array = locs()->in(0).reg();
   const Register index = locs()->in(1).reg();
   const Register result = locs()->out(0).reg();
-
-  __ LoadIndexed(result, array, index);
+  switch (class_id()) {
+    case kArrayCid:
+      __ LoadIndexed(result, array, index);
+      break;
+    case kTypedDataFloat64ArrayCid:
+      if ((index_scale() != 8) && (index_scale() != 1)) {
+        Unsupported(compiler);
+        UNREACHABLE();
+      }
+      if (index_scale() == 1) {
+        __ LoadConstant(result, Smi::Handle(Smi::New(3)));

[Florian Schneider, 2016/07/25 20:10:40]

Since LoadIndexed operations are very common, I think these 3 instructions
should be combined into one new bytecode. i.e. ShrImm which takes a small
immediate, and does not deoptimize.

[zra, 2016/07/25 20:39:30]

Done.

+        __ Shr(index, index, result);
+        __ Nop(0);
+      }
+      __ LoadFloat64Indexed(result, array, index);
+      break;
+    case kOneByteStringCid:
+      ASSERT(index_scale() == 1);
+      __ LoadOneByteStringIndexed(result, array, index);
+      break;
+    case kTwoByteStringCid:
+      if (index_scale() != 2) {
+        // TODO(zra): Fix-up index.
+        Unsupported(compiler);
+        UNREACHABLE();
+      }
+      __ LoadTwoByteStringIndexed(result, array, index);
+      break;
+    default:
+      Unsupported(compiler);
+      UNREACHABLE();
+      break;
+  }
 }
 
 
 EMIT_NATIVE_CODE(StringInterpolate,
                  1, Location::RegisterLocation(0),
                  LocationSummary::kCall) {
   if (compiler->is_optimizing()) {
     __ Push(locs()->in(0).reg());
   }
   const intptr_t kArgumentCount = 1;
@@ skipping 599 matching lines @@
 
 
 EMIT_NATIVE_CODE(UnaryDoubleOp, 1, Location::RequiresRegister()) {
   const Register value = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   __ DNeg(result, value);
 }
 
 
 EMIT_NATIVE_CODE(MathUnary, 1, Location::RequiresRegister()) {
+  const Register value = locs()->in(0).reg();
+  const Register result = locs()->out(0).reg();
   if (kind() == MathUnaryInstr::kSqrt) {
-    const Register value = locs()->in(0).reg();
-    const Register result = locs()->out(0).reg();
     __ DSqrt(result, value);
   } else if (kind() == MathUnaryInstr::kDoubleSquare) {
-    const Register value = locs()->in(0).reg();
-    const Register result = locs()->out(0).reg();
     __ DMul(result, value, value);
+  } else if (kind() == MathUnaryInstr::kSin) {
+    __ DSin(result, value);
+  } else if (kind() == MathUnaryInstr::kCos) {
+    __ DCos(result, value);
   } else {
     Unsupported(compiler);
     UNREACHABLE();
+  }
+}
+
+
+EMIT_NATIVE_CODE(InvokeMathCFunction,
+                 InputCount(), Location::RequiresRegister()) {
+  const Register left = locs()->in(0).reg();
+  const Register result = locs()->out(0).reg();
+  if (recognized_kind() == MethodRecognizer::kMathDoublePow) {
+    const Register right = locs()->in(1).reg();
+    __ DPow(result, left, right);
+  } else if (recognized_kind() == MethodRecognizer::kDoubleMod) {
+    const Register right = locs()->in(1).reg();
+    __ DMod(result, left, right);
+  } else {
+    Unsupported(compiler);
+    UNREACHABLE();
   }
 }
 
 
 EMIT_NATIVE_CODE(MathMinMax, 2, Location::RequiresRegister()) {
   ASSERT((op_kind() == MethodRecognizer::kMathMin) ||
          (op_kind() == MethodRecognizer::kMathMax));
   const Register left = locs()->in(0).reg();
   const Register right = locs()->in(1).reg();
   const Register result = locs()->out(0).reg();
@@ skipping 182 matching lines @@
   __ IfULe(length, index);
   compiler->EmitDeopt(deopt_id(),
                       ICData::kDeoptCheckArrayBound,
                       (generalized_ ? ICData::kGeneralized : 0) |
                       (licm_hoisted_ ? ICData::kHoisted : 0));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC