Implement some intrinsics on x64, fix a bug in ia32 intrinciscs (must return false if there is a fa…

runtime/vm/intrinsifier_x64.cc

 // Copyright (c) 2012, 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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intrinsifier.h"
 
+#include "vm/assembler.h"
+#include "vm/instructions.h"
+
 namespace dart {
+
+DECLARE_FLAG(bool, enable_type_checks);
+
+// When entering intrinsics code:
+// RBX: IC Data
+// R10: Arguments descriptor
+// TOS: Return address
+
+#define __ assembler->
+
 bool Intrinsifier::ObjectArray_Allocate(Assembler* assembler) {
   return false;
 }
 
 
 bool Intrinsifier::Array_getLength(Assembler* assembler) {
-  return false;
+  __ movq(RAX, Address(RSP, + 1 * kWordSize));
+  __ movq(RAX, FieldAddress(RAX, Array::length_offset()));
+  __ ret();
+  return true;
 }
 
 
 bool Intrinsifier::ImmutableArray_getLength(Assembler* assembler) {
-  return false;
+  return Array_getLength(assembler);
 }
 
 
 bool Intrinsifier::Array_getIndexed(Assembler* assembler) {
   return false;
 }
 
 
 bool Intrinsifier::ImmutableArray_getIndexed(Assembler* assembler) {
-  return false;
+  return Array_getIndexed(assembler);
 }
 
 
 bool Intrinsifier::Array_setIndexed(Assembler* assembler) {
   return false;
 }
 
 
 bool Intrinsifier::GArray_Allocate(Assembler* assembler) {

[regis, 2012/05/24 15:47:32]

GrowableArray_Allocate?
By looking at the header, I see why this is not a typo :-)
I could live with a broken up line in the header.

[srdjan, 2012/05/24 15:51:04]

For another CL. (renaming intrinsics touches several additional files).

   return false;
 }
 
 
+// Get length of growable object array.
+// On stack: growable array (+1), return-address (+0).
 bool Intrinsifier::GrowableArray_getLength(Assembler* assembler) {
-  return false;
+  __ movq(RAX, Address(RSP, + 1 * kWordSize));
+  __ movq(RAX, FieldAddress(RAX, GrowableObjectArray::length_offset()));
+  __ ret();
+  return true;
 }
 
 
 bool Intrinsifier::GrowableArray_getCapacity(Assembler* assembler) {
-  return false;
+  __ movq(RAX, Address(RSP, + 1 * kWordSize));
+  __ movq(RAX, FieldAddress(RAX, GrowableObjectArray::data_offset()));
+  __ movq(RAX, FieldAddress(RAX, Array::length_offset()));
+  __ ret();
+  return true;
 }
 
 
 bool Intrinsifier::GrowableArray_getIndexed(Assembler* assembler) {
   return false;
 }
 
 
 bool Intrinsifier::GrowableArray_setIndexed(Assembler* assembler) {
   return false;
 }
 
 
 bool Intrinsifier::GrowableArray_setLength(Assembler* assembler) {
   return false;
 }
 
 
+// Set data of growable object array.
+// On stack: growable array (+2), data (+1), return-address (+0).
 bool Intrinsifier::GrowableArray_setData(Assembler* assembler) {
-  return false;
+  if (FLAG_enable_type_checks) {
+    return false;
+  }
+  __ movq(RAX, Address(RSP, + 2 * kWordSize));
+  __ movq(RBX, Address(RSP, + 1 * kWordSize));
+  __ movq(FieldAddress(RAX, GrowableObjectArray::data_offset()), RBX);
+  __ ret();
+  return true;
 }
 
 
 bool Intrinsifier::Integer_addFromInteger(Assembler* assembler) {
   return false;
 }
 
 
 bool Intrinsifier::Integer_add(Assembler* assembler) {
   return false;
@@ skipping 135 matching lines @@
   return false;
 }
 
 
 bool Intrinsifier::Double_lessEqualThan(Assembler* assembler) {
   return false;
 }
 
 
 bool Intrinsifier::Double_toDouble(Assembler* assembler) {
-  return false;
+  __ movq(RAX, Address(RSP, + 1 * kWordSize));
+  __ ret();
+  // Generate enough code to satisfy patchability constraint.
+  intptr_t offset = __ CodeSize();
+  __ nop(JumpPattern::InstructionLength() - offset);

[regis, 2012/05/24 15:47:32]

Do we check for minimum code size when finalizing the code? That would be good.

[srdjan, 2012/05/24 15:51:04]

Yes, we do (was hitting an assert here).

+  return true;
 }
 
 bool Intrinsifier::Double_add(Assembler* assembler) {
   return false;
 }
 
 
 bool Intrinsifier::Double_mul(Assembler* assembler) {
   return false;
 }
@@ skipping 13 matching lines @@
   return false;
 }
 
 
 bool Intrinsifier::Double_fromInteger(Assembler* assembler) {
   return false;
 }
 
 
 bool Intrinsifier::Double_isNaN(Assembler* assembler) {
-  return false;
+  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
+  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
+  Label is_true;
+  __ movq(RAX, Address(RSP, +1 * kWordSize));
+  __ movsd(XMM0, FieldAddress(RAX, Double::value_offset()));
+  __ comisd(XMM0, XMM0);
+  __ j(PARITY_EVEN, &is_true, Assembler::kNearJump);  // NaN -> true;
+  __ LoadObject(RAX, bool_false);
+  __ ret();
+  __ Bind(&is_true);
+  __ LoadObject(RAX, bool_true);
+  __ ret();
+  return true;  // Method is complete, no slow case.
 }
 
 
 bool Intrinsifier::Double_isNegative(Assembler* assembler) {
   return false;
 }
 
 
 bool Intrinsifier::Math_sqrt(Assembler* assembler) {
   return false;
@@ skipping 37 matching lines @@
 
 bool Intrinsifier::String_hashCode(Assembler* assembler) {
   return false;
 }
 
 
 bool Intrinsifier::String_isEmpty(Assembler* assembler) {
   return false;
 }
 
+#undef __
+
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64