Distinction between FeedbackVectorICSlot and FeedbackVectorSlot eliminated.

src/typing.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/typing.h"
 
 #include "src/frames.h"
 #include "src/frames-inl.h"
 #include "src/ostreams.h"
 #include "src/parser.h"  // for CompileTimeValue; TODO(rossberg): should move
@@ skipping 384 matching lines @@
 
     // Collect type feedback.
     if ((prop->kind() == ObjectLiteral::Property::MATERIALIZED_LITERAL &&
         !CompileTimeValue::IsCompileTimeValue(prop->value())) ||
         prop->kind() == ObjectLiteral::Property::COMPUTED) {
       if (!prop->is_computed_name() &&
           prop->key()->AsLiteral()->value()->IsInternalizedString() &&
           prop->emit_store()) {
         // Record type feed back for the property.
         TypeFeedbackId id = prop->key()->AsLiteral()->LiteralFeedbackId();
-        FeedbackVectorICSlot slot = prop->GetSlot();
+        FeedbackVectorSlot slot = prop->GetSlot();
         SmallMapList maps;
         if (FLAG_vector_stores) {
           oracle()->CollectReceiverTypes(slot, &maps);
         } else {
           oracle()->CollectReceiverTypes(id, &maps);
         }
         prop->set_receiver_type(maps.length() == 1 ? maps.at(0)
                                                    : Handle<Map>::null());
       }
     }
@@ skipping 14 matching lines @@
 
   NarrowType(expr, Bounds(Type::Object(zone())));
 }
 
 
 void AstTyper::VisitAssignment(Assignment* expr) {
   // Collect type feedback.
   Property* prop = expr->target()->AsProperty();
   if (prop != NULL) {
     TypeFeedbackId id = expr->AssignmentFeedbackId();
-    FeedbackVectorICSlot slot = expr->AssignmentSlot();
+    FeedbackVectorSlot slot = expr->AssignmentSlot();
     expr->set_is_uninitialized(FLAG_vector_stores
                                    ? oracle()->StoreIsUninitialized(slot)
                                    : oracle()->StoreIsUninitialized(id));
     if (!expr->IsUninitialized()) {
       SmallMapList* receiver_types = expr->GetReceiverTypes();
       if (prop->key()->IsPropertyName()) {
         Literal* lit_key = prop->key()->AsLiteral();
         DCHECK(lit_key != NULL && lit_key->value()->IsString());
         Handle<String> name = Handle<String>::cast(lit_key->value());
         if (FLAG_vector_stores) {
@@ skipping 41 matching lines @@
 void AstTyper::VisitThrow(Throw* expr) {
   RECURSE(Visit(expr->exception()));
   // TODO(rossberg): is it worth having a non-termination effect?
 
   NarrowType(expr, Bounds(Type::None(zone())));
 }
 
 
 void AstTyper::VisitProperty(Property* expr) {
   // Collect type feedback.
-  FeedbackVectorICSlot slot(FeedbackVectorICSlot::Invalid());
-  slot = expr->PropertyFeedbackSlot();
+  FeedbackVectorSlot slot = expr->PropertyFeedbackSlot();
   expr->set_inline_cache_state(oracle()->LoadInlineCacheState(slot));
 
   if (!expr->IsUninitialized()) {
     if (expr->key()->IsPropertyName()) {
       Literal* lit_key = expr->key()->AsLiteral();
       DCHECK(lit_key != NULL && lit_key->value()->IsString());
       Handle<String> name = Handle<String>::cast(lit_key->value());
       oracle()->PropertyReceiverTypes(slot, name, expr->GetReceiverTypes());
     } else {
       bool is_string;
@@ skipping 10 matching lines @@
 
   // We don't know anything about the result type.
 }
 
 
 void AstTyper::VisitCall(Call* expr) {
   // Collect type feedback.
   RECURSE(Visit(expr->expression()));
   bool is_uninitialized = true;
   if (expr->IsUsingCallFeedbackICSlot(isolate())) {
-    FeedbackVectorICSlot slot = expr->CallFeedbackICSlot();
+    FeedbackVectorSlot slot = expr->CallFeedbackICSlot();
     is_uninitialized = oracle()->CallIsUninitialized(slot);
     if (!expr->expression()->IsProperty() &&
         oracle()->CallIsMonomorphic(slot)) {
       expr->set_target(oracle()->GetCallTarget(slot));
       Handle<AllocationSite> site = oracle()->GetCallAllocationSite(slot);
       expr->set_allocation_site(site);
     }
   }
 
   expr->set_is_uninitialized(is_uninitialized);
@@ skipping 70 matching lines @@
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 void AstTyper::VisitCountOperation(CountOperation* expr) {
   // Collect type feedback.
   TypeFeedbackId store_id = expr->CountStoreFeedbackId();
-  FeedbackVectorICSlot slot = expr->CountSlot();
+  FeedbackVectorSlot slot = expr->CountSlot();
   KeyedAccessStoreMode store_mode;
   IcCheckType key_type;
   if (FLAG_vector_stores) {
     oracle()->GetStoreModeAndKeyType(slot, &store_mode, &key_type);
     oracle()->CountReceiverTypes(slot, expr->GetReceiverTypes());
   } else {
     oracle()->GetStoreModeAndKeyType(store_id, &store_mode, &key_type);
     oracle()->CountReceiverTypes(store_id, expr->GetReceiverTypes());
   }
   expr->set_store_mode(store_mode);
@@ skipping 169 matching lines @@
 void AstTyper::VisitImportDeclaration(ImportDeclaration* declaration) {
 }
 
 
 void AstTyper::VisitExportDeclaration(ExportDeclaration* declaration) {
 }
 
 
 }  // namespace internal
 }  // namespace v8