// Copyright 2011 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/codegen/compilation-cache.h"

#include "src/common/globals.h"

#include "src/heap/factory.h"

#include "src/logging/counters.h"

#include "src/logging/log.h"

#include "src/objects/compilation-cache-table-inl.h"

#include "src/objects/objects-inl.h"

#include "src/objects/objects.h"

#include "src/objects/slots.h"

#include "src/objects/visitors.h"

#include "src/utils/ostreams.h"

namespace v8 {

namespace internal {

// Initial size of each compilation cache table allocated.

static const int kInitialCacheSize = 64;

CompilationCache::CompilationCache(Isolate* isolate)

: isolate_(isolate),

script_(isolate),

eval_global_(isolate),

eval_contextual_(isolate),

reg_exp_(isolate),

enabled_script_and_eval_(true) {}

Handle<CompilationCacheTable> CompilationCacheEvalOrScript::GetTable() {

if (IsUndefined(table_, isolate())) {

return CompilationCacheTable::New(isolate(), kInitialCacheSize);

}

return handle(Cast<CompilationCacheTable>(table_), isolate());

}

DirectHandle<CompilationCacheTable> CompilationCacheRegExp::GetTable(

int generation) {

DCHECK_LT(generation, kGenerations);

DirectHandle<CompilationCacheTable> result;

if (IsUndefined(tables_[generation], isolate())) {

result = CompilationCacheTable::New(isolate(), kInitialCacheSize);

tables_[generation] = *result;

} else {

Tagged<CompilationCacheTable> table =

Cast<CompilationCacheTable>(tables_[generation]);

result = DirectHandle<CompilationCacheTable>(table, isolate());

}

return result;

}

void CompilationCacheRegExp::Age() {

static_assert(kGenerations > 1);

// Age the generations implicitly killing off the oldest.

for (int i = kGenerations - 1; i > 0; i--) {

tables_[i] = tables_[i - 1];

}

// Set the first generation as unborn.

tables_[0] = ReadOnlyRoots(isolate()).undefined_value();

}

void CompilationCacheScript::Age() {

DisallowGarbageCollection no_gc;

if (IsUndefined(table_, isolate())) return;

Tagged<CompilationCacheTable> table = Cast<CompilationCacheTable>(table_);

for (InternalIndex entry : table->IterateEntries()) {

Tagged<Object> key;

if (!table->ToKey(isolate(), entry, &key)) continue;

DCHECK(IsWeakFixedArray(key));

Tagged<Object> value = table->PrimaryValueAt(entry);

if (!IsUndefined(value, isolate())) {

Tagged<SharedFunctionInfo> info = Cast<SharedFunctionInfo>(value);

// Clear entries after Bytecode was flushed from SFI.

if (!info->HasBytecodeArray()) {

table->SetPrimaryValueAt(entry,

ReadOnlyRoots(isolate()).undefined_value(),

SKIP_WRITE_BARRIER);

}

}

}

}

void CompilationCacheEval::Age() {

DisallowGarbageCollection no_gc;

if (IsUndefined(table_, isolate())) return;

Tagged<CompilationCacheTable> table = Cast<CompilationCacheTable>(table_);

for (InternalIndex entry : table->IterateEntries()) {

Tagged<Object> key;

if (!table->ToKey(isolate(), entry, &key)) continue;

DCHECK(IsFixedArray(key));

// The ageing mechanism for eval caches.

Tagged<SharedFunctionInfo> info =

Cast<SharedFunctionInfo>(table->PrimaryValueAt(entry));

// Clear entries after Bytecode was flushed from SFI.

if (!info->HasBytecodeArray()) {

table->RemoveEntry(entry);

}

}

}

void CompilationCacheEvalOrScript::Iterate(RootVisitor* v) {

v->VisitRootPointer(Root::kCompilationCache, nullptr,

FullObjectSlot(&table_));

}

void CompilationCacheRegExp::Iterate(RootVisitor* v) {

v->VisitRootPointers(Root::kCompilationCache, nullptr,

FullObjectSlot(&tables_[0]),

FullObjectSlot(&tables_[kGenerations]));

}

void CompilationCacheEvalOrScript::Clear() {

table_ = ReadOnlyRoots(isolate()).undefined_value();

}

void CompilationCacheRegExp::Clear() {

MemsetPointer(FullObjectSlot(tables_),

ReadOnlyRoots(isolate()).undefined_value(), kGenerations);

}

void CompilationCacheEvalOrScript::Remove(

DirectHandle<SharedFunctionInfo> function_info) {

if (IsUndefined(table_, isolate())) return;

Cast<CompilationCacheTable>(table_)->Remove(*function_info);

}

CompilationCacheScript::LookupResult CompilationCacheScript::Lookup(

Handle<String> source, const ScriptDetails& script_details) {

DirectHandle<CompilationCacheTable> table = GetTable();

LookupResult result = CompilationCacheTable::LookupScript(

table, source, script_details, isolate());

DirectHandle<Script> script;

if (result.script().ToHandle(&script)) {

DirectHandle<SharedFunctionInfo> sfi;

if (result.toplevel_sfi().ToHandle(&sfi)) {

isolate()->counters()->compilation_cache_hits()->Increment();

LOG(isolate(), CompilationCacheEvent("hit", "script", *sfi));

} else {

isolate()->counters()->compilation_cache_partial_hits()->Increment();

}

} else {

isolate()->counters()->compilation_cache_misses()->Increment();

}

return result;

}

void CompilationCacheScript::Put(

Handle<String> source, DirectHandle<SharedFunctionInfo> function_info) {

Handle<CompilationCacheTable> table = GetTable();

table_ = *CompilationCacheTable::PutScript(table, source, kNullMaybeHandle,

function_info, isolate());

}

void CompilationCacheEval::UpdateEval(

DirectHandle<String> source, DirectHandle<SharedFunctionInfo> outer_info,

DirectHandle<JSFunction> js_function, LanguageMode language_mode,

int position) {

DirectHandle<CompilationCacheTable> table = GetTable();

CompilationCacheTable::UpdateEval(table, source, outer_info, js_function,

language_mode, position);

}

InfoCellPair CompilationCacheEval::Lookup(

DirectHandle<String> source, DirectHandle<SharedFunctionInfo> outer_info,

DirectHandle<NativeContext> native_context, LanguageMode language_mode,

int position) {

InfoCellPair result;

DirectHandle<CompilationCacheTable> table = GetTable();

result = CompilationCacheTable::LookupEval(

table, source, outer_info, native_context, language_mode, position);

if (result.has_shared()) {

isolate()->counters()->compilation_cache_hits()->Increment();

} else {

isolate()->counters()->compilation_cache_misses()->Increment();

}

return result;

}

void CompilationCacheEval::Put(DirectHandle<String> source,

DirectHandle<SharedFunctionInfo> outer_info,

DirectHandle<JSFunction> js_function,

int position) {

DirectHandle<CompilationCacheTable> table = GetTable();

table_ = *CompilationCacheTable::PutEval(table, source, outer_info,

js_function, position);

}

MaybeDirectHandle<RegExpData> CompilationCacheRegExp::Lookup(

DirectHandle<String> source, JSRegExp::Flags flags) {

HandleScope scope(isolate());

// Make sure not to leak the table into the surrounding handle

// scope. Otherwise, we risk keeping old tables around even after

// having cleared the cache.

DirectHandle<Object> result = isolate()->factory()->undefined_value();

int generation;

for (generation = 0; generation < kGenerations; generation++) {

DirectHandle<CompilationCacheTable> table = GetTable(generation);

result = table->LookupRegExp(source, flags);

if (IsRegExpDataWrapper(*result)) break;

}

if (IsRegExpDataWrapper(*result)) {

Handle<RegExpData> data(Cast<RegExpDataWrapper>(result)->data(isolate()),

isolate());

if (generation != 0) {

Put(source, flags, data);

}

isolate()->counters()->compilation_cache_hits()->Increment();

return scope.CloseAndEscape(data);

} else {

isolate()->counters()->compilation_cache_misses()->Increment();

return MaybeDirectHandle<RegExpData>();

}

}

void CompilationCacheRegExp::Put(DirectHandle<String> source,

JSRegExp::Flags flags,

DirectHandle<RegExpData> data) {

HandleScope scope(isolate());

DirectHandle<CompilationCacheTable> table = GetTable(0);

tables_[0] =

*CompilationCacheTable::PutRegExp(isolate(), table, source, flags, data);

}

void CompilationCache::Remove(DirectHandle<SharedFunctionInfo> function_info) {

if (!IsEnabledScriptAndEval()) return;

eval_global_.Remove(function_info);

eval_contextual_.Remove(function_info);

script_.Remove(function_info);

}

CompilationCacheScript::LookupResult CompilationCache::LookupScript(

Handle<String> source, const ScriptDetails& script_details,

LanguageMode language_mode) {

if (!IsEnabledScript(language_mode)) return {};

return script_.Lookup(source, script_details);

}

void CompilationCache::UpdateEval(DirectHandle<String> source,

DirectHandle<SharedFunctionInfo> outer_info,

DirectHandle<JSFunction> js_function,

LanguageMode language_mode, int position) {

if (IsNativeContext(js_function->context())) {

eval_global_.UpdateEval(source, outer_info, js_function, language_mode,

position);

} else {

DCHECK_NE(position, kNoSourcePosition);

eval_contextual_.UpdateEval(source, outer_info, js_function, language_mode,

position);

}

}

InfoCellPair CompilationCache::LookupEval(

DirectHandle<String> source, DirectHandle<SharedFunctionInfo> outer_info,

DirectHandle<Context> context, LanguageMode language_mode, int position) {

InfoCellPair result;

if (!IsEnabledScriptAndEval()) return result;

const char* cache_type;

DirectHandle<NativeContext> maybe_native_context;

if (TryCast<NativeContext>(context, &maybe_native_context)) {

result = eval_global_.Lookup(source, outer_info, maybe_native_context,

language_mode, position);

cache_type = "eval-global";

} else {

DCHECK_NE(position, kNoSourcePosition);

DirectHandle<NativeContext> native_context(context->native_context(),

isolate());

result = eval_contextual_.Lookup(source, outer_info, native_context,

language_mode, position);

cache_type = "eval-contextual";

}

if (result.has_shared()) {

LOG(isolate(), CompilationCacheEvent("hit", cache_type, result.shared()));

}

return result;

}

MaybeDirectHandle<RegExpData> CompilationCache::LookupRegExp(

DirectHandle<String> source, JSRegExp::Flags flags) {

return reg_exp_.Lookup(source, flags);

}

void CompilationCache::PutScript(

Handle<String> source, LanguageMode language_mode,

DirectHandle<SharedFunctionInfo> function_info) {

if (!IsEnabledScript(language_mode)) return;

LOG(isolate(), CompilationCacheEvent("put", "script", *function_info));

script_.Put(source, function_info);

}

void CompilationCache::PutEval(DirectHandle<String> source,

DirectHandle<SharedFunctionInfo> outer_info,

DirectHandle<JSFunction> js_function,

int position) {

if (!IsEnabledScriptAndEval()) return;

const char* cache_type;

if (IsNativeContext(js_function->context())) {

eval_global_.Put(source, outer_info, js_function, position);

cache_type = "eval-global";

} else {

DCHECK_NE(position, kNoSourcePosition);

eval_contextual_.Put(source, outer_info, js_function, position);

cache_type = "eval-contextual";

}

LOG(isolate(),

CompilationCacheEvent("put", cache_type, js_function->shared()));

}

void CompilationCache::PutRegExp(DirectHandle<String> source,

JSRegExp::Flags flags,

DirectHandle<RegExpData> data) {

reg_exp_.Put(source, flags, data);

}

void CompilationCache::Clear() {

script_.Clear();

eval_global_.Clear();

eval_contextual_.Clear();

reg_exp_.Clear();

}

void CompilationCache::Iterate(RootVisitor* v) {

script_.Iterate(v);

eval_global_.Iterate(v);

eval_contextual_.Iterate(v);

reg_exp_.Iterate(v);

}

void CompilationCache::MarkCompactPrologue() {

// Drop SFI entries with flushed bytecode.

script_.Age();

eval_global_.Age();

eval_contextual_.Age();

// Drop entries in oldest generation.

reg_exp_.Age();

}

void CompilationCache::EnableScriptAndEval() {

enabled_script_and_eval_ = true;

}

void CompilationCache::DisableScriptAndEval() {

enabled_script_and_eval_ = false;

Clear();

}

} // namespace internal

} // namespace v8