Adding a type vector to replace type cells.

src/ast.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 21 matching lines @@
 #include "code-stubs.h"
 #include "contexts.h"
 #include "conversions.h"
 #include "hashmap.h"
 #include "parser.h"
 #include "property-details.h"
 #include "property.h"
 #include "scopes.h"
 #include "string-stream.h"
 #include "type-info.h"
+#include "third_party/loki/TypeManip.h"
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 // All the Accept member functions for each syntax tree node type.
 
 #define DECL_ACCEPT(type)                                       \
   void type::Accept(AstVisitor* v) { v->Visit##type(this); }
 AST_NODE_LIST(DECL_ACCEPT)
@@ skipping 535 matching lines @@
 // Recording of type feedback
 
 // TODO(rossberg): all RecordTypeFeedback functions should disappear
 // once we use the common type field in the AST consistently.
 
 void Expression::RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) {
   to_boolean_types_ = oracle->ToBooleanTypes(test_id());
 }
 
 
+int Call::GetFeedbackSlotCount(Isolate* isolate) {
+  CallType call_type = GetCallType(isolate);
+  if (call_type == LOOKUP_SLOT_CALL || call_type == OTHER_CALL) {
+    // Call only uses a slot in some cases.
+    return 1;
+  }
+
+  return 0;
+}
+
+
 Call::CallType Call::GetCallType(Isolate* isolate) const {
   VariableProxy* proxy = expression()->AsVariableProxy();
   if (proxy != NULL) {
     if (proxy->var()->is_possibly_eval(isolate)) {
       return POSSIBLY_EVAL_CALL;
     } else if (proxy->var()->IsUnallocated()) {
       return GLOBAL_CALL;
     } else if (proxy->var()->IsLookupSlot()) {
       return LOOKUP_SLOT_CALL;
     }
@@ skipping 98 matching lines @@
     case BOOLEAN_CHECK:
       function = native_context->boolean_function();
       break;
   }
   ASSERT(function != NULL);
   return Handle<JSObject>(JSObject::cast(function->instance_prototype()));
 }
 
 
 void Call::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
-  is_monomorphic_ = oracle->CallIsMonomorphic(CallFeedbackId());
-  Property* property = expression()->AsProperty();
-  if (property == NULL) {
-    // Function call.  Specialize for monomorphic calls.
-    if (is_monomorphic_) target_ = oracle->GetCallTarget(CallFeedbackId());
-  } else if (property->key()->IsPropertyName()) {
-    // Method call.  Specialize for the receiver types seen at runtime.
-    Literal* key = property->key()->AsLiteral();
-    ASSERT(key != NULL && key->value()->IsString());
-    Handle<String> name = Handle<String>::cast(key->value());
-    check_type_ = oracle->GetCallCheckType(CallFeedbackId());
-    receiver_types_.Clear();
-    if (check_type_ == RECEIVER_MAP_CHECK) {
-      oracle->CallReceiverTypes(CallFeedbackId(),
-          name, arguments()->length(), &receiver_types_);
-      is_monomorphic_ = is_monomorphic_ && receiver_types_.length() > 0;
-    } else {
-      holder_ = GetPrototypeForPrimitiveCheck(check_type_, oracle->isolate());
-      receiver_types_.Add(handle(holder_->map()), oracle->zone());
-    }
+  if (HasCallFeedbackSlot()) {
+    // We stored feedback in the type vector.
+    is_monomorphic_ = oracle->CallIsMonomorphic(CallFeedbackSlot());
+    ASSERT(expression()->AsProperty() == NULL);
+    if (is_monomorphic_) target_ = oracle->GetCallTarget(CallFeedbackSlot());
+  } else {
+    // We stored feedback in an IC.
+    is_monomorphic_ = oracle->CallIsMonomorphic(CallFeedbackId());
+    Property* property = expression()->AsProperty();
+    if (property != NULL) {
+      if (property->key()->IsPropertyName()) {
+        // Method call.  Specialize for the receiver types seen at runtime.
+        Literal* key = property->key()->AsLiteral();
+        ASSERT(key != NULL && key->value()->IsString());
+        Handle<String> name = Handle<String>::cast(key->value());
+        check_type_ = oracle->GetCallCheckType(CallFeedbackId());
+        receiver_types_.Clear();
+        if (check_type_ == RECEIVER_MAP_CHECK) {
+          oracle->CallReceiverTypes(CallFeedbackId(),
+                                    name, arguments()->length(),
+                                    &receiver_types_);
+          is_monomorphic_ = is_monomorphic_ && receiver_types_.length() > 0;
+        } else {
+          holder_ = GetPrototypeForPrimitiveCheck(check_type_,
+                                                  oracle->isolate());
+          receiver_types_.Add(handle(holder_->map()), oracle->zone());
+        }
 #ifdef ENABLE_SLOW_ASSERTS
-    if (FLAG_enable_slow_asserts) {
-      int length = receiver_types_.length();
-      for (int i = 0; i < length; i++) {
-        Handle<Map> map = receiver_types_.at(i);
-        ASSERT(!map.is_null() && *map != NULL);
+        if (FLAG_enable_slow_asserts) {
+          int length = receiver_types_.length();
+          for (int i = 0; i < length; i++) {
+            Handle<Map> map = receiver_types_.at(i);
+            ASSERT(!map.is_null() && *map != NULL);
+          }
+        }
+#endif
+        if (is_monomorphic_) {
+          Handle<Map> map = receiver_types_.first();
+          is_monomorphic_ = ComputeTarget(map, name);
+        }
+      } else {
+        if (is_monomorphic_) {
+          keyed_array_call_is_holey_ =
+              oracle->KeyedArrayCallIsHoley(CallFeedbackId());
+        }
       }
     }
-#endif
-    if (is_monomorphic_) {
-      Handle<Map> map = receiver_types_.first();
-      is_monomorphic_ = ComputeTarget(map, name);
-    }
-  } else {
-    if (is_monomorphic_) {
-      keyed_array_call_is_holey_ =
-          oracle->KeyedArrayCallIsHoley(CallFeedbackId());
-    }
   }
 }
 
 
 void CallNew::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
   allocation_site_ =
-      oracle->GetCallNewAllocationSite(CallNewFeedbackId());
-  is_monomorphic_ = oracle->CallNewIsMonomorphic(CallNewFeedbackId());
+      oracle->GetCallNewAllocationSite(CallNewFeedbackSlot());
+  is_monomorphic_ = oracle->CallNewIsMonomorphic(CallNewFeedbackSlot());
   if (is_monomorphic_) {
-    target_ = oracle->GetCallNewTarget(CallNewFeedbackId());
+    target_ = oracle->GetCallNewTarget(CallNewFeedbackSlot());
     if (!allocation_site_.is_null()) {
       elements_kind_ = allocation_site_->GetElementsKind();
     }
   }
 }
 
 
 void ObjectLiteral::Property::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
   TypeFeedbackId id = key()->LiteralFeedbackId();
   SmallMapList maps;
@@ skipping 378 matching lines @@
                        int pos)
     : Expression(zone, pos),
       label_(label),
       statements_(statements),
       compare_type_(Type::None(zone)),
       compare_id_(AstNode::GetNextId(zone)),
       entry_id_(AstNode::GetNextId(zone)) {
 }
 
 
+// FeedbackSlotUpdater exists to avoid a C-style cast from AstNode subtypes to
+// FeedbackSlotInterface. With partial template specialization, we allow Loki
+// to determine whether or not it's safe to cast an AstNode to
+// FeedbackSlotInterface, then make the cast and call add_slot_node()
+// in a compile-safe way.
+template<bool B, class N>
+class FeedbackSlotUpdater {
+ public:
+  static void Update(AstConstructionVisitor* visitor, N* n) {
+    FeedbackSlotInterface* slot = static_cast<FeedbackSlotInterface*>(n);
+    visitor->add_slot_node(slot);
+  }
+};
+
+
+template<class N>
+class FeedbackSlotUpdater<false, N> {
+ public:
+  static void Update(AstConstructionVisitor* visitor, N* n) {}
+};
+
+
+#define UPDATE_FEEDBACK_SLOTS(NodeType, node)                               \
+    FeedbackSlotUpdater<                                                    \
+      Loki::SuperSubclass<FeedbackSlotInterface, NodeType>::value,          \
+          NodeType>::Update(this, node)
+
+
 #define REGULAR_NODE(NodeType) \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
     increase_node_count(); \
+    UPDATE_FEEDBACK_SLOTS(NodeType, node); \
   }
 #define DONT_OPTIMIZE_NODE(NodeType) \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
     increase_node_count(); \
+    UPDATE_FEEDBACK_SLOTS(NodeType, node); \
     set_dont_optimize_reason(k##NodeType); \
     add_flag(kDontInline); \
     add_flag(kDontSelfOptimize); \
   }
 #define DONT_SELFOPTIMIZE_NODE(NodeType) \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
     increase_node_count(); \
+    UPDATE_FEEDBACK_SLOTS(NodeType, node); \
     add_flag(kDontSelfOptimize); \
   }
 #define DONT_CACHE_NODE(NodeType) \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
     increase_node_count(); \
+    UPDATE_FEEDBACK_SLOTS(NodeType, node); \
     set_dont_optimize_reason(k##NodeType); \
     add_flag(kDontInline); \
     add_flag(kDontSelfOptimize); \
     add_flag(kDontCache); \
   }
 
 REGULAR_NODE(VariableDeclaration)
 REGULAR_NODE(FunctionDeclaration)
 REGULAR_NODE(Block)
 REGULAR_NODE(ExpressionStatement)
@@ skipping 44 matching lines @@
 DONT_SELFOPTIMIZE_NODE(DoWhileStatement)
 DONT_SELFOPTIMIZE_NODE(WhileStatement)
 DONT_SELFOPTIMIZE_NODE(ForStatement)
 DONT_SELFOPTIMIZE_NODE(ForInStatement)
 DONT_SELFOPTIMIZE_NODE(ForOfStatement)
 
 DONT_CACHE_NODE(ModuleLiteral)
 
 void AstConstructionVisitor::VisitCallRuntime(CallRuntime* node) {
   increase_node_count();
+  UPDATE_FEEDBACK_SLOTS(CallRuntime, node);
   if (node->is_jsruntime()) {
     // Don't try to inline JS runtime calls because we don't (currently) even
     // optimize them.
     add_flag(kDontInline);
   } else if (node->function()->intrinsic_type == Runtime::INLINE &&
       (node->name()->IsOneByteEqualTo(
           STATIC_ASCII_VECTOR("_ArgumentsLength")) ||
        node->name()->IsOneByteEqualTo(STATIC_ASCII_VECTOR("_Arguments")))) {
     // Don't inline the %_ArgumentsLength or %_Arguments because their
     // implementation will not work.  There is no stack frame to get them
@@ skipping 19 matching lines @@
     OS::SNPrintF(buffer, "%d", Smi::cast(*value_)->value());
     str = arr;
   } else {
     str = DoubleToCString(value_->Number(), buffer);
   }
   return isolate_->factory()->NewStringFromAscii(CStrVector(str));
 }
 
 
 } }  // namespace v8::internal