Adds arm64 double arithmetic instructions.

runtime/vm/intermediate_language_arm64.cc

 // Copyright (c) 2014, 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_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 143 matching lines @@
     if (true_value == 0) {
       // Swap values so that false_value is zero.
       intptr_t temp = true_value;
       true_value = false_value;
       false_value = temp;
     } else {
       true_condition = NegateCondition(true_condition);
     }
   }
 
-  // TODO(zra): replace with cinc(result, ZR, ZR, true_condition)
-  __ LoadImmediate(TMP, 1, kNoPP);
-  __ csel(result, TMP, ZR, true_condition);
+  __ cset(result, true_condition);
 
   if (is_power_of_two_kind) {
     const intptr_t shift =
         Utils::ShiftForPowerOfTwo(Utils::Maximum(true_value, false_value));
     __ Lsl(result, result, shift + kSmiTagSize);
   } else {
     __ sub(result, result, Operand(1));
     const int32_t val =
         Smi::RawValue(true_value) - Smi::RawValue(false_value);
     __ AndImmediate(result, result, val, PP);
@@ skipping 100 matching lines @@
 
 LocationSummary* UnboxedConstantInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 0;
   return LocationSummary::Make(kNumInputs,
                                Location::RequiresFpuRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void UnboxedConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  if (!locs()->out(0).IsInvalid()) {
+    const VRegister dst = locs()->out(0).fpu_reg();
+    __ LoadDImmediate(dst, Double::Cast(value()).value(), PP);
+  }
 }
 
 
 LocationSummary* AssertAssignableInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(R0));  // Value.
   summary->set_in(1, Location::RegisterLocation(R2));  // Instantiator.
@@ skipping 146 matching lines @@
                         ? Location::RequiresRegister()
                         : Location::RegisterOrConstant(right()));
     locs->set_out(0, Location::RequiresRegister());
     return locs;
   }
   UNREACHABLE();
   return NULL;
 }
 
 
+static Condition TokenKindToDoubleCondition(Token::Kind kind) {
+  switch (kind) {
+    case Token::kEQ: return EQ;
+    case Token::kNE: return NE;
+    case Token::kLT: return LT;
+    case Token::kGT: return GT;
+    case Token::kLTE: return LE;
+    case Token::kGTE: return GE;
+    default:
+      UNREACHABLE();
+      return VS;
+  }
+}
+
+
+static Condition EmitDoubleComparisonOp(FlowGraphCompiler* compiler,
+                                        LocationSummary* locs,
+                                        Token::Kind kind) {
+  VRegister left = locs->in(0).fpu_reg();
+  VRegister right = locs->in(1).fpu_reg();
+  __ fcmpd(left, right);
+  Condition true_condition = TokenKindToDoubleCondition(kind);
+  return true_condition;
+}
+
+
 Condition EqualityCompareInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                                    BranchLabels labels) {
   if (operation_cid() == kSmiCid) {
     return EmitSmiComparisonOp(compiler, locs(), kind());
   } else {
-    UNIMPLEMENTED();
-    return VS;
+    ASSERT(operation_cid() == kDoubleCid);
+    return EmitDoubleComparisonOp(compiler, locs(), kind());
   }
 }
 
 
 void EqualityCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT((kind() == Token::kEQ) || (kind() == Token::kNE));
 
   Label is_true, is_false;
   BranchLabels labels = { &is_true, &is_false, &is_false };
   Condition true_condition = EmitComparisonCode(compiler, labels);
@@ skipping 552 matching lines @@
     case kTwoByteStringCid:
       __ ldr(result, element_address, kUnsignedHalfword);
       __ SmiTag(result);
       break;
     case kTypedDataInt32ArrayCid:
       __ ldr(result, element_address, kWord);
       __ SmiTag(result);
       break;
     case kTypedDataUint32ArrayCid:
       __ ldr(result, element_address, kUnsignedWord);
+      __ SmiTag(result);
       break;
     default:
       ASSERT((class_id() == kArrayCid) || (class_id() == kImmutableArrayCid));
       __ ldr(result, element_address);
       break;
   }
 }
 
 
 Representation StoreIndexedInstr::RequiredInputRepresentation(
@@ skipping 207 matching lines @@
       }
       break;
     }
     case kTypedDataFloat32ArrayCid:
       // TODO(zra): Implement when we add float store.
       UNIMPLEMENTED();
       break;
     case kTypedDataFloat64ArrayCid: {
       VRegister in2 = locs()->in(2).fpu_reg();
       __ add(index.reg(), index.reg(), Operand(array));
-      __ StoreDFieldToOffset(in2, index.reg(), 0);
+      __ StoreDToOffset(in2, index.reg(), 0);
       break;
     }
     case kTypedDataFloat64x2ArrayCid:
     case kTypedDataInt32x4ArrayCid:
     case kTypedDataFloat32x4ArrayCid: {
       // TODO(zra): Implement when we add simd loads and stores.
       UNIMPLEMENTED();
       break;
     }
     default:
@@ skipping 1512 matching lines @@
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 LocationSummary* CheckEitherNonSmiInstr::MakeLocationSummary(bool opt) const {
-  UNIMPLEMENTED();
-  return NULL;
+  intptr_t left_cid = left()->Type()->ToCid();
+  intptr_t right_cid = right()->Type()->ToCid();
+  ASSERT((left_cid != kDoubleCid) && (right_cid != kDoubleCid));
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary =
+    new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_in(1, Location::RequiresRegister());
+  return summary;
 }
 
 
 void CheckEitherNonSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  Label* deopt = compiler->AddDeoptStub(deopt_id(),
+                                        ICData::kDeoptBinaryDoubleOp);
+  intptr_t left_cid = left()->Type()->ToCid();
+  intptr_t right_cid = right()->Type()->ToCid();
+  Register left = locs()->in(0).reg();
+  Register right = locs()->in(1).reg();
+  if (left_cid == kSmiCid) {
+    __ tsti(right, kSmiTagMask);
+  } else if (right_cid == kSmiCid) {
+    __ tsti(left, kSmiTagMask);
+  } else {
+    __ orr(TMP, left, Operand(right));
+    __ tsti(TMP, kSmiTagMask);
+  }
+  __ b(deopt, EQ);
 }
 
 
 LocationSummary* BoxDoubleInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs,
                           kNumTemps,
                           LocationSummary::kCallOnSlowPath);
@@ skipping 15 matching lines @@
                  slow_path->entry_label(),
                  out_reg,
                  locs()->temp(0).reg(),
                  PP);
   __ Bind(slow_path->exit_label());
   __ StoreDFieldToOffset(value, out_reg, Double::value_offset());
 }
 
 
 LocationSummary* UnboxDoubleInstr::MakeLocationSummary(bool opt) const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_out(0, Location::RequiresFpuRegister());
+  return summary;
 }
 
 
 void UnboxDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  CompileType* value_type = value()->Type();
+  const intptr_t value_cid = value_type->ToCid();
+  const Register value = locs()->in(0).reg();
+  const VRegister result = locs()->out(0).fpu_reg();
+
+  if (value_cid == kDoubleCid) {
+    __ LoadDFieldFromOffset(result, value, Double::value_offset());
+  } else if (value_cid == kSmiCid) {
+    __ Asr(TMP, value, kSmiTagSize);  // Untag input before conversion.
+    __ scvtfd(result, TMP);
+  } else {
+    Label* deopt = compiler->AddDeoptStub(deopt_id_,
+                                          ICData::kDeoptBinaryDoubleOp);
+    if (value_type->is_nullable() &&
+        (value_type->ToNullableCid() == kDoubleCid)) {
+      __ CompareObject(value, Object::null_object(), PP);
+      __ b(deopt, EQ);
+      // It must be double now.
+      __ LoadDFieldFromOffset(result, value, Double::value_offset());
+    } else {
+      Label is_smi, done;
+      __ tsti(value, kSmiTagMask);
+      __ b(&is_smi, EQ);
+      __ CompareClassId(value, kDoubleCid);
+      __ b(deopt, NE);
+      __ LoadDFieldFromOffset(result, value, Double::value_offset());
+      __ b(&done);
+      __ Bind(&is_smi);
+      __ Asr(TMP, value, kSmiTagSize);  // Copy and untag.
+      __ scvtfd(result, TMP);
+      __ Bind(&done);
+    }
+  }
 }
 
 
 LocationSummary* BoxFloat32x4Instr::MakeLocationSummary(bool opt) const {
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 void BoxFloat32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 50 matching lines @@
   return NULL;
 }
 
 
 void UnboxInt32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* BinaryDoubleOpInstr::MakeLocationSummary(bool opt) const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresFpuRegister());
+  summary->set_in(1, Location::RequiresFpuRegister());
+  summary->set_out(0, Location::RequiresFpuRegister());
+  return summary;
 }
 
 
 void BinaryDoubleOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  const VRegister left = locs()->in(0).fpu_reg();
+  const VRegister right = locs()->in(1).fpu_reg();
+  const VRegister result = locs()->out(0).fpu_reg();
+  switch (op_kind()) {
+    case Token::kADD: __ faddd(result, left, right); break;
+    case Token::kSUB: __ fsubd(result, left, right); break;
+    case Token::kMUL: __ fmuld(result, left, right); break;
+    case Token::kDIV: __ fdivd(result, left, right); break;
+    default: UNREACHABLE();
+  }
 }
 
 
 LocationSummary* BinaryFloat32x4OpInstr::MakeLocationSummary(bool opt) const {
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 void BinaryFloat32x4OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 972 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64