f55ada7eef25ebb1a952799723f85462f672e260
[WebKit-https.git] / Source / JavaScriptCore / wasm / WasmOMGPlan.cpp
1 /*
2  * Copyright (C) 2017 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "WasmOMGPlan.h"
28
29 #if ENABLE(WEBASSEMBLY)
30
31 #include "B3Compilation.h"
32 #include "B3OpaqueByproducts.h"
33 #include "JSCInlines.h"
34 #include "LinkBuffer.h"
35 #include "WasmB3IRGenerator.h"
36 #include "WasmCallee.h"
37 #include "WasmContext.h"
38 #include "WasmInstance.h"
39 #include "WasmMachineThreads.h"
40 #include "WasmMemory.h"
41 #include "WasmValidate.h"
42 #include "WasmWorklist.h"
43 #include <wtf/DataLog.h>
44 #include <wtf/Locker.h>
45 #include <wtf/MonotonicTime.h>
46 #include <wtf/StdLibExtras.h>
47 #include <wtf/ThreadMessage.h>
48
49 namespace JSC { namespace Wasm {
50
51 namespace WasmOMGPlanInternal {
52 static const bool verbose = false;
53 }
54
55 OMGPlan::OMGPlan(Context* context, Ref<Module>&& module, uint32_t functionIndex, MemoryMode mode, CompletionTask&& task)
56     : Base(context, makeRef(const_cast<ModuleInformation&>(module->moduleInformation())), WTFMove(task))
57     , m_module(WTFMove(module))
58     , m_codeBlock(*m_module->codeBlockFor(mode))
59     , m_functionIndex(functionIndex)
60 {
61     setMode(mode);
62     ASSERT(m_codeBlock->runnable());
63     ASSERT(m_codeBlock.ptr() == m_module->codeBlockFor(m_mode));
64     dataLogLnIf(WasmOMGPlanInternal::verbose, "Starting OMG plan for ", functionIndex, " of module: ", RawPointer(&m_module.get()));
65 }
66
67 void OMGPlan::work(CompilationEffort)
68 {
69     ASSERT(m_codeBlock->runnable());
70     ASSERT(m_codeBlock.ptr() == m_module->codeBlockFor(mode()));
71     const FunctionLocationInBinary& location = m_moduleInformation->functionLocationInBinary[m_functionIndex];
72     const uint8_t* functionStart = m_moduleInformation->source.data() + location.start;
73     const size_t functionLength = location.end - location.start;
74     ASSERT(functionStart + functionLength <= m_moduleInformation->source.end());
75
76     const uint32_t functionIndexSpace = m_functionIndex + m_module->moduleInformation().importFunctionCount();
77     ASSERT(functionIndexSpace < m_module->moduleInformation().functionIndexSpaceSize());
78
79     SignatureIndex signatureIndex = m_moduleInformation->internalFunctionSignatureIndices[m_functionIndex];
80     const Signature& signature = SignatureInformation::get(signatureIndex);
81     ASSERT(validateFunction(functionStart, functionLength, signature, m_moduleInformation.get()));
82
83     Vector<UnlinkedWasmToWasmCall> unlinkedCalls;
84     CompilationContext context;
85     auto parseAndCompileResult = parseAndCompile(context, functionStart, functionLength, signature, unlinkedCalls, m_moduleInformation.get(), m_mode, CompilationMode::OMGMode, m_functionIndex);
86
87     if (UNLIKELY(!parseAndCompileResult)) {
88         fail(holdLock(m_lock), makeString(parseAndCompileResult.error(), "when trying to tier up ", String::number(m_functionIndex)));
89         return;
90     }
91
92     Entrypoint omgEntrypoint;
93     LinkBuffer linkBuffer(*context.wasmEntrypointJIT, nullptr, JITCompilationCanFail);
94     if (UNLIKELY(linkBuffer.didFailToAllocate())) {
95         Base::fail(holdLock(m_lock), makeString("Out of executable memory while tiering up function at index ", String::number(m_functionIndex)));
96         return;
97     }
98
99     omgEntrypoint.compilation = std::make_unique<B3::Compilation>(
100         FINALIZE_CODE(linkBuffer, ("WebAssembly OMG function[%i] %s", m_functionIndex, SignatureInformation::get(signatureIndex).toString().ascii().data())),
101         WTFMove(context.wasmEntrypointByproducts));
102
103     omgEntrypoint.calleeSaveRegisters = WTFMove(parseAndCompileResult.value()->entrypoint.calleeSaveRegisters);
104
105     void* entrypoint;
106     {
107         ASSERT(m_codeBlock.ptr() == m_module->codeBlockFor(mode()));
108         Ref<Callee> callee = Callee::create(WTFMove(omgEntrypoint), functionIndexSpace, m_moduleInformation->nameSection.get(functionIndexSpace));
109         MacroAssembler::repatchPointer(parseAndCompileResult.value()->calleeMoveLocation, CalleeBits::boxWasm(callee.ptr()));
110         ASSERT(!m_codeBlock->m_optimizedCallees[m_functionIndex]);
111         entrypoint = callee->entrypoint();
112
113         // We want to make sure we publish our callee at the same time as we link our callsites. This enables us to ensure we
114         // always call the fastest code. Any function linked after us will see our new code and the new callsites, which they
115         // will update. It's also ok if they publish their code before we reset the instruction caches because after we release
116         // the lock our code is ready to be published too.
117         LockHolder holder(m_codeBlock->m_lock);
118         m_codeBlock->m_optimizedCallees[m_functionIndex] = WTFMove(callee);
119
120         for (auto& call : unlinkedCalls) {
121             void* entrypoint;
122             if (call.functionIndexSpace < m_module->moduleInformation().importFunctionCount())
123                 entrypoint = m_codeBlock->m_wasmToWasmExitStubs[call.functionIndexSpace].code().executableAddress();
124             else
125                 entrypoint = m_codeBlock->wasmEntrypointCalleeFromFunctionIndexSpace(call.functionIndexSpace).entrypoint();
126
127             MacroAssembler::repatchNearCall(call.callLocation, CodeLocationLabel(entrypoint));
128         }
129         unlinkedCalls = std::exchange(m_codeBlock->m_wasmToWasmCallsites[m_functionIndex], unlinkedCalls);
130     }
131
132     // It's important to make sure we do this before we make any of the code we just compiled visible. If we didn't, we could end up
133     // where we are tiering up some function A to A' and we repatch some function B to call A' instead of A. Another CPU could see
134     // the updates to B but still not have reset its cache of A', which would lead to all kinds of badness.
135     resetInstructionCacheOnAllThreads();
136     WTF::storeStoreFence(); // This probably isn't necessary but it's good to be paranoid.
137
138     m_codeBlock->m_wasmIndirectCallEntryPoints[m_functionIndex] = entrypoint;
139     {
140         LockHolder holder(m_codeBlock->m_lock);
141
142         auto repatchCalls = [&] (const Vector<UnlinkedWasmToWasmCall>&  callsites) {
143             for (auto& call : callsites) {
144                 dataLogLnIf(WasmOMGPlanInternal::verbose, "Considering repatching call at: ", RawPointer(call.callLocation.dataLocation()), " that targets ", call.functionIndexSpace);
145                 if (call.functionIndexSpace == functionIndexSpace) {
146                     dataLogLnIf(WasmOMGPlanInternal::verbose, "Repatching call at: ", RawPointer(call.callLocation.dataLocation()), " to ", RawPointer(entrypoint));
147                     MacroAssembler::repatchNearCall(call.callLocation, CodeLocationLabel(entrypoint));
148                 }
149             }
150
151         };
152
153         for (unsigned i = 0; i < m_codeBlock->m_wasmToWasmCallsites.size(); ++i) {
154             if (i != functionIndexSpace)
155                 repatchCalls(m_codeBlock->m_wasmToWasmCallsites[i]);
156         }
157
158         // Make sure we repatch any recursive calls.
159         repatchCalls(unlinkedCalls);
160     }
161
162     dataLogLnIf(WasmOMGPlanInternal::verbose, "Finished with tier up count at: ", m_codeBlock->tierUpCount(m_functionIndex).count());
163     complete(holdLock(m_lock));
164 }
165
166 void OMGPlan::runForIndex(Instance* instance, uint32_t functionIndex)
167 {
168     Wasm::CodeBlock& codeBlock = *instance->codeBlock();
169     ASSERT(instance->memory()->mode() == codeBlock.mode());
170
171     if (codeBlock.tierUpCount(functionIndex).shouldStartTierUp()) {
172         Ref<Plan> plan = adoptRef(*new OMGPlan(instance->context(), Ref<Wasm::Module>(instance->module()), functionIndex, codeBlock.mode(), Plan::dontFinalize()));
173         ensureWorklist().enqueue(plan.copyRef());
174         if (UNLIKELY(!Options::useConcurrentJIT()))
175             plan->waitForCompletion();
176     }
177 }
178
179 } } // namespace JSC::Wasm
180
181 #endif // ENABLE(WEBASSEMBLY)