Intrinsic version of Object.runtimeType

runtime/vm/intrinsifier_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 1506 matching lines @@
   __ cmpq(RAX, Address(RSP, + kReceiverOffset * kWordSize));
   __ j(EQUAL, &is_true, Assembler::kNearJump);
   __ LoadObject(RAX, Bool::False(), PP);
   __ ret();
   __ Bind(&is_true);
   __ LoadObject(RAX, Bool::True(), PP);
   __ ret();
 }
 
 
+// Return type quickly for simple types (not parametrized and not signature)

[regis, 2015/06/30 23:28:32]

ditto

[srdjan, 2015/07/01 00:35:41]

ditto

+void Intrinsifier::ObjectRuntimeType(Assembler* assembler) {
+  Label fall_through, not_smi, cid_loaded;
+  __ movq(RAX, Address(RSP, + 1 * kWordSize));
+  // Note: we cannot refer to IntType inside intrinsic code.
+  __ testq(RAX, Immediate(kSmiTagMask));
+  __ j(NOT_ZERO, &not_smi, Assembler::kNearJump);
+  __ LoadImmediate(RCX, Immediate(kSmiCid), PP);
+  __ jmp(&cid_loaded);
+  __ Bind(&not_smi);
+  __ LoadClassId(RCX, RAX);
+  __ Bind(&cid_loaded);
+
+  // RCX: untagged cid of instance (RAX).
+  __ LoadClassById(RDI, RCX, PP);
+  // RDI: class of instance (RAX).
+  // if ((NumTypeArguments() == 0) && !IsSignatureClass()) {
+  //   return reinterpret_cast<RawType*>(raw_ptr()->canonical_types_);
+  // }
+  __ movq(RCX, FieldAddress(RDI, Class::signature_function_offset()));
+  __ CompareObject(RCX, Object::null_object(), PP);
+  __ j(NOT_EQUAL, &fall_through, Assembler::kNearJump);
+
+  __ movzxw(RCX, FieldAddress(RDI, Class::num_type_arguments_offset()));
+  __ cmpq(RCX, Immediate(0));
+  __ j(NOT_EQUAL, &fall_through, Assembler::kNearJump);
+  __ movq(RAX, FieldAddress(RDI, Class::canonical_types_offset()));
+  __ CompareObject(RAX, Object::null_object(), PP);
+  __ j(EQUAL, &fall_through, Assembler::kNearJump);  // Not yet set.
+  __ ret();
+
+  __ Bind(&fall_through);
+}
+
+
 void Intrinsifier::String_getHashCode(Assembler* assembler) {
   Label fall_through;
   __ movq(RAX, Address(RSP, + 1 * kWordSize));  // String object.
   __ movq(RAX, FieldAddress(RAX, String::hash_offset()));
   __ cmpq(RAX, Immediate(0));
   __ j(EQUAL, &fall_through, Assembler::kNearJump);
   __ ret();
   __ Bind(&fall_through);
   // Hash not yet computed.
 }
@@ skipping 388 matching lines @@
   __ movq(RBX, Address(RSP, kRegExpParamOffset));
   __ movq(RDI, Address(RSP, kStringParamOffset));
   __ LoadClassId(RDI, RDI);
   __ SubImmediate(RDI, Immediate(kOneByteStringCid), PP);
   __ movq(RAX, FieldAddress(RBX, RDI, TIMES_8,
                             JSRegExp::function_offset(kOneByteStringCid)));
 
   // Registers are now set up for the lazy compile stub. It expects the function
   // in RAX, the argument descriptor in R10, and IC-Data in RCX.
   static const intptr_t arg_count = RegExpMacroAssembler::kParamCount;
-  __ LoadObject(R10, Array::Handle(ArgumentsDescriptor::New(arg_count)), PP);
+  __ LoadObject(R10,
+      Array::ZoneHandle(ArgumentsDescriptor::New(arg_count)), PP);
   __ xorq(RCX, RCX);
 
   // Tail-call the function.
   __ movq(RDI, FieldAddress(RAX, Function::instructions_offset()));
   __ addq(RDI, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(RDI);
 }
 
 
 // On stack: user tag (+1), return-address (+0).
@@ skipping 39 matching lines @@
   // Set return value to Isolate::current_tag_.
   __ movq(RAX, Address(RBX, Isolate::current_tag_offset()));
   __ ret();
 }
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64