chromium/v8/src/compiler-dispatcher/optimizing-compile-dispatcher.cc

// 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.

#include "src/compiler-dispatcher/optimizing-compile-dispatcher.h"

#include "src/base/atomicops.h"
#include "src/codegen/compiler.h"
#include "src/codegen/optimized-compilation-info.h"
#include "src/execution/isolate.h"
#include "src/execution/local-isolate-inl.h"
#include "src/handles/handles-inl.h"
#include "src/heap/local-heap-inl.h"
#include "src/init/v8.h"
#include "src/logging/counters.h"
#include "src/logging/log.h"
#include "src/logging/runtime-call-stats-scope.h"
#include "src/objects/js-function.h"
#include "src/tasks/cancelable-task.h"
#include "src/tracing/trace-event.h"

namespace v8 {
namespace internal {

class OptimizingCompileDispatcher::CompileTask : public v8::JobTask {};

OptimizingCompileDispatcher::~OptimizingCompileDispatcher() {}

TurbofanCompilationJob* OptimizingCompileDispatcher::NextInput(
    LocalIsolate* local_isolate) {}

void OptimizingCompileDispatcher::CompileNext(TurbofanCompilationJob* job,
                                              LocalIsolate* local_isolate) {}

void OptimizingCompileDispatcher::FlushOutputQueue() {}

void OptimizingCompileDispatcherQueue::Flush(Isolate* isolate) {}

void OptimizingCompileDispatcher::FlushInputQueue() {}

void OptimizingCompileDispatcher::AwaitCompileTasks() {}

void OptimizingCompileDispatcher::FlushQueues(
    BlockingBehavior blocking_behavior) {}

void OptimizingCompileDispatcher::Flush(BlockingBehavior blocking_behavior) {}

void OptimizingCompileDispatcher::Stop() {}

void OptimizingCompileDispatcher::InstallOptimizedFunctions() {}

bool OptimizingCompileDispatcher::HasJobs() {}

void OptimizingCompileDispatcher::QueueForOptimization(
    TurbofanCompilationJob* job) {}

void OptimizingCompileDispatcherQueue::Prioritize(
    Tagged<SharedFunctionInfo> function) {}

void OptimizingCompileDispatcher::Prioritize(
    Tagged<SharedFunctionInfo> function) {}

OptimizingCompileDispatcher::OptimizingCompileDispatcher(Isolate* isolate)
    :{}

}  // namespace internal
}  // namespace v8