Re-optimize faster after making a pretenuring decision.

src/objects.h

 // Copyright 2012 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.
 
 #ifndef V8_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include "allocation.h"
 #include "assert-scope.h"
 #include "builtins.h"
@@ skipping 5443 matching lines @@
   // cache is passed to the stub.
   inline bool has_function_cache();
   inline void set_has_function_cache(bool flag);
 
 
   // [marked_for_deoptimization]: For kind OPTIMIZED_FUNCTION tells whether
   // the code is going to be deoptimized because of dead embedded maps.
   inline bool marked_for_deoptimization();
   inline void set_marked_for_deoptimization(bool flag);
 
+  inline bool marked_for_instant_optimization();
+  inline void set_marked_for_instant_optimization(bool flag);
+
   // [constant_pool]: The constant pool for this function.
   inline ConstantPoolArray* constant_pool();
   inline void set_constant_pool(Object* constant_pool);
 
   // Get the safepoint entry for the given pc.
   SafepointEntry GetSafepointEntry(Address pc);
 
   // Find an object in a stub with a specified map
   Object* FindNthObject(int n, Map* match_map);
 
@@ skipping 154 matching lines @@
   // Gets the raw code age, including psuedo code-age values such as
   // kNotExecutedCodeAge and kExecutedOnceCodeAge.
   Age GetRawAge();
   static inline Code* GetPreAgedCodeAgeStub(Isolate* isolate) {
     return GetCodeAgeStub(isolate, kNotExecutedCodeAge, NO_MARKING_PARITY);
   }
 
   void PrintDeoptLocation(FILE* out, int bailout_id);
   bool CanDeoptAt(Address pc);
 
+  void GetICCounts(int* ic_with_type_info_count,
+                   int* ic_total_count,
+                   int* percentage);
+
 #ifdef VERIFY_HEAP
   void VerifyEmbeddedObjectsDependency();
 #endif
 
   inline bool CanContainWeakObjects() {
     return is_optimized_code() || is_weak_stub();
   }
 
   inline bool IsWeakObject(Object* object) {
     return (is_optimized_code() && IsWeakObjectInOptimizedCode(object)) ||
@@ skipping 63 matching lines @@
   static const int kHasFunctionCacheBitCount = 1;
   static const int kMarkedForDeoptimizationFirstBit =
       kStackSlotsFirstBit + kStackSlotsBitCount + 1;
   static const int kMarkedForDeoptimizationBitCount = 1;
   static const int kWeakStubFirstBit =
       kMarkedForDeoptimizationFirstBit + kMarkedForDeoptimizationBitCount;
   static const int kWeakStubBitCount = 1;
   static const int kInvalidatedWeakStubFirstBit =
       kWeakStubFirstBit + kWeakStubBitCount;
   static const int kInvalidatedWeakStubBitCount = 1;
+  static const int kMarkedForInstantOptimizationFirstBit =
+      kInvalidatedWeakStubFirstBit + kInvalidatedWeakStubBitCount + 1;
+  static const int kMarkedForInstantOptimizationBitCount = 1;
 
   STATIC_ASSERT(kStackSlotsFirstBit + kStackSlotsBitCount <= 32);
   STATIC_ASSERT(kHasFunctionCacheFirstBit + kHasFunctionCacheBitCount <= 32);
-  STATIC_ASSERT(kInvalidatedWeakStubFirstBit +
-                kInvalidatedWeakStubBitCount <= 32);
+  STATIC_ASSERT(kMarkedForInstantOptimizationFirstBit +
+                kMarkedForInstantOptimizationBitCount <= 32);
 
   class StackSlotsField: public BitField<int,
       kStackSlotsFirstBit, kStackSlotsBitCount> {};  // NOLINT
   class HasFunctionCacheField: public BitField<bool,
       kHasFunctionCacheFirstBit, kHasFunctionCacheBitCount> {};  // NOLINT
   class MarkedForDeoptimizationField: public BitField<bool,
       kMarkedForDeoptimizationFirstBit,
       kMarkedForDeoptimizationBitCount> {};  // NOLINT
   class WeakStubField: public BitField<bool,
       kWeakStubFirstBit,
       kWeakStubBitCount> {};  // NOLINT
   class InvalidatedWeakStubField: public BitField<bool,
       kInvalidatedWeakStubFirstBit,
       kInvalidatedWeakStubBitCount> {};  // NOLINT
+  class MarkedForInstantOptimizationField: public BitField<bool,
+      kMarkedForInstantOptimizationFirstBit,
+      kMarkedForInstantOptimizationBitCount> {};  // NOLINT
 
   // KindSpecificFlags2 layout (ALL)
   static const int kIsCrankshaftedBit = 0;
   class IsCrankshaftedField: public BitField<bool,
       kIsCrankshaftedBit, 1> {};  // NOLINT
 
   // KindSpecificFlags2 layout (STUB and OPTIMIZED_FUNCTION)
   static const int kStubMajorKeyFirstBit = kIsCrankshaftedBit + 1;
   static const int kSafepointTableOffsetFirstBit =
       kStubMajorKeyFirstBit + kStubMajorKeyBits;
@@ skipping 124 matching lines @@
   void UpdateToFinishedCode(DependencyGroup group,
                             CompilationInfo* info,
                             Code* code);
   void RemoveCompilationInfo(DependentCode::DependencyGroup group,
                              CompilationInfo* info);
 
   void DeoptimizeDependentCodeGroup(Isolate* isolate,
                                     DependentCode::DependencyGroup group);
 
   bool MarkCodeForDeoptimization(Isolate* isolate,
-                                 DependentCode::DependencyGroup group);
+                                 DependentCode::DependencyGroup group,
+                                 bool instant_optimize = false);
+
   void AddToDependentICList(Handle<Code> stub);
 
   // The following low-level accessors should only be used by this class
   // and the mark compact collector.
   inline int number_of_entries(DependencyGroup group);
   inline void set_number_of_entries(DependencyGroup group, int value);
   inline bool is_code_at(int i);
   inline Code* code_at(int i);
   inline CompilationInfo* compilation_info_at(int i);
   inline void set_object_at(int i, Object* object);
@@ skipping 5221 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_