Use constexpr instead of const in symbol definitions that are obviously constexpr.
[WebKit-https.git] / Source / JavaScriptCore / wasm / WasmOMGPlan.cpp
1 /*
2  * Copyright (C) 2017-2019 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 "WasmNameSection.h"
42 #include "WasmSignatureInlines.h"
43 #include "WasmValidate.h"
44 #include "WasmWorklist.h"
45 #include <wtf/DataLog.h>
46 #include <wtf/Locker.h>
47 #include <wtf/MonotonicTime.h>
48 #include <wtf/StdLibExtras.h>
49 #include <wtf/ThreadMessage.h>
50
51 namespace JSC { namespace Wasm {
52
53 namespace WasmOMGPlanInternal {
54 static constexpr bool verbose = false;
55 }
56
57 OMGPlan::OMGPlan(Context* context, Ref<Module>&& module, uint32_t functionIndex, CodeBlock& codeBlock, CompletionTask&& task)
58     : Base(context, makeRef(const_cast<ModuleInformation&>(module->moduleInformation())), WTFMove(task))
59     , m_module(WTFMove(module))
60     , m_codeBlock(codeBlock)
61     , m_functionIndex(functionIndex)
62 {
63     setMode(codeBlock.mode());
64     ASSERT(m_codeBlock->runnable());
65     ASSERT(m_codeBlock.ptr() == m_module->codeBlockFor(m_mode));
66     dataLogLnIf(WasmOMGPlanInternal::verbose, "Starting OMG plan for ", functionIndex, " of module: ", RawPointer(&m_module.get()));
67 }
68
69 void OMGPlan::work(CompilationEffort)
70 {
71     ASSERT(m_codeBlock->runnable());
72     ASSERT(m_codeBlock.ptr() == m_module->codeBlockFor(mode()));
73     const FunctionData& function = m_moduleInformation->functions[m_functionIndex];
74
75     const uint32_t functionIndexSpace = m_functionIndex + m_module->moduleInformation().importFunctionCount();
76     ASSERT(functionIndexSpace < m_module->moduleInformation().functionIndexSpaceSize());
77
78     SignatureIndex signatureIndex = m_moduleInformation->internalFunctionSignatureIndices[m_functionIndex];
79     const Signature& signature = SignatureInformation::get(signatureIndex);
80     ASSERT(validateFunction(function, signature, m_moduleInformation.get()));
81
82     unsigned osrEntryScratchBufferSize;
83     CompilationContext context;
84     auto parseAndCompileResult = parseAndCompile(context, function, signature, m_codeBlock->m_wasmToWasmExitStubs, osrEntryScratchBufferSize, m_moduleInformation.get(), m_mode, CompilationMode::OMGMode, m_functionIndex, UINT32_MAX);
85
86     if (UNLIKELY(!parseAndCompileResult)) {
87         fail(holdLock(m_lock), makeString(parseAndCompileResult.error(), "when trying to tier up ", String::number(m_functionIndex)));
88         return;
89     }
90
91     LinkBuffer linkBuffer(*context.wasmEntrypointJIT, nullptr, JITCompilationCanFail);
92     if (UNLIKELY(linkBuffer.didFailToAllocate())) {
93         Base::fail(holdLock(m_lock), makeString("Out of executable memory while tiering up function at index ", String::number(m_functionIndex)));
94         return;
95     }
96
97     Ref<OMGCallee> omgCallee = OMGCallee::create(functionIndexSpace, m_moduleInformation->nameSection->get(functionIndexSpace));
98     omgCallee->entrypoint().compilation = makeUnique<B3::Compilation>(
99         FINALIZE_CODE(linkBuffer, B3CompilationPtrTag, "WebAssembly OMG function[%i] %s name %s", m_functionIndex, signature.toString().ascii().data(), makeString(IndexOrName(functionIndexSpace, m_moduleInformation->nameSection->get(functionIndexSpace))).ascii().data()),
100         WTFMove(context.wasmEntrypointByproducts));
101
102     omgCallee->entrypoint().calleeSaveRegisters = WTFMove(context.calleeSaveRegisters);
103
104     BBQCallee& bbqCallee = m_codeBlock->m_callees[m_functionIndex].get();
105     {
106         ASSERT(m_codeBlock.ptr() == m_module->codeBlockFor(mode()));
107         ASSERT(!m_codeBlock->m_optimizedCallees[m_functionIndex]);
108
109         // We want to make sure we publish our callee at the same time as we link our callsites. This enables us to ensure we
110         // always call the fastest code. Any function linked after us will see our new code and the new callsites, which they
111         // will update. It's also ok if they publish their code before we reset the instruction caches because after we release
112         // the lock our code is ready to be published too.
113         LockHolder holder(m_codeBlock->m_lock);
114         m_codeBlock->m_optimizedCallees[m_functionIndex] = omgCallee.copyRef();
115         {
116             auto locker = holdLock(bbqCallee.tierUpCount()->getLock());
117             bbqCallee.setReplacement(holder, omgCallee.copyRef());
118             bbqCallee.tierUpCount()->m_compilationStatusForOMG = TierUpCount::CompilationStatus::Compiled;
119         }
120
121         for (auto& call : context.outgoingCalls) {
122             BBQCallee& targetCallee = m_codeBlock->wasmBBQCalleeFromFunctionIndexSpace(call.targetFunctionIndexSpace);
123             targetCallee.addAndLinkCaller(holder, linkBuffer, call.unlinkedMoveAndCall);
124         }
125     }
126
127     // 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
128     // 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
129     // the updates to B but still not have reset its cache of A', which would lead to all kinds of badness.
130     resetInstructionCacheOnAllThreads();
131     WTF::storeStoreFence(); // This probably isn't necessary but it's good to be paranoid.
132
133     m_codeBlock->m_wasmIndirectCallEntryPoints[m_functionIndex] = omgCallee->code();
134     m_codeBlock->m_boxedCallees[m_functionIndex] = CalleeBits::boxWasm(omgCallee.ptr());
135     {
136         LockHolder holder(m_codeBlock->m_lock);
137         bbqCallee.repatchCallers(holder, omgCallee.get());
138     }
139
140     dataLogLnIf(WasmOMGPlanInternal::verbose, "Finished OMG ", m_functionIndex, " with tier up count at: ", m_codeBlock->m_callees[m_functionIndex]->tierUpCount()->count());
141     complete(holdLock(m_lock));
142 }
143
144 } } // namespace JSC::Wasm
145
146 #endif // ENABLE(WEBASSEMBLY)