function-tester.cc | Explore in Territory

// Copyright 2014 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 "test/unittests/compiler/function-tester.h"

#include "include/v8-function.h"
#include "src/codegen/assembler.h"
#include "src/codegen/compiler.h"
#include "src/codegen/optimized-compilation-info.h"
#include "src/compiler/graph.h"
#include "src/compiler/js-heap-broker.h"
#include "src/compiler/linkage.h"
#include "src/compiler/pipeline.h"
#include "src/execution/execution.h"
#include "src/handles/handles.h"
#include "src/objects/objects-inl.h"
#include "src/parsing/parse-info.h"

namespace v8 {
namespace internal {
namespace compiler {

namespace {
v8::Local<v8::Value> CompileRun(Isolate* isolate, const char* source) { … }
}  // namespace

FunctionTester::FunctionTester(Isolate* isolate, const char* source,
                               uint32_t flags)
    : … { … }

FunctionTester::FunctionTester(Isolate* isolate, Graph* graph, int param_count)
    : … { … }

FunctionTester::FunctionTester(Isolate* isolate, Handle<Code> code,
                               int param_count)
    : … { … }

void FunctionTester::CheckThrows(Handle<Object> a) { … }

void FunctionTester::CheckThrows(Handle<Object> a, Handle<Object> b) { … }

v8::Local<v8::Message> FunctionTester::CheckThrowsReturnMessage(
    Handle<Object> a, Handle<Object> b) { … }

void FunctionTester::CheckCall(DirectHandle<Object> expected, Handle<Object> a,
                               Handle<Object> b, Handle<Object> c,
                               Handle<Object> d) { … }

Handle<JSFunction> FunctionTester::NewFunction(const char* source) { … }

Handle<JSObject> FunctionTester::NewObject(const char* source) { … }

Handle<String> FunctionTester::NewString(const char* string) { … }

Handle<Object> FunctionTester::NewNumber(double value) { … }

Handle<Object> FunctionTester::infinity() { … }

Handle<Object> FunctionTester::minus_infinity() { … }

Handle<Object> FunctionTester::nan() { … }

Handle<Object> FunctionTester::undefined() { … }

Handle<Object> FunctionTester::null() { … }

Handle<Object> FunctionTester::true_value() { … }

Handle<Object> FunctionTester::false_value() { … }

Handle<JSFunction> FunctionTester::Compile(Handle<JSFunction> f) { … }

// Compile the given machine graph instead of the source of the function
// and replace the JSFunction's code with the result.
Handle<JSFunction> FunctionTester::CompileGraph(Graph* graph) { … }

Handle<JSFunction> FunctionTester::Optimize(Handle<JSFunction> function,
                                            Zone* zone, uint32_t flags) { … }
}  // namespace compiler
}  // namespace internal
}  // namespace v8
chromium/v8/test/unittests/compiler/function-tester.cc
