blob: f27b0d16e534227b3b31297304d493cb6899ea77 [file] [log] [blame]
// Copyright 2016 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_LOGGING_CODE_EVENTS_H_
#define V8_LOGGING_CODE_EVENTS_H_
#include <unordered_set>
#include "src/base/platform/mutex.h"
#include "src/common/globals.h"
#include "src/objects/code.h"
#include "src/objects/name.h"
#include "src/objects/shared-function-info.h"
#include "src/objects/string.h"
#include "src/utils/vector.h"
namespace v8 {
namespace internal {
class AbstractCode;
class Name;
class SharedFunctionInfo;
class String;
namespace wasm {
class WasmCode;
using WasmName = Vector<const char>;
} // namespace wasm
#define LOG_EVENTS_LIST(V) \
V(CODE_CREATION_EVENT, code-creation) \
V(CODE_DISABLE_OPT_EVENT, code-disable-optimization) \
V(CODE_MOVE_EVENT, code-move) \
V(CODE_DELETE_EVENT, code-delete) \
V(CODE_MOVING_GC, code-moving-gc) \
V(SHARED_FUNC_MOVE_EVENT, sfi-move) \
V(SNAPSHOT_CODE_NAME_EVENT, snapshot-code-name) \
V(TICK_EVENT, tick)
#define TAGS_LIST(V) \
V(BUILTIN_TAG, Builtin) \
V(CALLBACK_TAG, Callback) \
V(EVAL_TAG, Eval) \
V(FUNCTION_TAG, Function) \
V(INTERPRETED_FUNCTION_TAG, InterpretedFunction) \
V(HANDLER_TAG, Handler) \
V(BYTECODE_HANDLER_TAG, BytecodeHandler) \
V(LAZY_COMPILE_TAG, LazyCompile) \
V(REG_EXP_TAG, RegExp) \
V(SCRIPT_TAG, Script) \
V(STUB_TAG, Stub) \
V(NATIVE_FUNCTION_TAG, Function) \
V(NATIVE_LAZY_COMPILE_TAG, LazyCompile) \
V(NATIVE_SCRIPT_TAG, Script)
// Note that 'NATIVE_' cases for functions and scripts are mapped onto
// original tags when writing to the log.
#define LOG_EVENTS_AND_TAGS_LIST(V) \
LOG_EVENTS_LIST(V) \
TAGS_LIST(V)
#define PROFILE(the_isolate, Call) (the_isolate)->code_event_dispatcher()->Call;
class CodeEventListener {
public:
#define DECLARE_ENUM(enum_item, _) enum_item,
enum LogEventsAndTags {
LOG_EVENTS_AND_TAGS_LIST(DECLARE_ENUM) NUMBER_OF_LOG_EVENTS
};
#undef DECLARE_ENUM
virtual ~CodeEventListener() = default;
virtual void CodeCreateEvent(LogEventsAndTags tag, Handle<AbstractCode> code,
const char* name) = 0;
virtual void CodeCreateEvent(LogEventsAndTags tag, Handle<AbstractCode> code,
Handle<Name> name) = 0;
virtual void CodeCreateEvent(LogEventsAndTags tag, Handle<AbstractCode> code,
Handle<SharedFunctionInfo> shared,
Handle<Name> script_name) = 0;
virtual void CodeCreateEvent(LogEventsAndTags tag, Handle<AbstractCode> code,
Handle<SharedFunctionInfo> shared,
Handle<Name> script_name, int line,
int column) = 0;
virtual void CodeCreateEvent(LogEventsAndTags tag, const wasm::WasmCode* code,
wasm::WasmName name) = 0;
virtual void CallbackEvent(Handle<Name> name, Address entry_point) = 0;
virtual void GetterCallbackEvent(Handle<Name> name, Address entry_point) = 0;
virtual void SetterCallbackEvent(Handle<Name> name, Address entry_point) = 0;
virtual void RegExpCodeCreateEvent(Handle<AbstractCode> code,
Handle<String> source) = 0;
// Not handlified as this happens during GC. No allocation allowed.
virtual void CodeMoveEvent(AbstractCode from, AbstractCode to) = 0;
virtual void SharedFunctionInfoMoveEvent(Address from, Address to) = 0;
virtual void NativeContextMoveEvent(Address from, Address to) = 0;
virtual void CodeMovingGCEvent() = 0;
virtual void CodeDisableOptEvent(Handle<AbstractCode> code,
Handle<SharedFunctionInfo> shared) = 0;
virtual void CodeDeoptEvent(Handle<Code> code, DeoptimizeKind kind,
Address pc, int fp_to_sp_delta,
bool reuse_code) = 0;
// These events can happen when 1. an assumption made by optimized code fails
// or 2. a weakly embedded object dies.
virtual void CodeDependencyChangeEvent(Handle<Code> code,
Handle<SharedFunctionInfo> shared,
const char* reason) = 0;
virtual bool is_listening_to_code_events() { return false; }
};
// Dispatches code events to a set of registered listeners.
class CodeEventDispatcher : public CodeEventListener {
public:
using LogEventsAndTags = CodeEventListener::LogEventsAndTags;
CodeEventDispatcher() = default;
bool AddListener(CodeEventListener* listener) {
base::MutexGuard guard(&mutex_);
return listeners_.insert(listener).second;
}
void RemoveListener(CodeEventListener* listener) {
base::MutexGuard guard(&mutex_);
listeners_.erase(listener);
}
bool IsListeningToCodeEvents() {
for (auto it : listeners_) {
if (it->is_listening_to_code_events()) {
return true;
}
}
return false;
}
void DispatchEventToListeners(
std::function<void(CodeEventListener*)> callback) {
base::MutexGuard guard(&mutex_);
for (CodeEventListener* listener : listeners_) {
callback(listener);
}
}
void CodeCreateEvent(LogEventsAndTags tag, Handle<AbstractCode> code,
const char* comment) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->CodeCreateEvent(tag, code, comment);
});
}
void CodeCreateEvent(LogEventsAndTags tag, Handle<AbstractCode> code,
Handle<Name> name) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->CodeCreateEvent(tag, code, name);
});
}
void CodeCreateEvent(LogEventsAndTags tag, Handle<AbstractCode> code,
Handle<SharedFunctionInfo> shared,
Handle<Name> name) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->CodeCreateEvent(tag, code, shared, name);
});
}
void CodeCreateEvent(LogEventsAndTags tag, Handle<AbstractCode> code,
Handle<SharedFunctionInfo> shared, Handle<Name> source,
int line, int column) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->CodeCreateEvent(tag, code, shared, source, line, column);
});
}
void CodeCreateEvent(LogEventsAndTags tag, const wasm::WasmCode* code,
wasm::WasmName name) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->CodeCreateEvent(tag, code, name);
});
}
void CallbackEvent(Handle<Name> name, Address entry_point) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->CallbackEvent(name, entry_point);
});
}
void GetterCallbackEvent(Handle<Name> name, Address entry_point) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->GetterCallbackEvent(name, entry_point);
});
}
void SetterCallbackEvent(Handle<Name> name, Address entry_point) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->SetterCallbackEvent(name, entry_point);
});
}
void RegExpCodeCreateEvent(Handle<AbstractCode> code,
Handle<String> source) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->RegExpCodeCreateEvent(code, source);
});
}
void CodeMoveEvent(AbstractCode from, AbstractCode to) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->CodeMoveEvent(from, to);
});
}
void SharedFunctionInfoMoveEvent(Address from, Address to) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->SharedFunctionInfoMoveEvent(from, to);
});
}
void NativeContextMoveEvent(Address from, Address to) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->NativeContextMoveEvent(from, to);
});
}
void CodeMovingGCEvent() override {
DispatchEventToListeners(
[](CodeEventListener* listener) { listener->CodeMovingGCEvent(); });
}
void CodeDisableOptEvent(Handle<AbstractCode> code,
Handle<SharedFunctionInfo> shared) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->CodeDisableOptEvent(code, shared);
});
}
void CodeDeoptEvent(Handle<Code> code, DeoptimizeKind kind, Address pc,
int fp_to_sp_delta, bool reuse_code) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->CodeDeoptEvent(code, kind, pc, fp_to_sp_delta, reuse_code);
});
}
void CodeDependencyChangeEvent(Handle<Code> code,
Handle<SharedFunctionInfo> sfi,
const char* reason) override {
DispatchEventToListeners([=](CodeEventListener* listener) {
listener->CodeDependencyChangeEvent(code, sfi, reason);
});
}
private:
std::unordered_set<CodeEventListener*> listeners_;
base::Mutex mutex_;
DISALLOW_COPY_AND_ASSIGN(CodeEventDispatcher);
};
} // namespace internal
} // namespace v8
#endif // V8_LOGGING_CODE_EVENTS_H_