Avoid GC when compiling CallIC stubs....

src/heap.h

 // Copyright 2006-2008 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 859 matching lines @@
 
   // Invoke Shrink on shrinkable spaces.
   static void Shrink();
 
   enum HeapState { NOT_IN_GC, SCAVENGE, MARK_COMPACT };
   static inline HeapState gc_state() { return gc_state_; }
 
 #ifdef DEBUG
   static bool IsAllocationAllowed() { return allocation_allowed_; }
   static inline bool allow_allocation(bool enable);
+  static bool IsGCAllowed() { return gc_allowed_; }
+  static inline bool allow_gc(bool enable);
 
   static bool disallow_allocation_failure() {
     return disallow_allocation_failure_;
   }
 
   static void TracePathToObject(Object* target);
   static void TracePathToGlobal();
 #endif
 
   // Callback function passed to Heap::Iterate etc.  Copies an object if
@@ skipping 181 matching lines @@
 
 #define ROOT_ACCESSOR(type, name, camel_name)                                  \
   static inline void set_##name(type* value) {                                 \
     roots_[k##camel_name##RootIndex] = value;                                  \
   }
   ROOT_LIST(ROOT_ACCESSOR)
 #undef ROOT_ACCESSOR
 
 #ifdef DEBUG
   static bool allocation_allowed_;
+  static bool gc_allowed_;
 
   // If the --gc-interval flag is set to a positive value, this
   // variable holds the value indicating the number of allocations
   // remain until the next failure and garbage collection.
   static int allocation_timeout_;
 
   // Do we expect to be able to handle allocation failure at this
   // time?
   static bool disallow_allocation_failure_;
 #endif  // DEBUG
@@ skipping 582 matching lines @@
   }
 
   ~AssertNoAllocation() {
     Heap::allow_allocation(old_state_);
   }
 
  private:
   bool old_state_;
 };
 
+class AssertNoGC {
+ public:
+  AssertNoGC() {
+    old_state_ = Heap::allow_gc(false);
+  }
+
+  ~AssertNoGC() {
+    Heap::allow_gc(old_state_);
+  }
+
+ private:
+  bool old_state_;
+};
+
 class DisableAssertNoAllocation {
  public:
   DisableAssertNoAllocation() {
     old_state_ = Heap::allow_allocation(true);
   }
 
   ~DisableAssertNoAllocation() {
     Heap::allow_allocation(old_state_);
   }
 
  private:
   bool old_state_;
 };
 
 #else  // ndef DEBUG
 
 class AssertNoAllocation {
  public:
   AssertNoAllocation() { }
   ~AssertNoAllocation() { }
 };
 
+class AssertNoGC {
+ public:
+  AssertNoGC() { }
+  ~AssertNoGC() { }
+};
+
 class DisableAssertNoAllocation {
  public:
   DisableAssertNoAllocation() { }
   ~DisableAssertNoAllocation() { }
 };
 
 #endif
 
 // GCTracer collects and prints ONE line after each garbage collector
 // invocation IFF --trace_gc is used.
@@ skipping 260 matching lines @@
 
   // To speed up scavenge collections new space string are kept
   // separate from old space strings.
   static List<Object*> new_space_strings_;
   static List<Object*> old_space_strings_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_