Start porting fast typechecks to x64.

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 248 matching lines @@
         (kind == RawFunction::kConstImplicitGetter);
     const bool is_static = owner()->parsed_function().function().is_static();
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     if (is_static || !is_implicit_getter) {
       const AbstractType& dst_type =
           AbstractType::ZoneHandle(
               owner()->parsed_function().function().result_type());
       const String& dst_name =
           String::ZoneHandle(String::NewSymbol("function result"));
-      return_value = BuildAssignableValue(node->value(),
+      return_value = BuildAssignableValue(node->value()->token_index(),
                                           return_value,
                                           dst_type,
                                           dst_name);
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function().saved_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
@@ skipping 95 matching lines @@
 //                              dst_name: String }
 void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   UNREACHABLE();
 }
 
 
 void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->expr()->Visit(&for_value);
   Append(for_value);
-  ReturnValue(BuildAssignableValue(node->expr(),
+  ReturnValue(BuildAssignableValue(node->expr()->token_index(),
                                    for_value.value(),
                                    node->type(),
                                    node->dst_name()));
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
 void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
@@ skipping 173 matching lines @@
   StaticCallComp* call =
       new StaticCallComp(node->token_index(),
                          owner()->try_index(),
                          interpol_func,
                          interpol_arg->names(),
                          values);
   ReturnComputation(call);
 }
 
 
-void EffectGraphVisitor::BuildAssertAssignable(intptr_t token_index,
-                                               Value* value,
-                                               const AbstractType& dst_type,
-                                               const String& dst_name) {
-  // Build the type check computation.
+void EffectGraphVisitor::BuildTypecheckArguments(
+    intptr_t token_index,
+    Value** instantiator_result,
+    Value** instantiator_type_arguments_result) {
+  Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
-  if (!dst_type.IsInstantiated()) {
+  const Class& instantiator_class = Class::Handle(
+      owner()->parsed_function().function().owner());
+  if (instantiator_class.NumTypeParameters() > 0) {

[regis, 2012/05/18 00:41:38]

This does not look correct. The instantiator may have a type argument vector
even if its class does not have type parameters.

+    instantiator = BuildInstantiator();
+    if (instantiator == NULL) {
+      instantiator_type_arguments =
+          BuildInstantiatorTypeArguments(token_index, NULL);
+    } else {
+      // Preserve instantiator.
+      const LocalVariable& expr_temp =
+          *owner()->parsed_function().expression_temp_var();
+      Definition* saved =
+          new BindInstr(BuildStoreLocal(expr_temp, instantiator));
+      AddInstruction(saved);
+      instantiator = new UseVal(saved);
+      Definition* loaded = new BindInstr(BuildLoadLocal(expr_temp));
+      AddInstruction(loaded);
+      instantiator_type_arguments =
+          BuildInstantiatorTypeArguments(token_index, new UseVal(loaded));
+    }
+  } else {
     instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(token_index);
+        BuildInstantiatorTypeArguments(token_index, NULL);
   }
-  AssertAssignableComp* assert_assignable =
-      new AssertAssignableComp(token_index,
-                               owner()->try_index(),
-                               value,
-                               instantiator_type_arguments,
-                               dst_type,
-                               dst_name);
-  AddInstruction(new DoInstr(assert_assignable));
+  *instantiator_result = instantiator;
+  *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
-Value* EffectGraphVisitor::BuildAssignableValue(AstNode* value_node,
+// Used for testing incoming arguments.
+AssertAssignableComp* EffectGraphVisitor::BuildAssertAssignable(
+    intptr_t token_index,
+    Value* value,
+    const AbstractType& dst_type,
+    const String& dst_name) {
+  // Build the type check computation.
+  Value* instantiator = NULL;
+  Value* instantiator_type_arguments = NULL;
+  if (!dst_type.IsInstantiated()) {
+    BuildTypecheckArguments(token_index,
+                            &instantiator,
+                            &instantiator_type_arguments);
+  }
+  return new AssertAssignableComp(token_index,
+                                  owner()->try_index(),
+                                  value,
+                                  instantiator,
+                                  instantiator_type_arguments,
+                                  dst_type,
+                                  dst_name);
+}
+
+
+// Used to to test assignments.
+Value* EffectGraphVisitor::BuildAssignableValue(intptr_t token_index,
                                                 Value* value,
                                                 const AbstractType& dst_type,
                                                 const String& dst_name) {
   if (CanSkipTypeCheck(value, dst_type)) {
     return value;
   }
-
-  // Build the type check computation.
-  Value* instantiator_type_arguments = NULL;
-  if (!dst_type.IsInstantiated()) {
-    instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(value_node->token_index());
-  }
-  BindInstr* assert_assignable =
-      new BindInstr(new AssertAssignableComp(value_node->token_index(),
-                                             owner()->try_index(),
-                                             value,
-                                             instantiator_type_arguments,
-                                             dst_type,
-                                             dst_name));
+  AssertAssignableComp* comp = BuildAssertAssignable(token_index,
+                                                     value,
+                                                     dst_type,
+                                                     dst_name);
+  Definition* assert_assignable = new BindInstr(comp);
   AddInstruction(assert_assignable);
   return new UseVal(assert_assignable);
 }
 
 
 void EffectGraphVisitor::BuildInstanceOf(ComparisonNode* node) {
   ASSERT(Token::IsInstanceofOperator(node->kind()));
   EffectGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
@@ skipping 45 matching lines @@
         result = new ConstantVal(negate_result ? bool_true : bool_false);
       }
     }
     ReturnComputation(result);
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
+  Value* instantiator = NULL;
   Value* type_arguments = NULL;
   if (!type.IsInstantiated()) {
-    type_arguments =
-        BuildInstantiatorTypeArguments(node->token_index());
+    BuildTypecheckArguments(node->token_index(),
+                            &instantiator,
+                            &type_arguments);
   }
   InstanceOfComp* instance_of =
       new InstanceOfComp(node->token_index(),
                          owner()->try_index(),
                          for_left_value.value(),
+                         instantiator,
                          type_arguments,
                          node->right()->AsTypeNode()->type(),
                          (node->kind() == Token::kISNOT));
   ReturnComputation(instance_of);
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
@@ skipping 573 matching lines @@
   ASSERT(function.context_scope() != ContextScope::null());
 
   // The function type of a closure may have type arguments. In that case, pass
   // the type arguments of the instantiator.
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(!cls.IsNull());
   const bool requires_type_arguments = cls.HasTypeArguments();
   Value* type_arguments = NULL;
   if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
-    type_arguments =
-        BuildInstantiatorTypeArguments(node->token_index());
+    type_arguments = BuildInstantiatorTypeArguments(node->token_index(), NULL);
   }
 
   CreateClosureComp* create =
       new CreateClosureComp(node, owner()->try_index(), type_arguments);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node,
@@ skipping 160 matching lines @@
   //   t_n      <- AllocateObject(class)
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
   // No need to preserve allocated value (simpler than in ValueGraphVisitor).
   Definition* allocate = BuildObjectAllocation(node);
   BuildConstructorCall(node, new UseVal(allocate));
 }
 
 
-Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
-    intptr_t token_index) {
+Value* EffectGraphVisitor::BuildInstantiator() {
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().owner());
   if (instantiator_class.NumTypeParameters() == 0) {
+    return NULL;
+  }
+  Function& outer_function =
+      Function::Handle(owner()->parsed_function().function().raw());
+  while (outer_function.IsLocalFunction()) {
+    outer_function = outer_function.parent_function();
+  }
+  if (outer_function.IsFactory()) {
+    return NULL;
+  }
+
+  ASSERT(owner()->parsed_function().instantiator() != NULL);
+  ValueGraphVisitor for_instantiator(owner(), temp_index());
+  owner()->parsed_function().instantiator()->Visit(&for_instantiator);
+  Append(for_instantiator);
+  return for_instantiator.value();
+}
+
+
+// 'expression_temp_var' may not be used inside this method if 'instantiator'
+// is not NULL.
+Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
+    intptr_t token_index, Value* instantiator) {
+  const Class& instantiator_class = Class::Handle(
+      owner()->parsed_function().function().owner());
+  if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& type = Type::Handle(
         Type::New(instantiator_class, type_arguments, token_index));
     type ^= ClassFinalizer::FinalizeType(
         instantiator_class, type, ClassFinalizer::kFinalizeWellFormed);
     type_arguments = type.arguments();
     BindInstr* args = new BindInstr(new ConstantVal(type_arguments));
     AddInstruction(args);
     return new UseVal(args);
   }
-  ASSERT(owner()->parsed_function().instantiator() != NULL);
-  ValueGraphVisitor for_instantiator(owner(), temp_index());
-  owner()->parsed_function().instantiator()->Visit(&for_instantiator);
-  Append(for_instantiator);
   Function& outer_function =
       Function::Handle(owner()->parsed_function().function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
-    // All OK.
+    // No instantiator for factories.
+    ASSERT(instantiator == NULL);
+    ASSERT(owner()->parsed_function().instantiator() != NULL);
+    ValueGraphVisitor for_instantiator(owner(), temp_index());
+    owner()->parsed_function().instantiator()->Visit(&for_instantiator);
+    Append(for_instantiator);
     return for_instantiator.value();
   }
-
+  if (instantiator == NULL) {
+    instantiator = BuildInstantiator();
+  }
   // The instantiator is the receiver of the caller, which is not a factory.
   // The receiver cannot be null; extract its AbstractTypeArguments object.
   // Note that in the factory case, the instantiator is the first parameter
   // of the factory, i.e. already an AbstractTypeArguments object.
   intptr_t type_arguments_instance_field_offset =
       instantiator_class.type_arguments_instance_field_offset();
   ASSERT(type_arguments_instance_field_offset != Class::kNoTypeArguments);
 
   BindInstr* load =
       new BindInstr(new NativeLoadFieldComp(
-                        for_instantiator.value(),
+                        instantiator,
                         type_arguments_instance_field_offset,
                         Type::ZoneHandle()));  // Not an instance, no type.
   AddInstruction(load);
   return new UseVal(load);
 }
 
 
 Definition* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_index,
     const AbstractTypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     BindInstr* type_args =
         new BindInstr(new ConstantVal(type_arguments));
     AddInstruction(type_args);
     return type_args;
   }
   // The type arguments are uninstantiated.
-  Value* instantiator_value = BuildInstantiatorTypeArguments(token_index);
+  Value* instantiator_value =
+      BuildInstantiatorTypeArguments(token_index, NULL);
   BindInstr* instantiate =
       new BindInstr(new InstantiateTypeArgumentsComp(token_index,
                                                      owner()->try_index(),
                                                      type_arguments,
                                                      instantiator_value));
   AddInstruction(instantiate);
   return instantiate;
 }
 
 
@@ skipping 21 matching lines @@
   //   t1 = InstantiatorTypeArguments();
   //   t2 = ExtractConstructorTypeArguments(t1);
   //   t1 = ExtractConstructorInstantiator(t1);
   //   t_n   <- t2
   //   t_n+1 <- t1
   // Use expression_temp_var and node->allocated_object_var() locals to keep
   // intermediate results around (t1 and t2 above).
   ASSERT(owner()->parsed_function().expression_temp_var() != NULL);
   const LocalVariable& t1 = *owner()->parsed_function().expression_temp_var();
   const LocalVariable& t2 = node->allocated_object_var();
-  Value* instantiator = BuildInstantiatorTypeArguments(node->token_index());
-  ASSERT(instantiator->IsUse());
+  Value* instantiator_type_arguments = BuildInstantiatorTypeArguments(
+      node->token_index(), NULL);
+  ASSERT(instantiator_type_arguments->IsUse());
   Definition* stored_instantiator = new BindInstr(
-      BuildStoreLocal(t1, instantiator));
+      BuildStoreLocal(t1, instantiator_type_arguments));
   AddInstruction(stored_instantiator);
   // t1: instantiator type arguments.
 
   BindInstr* extract_type_arguments = new BindInstr(
       new ExtractConstructorTypeArgumentsComp(
           node->token_index(),
           owner()->try_index(),
           node->type_arguments(),
           new UseVal(stored_instantiator)));
   AddInstruction(extract_type_arguments);
@@ skipping 148 matching lines @@
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
-    store_value = BuildAssignableValue(node->value(),
+    store_value = BuildAssignableValue(node->value()->token_index(),
                                        store_value,
                                        node->local().type(),
                                        node->local().name());
   }
   Computation* store = BuildStoreLocal(node->local(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
@@ skipping 12 matching lines @@
   ValueGraphVisitor for_instance(owner(), temp_index());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   ValueGraphVisitor for_value(owner(), for_instance.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
-    store_value = BuildAssignableValue(node->value(),
+    store_value = BuildAssignableValue(node->value()->token_index(),
                                        store_value,
                                        type,
                                        dst_name);
   }
   StoreInstanceFieldComp* store =
       new StoreInstanceFieldComp(node, for_instance.value(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   LoadStaticFieldComp* load = new LoadStaticFieldComp(node->field());
   ReturnComputation(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
-    store_value = BuildAssignableValue(node->value(),
+    store_value = BuildAssignableValue(node->value()->token_index(),
                                        store_value,
                                        type,
                                        dst_name);
   }
   StoreStaticFieldComp* store =
       new StoreStaticFieldComp(node->field(), store_value);
   ReturnComputation(store);
 }
 
 
@@ skipping 150 matching lines @@
       // Skip type checking of type arguments for factory functions.
       // Skip type checking of receiver for instance functions.
       pos = 1;
     }
     while (pos < num_params) {
       const LocalVariable& parameter = *scope->VariableAt(pos);
       ASSERT(parameter.owner() == scope);
       if (!CanSkipTypeCheck(NULL, parameter.type())) {
         BindInstr* load = new BindInstr(BuildLoadLocal(parameter));
         AddInstruction(load);
-        BuildAssertAssignable(parameter.token_index(),
-                              new UseVal(load),
-                              parameter.type(),
-                              parameter.name());
+        AssertAssignableComp* assert_assignable =
+            BuildAssertAssignable(parameter.token_index(),
+                                  new UseVal(load),
+                                  parameter.type(),
+                                  parameter.name());
+        AddInstruction(new DoInstr(assert_assignable));
       }
       pos++;
     }
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner(), temp_index());
     node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
@@ skipping 326 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart