Minimize differences between ia32 and x64 sources to facilitate maintenance.

runtime/vm/flow_graph_compiler_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/flow_graph_compiler.h"
 
 #include "lib/error.h"
 #include "vm/ast_printer.h"
-#include "vm/code_descriptors.h"
-#include "vm/code_generator.h"
-#include "vm/disassembler.h"
 #include "vm/il_printer.h"
 #include "vm/locations.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
-DEFINE_FLAG(bool, trace_functions, false, "Trace entry of each function.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, print_ast);
+DECLARE_FLAG(bool, print_scopes);
+DECLARE_FLAG(bool, trace_functions);
 
 
 void DeoptimizationStub::GenerateCode(FlowGraphCompiler* compiler) {
   Assembler* assem = compiler->assembler();
 #define __ assem->
   __ Comment("Deopt stub for id %d", deopt_id_);
   __ Bind(entry_label());
   for (intptr_t i = 0; i < registers_.length(); i++) {
     if (registers_[i] != kNoRegister) {
       __ pushq(registers_[i]);
     }
   }
   __ movq(RAX, Immediate(Smi::RawValue(reason_)));
   __ call(&StubCode::DeoptimizeLabel());
   compiler->AddCurrentDescriptor(PcDescriptors::kOther,
                                  deopt_id_,
                                  deopt_token_pos_,
                                  try_index_);
 #undef __
 }
 
 
 #define __ assembler()->
 
 
-
 // Fall through if bool_register contains null.
 void FlowGraphCompiler::GenerateBoolToJump(Register bool_register,
                                            Label* is_true,
                                            Label* is_false) {
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label fall_through;
   __ cmpq(bool_register, raw_null);
   __ j(EQUAL, &fall_through, Assembler::kNearJump);
   __ CompareObject(bool_register, bool_true());
   __ j(EQUAL, is_true);
   __ jmp(is_false);
   __ Bind(&fall_through);
 }
 
 
+// Clobbers RCX.
 RawSubtypeTestCache* FlowGraphCompiler::GenerateCallSubtypeTestStub(
     TypeTestStubKind test_kind,
     Register instance_reg,
     Register type_arguments_reg,
     Register temp_reg,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   const SubtypeTestCache& type_test_cache =
       SubtypeTestCache::ZoneHandle(SubtypeTestCache::New());
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ LoadObject(temp_reg, type_test_cache);
   __ pushq(temp_reg);  // Subtype test cache.
   __ pushq(instance_reg);  // Instance.
   if (test_kind == kTestTypeOneArg) {
     ASSERT(type_arguments_reg == kNoRegister);
     __ pushq(raw_null);
     __ call(&StubCode::Subtype1TestCacheLabel());
   } else if (test_kind == kTestTypeTwoArgs) {
     ASSERT(type_arguments_reg == kNoRegister);
     __ pushq(raw_null);
     __ call(&StubCode::Subtype2TestCacheLabel());
   } else if (test_kind == kTestTypeThreeArgs) {
     __ pushq(type_arguments_reg);
     __ call(&StubCode::Subtype3TestCacheLabel());
   } else {
     UNREACHABLE();
   }
-  // Result is in ECX: null -> not found, otherwise Bool::True or Bool::False.
+  // Result is in RCX: null -> not found, otherwise Bool::True or Bool::False.
+  ASSERT(instance_reg != RCX);
+  ASSERT(temp_reg != RCX);
   __ popq(instance_reg);  // Discard.
   __ popq(instance_reg);  // Restore receiver.
   __ popq(temp_reg);  // Discard.
   GenerateBoolToJump(RCX, is_instance_lbl, is_not_instance_lbl);
   return type_test_cache.raw();
 }
 
+
 // Jumps to labels 'is_instance' or 'is_not_instance' respectively, if
 // type test is conclusive, otherwise fallthrough if a type test could not
 // be completed.
-// RAX: instance (must survive),
+// RAX: instance (must survive).
+// Clobbers R10.
 RawSubtypeTestCache*
 FlowGraphCompiler::GenerateInstantiatedTypeWithArgumentsTest(
     intptr_t cid,
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   ASSERT(type.IsInstantiated());
   const Class& type_class = Class::ZoneHandle(type.type_class());
   ASSERT(type_class.HasTypeArguments());
@@ skipping 30 matching lines @@
       // Check if type argument is dynamic or Object.
       const Type& object_type = Type::Handle(Type::ObjectType());
       Error& malformed_error = Error::Handle();
       if (object_type.IsSubtypeOf(tp_argument, &malformed_error)) {
         // Instance class test only necessary.
         return GenerateSubtype1TestCacheLookup(
             cid, token_pos, type_class, is_instance_lbl, is_not_instance_lbl);
       }
     }
   }
-
   // Regular subtype test cache involving instance's type arguments.
   const Register kTypeArgumentsReg = kNoRegister;
   const Register kTempReg = R10;
   return GenerateCallSubtypeTestStub(kTestTypeTwoArgs,
                                      kInstanceReg,
                                      kTypeArgumentsReg,
                                      kTempReg,
                                      is_instance_lbl,
                                      is_not_instance_lbl);
 }
 
 
 void FlowGraphCompiler::CheckClassIds(Register class_id_reg,
                                       const GrowableArray<intptr_t>& class_ids,
                                       Label* is_equal_lbl,
                                       Label* is_not_equal_lbl) {
   for (intptr_t i = 0; i < class_ids.length(); i++) {
     __ cmpl(class_id_reg, Immediate(class_ids[i]));
     __ j(EQUAL, is_equal_lbl);
   }
   __ jmp(is_not_equal_lbl);
 }
 
 
-
 // Testing against an instantiated type with no arguments, without
 // SubtypeTestCache.
 // RAX: instance to test against (preserved).
+// Clobbers R10, R13.
 void FlowGraphCompiler::GenerateInstantiatedTypeNoArgumentsTest(
     intptr_t cid,
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   ASSERT(type.IsInstantiated());
-  const Class& type_class = Class::ZoneHandle(type.type_class());
+  const Class& type_class = Class::Handle(type.type_class());
   ASSERT(!type_class.HasTypeArguments());
 
+  const Register kInstanceReg = RAX;
   Label compare_classes;
-  __ testq(RAX, Immediate(kSmiTagMask));
-  __ j(NOT_ZERO, &compare_classes);
+  __ testq(kInstanceReg, Immediate(kSmiTagMask));
+  __ j(NOT_ZERO, &compare_classes, Assembler::kNearJump);
   // Instance is Smi, check directly.
   const Class& smi_class = Class::Handle(Smi::Class());
   // TODO(regis): We should introduce a SmiType.
   Error& malformed_error = Error::Handle();
   if (smi_class.IsSubtypeOf(TypeArguments::Handle(),
                             type_class,
                             TypeArguments::Handle(),
                             &malformed_error)) {
     __ jmp(is_instance_lbl);
   } else {
     __ jmp(is_not_instance_lbl);
   }
-
-  // Compare if the classes are equal. Instance is not Smi.
+  // Compare if the classes are equal.
   __ Bind(&compare_classes);
   const Register kClassIdReg = R10;
-  __ LoadClassId(kClassIdReg, RAX);
+  __ LoadClassId(kClassIdReg, kInstanceReg);
   // If type is an interface, we can skip the class equality check.
   if (!type_class.is_interface()) {
     __ cmpl(kClassIdReg, Immediate(type_class.id()));
     __ j(EQUAL, is_instance_lbl);
   }
-  // Check for interfaces that cannot be implemented by user.
+  // Bool interface can be implemented only by core class Bool.
   // (see ClassFinalizer::ResolveInterfaces for list of restricted interfaces).
-  // Bool interface can be implemented only by core class Bool.
   if (type.IsBoolInterface()) {
     __ cmpl(kClassIdReg, Immediate(kBool));
     __ j(EQUAL, is_instance_lbl);
     __ jmp(is_not_instance_lbl);
     return;
   }
   if (type.IsFunctionInterface()) {
     // Check if instance is a closure.
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
@@ skipping 15 matching lines @@
   if (type.IsStringInterface()) {
     GenerateStringTypeCheck(kClassIdReg, is_instance_lbl, is_not_instance_lbl);
     return;
   }
   // Otherwise fallthrough.
 }
 
 
 // Uses SubtypeTestCache to store instance class and result.
 // RAX: instance to test.
+// Clobbers R10, R13.
 // Immediate class test already done.
+// TODO(srdjan): Implement a quicker subtype check, as type test
+// arrays can grow too high, but they may be useful when optimizing
+// code (type-feedback).
 RawSubtypeTestCache* FlowGraphCompiler::GenerateSubtype1TestCacheLookup(
     intptr_t cid,
     intptr_t token_pos,
     const Class& type_class,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   const Register kInstanceReg = RAX;
   __ LoadClass(R10, kInstanceReg);
+  // R10: instance class.
   // Check immediate superclass equality.
   __ movq(R13, FieldAddress(R10, Class::super_type_offset()));
   __ movq(R13, FieldAddress(R13, Type::type_class_offset()));
   __ CompareObject(R13, type_class);
   __ j(EQUAL, is_instance_lbl);
 
   const Register kTypeArgumentsReg = kNoRegister;
   const Register kTempReg = R10;
   return GenerateCallSubtypeTestStub(kTestTypeOneArg,
                                      kInstanceReg,
                                      kTypeArgumentsReg,
                                      kTempReg,
                                      is_instance_lbl,
                                      is_not_instance_lbl);
 }
 
 
 // Generates inlined check if 'type' is a type parameter or type itsef
 // RAX: instance (preserved).
+// Clobbers RDI, RDX, R10.
 RawSubtypeTestCache* FlowGraphCompiler::GenerateUninstantiatedTypeTest(
     intptr_t cid,
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   ASSERT(!type.IsInstantiated());
+  // Skip check if destination is a dynamic type.
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   if (type.IsTypeParameter()) {
      // Load instantiator (or null) and instantiator type arguments on stack.
     __ movq(RDX, Address(RSP, 0));  // Get instantiator type arguments.
     // RDX: instantiator type arguments.
     // Check if type argument is Dynamic.
     __ cmpq(RDX, raw_null);
     __ j(EQUAL, is_instance_lbl);
     // Can handle only type arguments that are instances of TypeArguments.
     // (runtime checks canonicalize type arguments).
     Label fall_through;
     __ CompareClassId(RDX, kTypeArguments);
     __ j(NOT_EQUAL, &fall_through);
     __ movq(RDI,
         FieldAddress(RDX, TypeArguments::type_at_offset(type.Index())));
-    // RDI: Concrete type.
-    // Check if it is Dynamic,
+    // RDI: Concrete type of type.
+    // Check if type argument is dynamic.
     __ CompareObject(RDI, Type::ZoneHandle(Type::DynamicType()));
     __ j(EQUAL,  is_instance_lbl);
     __ cmpq(RDI, raw_null);
     __ j(EQUAL,  is_instance_lbl);
     const Type& object_type = Type::ZoneHandle(Type::ObjectType());
     __ CompareObject(RDI, object_type);
     __ j(EQUAL,  is_instance_lbl);
 
-    // For Smi check quickly against int and num interface types.
+    // For Smi check quickly against int and num interfaces.
     Label not_smi;
     __ testq(RAX, Immediate(kSmiTagMask));  // Value is Smi?
     __ j(NOT_ZERO, &not_smi, Assembler::kNearJump);
     __ CompareObject(RDI, Type::ZoneHandle(Type::IntInterface()));
     __ j(EQUAL,  is_instance_lbl);
     __ CompareObject(RDI, Type::ZoneHandle(Type::NumberInterface()));
     __ j(EQUAL,  is_instance_lbl);
     // Smi must be handled in runtime.
     __ jmp(&fall_through);
 
     __ Bind(&not_smi);
     // RDX: instantiator type arguments.
     // RAX: instance.
     const Register kInstanceReg = RAX;
     const Register kTypeArgumentsReg = RDX;
     const Register kTempReg = R10;
     const SubtypeTestCache& type_test_cache =
         SubtypeTestCache::ZoneHandle(
             GenerateCallSubtypeTestStub(kTestTypeThreeArgs,
                                         kInstanceReg,
                                         kTypeArgumentsReg,
                                         kTempReg,
                                         is_instance_lbl,
                                         is_not_instance_lbl));
-
     __ Bind(&fall_through);
     return type_test_cache.raw();
   }
   if (type.IsType()) {
     const Register kInstanceReg = RAX;
     const Register kTypeArgumentsReg = RDX;
     __ testq(kInstanceReg, Immediate(kSmiTagMask));  // Is instance Smi?
     __ j(ZERO, is_not_instance_lbl);
     __ movq(kTypeArgumentsReg, Address(RSP, 0));  // Instantiator type args.
     // Uninstantiated type class is known at compile time, but the type
     // arguments are determined at runtime by the instantiator.
     const Register kTempReg = R10;
     return GenerateCallSubtypeTestStub(kTestTypeThreeArgs,
                                        kInstanceReg,
                                        kTypeArgumentsReg,
                                        kTempReg,
                                        is_instance_lbl,
                                        is_not_instance_lbl);
   }
   return SubtypeTestCache::null();
 }
 
 
 // Inputs:
 // - RAX: instance to test against (preserved).
 // - RDX: optional instantiator type arguments (preserved).
-// Destroys RCX.
+// Clobbers R10, R13.
 // Returns:
-// - unchanged object in RAX and optional instantiator type arguments in RDX.
+// - preserved instance in RAX and optional instantiator type arguments in RDX.
 // Note that this inlined code must be followed by the runtime_call code, as it
 // may fall through to it. Otherwise, this inline code will jump to the label
 // is_instance or to the label is_not_instance.
 RawSubtypeTestCache* FlowGraphCompiler::GenerateInlineInstanceof(
     intptr_t cid,
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
   if (type.IsInstantiated()) {
@@ skipping 24 matching lines @@
     return GenerateUninstantiatedTypeTest(cid,
                                           token_pos,
                                           type,
                                           is_instance_lbl,
                                           is_not_instance_lbl);
   }
   return SubtypeTestCache::null();
 }
 
 
+// If instanceof type test cannot be performed successfully at compile time and
+// therefore eliminated, optimize it by adding inlined tests for:
+// - NULL -> return false.
+// - Smi -> compile time subtype check (only if dst class is not parameterized).
+// - Class equality (only if class is not parameterized).
+// Inputs:
+// - RAX: object.
+// - RDX: instantiator type arguments or raw_null.
+// - RCX: instantiator or raw_null.
+// Clobbers RCX and RDX.
+// Returns:
+// - true or false in RAX.
+void FlowGraphCompiler::GenerateInstanceOf(intptr_t cid,
+                                           intptr_t token_pos,
+                                           intptr_t try_index,
+                                           const AbstractType& type,
+                                           bool negate_result) {
+  ASSERT(type.IsFinalized() && !type.IsMalformed());
+
+  const Immediate raw_null =
+      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+  Label is_instance, is_not_instance;
+  __ pushq(RCX);  // Store instantiator on stack.
+  __ pushq(RDX);  // Store instantiator type arguments.
+  // If type is instantiated and non-parameterized, we can inline code
+  // checking whether the tested instance is a Smi.
+  if (type.IsInstantiated()) {
+    // A null object is only an instance of Object and Dynamic, which has
+    // already been checked above (if the type is instantiated). So we can
+    // return false here if the instance is null (and if the type is
+    // instantiated).
+    // We can only inline this null check if the type is instantiated at compile
+    // time, since an uninstantiated type at compile time could be Object or
+    // Dynamic at run time.
+    __ cmpq(RAX, raw_null);
+    __ j(EQUAL, &is_not_instance);
+  }
+
+  // Generate inline instanceof test.
+  SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle();
+  test_cache = GenerateInlineInstanceof(cid, token_pos, type,
+                                        &is_instance, &is_not_instance);
+
+  // Generate runtime call.
+  __ movq(RDX, Address(RSP, 0));  // Get instantiator type arguments.
+  __ movq(RCX, Address(RSP, kWordSize));  // Get instantiator.
+  __ PushObject(Object::ZoneHandle());  // Make room for the result.
+  __ pushq(Immediate(Smi::RawValue(token_pos)));  // Source location.
+  __ pushq(Immediate(Smi::RawValue(cid)));  // Computation id.
+  __ pushq(RAX);  // Push the instance.
+  __ PushObject(type);  // Push the type.
+  __ pushq(RCX);  // TODO(srdjan): Pass instantiator instead of null.
+  __ pushq(RDX);  // Instantiator type arguments.
+  __ LoadObject(RAX, test_cache);
+  __ pushq(RAX);
+  GenerateCallRuntime(cid, token_pos, try_index, kInstanceofRuntimeEntry);
+  // Pop the two parameters supplied to the runtime entry. The result of the
+  // instanceof runtime call will be left as the result of the operation.
+  __ Drop(7);
+  Label done;
+  if (negate_result) {
+    __ popq(RDX);
+    __ LoadObject(RAX, bool_true());
+    __ cmpq(RDX, RAX);
+    __ j(NOT_EQUAL, &done, Assembler::kNearJump);
+    __ LoadObject(RAX, bool_false());
+  } else {
+    __ popq(RAX);
+  }
+  __ jmp(&done, Assembler::kNearJump);
+
+  __ Bind(&is_not_instance);
+  __ LoadObject(RAX, negate_result ? bool_true() : bool_false());
+  __ jmp(&done, Assembler::kNearJump);
+
+  __ Bind(&is_instance);
+  __ LoadObject(RAX, negate_result ? bool_false() : bool_true());
+  __ Bind(&done);
+  __ popq(RDX);  // Remove pushed instantiator type arguments.
+  __ popq(RCX);  // Remove pushed instantiator.
+}
+
+
 // Optimize assignable type check by adding inlined tests for:
 // - NULL -> return NULL.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - RAX: object.
 // - RDX: instantiator type arguments or raw_null.
 // - RCX: instantiator or raw_null.
 // Returns:
 // - object in RAX for successful assignable check (or throws TypeError).
@@ skipping 38 matching lines @@
     __ int3();
 
     __ Bind(&is_assignable);  // For a null object.
     return;
   }
 
   // Generate inline type check, linking to runtime call if not assignable.
   SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle();
   test_cache = GenerateInlineInstanceof(cid, token_pos, dst_type,
                                         &is_assignable, &runtime_call);
+
   __ Bind(&runtime_call);
   __ movq(RDX, Address(RSP, 0));  // Get instantiator type arguments.
   __ movq(RCX, Address(RSP, kWordSize));  // Get instantiator.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushq(Immediate(Smi::RawValue(token_pos)));  // Source location.
   __ pushq(Immediate(Smi::RawValue(cid)));  // Computation id.
   __ pushq(RAX);  // Push the source object.
   __ PushObject(dst_type);  // Push the type of the destination.
   __ pushq(RCX);  // Instantiator.
   __ pushq(RDX);  // Instantiator type arguments.
   __ PushObject(dst_name);  // Push the name of the destination.
   __ LoadObject(RAX, test_cache);
   __ pushq(RAX);
   GenerateCallRuntime(cid,
                       token_pos,
                       try_index,
                       kTypeCheckRuntimeEntry);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
   __ Drop(8);
   __ popq(RAX);
 
   __ Bind(&is_assignable);
   __ popq(RDX);  // Remove pushed instantiator type arguments..
   __ popq(RCX);  // Remove pushed instantiator.
 }
 
 
-void FlowGraphCompiler::LoadValue(Register dst, Value* value) {
-  if (value->IsConstant()) {
-    ConstantVal* constant = value->AsConstant();
-    if (constant->value().IsSmi()) {
-      int64_t imm = reinterpret_cast<int64_t>(constant->value().raw());
-      __ movq(dst, Immediate(imm));
-    } else {
-      __ LoadObject(dst, value->AsConstant()->value());
-    }
-  } else {
-    ASSERT(value->IsUse());
-    __ popq(dst);
-  }
-}
-
-
-intptr_t FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
-                                         const ICData& ic_data,
-                                         const Array& arguments_descriptor,
-                                         intptr_t argument_count) {
-  __ LoadObject(RBX, ic_data);
-  __ LoadObject(R10, arguments_descriptor);
-
-  __ call(target_label);
-  const intptr_t descr_offset = assembler()->CodeSize();
-  __ Drop(argument_count);
-  return descr_offset;
-}
-
-intptr_t FlowGraphCompiler::EmitStaticCall(const Function& function,
-                                           const Array& arguments_descriptor,
-                                           intptr_t argument_count) {
-  __ LoadObject(RBX, function);
-  __ LoadObject(R10, arguments_descriptor);
-  __ call(&StubCode::CallStaticFunctionLabel());
-  const intptr_t descr_offset = assembler()->CodeSize();
-  __ Drop(argument_count);
-  return descr_offset;
-}
-
-
-// Optimize instanceof type test by adding inlined tests for:
-// - NULL -> return false.
-// - Smi -> compile time subtype check (only if dst class is not parameterized).
-// - Class equality (only if class is not parameterized).
-// Inputs:
-// - RAX: object.
-// - RDX: instantiator type arguments or raw_null.
-// - RCX: instantiator or raw_null.
-// Destroys RCX and RDX.
-// Returns:
-// - true or false in RAX.
-void FlowGraphCompiler::GenerateInstanceOf(intptr_t cid,
-                                           intptr_t token_pos,
-                                           intptr_t try_index,
-                                           const AbstractType& type,
-                                           bool negate_result) {
-  ASSERT(type.IsFinalized() && !type.IsMalformed());
-
-  const Immediate raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  Label is_instance, is_not_instance;
-  __ pushq(RCX);  // Store instantiator on stack.
-  __ pushq(RDX);  // Store instantiator type arguments.
-  // If type is instantiated and non-parameterized, we can inline code
-  // checking whether the tested instance is a Smi.
-  if (type.IsInstantiated()) {
-    // A null object is only an instance of Object and Dynamic, which has
-    // already been checked above (if the type is instantiated). So we can
-    // return false here if the instance is null (and if the type is
-    // instantiated).
-    // We can only inline this null check if the type is instantiated at compile
-    // time, since an uninstantiated type at compile time could be Object or
-    // Dynamic at run time.
-    __ cmpq(RAX, raw_null);
-    __ j(EQUAL, &is_not_instance);
-  }
-
-  // Generate inline instanceof test.
-  SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle();
-  test_cache = GenerateInlineInstanceof(cid, token_pos, type,
-                                        &is_instance, &is_not_instance);
-
-  // Generate runtime call.
-  __ movq(RDX, Address(RSP, 0));  // Get instantiator type arguments.
-  __ movq(RCX, Address(RSP, kWordSize));  // Get instantiator.
-  __ PushObject(Object::ZoneHandle());  // Make room for the result.
-  __ pushq(Immediate(Smi::RawValue(token_pos)));  // Source location.
-  __ pushq(Immediate(Smi::RawValue(cid)));  // Computation id.
-  __ pushq(RAX);  // Push the instance.
-  __ PushObject(type);  // Push the type.
-  __ pushq(RCX);  // TODO(srdjan): Pass instantiator instead of null.
-  __ pushq(RDX);  // Instantiator type arguments.
-  __ LoadObject(RAX, test_cache);
-  __ pushq(RAX);
-  GenerateCallRuntime(cid, token_pos, try_index, kInstanceofRuntimeEntry);
-  // Pop the two parameters supplied to the runtime entry. The result of the
-  // instanceof runtime call will be left as the result of the operation.
-  __ Drop(7);
-  Label done;
-  if (negate_result) {
-    __ popq(RDX);
-    __ LoadObject(RAX, bool_true());
-    __ cmpq(RDX, RAX);
-    __ j(NOT_EQUAL, &done, Assembler::kNearJump);
-    __ LoadObject(RAX, bool_false());
-  } else {
-    __ popq(RAX);
-  }
-  __ jmp(&done, Assembler::kNearJump);
-
-  __ Bind(&is_not_instance);
-  __ LoadObject(RAX, negate_result ? bool_true() : bool_false());
-  __ jmp(&done, Assembler::kNearJump);
-
-  __ Bind(&is_instance);
-  __ LoadObject(RAX, negate_result ? bool_false() : bool_true());
-  __ Bind(&done);
-  __ popq(RDX);  // Remove pushed instantiator type arguments.
-  __ popq(RCX);  // Remove pushed instantiator.
-}
-
-
 void FlowGraphCompiler::EmitInstructionPrologue(Instruction* instr) {
   LocationSummary* locs = instr->locs();
   ASSERT(locs != NULL);
 
   frame_register_allocator()->AllocateRegisters(instr);
 
   // TODO(vegorov): adjust assertion when we start removing comparison from the
   // graph when it is merged with a branch.
   ASSERT(locs->is_call() ||
          (instr->IsBranch() && instr->AsBranch()->is_fused_with_comparison()) ||
          (locs->input_count() == instr->InputCount()));
 }
 
 
-// Copied from CodeGenerator::CopyParameters (CodeGenerator will be deprecated).
 void FlowGraphCompiler::CopyParameters() {
   const Function& function = parsed_function().function();
   const bool is_native_instance_closure =
       function.is_native() && function.IsImplicitInstanceClosureFunction();
   LocalScope* scope = parsed_function().node_sequence()->scope();
   const int num_fixed_params = function.num_fixed_parameters();
   const int num_opt_params = function.num_optional_parameters();
   int implicit_this_param_pos = is_native_instance_closure ? -1 : 0;
   ASSERT(parsed_function().first_parameter_index() ==
          ParsedFunction::kFirstLocalSlotIndex + implicit_this_param_pos);
@@ skipping 14 matching lines @@
   __ movq(RCX, FieldAddress(R10, Array::data_offset() + (1 * kWordSize)));
   // Check that num_pos_args >= num_fixed_params.
   __ cmpq(RCX, Immediate(Smi::RawValue(num_fixed_params)));
   __ j(LESS, &wrong_num_arguments);
 
   // Since RBX and RCX are Smi, use TIMES_4 instead of TIMES_8.
   // Let RBX point to the last passed positional argument, i.e. to
   // fp[1 + num_args - (num_pos_args - 1)].
   __ subq(RBX, RCX);
   __ leaq(RBX, Address(RBP, RBX, TIMES_4, 2 * kWordSize));
+
   // Let RDI point to the last copied positional argument, i.e. to
   // fp[ParsedFunction::kFirstLocalSlotIndex - (num_pos_args - 1)].
   const int index =
       ParsedFunction::kFirstLocalSlotIndex + 1 + implicit_this_param_pos;
   // First copy captured receiver if function is an implicit native closure.
   if (is_native_instance_closure) {
     __ movq(RAX, FieldAddress(CTX, Context::variable_offset(0)));
     __ movq(Address(RBP, (index * kWordSize)), RAX);
   }
   __ SmiUntag(RCX);
@@ skipping 209 matching lines @@
   __ SmiUntag(RAX);
   __ cvtsi2sd(XMM1, RAX);
   __ jmp(&double_op);
   __ Bind(&call_method);
 }
 
 
 void FlowGraphCompiler::CompileGraph() {
   InitCompiler();
   if (TryIntrinsify()) {
-    // Make it patchable: code must have a minimum code size, nop(2) increases
-    // the minimum code size appropriately.
+    // Although this intrinsified code will never be patched, it must satisfy
+    // CodePatcher::CodeIsPatchable, which verifies that this code has a minimum
+    // code size, and nop(2) increases the minimum code size appropriately.
     __ nop(2);
     __ int3();
     __ jmp(&StubCode::FixCallersTargetLabel());
     return;
   }
   // Specialized version of entry code from CodeGenerator::GenerateEntryCode.
   const Function& function = parsed_function().function();
 
   const int parameter_count = function.num_fixed_parameters();
   const int num_copied_params = parsed_function().copied_parameter_count();
   const int local_count = parsed_function().stack_local_count();
   AssemblerMacros::EnterDartFrame(assembler(), (StackSize() * kWordSize));
-
   // We check the number of passed arguments when we have to copy them due to
   // the presence of optional named parameters.
   // No such checking code is generated if only fixed parameters are declared,
   // unless we are debug mode or unless we are compiling a closure.
   if (num_copied_params == 0) {
 #ifdef DEBUG
     const bool check_arguments = true;
 #else
     const bool check_arguments = function.IsClosureFunction();
 #endif
@@ skipping 10 matching lines @@
                             CatchClauseNode::kInvalidTryIndex,
                             kClosureArgumentMismatchRuntimeEntry);
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&argc_in_range);
     }
   } else {
     CopyParameters();
   }
-
-  // Initialize locals to null.
+  // Initialize (non-argument) stack allocated locals to null.
   if (local_count > 0) {
-    __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(Object::null())));
+    const Immediate raw_null =
+        Immediate(reinterpret_cast<intptr_t>(Object::null()));
+    __ movq(RAX, raw_null);
     const int base = parsed_function().first_stack_local_index();
     for (int i = 0; i < local_count; ++i) {
       // Subtract index i (locals lie at lower addresses than RBP).
       __ movq(Address(RBP, (base - i) * kWordSize), RAX);
     }
   }
 
   // Generate stack overflow check.
   __ movq(RDI, Immediate(Isolate::Current()->stack_limit_address()));
   __ cmpq(RSP, Address(RDI, 0));
@@ skipping 23 matching lines @@
   // at entry point.
   pc_descriptors_list()->AddDescriptor(PcDescriptors::kPatchCode,
                                        assembler()->CodeSize(),
                                        AstNode::kNoId,
                                        0,
                                        -1);
   __ jmp(&StubCode::FixCallersTargetLabel());
 }
 
 
-// Infrastructure copied from class CodeGenerator.
 void FlowGraphCompiler::GenerateCall(intptr_t token_pos,
                                      intptr_t try_index,
                                      const ExternalLabel* label,
                                      PcDescriptors::Kind kind) {
   ASSERT(frame_register_allocator()->IsSpilled());
   __ call(label);
   AddCurrentDescriptor(kind, AstNode::kNoId, token_pos, try_index);
 }
 
 
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t cid,
                                             intptr_t token_pos,
                                             intptr_t try_index,
                                             const RuntimeEntry& entry) {
   ASSERT(frame_register_allocator()->IsSpilled());
   __ CallRuntime(entry);
   AddCurrentDescriptor(PcDescriptors::kOther, cid, token_pos, try_index);
 }
 
 
+intptr_t FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
+                                             const ICData& ic_data,
+                                             const Array& arguments_descriptor,
+                                             intptr_t argument_count) {
+  __ LoadObject(RBX, ic_data);
+  __ LoadObject(R10, arguments_descriptor);
+
+  __ call(target_label);
+  const intptr_t descr_offset = assembler()->CodeSize();
+  __ Drop(argument_count);
+  return descr_offset;
+}
+
+
+intptr_t FlowGraphCompiler::EmitStaticCall(const Function& function,
+                                           const Array& arguments_descriptor,
+                                           intptr_t argument_count) {
+  __ LoadObject(RBX, function);
+  __ LoadObject(R10, arguments_descriptor);
+  __ call(&StubCode::CallStaticFunctionLabel());
+  const intptr_t descr_offset = assembler()->CodeSize();
+  __ Drop(argument_count);
+  return descr_offset;
+}
+
+
 // Checks class id of instance against all 'class_ids'. Jump to 'deopt' label
 // if no match or instance is Smi.
 void FlowGraphCompiler::EmitClassChecksNoSmi(const ICData& ic_data,
                                              Register instance_reg,
                                              Register temp_reg,
                                              Label* deopt) {
   Label ok;
   ASSERT(ic_data.GetReceiverClassIdAt(0) != kSmi);
   __ testq(instance_reg, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
@@ skipping 34 matching lines @@
   __ cvtsi2sd(result, temp);
   __ Bind(&done);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64