Adds intrinsics for arm64.

runtime/vm/intrinsifier_mips.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_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 11 matching lines @@
 
 
 void Intrinsifier::Array_getLength(Assembler* assembler) {
   __ lw(V0, Address(SP, 0 * kWordSize));
   __ Ret();
   __ delay_slot()->lw(V0, FieldAddress(V0, Array::length_offset()));
 }
 
 
 void Intrinsifier::ImmutableList_getLength(Assembler* assembler) {
-  return Array_getLength(assembler);
+  Array_getLength(assembler);
 }
 
 
 void Intrinsifier::Array_getIndexed(Assembler* assembler) {
   Label fall_through;
 
   __ lw(T0, Address(SP, + 0 * kWordSize));  // Index
 
   __ andi(CMPRES1, T0, Immediate(kSmiTagMask));
   __ bne(CMPRES1, ZR, &fall_through);  // Index is not an smi, fall through
   __ delay_slot()->lw(T1, Address(SP, + 1 * kWordSize));  // Array
 
   // range check
   __ lw(T2, FieldAddress(T1, Array::length_offset()));
   __ BranchUnsignedGreaterEqual(T0, T2, &fall_through);
 
   ASSERT(kSmiTagShift == 1);
   // array element at T1 + T0*2 + Array::data_offset - 1
   __ sll(T2, T0, 1);
   __ addu(T2, T1, T2);
   __ Ret();
   __ delay_slot()->lw(V0, FieldAddress(T2, Array::data_offset()));
   __ 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 413 matching lines @@
 
   TestBothArgumentsSmis(assembler, &fall_through);  // Checks two Smis.
   __ AdduDetectOverflow(V0, T0, T1, CMPRES1);  // Add.
   __ bltz(CMPRES1, &fall_through);  // Fall through on overflow.
   __ Ret();  // Nothing in branch delay slot.
   __ 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);
   __ SubuDetectOverflow(V0, T0, T1, CMPRES1);  // Subtract.
   __ bltz(CMPRES1, &fall_through);  // Fall through on overflow.
   __ Ret();
@@ skipping 22 matching lines @@
   __ mflo(V0);  // V0 <- LO.
   __ mfhi(T2);  // T2 <- HI.
   __ sra(T3, V0, 31);  // T3 <- V0 >> 31.
   __ bne(T2, T3, &fall_through);  // Fall through on overflow.
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 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
 // T1: Tagged left (dividend).
@@ skipping 108 matching lines @@
   Label fall_through;
 
   TestBothArgumentsSmis(assembler, &fall_through);  // Checks two smis.
   __ Ret();
   __ delay_slot()->and_(V0, T0, T1);
   __ 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.
   __ Ret();
   __ delay_slot()->or_(V0, T0, T1);
   __ 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.
   __ Ret();
   __ delay_slot()->xor_(V0, T0, T1);
   __ 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, overflow;
 
   TestBothArgumentsSmis(assembler, &fall_through);
   __ BranchUnsignedGreater(T0, Smi::RawValue(Smi::kBits), &fall_through);
@@ skipping 133 matching lines @@
       break;
   }
   // 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.
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(T1, Address(SP, 1 * kWordSize));
@@ skipping 37 matching lines @@
   __ bne(CMPRES1, ZR, &fall_through);
   __ LoadObject(V0, 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 T0. Value to shift in T1.
 
   __ SmiUntag(T0);
@@ skipping 87 matching lines @@
   __ SmiUntag(T0);
   __ mtc1(T0, STMP1);
   __ cvtdw(D1, STMP1);
   __ b(&double_op);
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Double_greaterThan(Assembler* assembler) {
-  return CompareDoubles(assembler, GT);
+  CompareDoubles(assembler, GT);
 }
 
 
 void Intrinsifier::Double_greaterEqualThan(Assembler* assembler) {
-  return CompareDoubles(assembler, GE);
+  CompareDoubles(assembler, GE);
 }
 
 
 void Intrinsifier::Double_lessThan(Assembler* assembler) {
-  return CompareDoubles(assembler, LT);
+  CompareDoubles(assembler, LT);
 }
 
 
 void Intrinsifier::Double_equal(Assembler* assembler) {
-  return CompareDoubles(assembler, EQ);
+  CompareDoubles(assembler, EQ);
 }
 
 
 void Intrinsifier::Double_lessEqualThan(Assembler* assembler) {
-  return CompareDoubles(assembler, LE);
+  CompareDoubles(assembler, LE);
 }
 
 
 // Expects left argument to be double (receiver). Right argument is unknown.
 // Both arguments are on stack.
 static void DoubleArithmeticOperations(Assembler* assembler, Token::Kind kind) {
   Label fall_through;
 
   TestLastArgumentIsDouble(assembler, &fall_through, &fall_through);
   // Both arguments are double, right operand is in T0.
@@ skipping 14 matching lines @@
   __ TryAllocate(double_class, &fall_through, V0, T1);  // Result register.
   __ swc1(F0, FieldAddress(V0, Double::value_offset()));
   __ Ret();
   __ delay_slot()->swc1(F1,
                         FieldAddress(V0, Double::value_offset() + kWordSize));
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Double_add(Assembler* assembler) {
-  return DoubleArithmeticOperations(assembler, Token::kADD);
+  DoubleArithmeticOperations(assembler, Token::kADD);
 }
 
 
 void Intrinsifier::Double_mul(Assembler* assembler) {
-  return DoubleArithmeticOperations(assembler, Token::kMUL);
+  DoubleArithmeticOperations(assembler, Token::kMUL);
 }
 
 
 void Intrinsifier::Double_sub(Assembler* assembler) {
-  return DoubleArithmeticOperations(assembler, Token::kSUB);
+  DoubleArithmeticOperations(assembler, Token::kSUB);
 }
 
 
 void Intrinsifier::Double_div(Assembler* assembler) {
-  return DoubleArithmeticOperations(assembler, Token::kDIV);
+  DoubleArithmeticOperations(assembler, Token::kDIV);
 }
 
 
 // Left is double right is integer (Bigint, Mint or Smi)
 void Intrinsifier::Double_mulFromInteger(Assembler* assembler) {
   Label fall_through;
   // Only smis allowed.
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ andi(CMPRES1, T0, Immediate(kSmiTagMask));
   __ bne(CMPRES1, ZR, &fall_through);
@@ skipping 584 matching lines @@
   Isolate* isolate = Isolate::Current();
   __ LoadImmediate(V0, reinterpret_cast<uword>(isolate));
   // Set return value.
   __ Ret();
   __ delay_slot()->lw(V0, Address(V0, Isolate::current_tag_offset()));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS