Added type propagation from store to load locals, but only within a sequence node (not across bas...

vm/opt_code_generator_ia32.cc

 // Copyright (c) 2011, 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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/opt_code_generator.h"
 
 #include "vm/assembler_macros.h"
@@ skipping 18 matching lines @@
 // and a getter of specified type and name.
 // (name, type, default)
 #define PROPERTY_LIST(V)                                                       \
   V(is_temp, bool, false)                                                      \
   V(true_label, Label*, NULL)                                                  \
   V(false_label, Label*, NULL)                                                 \
   V(labels_used, bool, false)                                                  \
   V(request_result_in_eax, bool, false)                                        \
   V(result_returned_in_eax, bool, false)                                       \
   V(fallthrough_label, Label*, NULL)                                           \
-  V(is_class, const Class*, NULL)                                              \
+  V(is_class, const Class*, &Class::ZoneHandle())                              \
 
 
 // Class holding information being passed from source to destination.
 // Add needed properties in the PROPERTY_LIST above.
 class CodeGenInfo : public ValueObject {
  public:
   explicit CodeGenInfo(AstNode* node)
       : node_(node), data_(4) {
     ASSERT(node != NULL);
     ASSERT(node->info() == NULL);
     node->set_info(this);
   }
 
   ~CodeGenInfo() {
     ASSERT(node_->info() == this);
     node_->set_info(NULL);
   }
 
   bool IsClass(const Class& cls) const {
-    if (is_class() == NULL) {
-      return cls.IsNullClass();
-    }
     return is_class()->raw() == cls.raw();
   }
 
 #define GETTER(name, type, default)                                            \
   type name() const {                                                          \
     Pair* p = Get(k_##name);                                                   \
     return p == NULL ? default : p->name;                                      \
   }
 PROPERTY_LIST(GETTER)
 #undef GETTER
@@ skipping 128 matching lines @@
 RECOGNIZED_LIST(KIND_TO_STRING)
 #undef KIND_TO_STRING
     return "?";
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Recognizer);
 };
 
 
+// Maintain classes of locals as defined by a store to that local.
+// A simple initial implementation, memorizes last typed stores. Does not
+// scale well for large code pieces. This will be replaced by SSA based
+// type propagation.
+class ClassesForLocals : public ZoneAllocated {
+ public:
+  ClassesForLocals() : classes_(), locals_() {}
+  void SetLocalType(const LocalVariable& local, const Class& cls) {
+    classes_.Add(&cls);
+    locals_.Add(&local);
+  }
+  // If no type is stored/known, we return a null class in 'cls'.
+  void GetLocalClass(const LocalVariable& local, const Class** cls) const {
+    for (intptr_t i = locals_.length() - 1; i >=0; i--) {
+      if (locals_[i]->Equals(local)) {
+        *cls = classes_[i];
+        return;
+      }
+    }
+    *cls = &Class::ZoneHandle();
+  }
+
+  void Clear() {
+    classes_.Clear();
+    locals_.Clear();
+  }
+
+ private:
+  GrowableArray<const Class*> classes_;
+  GrowableArray<const LocalVariable*> locals_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClassesForLocals);
+};
+
+
 static const char* kGrowableArrayClassName = "GrowableObjectArray";
 static const char* kGrowableArrayLengthFieldName = "_length";
 static const char* kGrowableArrayArrayFieldName = "backingArray";
 
 
 OptimizingCodeGenerator::OptimizingCodeGenerator(
     Assembler* assembler, const ParsedFunction& parsed_function)
         : CodeGenerator(assembler, parsed_function),
           deoptimization_blobs_(4),
+          classes_for_locals_(new ClassesForLocals()),
           smi_class_(Class::ZoneHandle(Isolate::Current()->object_store()
               ->smi_class())),
           double_class_(Class::ZoneHandle(Isolate::Current()->object_store()
               ->double_class())) {
   ASSERT(parsed_function.function().is_optimizable());
 }
 
 
 DeoptimizationBlob*
 OptimizingCodeGenerator::AddDeoptimizationBlob(AstNode* node,
@@ skipping 194 matching lines @@
 void OptimizingCodeGenerator::VisitLoadOne(AstNode* node, Register reg) {
   if (!IsQuickLoad(node)) {
     node->Visit(this);
     __ popl(reg);
     return;
   }
   if (node->AsLoadLocalNode()) {
     LoadLocalNode* local_node = node->AsLoadLocalNode();
     ASSERT(local_node != NULL);
     GenerateLoadVariable(reg, local_node->local());
+    if (node->info() != NULL) {
+      const Class* cls = NULL;
+      classes_for_locals_->GetLocalClass(local_node->local(), &cls);
+      if (cls != NULL) {
+        node->info()->set_is_class(cls);
+      }
+    }
     return;
   }
   if (node->AsLiteralNode()) {
     LiteralNode* literal_node = node->AsLiteralNode();
     ASSERT(literal_node != NULL);
     __ LoadObject(reg, literal_node->literal());
     if (node->info() != NULL) {
       const Object& literal = literal_node->literal();
       if (literal.IsSmi()) {
         node->info()->set_is_class(&smi_class_);
@@ skipping 65 matching lines @@
 
 
 void OptimizingCodeGenerator::VisitLoadLocalNode(LoadLocalNode* node) {
   if (!IsResultNeeded(node)) return;
   if (IsResultInEaxRequested(node)) {
     GenerateLoadVariable(EAX, node->local());
     node->info()->set_result_returned_in_eax(true);
   } else {
     GeneratePushVariable(node->local(), EAX);
   }
+  if (node->info() != NULL) {
+    const Class* cls = NULL;
+    classes_for_locals_->GetLocalClass(node->local(), &cls);
+    if (cls != NULL) {
+      node->info()->set_is_class(cls);
+    }
+  }
 }
 
 
 void OptimizingCodeGenerator::VisitStoreLocalNode(StoreLocalNode* node) {
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitStoreLocalNode(node);
+    classes_for_locals_->SetLocalType(node->local(), Class::ZoneHandle());
     return;
   }
   CodeGenInfo value_info(node->value());
   value_info.set_request_result_in_eax(true);
   node->value()->Visit(this);
   if (value_info.is_temp()) {
     if (value_info.IsClass(double_class_)) {
       if (value_info.result_returned_in_eax()) {
         __ pushl(EAX);
       }
@@ skipping 11 matching lines @@
     }
   } else {
     if (!value_info.result_returned_in_eax()) {
       __ popl(EAX);
     }
     CodeGenerator::GenerateStoreVariable(node->local(), EAX, EDX);
   }
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
+  classes_for_locals_->SetLocalType(node->local(), *value_info.is_class());
 }
 
 
 static bool NodeHasBothReceiverClasses(AstNode* node,
                                        const Class& cls1,
                                        const Class& cls2) {
   ASSERT(node != NULL);
   ASSERT(!cls1.IsNull() && !cls2.IsNull());
   const ICData& ic_data = node->ICDataAtId(node->id());
   bool cls1_found = false;
@@ skipping 321 matching lines @@
   TraceNotOpt(node, kOptMessage);
   CodeGenerator::VisitBinaryOpNode(node);
 }
 
 
 // Conservative approach:
 // - true if both nodes are LoadLocalNodes with the same index.
 static bool AreNodesOfSameType(AstNode* a, AstNode* b) {
   ASSERT((a != NULL) && (b != NULL));
   if (a->IsLoadLocalNode() && b->IsLoadLocalNode()) {
-    return a->AsLoadLocalNode()->local().index() ==
-           b->AsLoadLocalNode()->local().index();
+    return a->AsLoadLocalNode()->local().Equals(b->AsLoadLocalNode()->local());
   }
   return false;
 }
 
 // 'reg' is not modified, 'temp' is trashed.
 // Fall through if double, jump to 'is_smi' if Smi and
 // jump to 'not_double_or_smi' if neither double nor Smi.
 void OptimizingCodeGenerator::CheckIfDoubleOrSmi(Register reg,
                                                  Register temp,
                                                  Label* is_smi,
@@ skipping 234 matching lines @@
   // Type feedback tells this is not a Smi or Double operation.
   TraceNotOpt(node,
       "BinaryOp: type feedback tells this is not a Smi or Double op");
   CodeGenerator::VisitBinaryOpNode(node);
   return;
 }
 
 
 void OptimizingCodeGenerator::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   if (FLAG_enable_type_checks) {
+    classes_for_locals_->SetLocalType(node->local(), Class::ZoneHandle());
     CodeGenerator::VisitIncrOpLocalNode(node);
     return;
   }
   const char* kOptMessage = "Inlines IncrOpLocal";
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   if (!AtIdNodeHasReceiverClass(node, node->id(), smi_class_)) {
+    classes_for_locals_->SetLocalType(node->local(), Class::ZoneHandle());
     TraceNotOpt(node, kOptMessage);
     CodeGenerator::VisitIncrOpLocalNode(node);
     return;
   }
   TraceOpt(node, kOptMessage);
 
   GenerateLoadVariable(EAX, node->local());
   if (!node->prefix() && IsResultNeeded(node)) {
     // Preserve as result.
     __ movl(ECX, EAX);
@@ skipping 10 matching lines @@
   if (IsResultNeeded(node)) {
     if (node->info() != NULL) {
       node->info()->set_is_class(&smi_class_);
     }
     if (node->prefix()) {
       __ pushl(EAX);
     } else {
       __ pushl(ECX);
     }
   }
+  classes_for_locals_->SetLocalType(node->local(), smi_class_);
 }
 
 
 // Debugging helper method, used in assert only.
 static bool HaveSameClassesInICData(const ICData& a, const ICData& b) {
   if (a.NumberOfChecks() != b.NumberOfChecks()) {
     return false;
   }
   if (a.NumberOfChecks() == 0) {
     return true;
@@ skipping 1418 matching lines @@
     return;
   }
   ASSERT(!IsResultNeeded(node));
   ASSERT(node->value() != NULL);
   VisitLoadOne(node->value(), EAX);
   GenerateReturnEpilog();
 }
 
 
 void OptimizingCodeGenerator::VisitSequenceNode(SequenceNode* node_sequence) {
+  // TODO(srdjan): Allow limited forwarding of types across sequence nodes.
+  classes_for_locals_->Clear();
   const intptr_t num_context_variables = (node_sequence->scope() != NULL) ?
       node_sequence->scope()->num_context_variables() : 0;
   if (FLAG_enable_type_checks || (num_context_variables > 0)) {
     CodeGenerator::VisitSequenceNode(node_sequence);
     return;
   }
   for (int i = 0; i < node_sequence->length(); i++) {
     AstNode* child_node = node_sequence->NodeAt(i);
     state()->set_root_node(child_node);
     child_node->Visit(this);
   }
   if (node_sequence->label() != NULL) {
     __ Bind(node_sequence->label()->break_label());
   }
+  classes_for_locals_->Clear();
 }
 
 
 void OptimizingCodeGenerator::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitStoreInstanceFieldNode(node);
     return;
   }
   VisitLoadTwo(node->instance(), node->value(), EDX, EAX);
   __ StoreIntoObject(EDX, FieldAddress(EDX, node->field().Offset()), EAX);
   if (IsResultNeeded(node)) {
     // The result is the input value.
     __ pushl(EAX);
   }
 }
 
 
+void OptimizingCodeGenerator::VisitCatchClauseNode(CatchClauseNode* node) {
+  // TODO(srdjan): Set classes for locals.
+  classes_for_locals_->Clear();
+  CodeGenerator::VisitCatchClauseNode(node);
+}
+
+
+void OptimizingCodeGenerator::VisitTryCatchNode(TryCatchNode* node) {
+  // TODO(srdjan): Set classes for locals.
+  classes_for_locals_->Clear();
+  CodeGenerator::VisitTryCatchNode(node);
+}
+
+
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32