Improved function entry hook coverage

src/isolate.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 1736 matching lines @@
       global_handles_(NULL),
       context_switcher_(NULL),
       thread_manager_(NULL),
       fp_stubs_generated_(false),
       has_installed_extensions_(false),
       string_tracker_(NULL),
       regexp_stack_(NULL),
       date_cache_(NULL),
       code_stub_interface_descriptors_(NULL),
       context_exit_happened_(false),
+      initialized_from_snapshot_(false),
       cpu_profiler_(NULL),
       heap_profiler_(NULL),
+      function_entry_hook_(NullFunctionEntryHook),
       deferred_handles_head_(NULL),
       optimizing_compiler_thread_(this),
       marking_thread_(NULL),
       sweeper_thread_(NULL),
       callback_table_(NULL) {
   id_ = NoBarrier_AtomicIncrement(&isolate_counter_, 1);
   TRACE_ISOLATE(constructor);
 
   memset(isolate_addresses_, 0,
       sizeof(isolate_addresses_[0]) * (kIsolateAddressCount + 1));
@@ skipping 156 matching lines @@
 }
 
 
 void Isolate::SetIsolateThreadLocals(Isolate* isolate,
                                      PerIsolateThreadData* data) {
   Thread::SetThreadLocal(isolate_key_, isolate);
   Thread::SetThreadLocal(per_isolate_thread_data_key_, data);
 }
 
 
+void Isolate::NullFunctionEntryHook(uintptr_t function,
+                                    uintptr_t return_addr_location) {
+  // Ignore callbacks.
+}
+
+
+
 Isolate::~Isolate() {
   TRACE_ISOLATE(destructor);
 
   // Has to be called while counters_ are still alive.
   runtime_zone_.DeleteKeptSegment();
 
   delete[] assembler_spare_buffer_;
   assembler_spare_buffer_ = NULL;
 
   delete unicode_cache_;
@@ skipping 129 matching lines @@
   Release_Store(&debugger_initialized_, true);
 #endif
 }
 
 
 bool Isolate::Init(Deserializer* des) {
   ASSERT(state_ != INITIALIZED);
   ASSERT(Isolate::Current() == this);
   TRACE_ISOLATE(init);
 
+  // When function entry hooking is in effect, we have to create the
+  // code stubs from scratch to get entry hooks, rather than loading the
+  // previously generated stubs from disk. There need to be guards on
+  // isolate creation to
+  if (HasFunctionEntryHook()) {
+    ASSERT(des == NULL);
+  }
+
   // The initialization process does not handle memory exhaustion.
   DisallowAllocationFailure disallow_allocation_failure;
 
   InitializeLoggingAndCounters();
 
   InitializeDebugger();
 
   memory_allocator_ = new MemoryAllocator(this);
   code_range_ = new CodeRange(this);
 
@@ skipping 50 matching lines @@
   // SetUp the object heap.
   ASSERT(!heap_.HasBeenSetUp());
   if (!heap_.SetUp()) {
     V8::FatalProcessOutOfMemory("heap setup");
     return false;
   }
 
   deoptimizer_data_ = new DeoptimizerData(memory_allocator_);
 
   const bool create_heap_objects = (des == NULL);
+

[danno, 2013/06/13 15:33:44]

Stray whitespace change?

[Sigurður Ásgeirsson, 2013/06/19 20:51:51]

Done.

   if (create_heap_objects && !heap_.CreateHeapObjects()) {
     V8::FatalProcessOutOfMemory("heap object creation");
     return false;
   }
 
   if (create_heap_objects) {
     // Terminate the cache array with the sentinel so we can iterate.
     PushToPartialSnapshotCache(heap_.undefined_value());
   }
 
@@ skipping 129 matching lines @@
     }
   } else {
     FLAG_concurrent_sweeping = false;
     FLAG_parallel_sweeping = false;
   }
   if (FLAG_parallel_recompilation &&
       SystemThreadManager::NumberOfParallelSystemThreads(
           SystemThreadManager::PARALLEL_RECOMPILATION) == 0) {
     FLAG_parallel_recompilation = false;
   }
+
+  initialized_from_snapshot_ = (des != NULL);
+
   return true;
 }
 
 
 // Initialized lazily to allow early
 // v8::V8::SetAddHistogramSampleFunction calls.
 StatsTable* Isolate::stats_table() {
   if (stats_table_ == NULL) {
     stats_table_ = new StatsTable;
   }
@@ skipping 105 matching lines @@
   return hstatistics();
 }
 
 
 HTracer* Isolate::GetHTracer() {
   if (htracer() == NULL) set_htracer(new HTracer(id()));
   return htracer();
 }
 
 
+FunctionEntryHook Isolate::GetFunctionEntryHook() {
+  if (function_entry_hook_ == NullFunctionEntryHook)
+    return NULL;
+
+  return function_entry_hook_;
+}
+
+
+void Isolate::SetFunctionEntryHook(FunctionEntryHook function_entry_hook) {
+  if (function_entry_hook == NULL && function_entry_hook_ != NULL) {

[danno, 2013/06/13 15:33:44]

Might it be a little clearer if you can never pass a non-null value to
function_entry_hook? Instead have an explicit DisableFunctionEntryHook that
resets function_entry_hook_ to NullFunctionEntryHook?

[Sigurður Ásgeirsson, 2013/06/19 20:51:51]

I made this one-way as we'd discussed. It makes everything simpler and slightly
more efficient.

+    // After an entry hook has once been set on an isolate, the injected entry
+    // hooking code can't be revoked, and we don't want it calling NULL.
+    // So instead of NULLing the function, we divert it to a no-op.
+    function_entry_hook_ = NullFunctionEntryHook;
+  } else {
+    function_entry_hook_ = function_entry_hook;
+  }
+}
+
+
 Map* Isolate::get_initial_js_array_map(ElementsKind kind) {
   Context* native_context = context()->native_context();
   Object* maybe_map_array = native_context->js_array_maps();
   if (!maybe_map_array->IsUndefined()) {
     Object* maybe_transitioned_map =
         FixedArray::cast(maybe_map_array)->get(kind);
     if (!maybe_transitioned_map->IsUndefined()) {
       return Map::cast(maybe_transitioned_map);
     }
   }
@@ skipping 33 matching lines @@
 
 #ifdef DEBUG
 #define ISOLATE_FIELD_OFFSET(type, name, ignored)                       \
 const intptr_t Isolate::name##_debug_offset_ = OFFSET_OF(Isolate, name##_);
 ISOLATE_INIT_LIST(ISOLATE_FIELD_OFFSET)
 ISOLATE_INIT_ARRAY_LIST(ISOLATE_FIELD_OFFSET)
 #undef ISOLATE_FIELD_OFFSET
 #endif
 
 } }  // namespace v8::internal