mirror of
https://github.com/dart-lang/sdk
synced 2024-09-05 00:13:50 +00:00
04ba20aa98
Implements a backend targeting RV32GC and RV64GC, based on Linux standardizing around GC. The assembler is written to make it easy to disable usage of C, but because the sizes of some instruction sequences are compile-time constants, an additional build configuration would need to be defined to make use of it. The assembler and disassembler cover every RV32/64GC instruction. The simulator covers all instructions except accessing CSRs and the floating point state accessible through such, include accrued exceptions and dynamic rounding mode. Quirks: - RISC-V is a compare-and-branch architecture, but some existing "architecture-independent" parts of the Dart compiler assume a condition code architecture. To avoid rewriting these parts, we use a peephole in the assembler to map to compare-and-branch. See Assembler::BranchIf. Luckily nothing depended on taking multiple branches on the same condition code set. - There are no hardware overflow checks, so we must use Hacker's Delight style software checks. Often these are very cheap: if the sign of one operand is known, a single branch is needed. - The ranges of RISC-V branches and jumps are such that we use 3 levels of generation for forward branches, instead of the 2 levels of near and far branches used on ARM[64]. Nearly all code is handled by the first two levels with 20-bits of range, with enormous regex matchers triggering the third level that uses aupic+jalr to get 32-bits of range. - For PC-relative calls in AOT, we always generate auipc+jalr pairs with 32-bits of range, so we never generate trampolines. - Only a subset of registers are available in some compressed instructions, so we assign the most popular uses to these registers. In particular, THR, TMP[2], CODE and PP. This has the effect of assigning CODE and PP to volatile registers in the C calling convention, whereas they are assigned preserved registers on the other architectures. As on ARM64, PP is untagged; this is so short indices can be accessed with a compressed instruction. - There are no push or pop instructions, so combining pushes and pops is preferred so we can update SP once. - The C calling convention has a strongly aligned stack, but unlike on ARM64 we don't need to use an alternate stack pointer. The author ensured language was added to the RISC-V psABI making the OS responsible for realigning the stack pointer for signal handlers, allowing Dart to leave the stack pointer misaligned from the C calling convention's point of view until a foreign call. - We don't bother with the link register tracking done on ARM[64]. Instead we make use of an alternate link register to avoid inline spilling in the write barrier. Unimplemented: - non-trivial FFI cases - Compressed pointers - No intention to implement. - Unboxed SIMD - We might make use of the V extension registers when the V extension is ratified. - BigInt intrinsics TEST=existing tests for IL level, new tests for assembler/disassembler/simulator Bug: https://github.com/dart-lang/sdk/issues/38587 Bug: https://github.com/dart-lang/sdk/issues/48164 Change-Id: I991d1df4be5bf55efec5371b767b332d37dfa3e0 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/217289 Reviewed-by: Alexander Markov <alexmarkov@google.com> Reviewed-by: Daco Harkes <dacoharkes@google.com> Reviewed-by: Slava Egorov <vegorov@google.com> Commit-Queue: Ryan Macnak <rmacnak@google.com>
722 lines
32 KiB
C++
722 lines
32 KiB
C++
// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
#ifndef RUNTIME_VM_UNIT_TEST_H_
|
|
#define RUNTIME_VM_UNIT_TEST_H_
|
|
|
|
#include <functional>
|
|
|
|
#include "include/dart_native_api.h"
|
|
|
|
#include "platform/globals.h"
|
|
|
|
#include "vm/dart.h"
|
|
#include "vm/dart_api_state.h"
|
|
#include "vm/dart_entry.h"
|
|
#include "vm/globals.h"
|
|
#include "vm/heap/heap.h"
|
|
#include "vm/isolate.h"
|
|
#include "vm/longjump.h"
|
|
#include "vm/object.h"
|
|
#include "vm/object_store.h"
|
|
#include "vm/simulator.h"
|
|
#include "vm/zone.h"
|
|
|
|
// The VM_UNIT_TEST_CASE macro is used for tests that do not need any
|
|
// default isolate or zone functionality.
|
|
#define VM_UNIT_TEST_CASE_WITH_EXPECTATION(name, expectation) \
|
|
void Dart_Test##name(); \
|
|
static const dart::TestCase kRegister##name(Dart_Test##name, #name, \
|
|
expectation); \
|
|
void Dart_Test##name()
|
|
|
|
#define VM_UNIT_TEST_CASE(name) VM_UNIT_TEST_CASE_WITH_EXPECTATION(name, "Pass")
|
|
|
|
// The UNIT_TEST_CASE macro is used for tests that do not require any
|
|
// functionality provided by the VM. Tests declared using this macro will be run
|
|
// after the VM is cleaned up.
|
|
#define UNIT_TEST_CASE_WITH_EXPECTATION(name, expectation) \
|
|
void Dart_Test##name(); \
|
|
static const dart::RawTestCase kRegister##name(Dart_Test##name, #name, \
|
|
expectation); \
|
|
void Dart_Test##name()
|
|
|
|
#define UNIT_TEST_CASE(name) UNIT_TEST_CASE_WITH_EXPECTATION(name, "Pass")
|
|
|
|
// The ISOLATE_UNIT_TEST_CASE macro is used for tests that need an isolate and
|
|
// zone in order to test its functionality. This macro is used for tests that
|
|
// are implemented using the VM code directly and do not use the Dart API
|
|
// for calling into the VM. The safepoint execution state of threads using
|
|
// this macro is transitioned from kThreadInNative to kThreadInVM.
|
|
#define ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION(name, expectation) \
|
|
static void Dart_TestHelper##name(Thread* thread); \
|
|
VM_UNIT_TEST_CASE_WITH_EXPECTATION(name, expectation) { \
|
|
TestIsolateScope __test_isolate__; \
|
|
Thread* __thread__ = Thread::Current(); \
|
|
ASSERT(__thread__->isolate() == __test_isolate__.isolate()); \
|
|
TransitionNativeToVM transition(__thread__); \
|
|
StackZone __zone__(__thread__); \
|
|
HandleScope __hs__(__thread__); \
|
|
Dart_TestHelper##name(__thread__); \
|
|
} \
|
|
static void Dart_TestHelper##name(Thread* thread)
|
|
|
|
#define ISOLATE_UNIT_TEST_CASE(name) \
|
|
ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION(name, "Pass")
|
|
|
|
// The TEST_CASE macro is used for tests that need an isolate and zone
|
|
// in order to test its functionality. This macro is used for tests that
|
|
// are implemented using the Dart API for calling into the VM. The safepoint
|
|
// execution state of threads using this macro remains kThreadNative.
|
|
#define TEST_CASE_WITH_EXPECTATION(name, expectation) \
|
|
static void Dart_TestHelper##name(Thread* thread); \
|
|
VM_UNIT_TEST_CASE_WITH_EXPECTATION(name, expectation) { \
|
|
TestIsolateScope __test_isolate__; \
|
|
Thread* __thread__ = Thread::Current(); \
|
|
ASSERT(__thread__->isolate() == __test_isolate__.isolate()); \
|
|
TransitionNativeToVM transition1(__thread__); \
|
|
StackZone __zone__(__thread__); \
|
|
HandleScope __hs__(__thread__); \
|
|
TransitionVMToNative transition2(__thread__); \
|
|
Dart_TestHelper##name(__thread__); \
|
|
} \
|
|
static void Dart_TestHelper##name(Thread* thread)
|
|
|
|
#define TEST_CASE(name) TEST_CASE_WITH_EXPECTATION(name, "Pass")
|
|
|
|
// The ASSEMBLER_TEST_GENERATE macro is used to generate a unit test
|
|
// for the assembler.
|
|
#define ASSEMBLER_TEST_GENERATE(name, assembler) \
|
|
void AssemblerTestGenerate##name(compiler::Assembler* assembler)
|
|
|
|
// The ASSEMBLER_TEST_EXTERN macro is used to declare a unit test
|
|
// for the assembler.
|
|
#define ASSEMBLER_TEST_EXTERN(name) \
|
|
extern void AssemblerTestGenerate##name(compiler::Assembler* assembler);
|
|
|
|
// The ASSEMBLER_TEST_RUN macro is used to execute the assembler unit
|
|
// test generated using the ASSEMBLER_TEST_GENERATE macro.
|
|
// C++ callee-saved registers are not preserved. Arguments may be passed in.
|
|
#define ASSEMBLER_TEST_RUN_WITH_EXPECTATION(name, test, expectation) \
|
|
static void AssemblerTestRun##name(AssemblerTest* test); \
|
|
ISOLATE_UNIT_TEST_CASE_WITH_EXPECTATION(name, expectation) { \
|
|
volatile intptr_t far_branch_level = 0; \
|
|
while (true) { \
|
|
LongJumpScope jump; \
|
|
if (setjmp(*jump.Set()) == 0) { \
|
|
compiler::ObjectPoolBuilder object_pool_builder; \
|
|
compiler::Assembler assembler(&object_pool_builder, far_branch_level); \
|
|
AssemblerTest test("" #name, &assembler); \
|
|
AssemblerTestGenerate##name(test.assembler()); \
|
|
test.Assemble(); \
|
|
AssemblerTestRun##name(&test); \
|
|
return; \
|
|
} else { \
|
|
const Error& error = Error::Handle(Thread::Current()->sticky_error()); \
|
|
if (error.ptr() == Object::branch_offset_error().ptr()) { \
|
|
ASSERT(far_branch_level < 2); \
|
|
far_branch_level++; \
|
|
} else { \
|
|
FATAL1("Unexpected error: %s\n", error.ToErrorCString()); \
|
|
} \
|
|
} \
|
|
} \
|
|
} \
|
|
static void AssemblerTestRun##name(AssemblerTest* test)
|
|
|
|
#define ASSEMBLER_TEST_RUN(name, test) \
|
|
ASSEMBLER_TEST_RUN_WITH_EXPECTATION(name, test, "Pass")
|
|
|
|
#if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_ARM64) || \
|
|
defined(TARGET_ARCH_RISCV32) || defined(TARGET_ARCH_RISCV64)
|
|
#if defined(HOST_ARCH_ARM) || defined(HOST_ARCH_ARM64) || \
|
|
defined(HOST_ARCH_RISCV32) || defined(HOST_ARCH_RISCV64)
|
|
// Running on actual ARM hardware, execute code natively.
|
|
#define EXECUTE_TEST_CODE_INT32(name, entry) reinterpret_cast<name>(entry)()
|
|
#define EXECUTE_TEST_CODE_INT64(name, entry) reinterpret_cast<name>(entry)()
|
|
#define EXECUTE_TEST_CODE_INT64_LL(name, entry, long_arg0, long_arg1) \
|
|
reinterpret_cast<name>(entry)(long_arg0, long_arg1)
|
|
#define EXECUTE_TEST_CODE_FLOAT(name, entry) reinterpret_cast<name>(entry)()
|
|
#define EXECUTE_TEST_CODE_DOUBLE(name, entry) reinterpret_cast<name>(entry)()
|
|
#define EXECUTE_TEST_CODE_INT32_F(name, entry, float_arg) \
|
|
reinterpret_cast<name>(entry)(float_arg)
|
|
#define EXECUTE_TEST_CODE_INT32_D(name, entry, double_arg) \
|
|
reinterpret_cast<name>(entry)(double_arg)
|
|
#define EXECUTE_TEST_CODE_INTPTR_INTPTR(name, entry, pointer_arg) \
|
|
reinterpret_cast<name>(entry)(pointer_arg)
|
|
#define EXECUTE_TEST_CODE_INT32_INTPTR(name, entry, pointer_arg) \
|
|
reinterpret_cast<name>(entry)(pointer_arg)
|
|
#else
|
|
// Not running on ARM hardware, call simulator to execute code.
|
|
#if defined(ARCH_IS_64_BIT)
|
|
#define EXECUTE_TEST_CODE_INT64(name, entry) \
|
|
static_cast<int64_t>( \
|
|
Simulator::Current()->Call(bit_cast<int64_t, uword>(entry), 0, 0, 0, 0))
|
|
#define EXECUTE_TEST_CODE_DOUBLE(name, entry) \
|
|
bit_cast<double, int64_t>(Simulator::Current()->Call( \
|
|
bit_cast<int64_t, uword>(entry), 0, 0, 0, 0, true))
|
|
#define EXECUTE_TEST_CODE_INTPTR_INTPTR(name, entry, pointer_arg) \
|
|
static_cast<intptr_t>(Simulator::Current()->Call( \
|
|
bit_cast<int64_t, uword>(entry), \
|
|
bit_cast<int64_t, intptr_t>(pointer_arg), 0, 0, 0))
|
|
#define EXECUTE_TEST_CODE_INT32_INTPTR(name, entry, pointer_arg) \
|
|
static_cast<int32_t>(Simulator::Current()->Call( \
|
|
bit_cast<int64_t, uword>(entry), \
|
|
bit_cast<int64_t, intptr_t>(pointer_arg), 0, 0, 0))
|
|
#else
|
|
#define EXECUTE_TEST_CODE_INT32(name, entry) \
|
|
static_cast<int32_t>( \
|
|
Simulator::Current()->Call(bit_cast<int32_t, uword>(entry), 0, 0, 0, 0))
|
|
#define EXECUTE_TEST_CODE_DOUBLE(name, entry) \
|
|
bit_cast<double, int64_t>(Simulator::Current()->Call( \
|
|
bit_cast<int32_t, uword>(entry), 0, 0, 0, 0, true))
|
|
#define EXECUTE_TEST_CODE_INTPTR_INTPTR(name, entry, pointer_arg) \
|
|
static_cast<intptr_t>(Simulator::Current()->Call( \
|
|
bit_cast<int32_t, uword>(entry), \
|
|
bit_cast<int32_t, intptr_t>(pointer_arg), 0, 0, 0))
|
|
#define EXECUTE_TEST_CODE_INT32_INTPTR(name, entry, pointer_arg) \
|
|
static_cast<int32_t>(Simulator::Current()->Call( \
|
|
bit_cast<int32_t, uword>(entry), \
|
|
bit_cast<int32_t, intptr_t>(pointer_arg), 0, 0, 0))
|
|
#endif // defined(ARCH_IS_64_BIT)
|
|
#define EXECUTE_TEST_CODE_INT64_LL(name, entry, long_arg0, long_arg1) \
|
|
static_cast<int64_t>(Simulator::Current()->Call( \
|
|
bit_cast<int32_t, uword>(entry), Utils::Low32Bits(long_arg0), \
|
|
Utils::High32Bits(long_arg0), Utils::Low32Bits(long_arg1), \
|
|
Utils::High32Bits(long_arg1)))
|
|
#define EXECUTE_TEST_CODE_FLOAT(name, entry) \
|
|
bit_cast<float, int32_t>(Simulator::Current()->Call( \
|
|
bit_cast<int32_t, uword>(entry), 0, 0, 0, 0, true))
|
|
#define EXECUTE_TEST_CODE_INT32_F(name, entry, float_arg) \
|
|
static_cast<int32_t>(Simulator::Current()->Call( \
|
|
bit_cast<int32_t, uword>(entry), bit_cast<int32_t, float>(float_arg), 0, \
|
|
0, 0, false, true))
|
|
#define EXECUTE_TEST_CODE_INT32_D(name, entry, double_arg) \
|
|
static_cast<int32_t>(Simulator::Current()->Call( \
|
|
bit_cast<int32_t, uword>(entry), \
|
|
Utils::Low32Bits(bit_cast<int64_t, double>(double_arg)), \
|
|
Utils::High32Bits(bit_cast<int64_t, double>(double_arg)), 0, 0, false, \
|
|
true))
|
|
#endif // defined(HOST_ARCH_ARM)
|
|
#endif // defined(TARGET_ARCH_{ARM, ARM64})
|
|
|
|
#define ZONE_STR(FMT, ...) \
|
|
OS::SCreate(Thread::Current()->zone(), FMT, __VA_ARGS__)
|
|
|
|
inline Dart_Handle NewString(const char* str) {
|
|
return Dart_NewStringFromCString(str);
|
|
}
|
|
|
|
namespace dart {
|
|
|
|
// Forward declarations.
|
|
namespace compiler {
|
|
class Assembler;
|
|
}
|
|
class CodeGenerator;
|
|
class VirtualMemory;
|
|
|
|
namespace bin {
|
|
// Snapshot pieces if we link in a snapshot, otherwise initialized to NULL.
|
|
extern const uint8_t* vm_snapshot_data;
|
|
extern const uint8_t* vm_snapshot_instructions;
|
|
extern const uint8_t* core_isolate_snapshot_data;
|
|
extern const uint8_t* core_isolate_snapshot_instructions;
|
|
} // namespace bin
|
|
|
|
extern const uint8_t* platform_strong_dill;
|
|
extern const intptr_t platform_strong_dill_size;
|
|
|
|
class TesterState : public AllStatic {
|
|
public:
|
|
static const uint8_t* vm_snapshot_data;
|
|
static Dart_IsolateGroupCreateCallback create_callback;
|
|
static Dart_IsolateShutdownCallback shutdown_callback;
|
|
static Dart_IsolateGroupCleanupCallback group_cleanup_callback;
|
|
static const char** argv;
|
|
static int argc;
|
|
};
|
|
|
|
class KernelBufferList {
|
|
public:
|
|
explicit KernelBufferList(const uint8_t* kernel_buffer)
|
|
: kernel_buffer_(kernel_buffer), next_(NULL) {}
|
|
|
|
KernelBufferList(const uint8_t* kernel_buffer, KernelBufferList* next)
|
|
: kernel_buffer_(kernel_buffer), next_(next) {}
|
|
|
|
~KernelBufferList() {
|
|
free(const_cast<uint8_t*>(kernel_buffer_));
|
|
if (next_ != NULL) {
|
|
delete next_;
|
|
}
|
|
}
|
|
|
|
void AddBufferToList(const uint8_t* kernel_buffer);
|
|
|
|
private:
|
|
const uint8_t* kernel_buffer_;
|
|
KernelBufferList* next_;
|
|
};
|
|
|
|
class TestCaseBase {
|
|
public:
|
|
explicit TestCaseBase(const char* name, const char* expectation);
|
|
virtual ~TestCaseBase() {}
|
|
|
|
const char* name() const { return name_; }
|
|
const char* expectation() const { return expectation_; }
|
|
|
|
virtual void Run() = 0;
|
|
void RunTest();
|
|
|
|
static void RunAll();
|
|
static void RunAllRaw();
|
|
static void CleanupState();
|
|
static void AddToKernelBuffers(const uint8_t* kernel_buffer);
|
|
|
|
protected:
|
|
static KernelBufferList* current_kernel_buffers_;
|
|
bool raw_test_;
|
|
|
|
private:
|
|
static TestCaseBase* first_;
|
|
static TestCaseBase* tail_;
|
|
|
|
TestCaseBase* next_;
|
|
const char* name_;
|
|
const char* expectation_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(TestCaseBase);
|
|
};
|
|
|
|
#define USER_TEST_URI "test-lib"
|
|
#define RESOLVED_USER_TEST_URI "file:///test-lib"
|
|
#define CORELIB_TEST_URI "dart:test-lib"
|
|
|
|
class TestCase : TestCaseBase {
|
|
public:
|
|
typedef void(RunEntry)();
|
|
|
|
TestCase(RunEntry* run, const char* name, const char* expectation)
|
|
: TestCaseBase(name, expectation), run_(run) {}
|
|
|
|
static char* CompileTestScriptWithDFE(const char* url,
|
|
const char* source,
|
|
const uint8_t** kernel_buffer,
|
|
intptr_t* kernel_buffer_size,
|
|
bool incrementally = true,
|
|
bool allow_compile_errors = false,
|
|
const char* multiroot_filepaths = NULL,
|
|
const char* multiroot_scheme = NULL);
|
|
static char* CompileTestScriptWithDFE(const char* url,
|
|
int sourcefiles_count,
|
|
Dart_SourceFile sourcefiles[],
|
|
const uint8_t** kernel_buffer,
|
|
intptr_t* kernel_buffer_size,
|
|
bool incrementally = true,
|
|
bool allow_compile_errors = false,
|
|
const char* multiroot_filepaths = NULL,
|
|
const char* multiroot_scheme = NULL);
|
|
static Dart_Handle LoadTestScript(
|
|
const char* script,
|
|
Dart_NativeEntryResolver resolver,
|
|
const char* lib_uri = RESOLVED_USER_TEST_URI,
|
|
bool finalize = true,
|
|
bool allow_compile_errors = false);
|
|
static Dart_Handle LoadTestScriptWithErrors(
|
|
const char* script,
|
|
Dart_NativeEntryResolver resolver = NULL,
|
|
const char* lib_uri = RESOLVED_USER_TEST_URI,
|
|
bool finalize = true);
|
|
static Dart_Handle LoadTestLibrary(const char* lib_uri,
|
|
const char* script,
|
|
Dart_NativeEntryResolver resolver = NULL);
|
|
static Dart_Handle LoadTestScriptWithDFE(
|
|
int sourcefiles_count,
|
|
Dart_SourceFile sourcefiles[],
|
|
Dart_NativeEntryResolver resolver = NULL,
|
|
bool finalize = true,
|
|
bool incrementally = true,
|
|
bool allow_compile_errors = false,
|
|
const char* entry_script_uri = NULL,
|
|
const char* multiroot_filepaths = NULL,
|
|
const char* multiroot_scheme = NULL);
|
|
static Dart_Handle LoadCoreTestScript(const char* script,
|
|
Dart_NativeEntryResolver resolver);
|
|
|
|
static Dart_Handle EvaluateExpression(const Library& lib,
|
|
const String& expr,
|
|
const Array& param_names,
|
|
const Array& param_values);
|
|
|
|
static Dart_Handle lib();
|
|
static const char* url();
|
|
static Dart_Isolate CreateTestIsolateFromSnapshot(uint8_t* buffer,
|
|
const char* name = NULL) {
|
|
return CreateIsolate(buffer, 0, NULL, name);
|
|
}
|
|
static Dart_Isolate CreateTestIsolate(const char* name = nullptr,
|
|
void* isolate_group_data = nullptr,
|
|
void* isolate_data = nullptr);
|
|
static Dart_Isolate CreateTestIsolateInGroup(const char* name,
|
|
Dart_Isolate parent,
|
|
void* group_data = nullptr,
|
|
void* isolate_data = nullptr);
|
|
|
|
static Dart_Handle library_handler(Dart_LibraryTag tag,
|
|
Dart_Handle library,
|
|
Dart_Handle url);
|
|
|
|
virtual void Run();
|
|
|
|
// Sets |script| to be the source used at next reload.
|
|
static Dart_Handle SetReloadTestScript(const char* script);
|
|
|
|
// Initiates the reload.
|
|
static Dart_Handle TriggerReload(const uint8_t* kernel_buffer,
|
|
intptr_t kernel_buffer_size);
|
|
static Dart_Handle TriggerReload(const char* root_script_url);
|
|
|
|
// Helper function which reloads the current isolate using |script|.
|
|
static Dart_Handle ReloadTestScript(const char* script);
|
|
|
|
// Helper function which reloads the current isolate using |script|.
|
|
static Dart_Handle ReloadTestKernel(const uint8_t* kernel_buffer,
|
|
intptr_t kernel_buffer_size);
|
|
|
|
static void AddTestLib(const char* url, const char* source);
|
|
static const char* GetTestLib(const char* url);
|
|
|
|
// Return true if non-nullable experiment is enabled.
|
|
static bool IsNNBD();
|
|
|
|
static const char* NullableTag() { return IsNNBD() ? "?" : ""; }
|
|
static const char* NullAssertTag() { return IsNNBD() ? "!" : ""; }
|
|
static const char* LateTag() { return IsNNBD() ? "late" : ""; }
|
|
|
|
private:
|
|
static Dart_Handle TriggerReload(
|
|
std::function<bool(IsolateGroup*, JSONStream*)> do_reload);
|
|
|
|
// |data_buffer| can either be snapshot data, or kernel binary data.
|
|
// If |data_buffer| is snapshot data, then |len| should be zero as snapshot
|
|
// size is encoded within them. If |len| is non-zero, then |data_buffer|
|
|
// will be treated as a kernel binary (but CreateIsolate will not
|
|
// take ownership of the buffer) and |instr_buffer| will be ignored.
|
|
static Dart_Isolate CreateIsolate(const uint8_t* data_buffer,
|
|
intptr_t len,
|
|
const uint8_t* instr_buffer,
|
|
const char* name,
|
|
void* group_data = nullptr,
|
|
void* isolate_data = nullptr);
|
|
|
|
static char* ValidateCompilationResult(Zone* zone,
|
|
Dart_KernelCompilationResult result,
|
|
const uint8_t** kernel_buffer,
|
|
intptr_t* kernel_buffer_size,
|
|
bool allow_compile_errors);
|
|
|
|
RunEntry* const run_;
|
|
};
|
|
|
|
class RawTestCase : TestCaseBase {
|
|
public:
|
|
typedef void(RunEntry)();
|
|
|
|
RawTestCase(RunEntry* run, const char* name, const char* expectation)
|
|
: TestCaseBase(name, expectation), run_(run) {
|
|
raw_test_ = true;
|
|
}
|
|
virtual void Run();
|
|
|
|
private:
|
|
RunEntry* const run_;
|
|
};
|
|
|
|
class TestIsolateScope {
|
|
public:
|
|
TestIsolateScope() {
|
|
isolate_ = reinterpret_cast<Isolate*>(TestCase::CreateTestIsolate());
|
|
Dart_EnterScope(); // Create a Dart API scope for unit tests.
|
|
}
|
|
~TestIsolateScope() {
|
|
Dart_ExitScope(); // Exit the Dart API scope created for unit tests.
|
|
ASSERT(isolate_ == Isolate::Current());
|
|
Dart_ShutdownIsolate();
|
|
isolate_ = NULL;
|
|
}
|
|
Isolate* isolate() const { return isolate_; }
|
|
|
|
private:
|
|
Isolate* isolate_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(TestIsolateScope);
|
|
};
|
|
|
|
// Ensures core libraries are initialized, thereby allowing vm/cc tests to
|
|
// e.g. run functions using microtasks.
|
|
void SetupCoreLibrariesForUnitTest();
|
|
|
|
template <typename T>
|
|
struct is_void {
|
|
static const bool value = false;
|
|
};
|
|
|
|
template <>
|
|
struct is_void<void> {
|
|
static const bool value = true;
|
|
};
|
|
|
|
template <typename T>
|
|
struct is_double {
|
|
static const bool value = false;
|
|
};
|
|
|
|
template <>
|
|
struct is_double<double> {
|
|
static const bool value = true;
|
|
};
|
|
|
|
class AssemblerTest {
|
|
public:
|
|
AssemblerTest(const char* name, compiler::Assembler* assembler)
|
|
: name_(name),
|
|
assembler_(assembler),
|
|
code_(Code::ZoneHandle()),
|
|
disassembly_(Thread::Current()->zone()->Alloc<char>(DISASSEMBLY_SIZE)) {
|
|
ASSERT(name != NULL);
|
|
ASSERT(assembler != NULL);
|
|
}
|
|
~AssemblerTest() {}
|
|
|
|
compiler::Assembler* assembler() const { return assembler_; }
|
|
|
|
const Code& code() const { return code_; }
|
|
|
|
uword payload_start() const { return code_.PayloadStart(); }
|
|
uword payload_size() const { return assembler_->CodeSize(); }
|
|
uword entry() const { return code_.EntryPoint(); }
|
|
|
|
// Invoke/InvokeWithCodeAndThread is used to call assembler test functions
|
|
// using the ABI calling convention.
|
|
// ResultType is the return type of the assembler test function.
|
|
// ArgNType is the type of the Nth argument.
|
|
#if defined(USING_SIMULATOR)
|
|
|
|
#if defined(ARCH_IS_64_BIT)
|
|
// TODO(fschneider): Make InvokeWithCodeAndThread<> more general and work on
|
|
// 32-bit.
|
|
// Since Simulator::Call always return a int64_t, bit_cast does not work
|
|
// on 32-bit platforms when returning an int32_t. Since template functions
|
|
// don't support partial specialization, we'd need to introduce a helper
|
|
// class to support 32-bit return types.
|
|
template <typename ResultType>
|
|
ResultType InvokeWithCodeAndThread() {
|
|
const bool fp_return = is_double<ResultType>::value;
|
|
const bool fp_args = false;
|
|
Thread* thread = Thread::Current();
|
|
ASSERT(thread != NULL);
|
|
return bit_cast<ResultType, int64_t>(Simulator::Current()->Call(
|
|
bit_cast<intptr_t, uword>(entry()), reinterpret_cast<intptr_t>(&code_),
|
|
reinterpret_cast<intptr_t>(thread), 0, 0, fp_return, fp_args));
|
|
}
|
|
template <typename ResultType, typename Arg1Type>
|
|
ResultType InvokeWithCodeAndThread(Arg1Type arg1) {
|
|
const bool fp_return = is_double<ResultType>::value;
|
|
const bool fp_args = is_double<Arg1Type>::value;
|
|
// TODO(fschneider): Support double arguments for simulator calls.
|
|
COMPILE_ASSERT(!fp_args);
|
|
Thread* thread = Thread::Current();
|
|
ASSERT(thread != NULL);
|
|
return bit_cast<ResultType, int64_t>(Simulator::Current()->Call(
|
|
bit_cast<intptr_t, uword>(entry()), reinterpret_cast<intptr_t>(&code_),
|
|
reinterpret_cast<intptr_t>(thread), reinterpret_cast<intptr_t>(arg1), 0,
|
|
fp_return, fp_args));
|
|
}
|
|
#endif // ARCH_IS_64_BIT
|
|
|
|
template <typename ResultType,
|
|
typename Arg1Type,
|
|
typename Arg2Type,
|
|
typename Arg3Type>
|
|
ResultType Invoke(Arg1Type arg1, Arg2Type arg2, Arg3Type arg3) {
|
|
// TODO(fschneider): Support double arguments for simulator calls.
|
|
COMPILE_ASSERT(is_void<ResultType>::value);
|
|
COMPILE_ASSERT(!is_double<Arg1Type>::value);
|
|
COMPILE_ASSERT(!is_double<Arg2Type>::value);
|
|
COMPILE_ASSERT(!is_double<Arg3Type>::value);
|
|
const bool fp_args = false;
|
|
const bool fp_return = false;
|
|
Simulator::Current()->Call(
|
|
bit_cast<intptr_t, uword>(entry()), static_cast<intptr_t>(arg1),
|
|
static_cast<intptr_t>(arg2), reinterpret_cast<intptr_t>(arg3), 0,
|
|
fp_return, fp_args);
|
|
}
|
|
#else
|
|
template <typename ResultType>
|
|
ResultType InvokeWithCodeAndThread() {
|
|
Thread* thread = Thread::Current();
|
|
ASSERT(thread != NULL);
|
|
typedef ResultType (*FunctionType)(const Code&, Thread*);
|
|
return reinterpret_cast<FunctionType>(entry())(code_, thread);
|
|
}
|
|
|
|
template <typename ResultType, typename Arg1Type>
|
|
ResultType InvokeWithCodeAndThread(Arg1Type arg1) {
|
|
Thread* thread = Thread::Current();
|
|
ASSERT(thread != NULL);
|
|
typedef ResultType (*FunctionType)(const Code&, Thread*, Arg1Type);
|
|
return reinterpret_cast<FunctionType>(entry())(code_, thread, arg1);
|
|
}
|
|
|
|
template <typename ResultType,
|
|
typename Arg1Type,
|
|
typename Arg2Type,
|
|
typename Arg3Type>
|
|
ResultType Invoke(Arg1Type arg1, Arg2Type arg2, Arg3Type arg3) {
|
|
typedef ResultType (*FunctionType)(Arg1Type, Arg2Type, Arg3Type);
|
|
return reinterpret_cast<FunctionType>(entry())(arg1, arg2, arg3);
|
|
}
|
|
#endif // defined(USING_SIMULATOR)
|
|
|
|
// Assemble test and set code_.
|
|
void Assemble();
|
|
|
|
// Disassembly of the code with relative branch/jump targets.
|
|
char* RelativeDisassembly() { return disassembly_; }
|
|
|
|
private:
|
|
const char* name_;
|
|
compiler::Assembler* assembler_;
|
|
Code& code_;
|
|
static const intptr_t DISASSEMBLY_SIZE = 10240;
|
|
char* disassembly_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(AssemblerTest);
|
|
};
|
|
|
|
class CompilerTest : public AllStatic {
|
|
public:
|
|
// Test the Compiler::CompileFunction functionality by checking the return
|
|
// value to see if no parse errors were reported.
|
|
static bool TestCompileFunction(const Function& function);
|
|
};
|
|
|
|
#define EXPECT_VALID(handle) \
|
|
do { \
|
|
Dart_Handle tmp_handle = (handle); \
|
|
if (!Api::IsValid(tmp_handle)) { \
|
|
dart::Expect(__FILE__, __LINE__) \
|
|
.Fail( \
|
|
"expected '%s' to be a valid handle but '%s' has already been " \
|
|
"freed\n", \
|
|
#handle, #handle); \
|
|
} \
|
|
if (Dart_IsError(tmp_handle)) { \
|
|
dart::Expect(__FILE__, __LINE__) \
|
|
.Fail( \
|
|
"expected '%s' to be a valid handle but found an error " \
|
|
"handle:\n" \
|
|
" '%s'\n", \
|
|
#handle, Dart_GetError(tmp_handle)); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define EXPECT_ERROR(handle, substring) \
|
|
do { \
|
|
Dart_Handle tmp_handle = (handle); \
|
|
if (Dart_IsError(tmp_handle)) { \
|
|
dart::Expect(__FILE__, __LINE__) \
|
|
.IsSubstring((substring), Dart_GetError(tmp_handle)); \
|
|
} else { \
|
|
dart::Expect(__FILE__, __LINE__) \
|
|
.Fail( \
|
|
"expected '%s' to be an error handle but found a valid " \
|
|
"handle.\n", \
|
|
#handle); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define EXPECT_TRUE(handle) \
|
|
do { \
|
|
Dart_Handle tmp_handle = (handle); \
|
|
if (Dart_IsBoolean(tmp_handle)) { \
|
|
bool value; \
|
|
Dart_BooleanValue(tmp_handle, &value); \
|
|
if (!value) { \
|
|
dart::Expect(__FILE__, __LINE__) \
|
|
.Fail("expected True, but was '%s'\n", #handle); \
|
|
} \
|
|
} else { \
|
|
dart::Expect(__FILE__, __LINE__) \
|
|
.Fail("expected True, but was '%s'\n", #handle); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define EXPECT_NULL(handle) \
|
|
do { \
|
|
Dart_Handle tmp_handle = (handle); \
|
|
if (!Dart_IsNull(tmp_handle)) { \
|
|
dart::Expect(__FILE__, __LINE__) \
|
|
.Fail("expected '%s' to be a null handle.\n", #handle); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define EXPECT_NON_NULL(handle) \
|
|
do { \
|
|
Dart_Handle tmp_handle = (handle); \
|
|
if (Dart_IsNull(tmp_handle)) { \
|
|
dart::Expect(__FILE__, __LINE__) \
|
|
.Fail("expected '%s' to be a non-null handle.\n", #handle); \
|
|
} \
|
|
} while (0)
|
|
|
|
// Elide a substring which starts with some prefix and ends with some postfix.
|
|
//
|
|
// Prefix is inclusive, postfix is exclusive.
|
|
//
|
|
// This is used to remove non-deterministic or fragile substrings from
|
|
// JSON output.
|
|
//
|
|
// For example:
|
|
//
|
|
// prefix = "classes"
|
|
// in = "\"id\":\"classes/46\""
|
|
//
|
|
// Yields:
|
|
//
|
|
// out = "\"id\":\"\""
|
|
//
|
|
// WARNING: This function is not safe to use if `in` is bigger than `out`!
|
|
void ElideJSONSubstring(const char* prefix,
|
|
const char* in,
|
|
char* out,
|
|
const char* postfix = "\"");
|
|
|
|
// Elide a substrings such as ",\"tokenPos\":4372,\"endTokenPos\":4430".
|
|
//
|
|
// Substring to be followed by "}".
|
|
//
|
|
// Modifies buffer in place.
|
|
void StripTokenPositions(char* buffer);
|
|
|
|
template <typename T>
|
|
class SetFlagScope : public ValueObject {
|
|
public:
|
|
SetFlagScope(T* flag, T value) : flag_(flag), original_value_(*flag) {
|
|
*flag_ = value;
|
|
}
|
|
|
|
~SetFlagScope() { *flag_ = original_value_; }
|
|
|
|
private:
|
|
T* flag_;
|
|
T original_value_;
|
|
};
|
|
|
|
} // namespace dart
|
|
|
|
#endif // RUNTIME_VM_UNIT_TEST_H_
|