OLD | NEW |
| (Empty) |
1 // Copyright 2015 the V8 project authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include <stdint.h> | |
6 #include <stdlib.h> | |
7 #include <string.h> | |
8 | |
9 #include "src/wasm/wasm-macro-gen.h" | |
10 | |
11 #include "test/cctest/cctest.h" | |
12 #include "test/cctest/wasm/test-signatures.h" | |
13 #include "test/cctest/wasm/wasm-run-utils.h" | |
14 | |
15 using namespace v8::base; | |
16 using namespace v8::internal; | |
17 using namespace v8::internal::compiler; | |
18 using namespace v8::internal::wasm; | |
19 | |
20 #define BUILD(r, ...) \ | |
21 do { \ | |
22 byte code[] = {__VA_ARGS__}; \ | |
23 r.Build(code, code + arraysize(code)); \ | |
24 } while (false) | |
25 | |
26 | |
27 static uint32_t AddJsFunction(TestingModule* module, FunctionSig* sig, | |
28 const char* source) { | |
29 Handle<JSFunction> jsfunc = Handle<JSFunction>::cast(v8::Utils::OpenHandle( | |
30 *v8::Local<v8::Function>::Cast(CompileRun(source)))); | |
31 module->AddFunction(sig, Handle<Code>::null()); | |
32 uint32_t index = static_cast<uint32_t>(module->module->functions->size() - 1); | |
33 Isolate* isolate = CcTest::InitIsolateOnce(); | |
34 Handle<Code> code = CompileWasmToJSWrapper(isolate, module, jsfunc, index); | |
35 module->function_code->at(index) = code; | |
36 return index; | |
37 } | |
38 | |
39 | |
40 static Handle<JSFunction> WrapCode(ModuleEnv* module, uint32_t index) { | |
41 Isolate* isolate = module->module->shared_isolate; | |
42 // Wrap the code so it can be called as a JS function. | |
43 Handle<String> name = isolate->factory()->NewStringFromStaticChars("main"); | |
44 Handle<JSObject> module_object = Handle<JSObject>(0, isolate); | |
45 Handle<Code> code = module->function_code->at(index); | |
46 WasmJs::InstallWasmFunctionMap(isolate, isolate->native_context()); | |
47 return compiler::CompileJSToWasmWrapper(isolate, module, name, code, | |
48 module_object, index); | |
49 } | |
50 | |
51 | |
52 static void EXPECT_CALL(double expected, Handle<JSFunction> jsfunc, double a, | |
53 double b) { | |
54 Isolate* isolate = jsfunc->GetIsolate(); | |
55 Handle<Object> buffer[] = {isolate->factory()->NewNumber(a), | |
56 isolate->factory()->NewNumber(b)}; | |
57 Handle<Object> undefined(isolate->heap()->undefined_value(), isolate); | |
58 MaybeHandle<Object> retval = | |
59 Execution::Call(isolate, jsfunc, undefined, 2, buffer); | |
60 | |
61 CHECK(!retval.is_null()); | |
62 Handle<Object> result = retval.ToHandleChecked(); | |
63 if (result->IsSmi()) { | |
64 CHECK_EQ(expected, Smi::cast(*result)->value()); | |
65 } else { | |
66 CHECK(result->IsHeapNumber()); | |
67 CHECK_EQ(expected, HeapNumber::cast(*result)->value()); | |
68 } | |
69 } | |
70 | |
71 | |
72 TEST(Run_Int32Sub_jswrapped) { | |
73 TestSignatures sigs; | |
74 TestingModule module; | |
75 WasmFunctionCompiler t(sigs.i_ii()); | |
76 BUILD(t, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | |
77 Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd(&module)); | |
78 | |
79 EXPECT_CALL(33, jsfunc, 44, 11); | |
80 EXPECT_CALL(-8723487, jsfunc, -8000000, 723487); | |
81 } | |
82 | |
83 | |
84 TEST(Run_Float32Div_jswrapped) { | |
85 TestSignatures sigs; | |
86 TestingModule module; | |
87 WasmFunctionCompiler t(sigs.f_ff()); | |
88 BUILD(t, WASM_F32_DIV(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | |
89 Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd(&module)); | |
90 | |
91 EXPECT_CALL(92, jsfunc, 46, 0.5); | |
92 EXPECT_CALL(64, jsfunc, -16, -0.25); | |
93 } | |
94 | |
95 | |
96 TEST(Run_Float64Add_jswrapped) { | |
97 TestSignatures sigs; | |
98 TestingModule module; | |
99 WasmFunctionCompiler t(sigs.d_dd()); | |
100 BUILD(t, WASM_F64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))); | |
101 Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd(&module)); | |
102 | |
103 EXPECT_CALL(3, jsfunc, 2, 1); | |
104 EXPECT_CALL(-5.5, jsfunc, -5.25, -0.25); | |
105 } | |
106 | |
107 | |
108 TEST(Run_I32Popcount_jswrapped) { | |
109 TestSignatures sigs; | |
110 TestingModule module; | |
111 WasmFunctionCompiler t(sigs.i_i()); | |
112 BUILD(t, WASM_I32_POPCNT(WASM_GET_LOCAL(0))); | |
113 Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd(&module)); | |
114 | |
115 EXPECT_CALL(2, jsfunc, 9, 0); | |
116 EXPECT_CALL(3, jsfunc, 11, 0); | |
117 EXPECT_CALL(6, jsfunc, 0x3F, 0); | |
118 | |
119 USE(AddJsFunction); | |
120 } | |
121 | |
122 | |
123 #if !V8_TARGET_ARCH_ARM64 | |
124 // TODO(titzer): fix wasm->JS calls on arm64 (wrapper issues) | |
125 | |
126 TEST(Run_CallJS_Add_jswrapped) { | |
127 TestSignatures sigs; | |
128 TestingModule module; | |
129 WasmFunctionCompiler t(sigs.i_i(), &module); | |
130 uint32_t js_index = | |
131 AddJsFunction(&module, sigs.i_i(), "(function(a) { return a + 99; })"); | |
132 BUILD(t, WASM_CALL_FUNCTION(js_index, WASM_GET_LOCAL(0))); | |
133 | |
134 Handle<JSFunction> jsfunc = WrapCode(&module, t.CompileAndAdd(&module)); | |
135 | |
136 EXPECT_CALL(101, jsfunc, 2, -8); | |
137 EXPECT_CALL(199, jsfunc, 100, -1); | |
138 EXPECT_CALL(-666666801, jsfunc, -666666900, -1); | |
139 } | |
140 | |
141 #endif | |
OLD | NEW |