Adds intrinsics for arm64.

runtime/vm/intrinsifier_arm.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/globals.h"  // Needed here to get TARGET_ARCH_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 12 matching lines @@
 
 
 void Intrinsifier::Array_getLength(Assembler* assembler) {
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ ldr(R0, FieldAddress(R0, Array::length_offset()));
   __ Ret();
 }
 
 
 void Intrinsifier::ImmutableList_getLength(Assembler* assembler) {
-  return Array_getLength(assembler);
+  Array_getLength(assembler);
 }
 
 
 void Intrinsifier::Array_getIndexed(Assembler* assembler) {
   Label fall_through;
 
   __ ldr(R0, Address(SP, + 0 * kWordSize));  // Index
   __ ldr(R1, Address(SP, + 1 * kWordSize));  // Array
 
   __ tst(R0, ShifterOperand(kSmiTagMask));
   __ b(&fall_through, NE);  // Index is not an smi, fall through
 
   // range check
   __ ldr(R6, FieldAddress(R1, Array::length_offset()));
   __ cmp(R0, ShifterOperand(R6));
 
   ASSERT(kSmiTagShift == 1);
   // array element at R1 + R0*2 + Array::data_offset - 1
   __ add(R6, R1, ShifterOperand(R0, LSL, 1), CC);
   __ ldr(R0, FieldAddress(R6, Array::data_offset()), CC);
   __ bx(LR, CC);
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::ImmutableList_getIndexed(Assembler* assembler) {
-  return Array_getIndexed(assembler);
+  Array_getIndexed(assembler);
 }
 
 
 static intptr_t ComputeObjectArrayTypeArgumentsOffset() {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const Class& cls = Class::Handle(
       core_lib.LookupClassAllowPrivate(Symbols::_List()));
   ASSERT(!cls.IsNull());
   ASSERT(cls.NumTypeArguments() == 1);
   const intptr_t field_offset = cls.type_arguments_field_offset();
@@ skipping 235 matching lines @@
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 // Add an element to growable array if it doesn't need to grow, otherwise
 // call into regular code.
 // On stack: growable array (+1), value (+0).
 void Intrinsifier::GrowableList_add(Assembler* assembler) {
   // In checked mode we need to type-check the incoming argument.
-  if (FLAG_enable_type_checks) return;
+  if (FLAG_enable_type_checks) {
+    return;
+  }
   Label fall_through;
   // R0: Array.
   __ ldr(R0, Address(SP, 1 * kWordSize));
   // R1: length.
   __ ldr(R1, FieldAddress(R0, GrowableObjectArray::length_offset()));
   // R2: data.
   __ ldr(R2, FieldAddress(R0, GrowableObjectArray::data_offset()));
   // R3: capacity.
   __ ldr(R3, FieldAddress(R2, Array::length_offset()));
   // Compare length with capacity.
@@ skipping 154 matching lines @@
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);  // Checks two smis.
   __ adds(R0, R0, ShifterOperand(R1));  // Adds.
   __ bx(LR, VC);  // Return if no overflow.
   // Otherwise fall through.
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_add(Assembler* assembler) {
-  return Integer_addFromInteger(assembler);
+  Integer_addFromInteger(assembler);
 }
 
 
 void Intrinsifier::Integer_subFromInteger(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   __ subs(R0, R0, ShifterOperand(R1));  // Subtract.
   __ bx(LR, VC);  // Return if no overflow.
   // Otherwise fall through.
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_sub(Assembler* assembler) {
   Label fall_through;
   TestBothArgumentsSmis(assembler, &fall_through);
   __ subs(R0, R1, ShifterOperand(R0));  // Subtract.
   __ bx(LR, VC);  // Return if no overflow.
   // Otherwise fall through.
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_mulFromInteger(Assembler* assembler) {
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);  // checks two smis
-  __ SmiUntag(R0);  // untags R6. only want result shifted by one
+  __ SmiUntag(R0);  // Untags R6. We only want result shifted by one.
 
   if (TargetCPUFeatures::arm_version() == ARMv7) {
     __ smull(R0, IP, R0, R1);  // IP:R0 <- R0 * R1.
     __ cmp(IP, ShifterOperand(R0, ASR, 31));
     __ bx(LR, EQ);
   } else {
     __ CheckMultSignedOverflow(R0, R1, IP, D0, D1, &fall_through);
     __ mul(R0, R0, R1);
     __ Ret();
   }
 
   __ Bind(&fall_through);  // Fall through on overflow.
 }
 
 
 void Intrinsifier::Integer_mul(Assembler* assembler) {
-  return Integer_mulFromInteger(assembler);
+  Integer_mulFromInteger(assembler);
 }
 
 
 // Optimizations:
 // - result is 0 if:
 //   - left is 0
 //   - left equals right
 // - result is left if
 //   - left > 0 && left < right
 // R1: Tagged left (dividend).
@@ skipping 41 matching lines @@
 //  res = left % right;
 //  if (res < 0) {
 //    if (right < 0) {
 //      res = res - right;
 //    } else {
 //      res = res + right;
 //    }
 //  }
 void Intrinsifier::Integer_moduloFromInteger(Assembler* assembler) {
   // Check to see if we have integer division
-  Label fall_through, subtract;
+  Label fall_through;
   __ ldr(R1, Address(SP, + 0 * kWordSize));
   __ ldr(R0, Address(SP, + 1 * kWordSize));
   __ orr(TMP, R0, ShifterOperand(R1));
   __ tst(TMP, ShifterOperand(kSmiTagMask));
   __ b(&fall_through, NE);
   // R1: Tagged left (dividend).
   // R0: Tagged right (divisor).
   // Check if modulo by zero -> exception thrown in main function.
   __ cmp(R0, ShifterOperand(0));
   __ b(&fall_through, EQ);
@@ skipping 54 matching lines @@
 
   TestBothArgumentsSmis(assembler, &fall_through);  // checks two smis
   __ and_(R0, R0, ShifterOperand(R1));
 
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_bitAnd(Assembler* assembler) {
-  return Integer_bitAndFromInteger(assembler);
+  Integer_bitAndFromInteger(assembler);
 }
 
 
 void Intrinsifier::Integer_bitOrFromInteger(Assembler* assembler) {
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);  // checks two smis
   __ orr(R0, R0, ShifterOperand(R1));
 
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_bitOr(Assembler* assembler) {
-  return Integer_bitOrFromInteger(assembler);
+  Integer_bitOrFromInteger(assembler);
 }
 
 
 void Intrinsifier::Integer_bitXorFromInteger(Assembler* assembler) {
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);  // checks two smis
   __ eor(R0, R0, ShifterOperand(R1));
 
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_bitXor(Assembler* assembler) {
-  return Integer_bitXorFromInteger(assembler);
+  Integer_bitXorFromInteger(assembler);
 }
 
 
 void Intrinsifier::Integer_shl(Assembler* assembler) {
   ASSERT(kSmiTagShift == 1);
   ASSERT(kSmiTag == 0);
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);
   __ CompareImmediate(R0, Smi::RawValue(Smi::kBits));
@@ skipping 118 matching lines @@
   __ cmp(R2, ShifterOperand(R6));  // Compare left lo, right lo.
   __ b(&is_false, lo_false_cond);
   // Else is true.
   __ b(&is_true);
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_greaterThanFromInt(Assembler* assembler) {
-  return CompareIntegers(assembler, LT);
+  CompareIntegers(assembler, LT);
 }
 
 
 void Intrinsifier::Integer_lessThan(Assembler* assembler) {
-  return Integer_greaterThanFromInt(assembler);
+  Integer_greaterThanFromInt(assembler);
 }
 
 
 void Intrinsifier::Integer_greaterThan(Assembler* assembler) {
-  return CompareIntegers(assembler, GT);
+  CompareIntegers(assembler, GT);
 }
 
 
 void Intrinsifier::Integer_lessEqualThan(Assembler* assembler) {
-  return CompareIntegers(assembler, LE);
+  CompareIntegers(assembler, LE);
 }
 
 
 void Intrinsifier::Integer_greaterEqualThan(Assembler* assembler) {
-  return CompareIntegers(assembler, GE);
+  CompareIntegers(assembler, GE);
 }
 
 
 // This is called for Smi, Mint and Bigint receivers. The right argument
 // can be Smi, Mint, Bigint or double.
 void Intrinsifier::Integer_equalToInteger(Assembler* assembler) {
   Label fall_through, true_label, check_for_mint;
   // For integer receiver '===' check first.
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ ldr(R1, Address(SP, 1 * kWordSize));
@@ skipping 37 matching lines @@
   __ b(&fall_through, NE);
   __ LoadObject(R0, Bool::False());
   __ Ret();
   // TODO(srdjan): Implement Mint == Mint comparison.
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_equal(Assembler* assembler) {
-  return Integer_equalToInteger(assembler);
+  Integer_equalToInteger(assembler);
 }
 
 
 void Intrinsifier::Integer_sar(Assembler* assembler) {
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);
   // Shift amount in R0. Value to shift in R1.
 
   // Fall through if shift amount is negative.
@@ skipping 205 matching lines @@
     __ Ret();
   }
 }
 
 
 void Intrinsifier::Double_getIsNegative(Assembler* assembler) {
   if (TargetCPUFeatures::vfp_supported()) {
     Label is_false, is_true, is_zero;
     __ ldr(R0, Address(SP, 0 * kWordSize));
     __ LoadDFromOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
-    __ LoadDImmediate(D1, 0.0, R1);
-    __ vcmpd(D0, D1);
+    __ vcmpdz(D0);
     __ vmstat();
     __ b(&is_false, VS);  // NaN -> false.
     __ b(&is_zero, EQ);  // Check for negative zero.
     __ b(&is_false, CS);  // >= 0 -> false.
 
     __ Bind(&is_true);
     __ LoadObject(R0, Bool::True());
     __ Ret();
 
     __ Bind(&is_false);
@@ skipping 503 matching lines @@
   Isolate* isolate = Isolate::Current();
   __ LoadImmediate(R1, reinterpret_cast<uword>(isolate));
   // Set return value to Isolate::current_tag_.
   __ ldr(R0, Address(R1, Isolate::current_tag_offset()));
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM