blob: 8ed23093f713e1f4229eb3f1fc745d541bffb277 [file] [log] [blame]
/*
* Copyright (C) 2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "WasmLLIntGenerator.h"
#if ENABLE(WEBASSEMBLY)
#include "BytecodeGeneratorBaseInlines.h"
#include "BytecodeStructs.h"
#include "InstructionStream.h"
#include "JSCJSValueInlines.h"
#include "Label.h"
#include "WasmCallingConvention.h"
#include "WasmContextInlines.h"
#include "WasmFunctionCodeBlock.h"
#include "WasmFunctionParser.h"
#include "WasmGeneratorTraits.h"
#include <variant>
#include <wtf/CompletionHandler.h>
#include <wtf/RefPtr.h>
namespace JSC { namespace Wasm {
class LLIntGenerator : public BytecodeGeneratorBase<GeneratorTraits> {
public:
using ExpressionType = VirtualRegister;
struct ControlLoop {
Ref<Label> m_body;
};
struct ControlTopLevel {
};
struct ControlBlock {
};
struct ControlIf {
Ref<Label> m_alternate;
};
struct ControlTry {
Ref<Label> m_try;
unsigned m_tryDepth;
};
struct ControlCatch {
CatchKind m_kind;
Ref<Label> m_tryStart;
Ref<Label> m_tryEnd;
unsigned m_tryDepth;
VirtualRegister m_exception;
};
struct CatchRewriteInfo {
unsigned m_instructionOffset;
unsigned m_tryDepth;
};
struct ControlType : public std::variant<ControlLoop, ControlTopLevel, ControlBlock, ControlIf, ControlTry, ControlCatch> {
using Base = std::variant<ControlLoop, ControlTopLevel, ControlBlock, ControlIf, ControlTry, ControlCatch>;
ControlType()
: Base(ControlBlock { })
{
}
static ControlType topLevel(BlockSignature signature, unsigned stackSize, RefPtr<Label>&& continuation)
{
return ControlType(signature, stackSize, WTFMove(continuation), ControlTopLevel { });
}
static ControlType loop(BlockSignature signature, unsigned stackSize, Ref<Label>&& body, RefPtr<Label>&& continuation)
{
return ControlType(signature, stackSize - signature->argumentCount(), WTFMove(continuation), ControlLoop { WTFMove(body) });
}
static ControlType block(BlockSignature signature, unsigned stackSize, RefPtr<Label>&& continuation)
{
return ControlType(signature, stackSize - signature->argumentCount(), WTFMove(continuation), ControlBlock { });
}
static ControlType if_(BlockSignature signature, unsigned stackSize, Ref<Label>&& alternate, RefPtr<Label>&& continuation)
{
return ControlType(signature, stackSize - signature->argumentCount(), WTFMove(continuation), ControlIf { WTFMove(alternate) });
}
static ControlType createTry(BlockSignature signature, unsigned stackSize, Ref<Label>&& tryLabel, RefPtr<Label>&& continuation, unsigned tryDepth)
{
return ControlType(signature, stackSize - signature->argumentCount(), WTFMove(continuation), ControlTry { WTFMove(tryLabel), tryDepth });
}
static ControlType createCatch(BlockSignature signature, unsigned stackSize, Ref<Label>&& tryStart, RefPtr<Label>&& continuation, Ref<Label> tryEnd, unsigned tryDepth, VirtualRegister exception)
{
return ControlType(signature, stackSize - signature->argumentCount(), WTFMove(continuation), ControlCatch { CatchKind::Catch, WTFMove(tryStart), WTFMove(tryEnd), tryDepth, exception });
}
static bool isLoop(const ControlType& control) { return std::holds_alternative<ControlLoop>(control); }
static bool isTopLevel(const ControlType& control) { return std::holds_alternative<ControlTopLevel>(control); }
static bool isBlock(const ControlType& control) { return std::holds_alternative<ControlBlock>(control); }
static bool isIf(const ControlType& control) { return std::holds_alternative<ControlIf>(control); }
static bool isTry(const ControlType& control) { return std::holds_alternative<ControlTry>(control); }
static bool isAnyCatch(const ControlType& control) { return std::holds_alternative<ControlCatch>(control); }
static bool isCatch(const ControlType& control)
{
if (!std::holds_alternative<ControlCatch>(control))
return false;
ControlCatch catchData = std::get<ControlCatch>(control);
return catchData.m_kind == CatchKind::Catch;
}
unsigned stackSize() const { return m_stackSize; }
BlockSignature signature() const { return m_signature; }
RefPtr<Label> targetLabelForBranch() const
{
if (std::holds_alternative<ControlLoop>(*this))
return std::get<ControlLoop>(*this).m_body.ptr();
return m_continuation;
}
SignatureArgCount branchTargetArity() const
{
if (std::holds_alternative<ControlLoop>(*this))
return m_signature->argumentCount();
return m_signature->returnCount();
}
Type branchTargetType(unsigned i) const
{
ASSERT(i < branchTargetArity());
if (std::holds_alternative<ControlLoop>(*this))
return m_signature->argument(i);
return m_signature->returnType(i);
}
BlockSignature m_signature;
unsigned m_stackSize;
RefPtr<Label> m_continuation;
private:
template<typename T>
ControlType(BlockSignature signature, unsigned stackSize, RefPtr<Label>&& continuation, T&& t)
: Base(WTFMove(t))
, m_signature(signature)
, m_stackSize(stackSize)
, m_continuation(WTFMove(continuation))
{
}
};
using ErrorType = String;
using PartialResult = Expected<void, ErrorType>;
using UnexpectedResult = Unexpected<ErrorType>;
using ControlEntry = FunctionParser<LLIntGenerator>::ControlEntry;
using ControlStack = FunctionParser<LLIntGenerator>::ControlStack;
using ResultList = FunctionParser<LLIntGenerator>::ResultList;
using Stack = FunctionParser<LLIntGenerator>::Stack;
using TypedExpression = FunctionParser<LLIntGenerator>::TypedExpression;
static ExpressionType emptyExpression() { return { }; };
template <typename ...Args>
NEVER_INLINE UnexpectedResult WARN_UNUSED_RETURN fail(Args... args) const
{
using namespace FailureHelper; // See ADL comment in WasmParser.h.
return UnexpectedResult(makeString("WebAssembly.Module failed compiling: "_s, makeString(args)...));
}
LLIntGenerator(ModuleInformation&, unsigned functionIndex, const Signature&);
std::unique_ptr<FunctionCodeBlock> finalize();
template<typename ExpressionListA, typename ExpressionListB>
void unifyValuesWithBlock(const ExpressionListA& destinations, const ExpressionListB& values)
{
ASSERT(destinations.size() <= values.size());
auto offset = values.size() - destinations.size();
for (size_t i = 0; i < destinations.size(); ++i) {
auto& src = values[offset + i];
auto& dst = destinations[i];
if (static_cast<VirtualRegister>(src) != static_cast<VirtualRegister>(dst))
WasmMov::emit(this, dst, src);
}
}
enum NoConsistencyCheckTag { NoConsistencyCheck };
ExpressionType push(NoConsistencyCheckTag)
{
m_maxStackSize = std::max(m_maxStackSize, ++m_stackSize);
return virtualRegisterForLocal(m_stackSize - 1);
}
ExpressionType push()
{
checkConsistency();
return push(NoConsistencyCheck);
}
void didPopValueFromStack() { --m_stackSize; }
PartialResult WARN_UNUSED_RETURN addArguments(const Signature&);
PartialResult WARN_UNUSED_RETURN addLocal(Type, uint32_t);
ExpressionType addConstant(Type, int64_t);
// References
PartialResult WARN_UNUSED_RETURN addRefIsNull(ExpressionType value, ExpressionType& result);
PartialResult WARN_UNUSED_RETURN addRefFunc(uint32_t index, ExpressionType& result);
// Tables
PartialResult WARN_UNUSED_RETURN addTableGet(unsigned, ExpressionType index, ExpressionType& result);
PartialResult WARN_UNUSED_RETURN addTableSet(unsigned, ExpressionType index, ExpressionType value);
PartialResult WARN_UNUSED_RETURN addTableInit(unsigned, unsigned, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length);
PartialResult WARN_UNUSED_RETURN addElemDrop(unsigned);
PartialResult WARN_UNUSED_RETURN addTableSize(unsigned, ExpressionType& result);
PartialResult WARN_UNUSED_RETURN addTableGrow(unsigned, ExpressionType fill, ExpressionType delta, ExpressionType& result);
PartialResult WARN_UNUSED_RETURN addTableFill(unsigned, ExpressionType offset, ExpressionType fill, ExpressionType count);
PartialResult WARN_UNUSED_RETURN addTableCopy(unsigned, unsigned, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length);
// Locals
PartialResult WARN_UNUSED_RETURN getLocal(uint32_t index, ExpressionType& result);
PartialResult WARN_UNUSED_RETURN setLocal(uint32_t index, ExpressionType value);
// Globals
PartialResult WARN_UNUSED_RETURN getGlobal(uint32_t index, ExpressionType& result);
PartialResult WARN_UNUSED_RETURN setGlobal(uint32_t index, ExpressionType value);
// Memory
PartialResult WARN_UNUSED_RETURN load(LoadOpType, ExpressionType pointer, ExpressionType& result, uint32_t offset);
PartialResult WARN_UNUSED_RETURN store(StoreOpType, ExpressionType pointer, ExpressionType value, uint32_t offset);
PartialResult WARN_UNUSED_RETURN addGrowMemory(ExpressionType delta, ExpressionType& result);
PartialResult WARN_UNUSED_RETURN addCurrentMemory(ExpressionType& result);
PartialResult WARN_UNUSED_RETURN addMemoryFill(ExpressionType dstAddress, ExpressionType targetValue, ExpressionType count);
PartialResult WARN_UNUSED_RETURN addMemoryCopy(ExpressionType dstAddress, ExpressionType srcAddress, ExpressionType count);
PartialResult WARN_UNUSED_RETURN addMemoryInit(unsigned, ExpressionType dstAddress, ExpressionType srcAddress, ExpressionType length);
PartialResult WARN_UNUSED_RETURN addDataDrop(unsigned);
// Atomics
PartialResult WARN_UNUSED_RETURN atomicLoad(ExtAtomicOpType, Type, ExpressionType pointer, ExpressionType& result, uint32_t offset);
PartialResult WARN_UNUSED_RETURN atomicStore(ExtAtomicOpType, Type, ExpressionType pointer, ExpressionType value, uint32_t offset);
PartialResult WARN_UNUSED_RETURN atomicBinaryRMW(ExtAtomicOpType, Type, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset);
PartialResult WARN_UNUSED_RETURN atomicCompareExchange(ExtAtomicOpType, Type, ExpressionType pointer, ExpressionType expected, ExpressionType value, ExpressionType& result, uint32_t offset);
PartialResult WARN_UNUSED_RETURN atomicWait(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, ExpressionType timeout, ExpressionType& result, uint32_t offset);
PartialResult WARN_UNUSED_RETURN atomicNotify(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset);
PartialResult WARN_UNUSED_RETURN atomicFence(ExtAtomicOpType, uint8_t flags);
// Saturated truncation.
PartialResult WARN_UNUSED_RETURN truncSaturated(Ext1OpType, ExpressionType operand, ExpressionType& result, Type, Type);
// Basic operators
template<OpType>
PartialResult WARN_UNUSED_RETURN addOp(ExpressionType arg, ExpressionType& result);
template<OpType>
PartialResult WARN_UNUSED_RETURN addOp(ExpressionType left, ExpressionType right, ExpressionType& result);
PartialResult WARN_UNUSED_RETURN addSelect(ExpressionType condition, ExpressionType nonZero, ExpressionType zero, ExpressionType& result);
// Control flow
ControlType WARN_UNUSED_RETURN addTopLevel(BlockSignature);
PartialResult WARN_UNUSED_RETURN addBlock(BlockSignature, Stack& enclosingStack, ControlType& newBlock, Stack& newStack);
PartialResult WARN_UNUSED_RETURN addLoop(BlockSignature, Stack& enclosingStack, ControlType& block, Stack& newStack, uint32_t loopIndex);
PartialResult WARN_UNUSED_RETURN addIf(ExpressionType condition, BlockSignature, Stack& enclosingStack, ControlType& result, Stack& newStack);
PartialResult WARN_UNUSED_RETURN addElse(ControlType&, Stack&);
PartialResult WARN_UNUSED_RETURN addElseToUnreachable(ControlType&);
PartialResult WARN_UNUSED_RETURN addTry(BlockSignature, Stack& enclosingStack, ControlType& result, Stack& newStack);
PartialResult WARN_UNUSED_RETURN addCatch(unsigned exceptionIndex, const Signature&, Stack&, ControlType&, ResultList&);
PartialResult WARN_UNUSED_RETURN addCatchToUnreachable(unsigned exceptionIndex, const Signature&, ControlType&, ResultList&);
PartialResult WARN_UNUSED_RETURN addCatchAll(Stack&, ControlType&);
PartialResult WARN_UNUSED_RETURN addCatchAllToUnreachable(ControlType&);
PartialResult WARN_UNUSED_RETURN addDelegate(ControlType&, ControlType&);
PartialResult WARN_UNUSED_RETURN addDelegateToUnreachable(ControlType&, ControlType&);
PartialResult WARN_UNUSED_RETURN addThrow(unsigned exceptionIndex, Vector<ExpressionType>& args, Stack&);
PartialResult WARN_UNUSED_RETURN addRethrow(unsigned, ControlType&);
PartialResult WARN_UNUSED_RETURN addReturn(const ControlType&, Stack& returnValues);
PartialResult WARN_UNUSED_RETURN addBranch(ControlType&, ExpressionType condition, Stack& returnValues);
PartialResult WARN_UNUSED_RETURN addSwitch(ExpressionType condition, const Vector<ControlType*>& targets, ControlType& defaultTargets, Stack& expressionStack);
PartialResult WARN_UNUSED_RETURN endBlock(ControlEntry&, Stack& expressionStack);
PartialResult WARN_UNUSED_RETURN addEndToUnreachable(ControlEntry&, Stack& expressionStack, bool unreachable = true);
PartialResult WARN_UNUSED_RETURN endTopLevel(BlockSignature, const Stack&);
// Calls
PartialResult WARN_UNUSED_RETURN addCall(uint32_t calleeIndex, const Signature&, Vector<ExpressionType>& args, ResultList& results);
PartialResult WARN_UNUSED_RETURN addCallIndirect(unsigned tableIndex, const Signature&, Vector<ExpressionType>& args, ResultList& results);
PartialResult WARN_UNUSED_RETURN addCallRef(const Signature&, Vector<ExpressionType>& args, ResultList& results);
PartialResult WARN_UNUSED_RETURN addUnreachable();
void didFinishParsingLocals();
void setParser(FunctionParser<LLIntGenerator>* parser) { m_parser = parser; };
// We need this for autogenerated templates used by JS bytecodes.
void setUsesCheckpoints() const { UNREACHABLE_FOR_PLATFORM(); }
void dump(const ControlStack&, const Stack*) { }
private:
friend GenericLabel<Wasm::GeneratorTraits>;
struct LLIntCallInformation {
unsigned stackOffset;
unsigned numberOfStackArguments;
ResultList arguments;
CompletionHandler<void(ResultList&)> commitResults;
};
LLIntCallInformation callInformationForCaller(const Signature&);
Vector<VirtualRegister, 2> callInformationForCallee(const Signature&);
void linkSwitchTargets(Label&, unsigned location);
VirtualRegister virtualRegisterForWasmLocal(uint32_t index)
{
if (index < m_codeBlock->m_numArguments)
return m_normalizedArguments[index];
const auto& callingConvention = wasmCallingConvention();
const uint32_t gprCount = callingConvention.gprArgs.size();
const uint32_t fprCount = callingConvention.fprArgs.size();
return virtualRegisterForLocal(index - m_codeBlock->m_numArguments + gprCount + fprCount + numberOfLLIntCalleeSaveRegisters);
}
ExpressionType jsNullConstant()
{
if (UNLIKELY(!m_jsNullConstant.isValid())) {
m_jsNullConstant = VirtualRegister(FirstConstantRegisterIndex + m_codeBlock->m_constants.size());
m_codeBlock->m_constants.append(JSValue::encode(jsNull()));
if (UNLIKELY(Options::dumpGeneratedWasmBytecodes()))
m_codeBlock->m_constantTypes.append(Types::Externref);
}
return m_jsNullConstant;
}
ExpressionType zeroConstant()
{
if (UNLIKELY(!m_zeroConstant.isValid())) {
m_zeroConstant = VirtualRegister(FirstConstantRegisterIndex + m_codeBlock->m_constants.size());
m_codeBlock->m_constants.append(0);
if (UNLIKELY(Options::dumpGeneratedWasmBytecodes()))
m_codeBlock->m_constantTypes.append(Types::I32);
}
return m_zeroConstant;
}
void getDropKeepCount(const ControlType& target, unsigned& startOffset, unsigned& drop, unsigned& keep)
{
startOffset = target.stackSize() + 1;
keep = target.branchTargetArity();
drop = m_stackSize - target.stackSize() - target.branchTargetArity();
}
void dropKeep(Stack& values, const ControlType& target, bool dropValues)
{
unsigned startOffset;
unsigned keep;
unsigned drop;
getDropKeepCount(target, startOffset, drop, keep);
if (dropValues)
values.shrink(keep);
if (!drop)
return;
if (keep)
WasmDropKeep::emit(this, startOffset, drop, keep);
}
template<typename Stack, typename Functor>
void walkExpressionStack(Stack& expressionStack, unsigned stackSize, const Functor& functor)
{
for (unsigned i = expressionStack.size(); i > 0; --i) {
VirtualRegister slot = virtualRegisterForLocal(stackSize - i);
functor(expressionStack[expressionStack.size() - i], slot);
}
}
template<typename Stack, typename Functor>
void walkExpressionStack(Stack& expressionStack, const Functor& functor)
{
walkExpressionStack(expressionStack, m_stackSize, functor);
}
template<typename Functor>
void walkExpressionStack(ControlEntry& entry, const Functor& functor)
{
unsigned stackSize = entry.controlData.stackSize();
walkExpressionStack(entry.enclosedExpressionStack, stackSize, functor);
}
void checkConsistency()
{
#if ASSERT_ENABLED
// The rules for locals and constants in the stack are:
// 1) Locals have to be materialized whenever a control entry is pushed to the control stack (i.e. every time we splitStack)
// NOTE: This is a trade-off so that set_local does not have to walk up the control stack looking for delayed get_locals
// 2) If the control entry is a loop, we also need to materialize constants in the newStack, since those slots will be written
// to from loop back edges
// 3) Both locals and constants have to be materialized before branches, since multiple branches might share the same target,
// we can't make any assumptions about the stack state at that point, so we materialize the stack.
for (ControlEntry& controlEntry : m_parser->controlStack()) {
walkExpressionStack(controlEntry, [&](VirtualRegister expression, VirtualRegister slot) {
ASSERT(expression == slot || expression.isConstant());
});
}
walkExpressionStack(m_parser->expressionStack(), [&](VirtualRegister expression, VirtualRegister slot) {
ASSERT(expression == slot || expression.isConstant() || expression.isArgument() || static_cast<unsigned>(expression.toLocal()) < m_codeBlock->m_numVars);
});
#endif // ASSERT_ENABLED
}
void materializeConstantsAndLocals(Stack& expressionStack, NoConsistencyCheckTag)
{
walkExpressionStack(expressionStack, [&](auto& expression, VirtualRegister slot) {
ASSERT(expression.value() == slot || expression.value().isConstant() || expression.value().isArgument() || static_cast<unsigned>(expression.value().toLocal()) < m_codeBlock->m_numVars);
if (expression.value() == slot)
return;
WasmMov::emit(this, slot, expression);
expression = TypedExpression { expression.type(), slot };
});
}
void materializeConstantsAndLocals(Stack& expressionStack)
{
if (expressionStack.isEmpty())
return;
checkConsistency();
materializeConstantsAndLocals(expressionStack, NoConsistencyCheck);
checkConsistency();
}
void splitStack(BlockSignature signature, Stack& enclosingStack, Stack& newStack)
{
JSC::Wasm::splitStack(signature, enclosingStack, newStack);
m_stackSize -= newStack.size();
checkConsistency();
walkExpressionStack(enclosingStack, [&](TypedExpression& expression, VirtualRegister slot) {
ASSERT(expression.value() == slot || expression.value().isConstant() || expression.value().isArgument() || static_cast<unsigned>(expression.value().toLocal()) < m_codeBlock->m_numVars);
if (expression.value() == slot || expression.value().isConstant())
return;
WasmMov::emit(this, slot, expression);
expression = TypedExpression { expression.type(), slot };
});
checkConsistency();
m_stackSize += newStack.size();
}
void finalizePreviousBlockForCatch(ControlType&, Stack&);
struct SwitchEntry {
InstructionStream::Offset offset;
int* jumpTarget;
};
struct ConstantMapHashTraits : HashTraits<EncodedJSValue> {
static constexpr bool emptyValueIsZero = true;
static void constructDeletedValue(EncodedJSValue& slot) { slot = JSValue::encode(jsNull()); }
static bool isDeletedValue(EncodedJSValue value) { return value == JSValue::encode(jsNull()); }
};
FunctionParser<LLIntGenerator>* m_parser { nullptr };
ModuleInformation& m_info;
const unsigned m_functionIndex { UINT_MAX };
Vector<VirtualRegister> m_normalizedArguments;
HashMap<Label*, Vector<SwitchEntry>> m_switches;
ExpressionType m_jsNullConstant;
ExpressionType m_zeroConstant;
ResultList m_unitializedLocals;
HashMap<EncodedJSValue, VirtualRegister, WTF::IntHash<EncodedJSValue>, ConstantMapHashTraits> m_constantMap;
Vector<VirtualRegister, 2> m_results;
Checked<unsigned> m_stackSize { 0 };
Checked<unsigned> m_maxStackSize { 0 };
Checked<unsigned> m_tryDepth { 0 };
bool m_usesExceptions { false };
};
Expected<std::unique_ptr<FunctionCodeBlock>, String> parseAndCompileBytecode(const uint8_t* functionStart, size_t functionLength, const Signature& signature, ModuleInformation& info, uint32_t functionIndex)
{
LLIntGenerator llintGenerator(info, functionIndex, signature);
FunctionParser<LLIntGenerator> parser(llintGenerator, functionStart, functionLength, signature, info);
WASM_FAIL_IF_HELPER_FAILS(parser.parse());
return llintGenerator.finalize();
}
using Buffer = InstructionStream::InstructionBuffer;
static ThreadSpecific<Buffer>* threadSpecificBufferPtr;
static ThreadSpecific<Buffer>& threadSpecificBuffer()
{
static std::once_flag flag;
std::call_once(
flag,
[] () {
threadSpecificBufferPtr = new ThreadSpecific<Buffer>();
});
return *threadSpecificBufferPtr;
}
LLIntGenerator::LLIntGenerator(ModuleInformation& info, unsigned functionIndex, const Signature&)
: BytecodeGeneratorBase(makeUnique<FunctionCodeBlock>(functionIndex), 0)
, m_info(info)
, m_functionIndex(functionIndex)
{
{
auto& threadSpecific = threadSpecificBuffer();
Buffer buffer = WTFMove(*threadSpecific);
*threadSpecific = Buffer();
m_writer.setInstructionBuffer(WTFMove(buffer));
}
m_codeBlock->m_numVars = numberOfLLIntCalleeSaveRegisters;
m_stackSize = numberOfLLIntCalleeSaveRegisters;
m_maxStackSize = numberOfLLIntCalleeSaveRegisters;
WasmEnter::emit(this);
}
std::unique_ptr<FunctionCodeBlock> LLIntGenerator::finalize()
{
RELEASE_ASSERT(m_codeBlock);
size_t numCalleeLocals = WTF::roundUpToMultipleOf(stackAlignmentRegisters(), m_maxStackSize);
m_codeBlock->m_numCalleeLocals = numCalleeLocals;
RELEASE_ASSERT(numCalleeLocals == m_codeBlock->m_numCalleeLocals);
auto& threadSpecific = threadSpecificBuffer();
Buffer usedBuffer;
m_codeBlock->setInstructions(m_writer.finalize(usedBuffer));
size_t oldCapacity = usedBuffer.capacity();
usedBuffer.resize(0);
RELEASE_ASSERT(usedBuffer.capacity() == oldCapacity);
*threadSpecific = WTFMove(usedBuffer);
if (!m_usesExceptions)
m_info.m_functionDoesNotUseExceptions.quickSet(m_functionIndex);
return WTFMove(m_codeBlock);
}
// Generated from wasm.json
#include "WasmLLIntGeneratorInlines.h"
auto LLIntGenerator::callInformationForCaller(const Signature& signature) -> LLIntCallInformation
{
// This function sets up the stack layout for calls. The desired stack layout is:
// FPRn
// ...
// FPR1
// FPR0
// ---
// GPRn
// ...
// GPR1
// GPR0
// ----
// stackN
// ...
// stack1
// stack0
// ---
// call frame header
// We need to allocate at least space for all GPRs and FPRs.
// Return values use the same allocation layout.
const auto initialStackSize = m_stackSize;
const auto& callingConvention = wasmCallingConvention();
const uint32_t gprCount = callingConvention.gprArgs.size();
const uint32_t fprCount = callingConvention.fprArgs.size();
uint32_t stackCount = 0;
uint32_t gprIndex = 0;
uint32_t fprIndex = 0;
uint32_t stackIndex = 0;
auto allocateStackRegister = [&](Type type) {
switch (type.kind) {
case TypeKind::I32:
case TypeKind::I64:
case TypeKind::Externref:
case TypeKind::Funcref:
case TypeKind::RefNull:
case TypeKind::Ref:
if (gprIndex < gprCount)
++gprIndex;
else if (stackIndex++ >= stackCount)
++stackCount;
break;
case TypeKind::F32:
case TypeKind::F64:
if (fprIndex < fprCount)
++fprIndex;
else if (stackIndex++ >= stackCount)
++stackCount;
break;
case TypeKind::Void:
case TypeKind::Func:
RELEASE_ASSERT_NOT_REACHED();
}
};
for (uint32_t i = 0; i < signature.argumentCount(); i++)
allocateStackRegister(signature.argument(i));
gprIndex = 0;
fprIndex = 0;
stackIndex = 0;
for (uint32_t i = 0; i < signature.returnCount(); i++)
allocateStackRegister(signature.returnType(i));
// FIXME: we are allocating the extra space for the argument/return count in order to avoid interference, but we could do better
// NOTE: We increase arg count by 1 for the case of indirect calls
m_stackSize += std::max(signature.argumentCount() + 1, signature.returnCount()) + gprCount + fprCount + stackCount + CallFrame::headerSizeInRegisters + 1;
if (m_stackSize.value() % stackAlignmentRegisters())
++m_stackSize;
if (m_maxStackSize < m_stackSize)
m_maxStackSize = m_stackSize;
ResultList arguments(signature.argumentCount());
ResultList temporaryResults(signature.returnCount());
const unsigned stackOffset = m_stackSize;
const unsigned base = stackOffset - CallFrame::headerSizeInRegisters - 1;
const uint32_t gprLimit = base - stackCount - gprCount;
const uint32_t fprLimit = gprLimit - fprCount;
stackIndex = base;
gprIndex = base - stackCount;
fprIndex = gprIndex - gprCount;
for (uint32_t i = 0; i < signature.argumentCount(); i++) {
switch (signature.argument(i).kind) {
case TypeKind::I32:
case TypeKind::I64:
case TypeKind::Externref:
case TypeKind::Funcref:
case TypeKind::RefNull:
case TypeKind::Ref:
if (gprIndex > gprLimit)
arguments[i] = virtualRegisterForLocal(--gprIndex);
else
arguments[i] = virtualRegisterForLocal(--stackIndex);
break;
case TypeKind::F32:
case TypeKind::F64:
if (fprIndex > fprLimit)
arguments[i] = virtualRegisterForLocal(--fprIndex);
else
arguments[i] = virtualRegisterForLocal(--stackIndex);
break;
case TypeKind::Void:
case TypeKind::Func:
RELEASE_ASSERT_NOT_REACHED();
}
}
stackIndex = base;
gprIndex = base - stackCount;
fprIndex = gprIndex - gprCount;
for (uint32_t i = 0; i < signature.returnCount(); i++) {
switch (signature.returnType(i).kind) {
case TypeKind::I32:
case TypeKind::I64:
case TypeKind::Externref:
case TypeKind::Funcref:
case TypeKind::RefNull:
case TypeKind::Ref:
if (gprIndex > gprLimit)
temporaryResults[i] = virtualRegisterForLocal(--gprIndex);
else
temporaryResults[i] = virtualRegisterForLocal(--stackIndex);
break;
case TypeKind::F32:
case TypeKind::F64:
if (fprIndex > fprLimit)
temporaryResults[i] = virtualRegisterForLocal(--fprIndex);
else
temporaryResults[i] = virtualRegisterForLocal(--stackIndex);
break;
case TypeKind::Void:
case TypeKind::Func:
RELEASE_ASSERT_NOT_REACHED();
}
}
m_stackSize = initialStackSize;
auto commitResults = [this, temporaryResults = WTFMove(temporaryResults)](ResultList& results) {
checkConsistency();
for (auto temporaryResult : temporaryResults) {
ExpressionType result = push(NoConsistencyCheck);
WasmMov::emit(this, result, temporaryResult);
results.append(result);
}
};
return LLIntCallInformation { stackOffset, stackCount, WTFMove(arguments), WTFMove(commitResults) };
}
auto LLIntGenerator::callInformationForCallee(const Signature& signature) -> Vector<VirtualRegister, 2>
{
if (m_results.size())
return m_results;
m_results.reserveInitialCapacity(signature.returnCount());
const auto& callingConvention = wasmCallingConvention();
const uint32_t gprCount = callingConvention.gprArgs.size();
const uint32_t fprCount = callingConvention.fprArgs.size();
uint32_t gprIndex = 0;
uint32_t fprIndex = gprCount;
uint32_t stackIndex = 1;
const uint32_t maxGPRIndex = gprCount;
const uint32_t maxFPRIndex = maxGPRIndex + fprCount;
for (uint32_t i = 0; i < signature.returnCount(); i++) {
switch (signature.returnType(i).kind) {
case TypeKind::I32:
case TypeKind::I64:
case TypeKind::Externref:
case TypeKind::Funcref:
case TypeKind::RefNull:
case TypeKind::Ref:
if (gprIndex < maxGPRIndex)
m_results.append(virtualRegisterForLocal(numberOfLLIntCalleeSaveRegisters + gprIndex++));
else
m_results.append(virtualRegisterForArgumentIncludingThis(stackIndex++));
break;
case TypeKind::F32:
case TypeKind::F64:
if (fprIndex < maxFPRIndex)
m_results.append(virtualRegisterForLocal(numberOfLLIntCalleeSaveRegisters + fprIndex++));
else
m_results.append(virtualRegisterForArgumentIncludingThis(stackIndex++));
break;
case TypeKind::Void:
case TypeKind::Func:
RELEASE_ASSERT_NOT_REACHED();
}
}
return m_results;
}
auto LLIntGenerator::addArguments(const Signature& signature) -> PartialResult
{
checkConsistency();
m_codeBlock->m_numArguments = signature.argumentCount();
m_normalizedArguments.resize(m_codeBlock->m_numArguments);
const auto& callingConvention = wasmCallingConvention();
const uint32_t gprCount = callingConvention.gprArgs.size();
const uint32_t fprCount = callingConvention.fprArgs.size();
const uint32_t maxGPRIndex = gprCount;
const uint32_t maxFPRIndex = gprCount + fprCount;
uint32_t gprIndex = 0;
uint32_t fprIndex = maxGPRIndex;
uint32_t stackIndex = 1;
Vector<VirtualRegister> registerArguments(gprCount + fprCount);
for (uint32_t i = 0; i < gprCount + fprCount; i++)
registerArguments[i] = push(NoConsistencyCheck);
const auto addArgument = [&](uint32_t index, uint32_t& count, uint32_t max) {
if (count < max)
m_normalizedArguments[index] = registerArguments[count++];
else
m_normalizedArguments[index] = virtualRegisterForArgumentIncludingThis(stackIndex++);
};
for (uint32_t i = 0; i < signature.argumentCount(); i++) {
switch (signature.argument(i).kind) {
case TypeKind::I32:
case TypeKind::I64:
case TypeKind::Externref:
case TypeKind::Funcref:
case TypeKind::RefNull:
case TypeKind::Ref:
addArgument(i, gprIndex, maxGPRIndex);
break;
case TypeKind::F32:
case TypeKind::F64:
addArgument(i, fprIndex, maxFPRIndex);
break;
case TypeKind::Void:
case TypeKind::Func:
RELEASE_ASSERT_NOT_REACHED();
}
}
m_codeBlock->m_numVars += gprCount + fprCount;
return { };
}
auto LLIntGenerator::addLocal(Type type, uint32_t count) -> PartialResult
{
checkConsistency();
m_codeBlock->m_numVars += count;
if (isFuncref(type) || isExternref(type)) {
while (count--)
m_unitializedLocals.append(push(NoConsistencyCheck));
} else
m_stackSize += count;
return { };
}
void LLIntGenerator::didFinishParsingLocals()
{
if (m_unitializedLocals.isEmpty())
return;
auto null = jsNullConstant();
for (auto local : m_unitializedLocals)
WasmMov::emit(this, local, null);
m_unitializedLocals.clear();
}
auto LLIntGenerator::addConstant(Type type, int64_t value) -> ExpressionType
{
auto constant = [&] {
if (!value)
return zeroConstant();
if (value == JSValue::encode(jsNull()))
return jsNullConstant();
VirtualRegister source(FirstConstantRegisterIndex + m_codeBlock->m_constants.size());
auto result = m_constantMap.add(value, source);
if (!result.isNewEntry)
return result.iterator->value;
m_codeBlock->m_constants.append(value);
if (UNLIKELY(Options::dumpGeneratedWasmBytecodes()))
m_codeBlock->m_constantTypes.append(type);
return source;
};
// leave a hole if we need to materialize the constant
push();
return constant();
}
auto LLIntGenerator::getLocal(uint32_t index, ExpressionType& result) -> PartialResult
{
// leave a hole if we need to materialize the local
push();
result = virtualRegisterForWasmLocal(index);
return { };
}
auto LLIntGenerator::setLocal(uint32_t index, ExpressionType value) -> PartialResult
{
VirtualRegister target = virtualRegisterForWasmLocal(index);
// If this local is currently on the stack we need to materialize it, otherwise it'll see the new value instead of the old one
walkExpressionStack(m_parser->expressionStack(), [&](TypedExpression& expression, VirtualRegister slot) {
if (expression.value() != target)
return;
WasmMov::emit(this, slot, expression);
expression = TypedExpression { expression.type(), slot };
});
WasmMov::emit(this, target, value);
return { };
}
auto LLIntGenerator::getGlobal(uint32_t index, ExpressionType& result) -> PartialResult
{
const Wasm::GlobalInformation& global = m_info.globals[index];
result = push();
switch (global.bindingMode) {
case Wasm::GlobalInformation::BindingMode::EmbeddedInInstance:
WasmGetGlobal::emit(this, result, index);
break;
case Wasm::GlobalInformation::BindingMode::Portable:
WasmGetGlobalPortableBinding::emit(this, result, index);
break;
}
return { };
}
auto LLIntGenerator::setGlobal(uint32_t index, ExpressionType value) -> PartialResult
{
const Wasm::GlobalInformation& global = m_info.globals[index];
Type type = global.type;
switch (global.bindingMode) {
case Wasm::GlobalInformation::BindingMode::EmbeddedInInstance:
if (isRefType(type))
WasmSetGlobalRef::emit(this, index, value);
else
WasmSetGlobal::emit(this, index, value);
break;
case Wasm::GlobalInformation::BindingMode::Portable:
if (isRefType(type))
WasmSetGlobalRefPortableBinding::emit(this, index, value);
else
WasmSetGlobalPortableBinding::emit(this, index, value);
break;
}
return { };
}
auto LLIntGenerator::addLoop(BlockSignature signature, Stack& enclosingStack, ControlType& block, Stack& newStack, uint32_t loopIndex) -> PartialResult
{
splitStack(signature, enclosingStack, newStack);
materializeConstantsAndLocals(newStack, NoConsistencyCheck);
#if ASSERT_ENABLED
// We cannot yet call checkConsistency, since the arguments we are
// materializing for the loop are not neither in the expression
// nor the control stack, and it won't know what to do in this
// intermediate state. As a sanity check just verify that
// everything in newStack is a virtual register that is actually
// pointing to each stack position, which is what we should have
// after we split the stack and the previous call materializes
// constants and aliases if needed.
walkExpressionStack(newStack, [](VirtualRegister expression, VirtualRegister slot) {
ASSERT(expression == slot);
});
#endif
Ref<Label> body = newEmittedLabel();
Ref<Label> continuation = newLabel();
block = ControlType::loop(signature, m_stackSize, WTFMove(body), WTFMove(continuation));
Vector<unsigned> unresolvedOffsets;
Vector<VirtualRegister> osrEntryData;
for (uint32_t i = 0; i < m_codeBlock->m_numArguments; i++)
osrEntryData.append(m_normalizedArguments[i]);
const auto& callingConvention = wasmCallingConvention();
const uint32_t gprCount = callingConvention.gprArgs.size();
const uint32_t fprCount = callingConvention.fprArgs.size();
for (uint32_t i = gprCount + fprCount + numberOfLLIntCalleeSaveRegisters; i < m_codeBlock->m_numVars; i++)
osrEntryData.append(virtualRegisterForLocal(i));
for (unsigned controlIndex = 0; controlIndex < m_parser->controlStack().size(); ++controlIndex) {
ControlType& data = m_parser->controlStack()[controlIndex].controlData;
Stack& expressionStack = m_parser->controlStack()[controlIndex].enclosedExpressionStack;
for (TypedExpression expression : expressionStack)
osrEntryData.append(expression);
if (ControlType::isAnyCatch(data))
osrEntryData.append(std::get<ControlCatch>(data).m_exception);
}
for (TypedExpression expression : enclosingStack)
osrEntryData.append(expression);
for (TypedExpression expression : newStack)
osrEntryData.append(expression);
WasmLoopHint::emit(this);
m_codeBlock->tierUpCounter().addOSREntryDataForLoop(m_lastInstruction.offset(), { loopIndex, WTFMove(osrEntryData) });
return { };
}
auto LLIntGenerator::addTopLevel(BlockSignature signature) -> ControlType
{
return ControlType::topLevel(signature, m_stackSize, newLabel());
}
auto LLIntGenerator::addBlock(BlockSignature signature, Stack& enclosingStack, ControlType& newBlock, Stack& newStack) -> PartialResult
{
splitStack(signature, enclosingStack, newStack);
newBlock = ControlType::block(signature, m_stackSize, newLabel());
return { };
}
auto LLIntGenerator::addIf(ExpressionType condition, BlockSignature signature, Stack& enclosingStack, ControlType& result, Stack& newStack) -> PartialResult
{
Ref<Label> alternate = newLabel();
Ref<Label> continuation = newLabel();
splitStack(signature, enclosingStack, newStack);
WasmJfalse::emit(this, condition, alternate->bind(this));
result = ControlType::if_(signature, m_stackSize, WTFMove(alternate), WTFMove(continuation));
return { };
}
auto LLIntGenerator::addElse(ControlType& data, Stack& expressionStack) -> PartialResult
{
ASSERT(std::holds_alternative<ControlIf>(data));
materializeConstantsAndLocals(expressionStack);
WasmJmp::emit(this, data.m_continuation->bind(this));
return addElseToUnreachable(data);
}
auto LLIntGenerator::addElseToUnreachable(ControlType& data) -> PartialResult
{
m_stackSize = data.stackSize() + data.m_signature->argumentCount();
ControlIf& control = std::get<ControlIf>(data);
emitLabel(control.m_alternate.get());
data = ControlType::block(data.m_signature, m_stackSize, WTFMove(data.m_continuation));
return { };
}
auto LLIntGenerator::addTry(BlockSignature signature, Stack& enclosingStack, ControlType& result, Stack& newStack) -> PartialResult
{
m_usesExceptions = true;
++m_tryDepth;
splitStack(signature, enclosingStack, newStack);
Ref<Label> tryLabel = newEmittedLabel();
Ref<Label> continuation = newLabel();
result = ControlType::createTry(signature, m_stackSize, WTFMove(tryLabel), WTFMove(continuation), m_tryDepth);
return { };
}
void LLIntGenerator::finalizePreviousBlockForCatch(ControlType& data, Stack& expressionStack)
{
if (!ControlType::isAnyCatch(data))
materializeConstantsAndLocals(expressionStack);
else {
checkConsistency();
VirtualRegister dst = virtualRegisterForLocal(data.stackSize());
for (TypedExpression& value : expressionStack) {
WasmMov::emit(this, dst, value);
value = TypedExpression { value.type(), dst };
dst -= 1;
}
}
WasmJmp::emit(this, data.m_continuation->bind(this));
}
auto LLIntGenerator::addCatch(unsigned exceptionIndex, const Signature& exceptionSignature, Stack& expressionStack, ControlType& data, ResultList& results) -> PartialResult
{
finalizePreviousBlockForCatch(data, expressionStack);
return addCatchToUnreachable(exceptionIndex, exceptionSignature, data, results);
}
auto LLIntGenerator::addCatchToUnreachable(unsigned exceptionIndex, const Signature& exceptionSignature, ControlType& data, ResultList& results) -> PartialResult
{
m_usesExceptions = true;
Ref<Label> catchLabel = newEmittedLabel();
m_stackSize = data.stackSize();
VirtualRegister exception = push();
if (std::holds_alternative<ControlTry>(data)) {
ControlTry& tryData = std::get<ControlTry>(data);
data = ControlType::createCatch(data.m_signature, data.stackSize(), WTFMove(tryData.m_try), WTFMove(data.m_continuation), catchLabel, tryData.m_tryDepth, exception);
}
for (unsigned i = 0; i < exceptionSignature.argumentCount(); ++i)
results.append(push());
if (Context::useFastTLS())
WasmCatch::emit(this, exceptionIndex, exception, exceptionSignature.argumentCount(), results.isEmpty() ? 0 : -results[0].offset());
else
WasmCatchNoTls::emit(this, exceptionIndex, exception, exceptionSignature.argumentCount(), results.isEmpty() ? 0 : -results[0].offset());
for (unsigned i = 0; i < exceptionSignature.argumentCount(); ++i) {
VirtualRegister dst = results[i];
Type type = exceptionSignature.argument(i);
switch (type.kind) {
case Wasm::TypeKind::F32:
WasmF32ReinterpretI32::emit(this, dst, dst);
break;
case Wasm::TypeKind::F64:
WasmF64ReinterpretI64::emit(this, dst, dst);
break;
case Wasm::TypeKind::I32:
case Wasm::TypeKind::I64:
case Wasm::TypeKind::Externref:
case Wasm::TypeKind::Funcref:
break;
default:
RELEASE_ASSERT_NOT_REACHED();
break;
}
}
ControlCatch& catchData = std::get<ControlCatch>(data);
catchData.m_kind = CatchKind::Catch;
m_codeBlock->addExceptionHandler({ HandlerType::Catch, catchData.m_tryStart->location(), catchData.m_tryEnd->location(), catchLabel->location(), m_tryDepth, exceptionIndex });
return { };
}
auto LLIntGenerator::addCatchAll(Stack& expressionStack, ControlType& data) -> PartialResult
{
finalizePreviousBlockForCatch(data, expressionStack);
WasmJmp::emit(this, data.m_continuation->bind(this));
return addCatchAllToUnreachable(data);
}
auto LLIntGenerator::addCatchAllToUnreachable(ControlType& data) -> PartialResult
{
m_usesExceptions = true;
Ref<Label> catchLabel = newEmittedLabel();
m_stackSize = data.stackSize();
VirtualRegister exception = push();
if (std::holds_alternative<ControlTry>(data)) {
ControlTry& tryData = std::get<ControlTry>(data);
data = ControlType::createCatch(data.m_signature, data.stackSize(), WTFMove(tryData.m_try), WTFMove(data.m_continuation), catchLabel, tryData.m_tryDepth, exception);
}
ControlCatch& catchData = std::get<ControlCatch>(data);
catchData.m_kind = CatchKind::CatchAll;
if (Context::useFastTLS())
WasmCatchAll::emit(this, exception);
else
WasmCatchAllNoTls::emit(this, exception);
m_codeBlock->addExceptionHandler({ HandlerType::CatchAll, catchData.m_tryStart->location(), catchData.m_tryEnd->location(), catchLabel->location(), m_tryDepth, 0 });
return { };
}
auto LLIntGenerator::addDelegate(ControlType& target, ControlType& data) -> PartialResult
{
return addDelegateToUnreachable(target, data);
}
auto LLIntGenerator::addDelegateToUnreachable(ControlType& target, ControlType& data) -> PartialResult
{
m_usesExceptions = true;
Ref<Label> delegateLabel = newEmittedLabel();
ASSERT(ControlType::isTry(target) || ControlType::isTopLevel(target));
unsigned targetDepth = ControlType::isTry(target) ? std::get<ControlTry>(target).m_tryDepth : 0;
ControlTry& tryData = std::get<ControlTry>(data);
m_codeBlock->addExceptionHandler({ HandlerType::Delegate, tryData.m_try->location(), delegateLabel->location(), 0, m_tryDepth, targetDepth });
checkConsistency();
return { };
}
auto LLIntGenerator::addThrow(unsigned exceptionIndex, Vector<ExpressionType>& args, Stack&) -> PartialResult
{
m_usesExceptions = true;
// We have to materialize the arguments here since it might include constants or
// delayed moves, but the wasm_throw opcode expects all the arguments to be contiguous
// in the stack. The reason we don't call materializeConstantsAndLocals here is that
// it expects a stack, not a vector of ExpressionType arguments.
walkExpressionStack(args, [&](VirtualRegister& arg, VirtualRegister slot) {
if (arg == slot)
return;
WasmMov::emit(this, slot, arg);
arg = slot;
});
WasmThrow::emit(this, exceptionIndex, args.isEmpty() ? virtualRegisterForLocal(0) : args[0]);
return { };
}
auto LLIntGenerator::addRethrow(unsigned, ControlType& data) -> PartialResult
{
m_usesExceptions = true;
ASSERT(std::holds_alternative<ControlCatch>(data));
ControlCatch catchData = std::get<ControlCatch>(data);
WasmRethrow::emit(this, catchData.m_exception);
return { };
}
auto LLIntGenerator::addReturn(const ControlType& data, Stack& returnValues) -> PartialResult
{
if (!data.m_signature->returnCount()) {
WasmRetVoid::emit(this);
return { };
}
// no need to drop keep here, since we have to move anyway
unifyValuesWithBlock(callInformationForCallee(*data.m_signature), returnValues);
WasmRet::emit(this);
return { };
}
auto LLIntGenerator::addBranch(ControlType& data, ExpressionType condition, Stack& returnValues) -> PartialResult
{
RefPtr<Label> target = data.targetLabelForBranch();
RefPtr<Label> skip = nullptr;
materializeConstantsAndLocals(returnValues);
if (condition.isValid()) {
skip = newLabel();
WasmJfalse::emit(this, condition, skip->bind(this));
}
dropKeep(returnValues, data, !skip);
WasmJmp::emit(this, target->bind(this));
if (skip)
emitLabel(*skip);
return { };
}
auto LLIntGenerator::addSwitch(ExpressionType condition, const Vector<ControlType*>& targets, ControlType& defaultTarget, Stack& expressionStack) -> PartialResult
{
materializeConstantsAndLocals(expressionStack);
unsigned tableIndex = m_codeBlock->numberOfJumpTables();
FunctionCodeBlock::JumpTable& jumpTable = m_codeBlock->addJumpTable(targets.size() + 1);
WasmSwitch::emit(this, condition, tableIndex);
unsigned index = 0;
InstructionStream::Offset offset = m_lastInstruction.offset();
auto addTarget = [&](ControlType& target) {
RefPtr<Label> targetLabel = target.targetLabelForBranch();
getDropKeepCount(target, jumpTable[index].startOffset, jumpTable[index].dropCount, jumpTable[index].keepCount);
if (targetLabel->isForward()) {
auto result = m_switches.add(targetLabel.get(), Vector<SwitchEntry>());
ASSERT(!jumpTable[index].target);
result.iterator->value.append(SwitchEntry { offset, &jumpTable[index++].target });
} else {
int jumpTarget = targetLabel->location() - offset;
ASSERT(jumpTarget);
jumpTable[index++].target = jumpTarget;
}
};
for (const auto& target : targets)
addTarget(*target);
addTarget(defaultTarget);
return { };
}
auto LLIntGenerator::endBlock(ControlEntry& entry, Stack& expressionStack) -> PartialResult
{
// FIXME: We only need to materialize constants here if there exists a jump to this label
// https://bugs.webkit.org/show_bug.cgi?id=203657
finalizePreviousBlockForCatch(entry.controlData, expressionStack);
return addEndToUnreachable(entry, expressionStack, false);
}
auto LLIntGenerator::addEndToUnreachable(ControlEntry& entry, Stack& expressionStack, bool unreachable) -> PartialResult
{
ControlType& data = entry.controlData;
unsigned stackSize = data.stackSize();
if (ControlType::isAnyCatch(entry.controlData))
++stackSize; // Account for the caught exception
RELEASE_ASSERT(unreachable || m_stackSize == stackSize + data.m_signature->returnCount());
m_stackSize = data.stackSize();
if (ControlType::isTry(data) || std::holds_alternative<ControlCatch>(data))
--m_tryDepth;
for (unsigned i = 0; i < data.m_signature->returnCount(); ++i) {
// We don't want to do a consistency check here because we just reset the stack size
// are pushing new values, while we already have the same values in the stack.
// The only reason we do things this way is so that it also works for unreachable blocks,
// since they might not have the right number of values in the expression stack.
// Instead, we do a stricter consistency check below.
auto tmp = push(NoConsistencyCheck);
ASSERT(unreachable || tmp == expressionStack[i].value());
if (unreachable)
entry.enclosedExpressionStack.constructAndAppend(data.m_signature->returnType(i), tmp);
else
entry.enclosedExpressionStack.append(expressionStack[i]);
}
if (m_lastOpcodeID == wasm_jmp && data.m_continuation->unresolvedJumps().size() == 1 && data.m_continuation->unresolvedJumps()[0] == static_cast<int>(m_lastInstruction.offset())) {
linkSwitchTargets(*data.m_continuation, m_lastInstruction.offset());
m_lastOpcodeID = wasm_unreachable;
m_writer.rewind(m_lastInstruction);
} else
emitLabel(*data.m_continuation);
return { };
}
auto LLIntGenerator::endTopLevel(BlockSignature signature, const Stack& expressionStack) -> PartialResult
{
RELEASE_ASSERT(expressionStack.size() == signature->returnCount());
if (!signature->returnCount()) {
WasmRetVoid::emit(this);
return { };
}
checkConsistency();
unifyValuesWithBlock(callInformationForCallee(*signature), expressionStack);
WasmRet::emit(this);
return { };
}
auto LLIntGenerator::addCall(uint32_t functionIndex, const Signature& signature, Vector<ExpressionType>& args, ResultList& results) -> PartialResult
{
ASSERT(signature.argumentCount() == args.size());
LLIntCallInformation info = callInformationForCaller(signature);
unifyValuesWithBlock(info.arguments, args);
if (Context::useFastTLS())
WasmCall::emit(this, functionIndex, info.stackOffset, info.numberOfStackArguments);
else
WasmCallNoTls::emit(this, functionIndex, info.stackOffset, info.numberOfStackArguments);
info.commitResults(results);
return { };
}
auto LLIntGenerator::addCallIndirect(unsigned tableIndex, const Signature& signature, Vector<ExpressionType>& args, ResultList& results) -> PartialResult
{
ExpressionType calleeIndex = args.takeLast();
ASSERT(signature.argumentCount() == args.size());
ASSERT(m_info.tableCount() > tableIndex);
ASSERT(m_info.tables[tableIndex].type() == TableElementType::Funcref);
LLIntCallInformation info = callInformationForCaller(signature);
unifyValuesWithBlock(info.arguments, args);
if (Context::useFastTLS())
WasmCallIndirect::emit(this, calleeIndex, m_codeBlock->addSignature(signature), info.stackOffset, info.numberOfStackArguments, tableIndex);
else
WasmCallIndirectNoTls::emit(this, calleeIndex, m_codeBlock->addSignature(signature), info.stackOffset, info.numberOfStackArguments, tableIndex);
info.commitResults(results);
return { };
}
auto LLIntGenerator::addCallRef(const Signature& signature, Vector<ExpressionType>& args, ResultList& results) -> PartialResult
{
ExpressionType callee = args.takeLast();
LLIntCallInformation info = callInformationForCaller(signature);
unifyValuesWithBlock(info.arguments, args);
if (Context::useFastTLS())
WasmCallRef::emit(this, callee, m_codeBlock->addSignature(signature), info.stackOffset, info.numberOfStackArguments);
else
WasmCallRefNoTls::emit(this, callee, m_codeBlock->addSignature(signature), info.stackOffset, info.numberOfStackArguments);
info.commitResults(results);
return { };
}
auto LLIntGenerator::addRefIsNull(ExpressionType value, ExpressionType& result) -> PartialResult
{
result = push();
WasmRefIsNull::emit(this, result, value);
return { };
}
auto LLIntGenerator::addRefFunc(uint32_t index, ExpressionType& result) -> PartialResult
{
result = push();
WasmRefFunc::emit(this, result, index);
return { };
}
auto LLIntGenerator::addTableGet(unsigned tableIndex, ExpressionType index, ExpressionType& result) -> PartialResult
{
result = push();
WasmTableGet::emit(this, result, index, tableIndex);
return { };
}
auto LLIntGenerator::addTableSet(unsigned tableIndex, ExpressionType index, ExpressionType value) -> PartialResult
{
WasmTableSet::emit(this, index, value, tableIndex);
return { };
}
auto LLIntGenerator::addTableInit(unsigned elementIndex, unsigned tableIndex, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length) -> PartialResult
{
WasmTableInit::emit(this, dstOffset, srcOffset, length, elementIndex, tableIndex);
return { };
}
auto LLIntGenerator::addElemDrop(unsigned elementIndex) -> PartialResult
{
WasmElemDrop::emit(this, elementIndex);
return { };
}
auto LLIntGenerator::addTableSize(unsigned tableIndex, ExpressionType& result) -> PartialResult
{
result = push();
WasmTableSize::emit(this, result, tableIndex);
return { };
}
auto LLIntGenerator::addTableGrow(unsigned tableIndex, ExpressionType fill, ExpressionType delta, ExpressionType& result) -> PartialResult
{
result = push();
WasmTableGrow::emit(this, result, fill, delta, tableIndex);
return { };
}
auto LLIntGenerator::addTableFill(unsigned tableIndex, ExpressionType offset, ExpressionType fill, ExpressionType count) -> PartialResult
{
WasmTableFill::emit(this, offset, fill, count, tableIndex);
return { };
}
auto LLIntGenerator::addTableCopy(unsigned dstTableIndex, unsigned srcTableIndex, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length) -> PartialResult
{
WasmTableCopy::emit(this, dstOffset, srcOffset, length, dstTableIndex, srcTableIndex);
return { };
}
auto LLIntGenerator::addUnreachable() -> PartialResult
{
WasmUnreachable::emit(this);
return { };
}
auto LLIntGenerator::addCurrentMemory(ExpressionType& result) -> PartialResult
{
result = push();
WasmCurrentMemory::emit(this, result);
return { };
}
auto LLIntGenerator::addMemoryInit(unsigned dataSegmentIndex, ExpressionType dstAddress, ExpressionType srcAddress, ExpressionType length) -> PartialResult
{
WasmMemoryInit::emit(this, dstAddress, srcAddress, length, dataSegmentIndex);
return { };
}
auto LLIntGenerator::addDataDrop(unsigned dataSegmentIndex) -> PartialResult
{
WasmDataDrop::emit(this, dataSegmentIndex);
return { };
}
auto LLIntGenerator::addGrowMemory(ExpressionType delta, ExpressionType& result) -> PartialResult
{
result = push();
WasmGrowMemory::emit(this, result, delta);
return { };
}
auto LLIntGenerator::addMemoryFill(ExpressionType dstAddress, ExpressionType targetValue, ExpressionType count) -> PartialResult
{
WasmMemoryFill::emit(this, dstAddress, targetValue, count);
return { };
}
auto LLIntGenerator::addMemoryCopy(ExpressionType dstAddress, ExpressionType srcAddress, ExpressionType count) -> PartialResult
{
WasmMemoryCopy::emit(this, dstAddress, srcAddress, count);
return { };
}
auto LLIntGenerator::addSelect(ExpressionType condition, ExpressionType nonZero, ExpressionType zero, ExpressionType& result) -> PartialResult
{
result = push();
WasmSelect::emit(this, result, condition, nonZero, zero);
return { };
}
auto LLIntGenerator::load(LoadOpType op, ExpressionType pointer, ExpressionType& result, uint32_t offset) -> PartialResult
{
result = push();
switch (op) {
case LoadOpType::I32Load8S:
WasmI32Load8S::emit(this, result, pointer, offset);
break;
case LoadOpType::I64Load8S:
WasmI64Load8S::emit(this, result, pointer, offset);
break;
case LoadOpType::I32Load8U:
case LoadOpType::I64Load8U:
WasmLoad8U::emit(this, result, pointer, offset);
break;
case LoadOpType::I32Load16S:
WasmI32Load16S::emit(this, result, pointer, offset);
break;
case LoadOpType::I64Load16S:
WasmI64Load16S::emit(this, result, pointer, offset);
break;
case LoadOpType::I32Load16U:
case LoadOpType::I64Load16U:
WasmLoad16U::emit(this, result, pointer, offset);
break;
case LoadOpType::I32Load:
case LoadOpType::F32Load:
case LoadOpType::I64Load32U:
WasmLoad32U::emit(this, result, pointer, offset);
break;
case LoadOpType::I64Load32S:
WasmI64Load32S::emit(this, result, pointer, offset);
break;
case LoadOpType::I64Load:
case LoadOpType::F64Load:
WasmLoad64U::emit(this, result, pointer, offset);
break;
}
return { };
}
auto LLIntGenerator::store(StoreOpType op, ExpressionType pointer, ExpressionType value, uint32_t offset) -> PartialResult
{
switch (op) {
case StoreOpType::I64Store8:
case StoreOpType::I32Store8:
WasmStore8::emit(this, pointer, value, offset);
break;
case StoreOpType::I64Store16:
case StoreOpType::I32Store16:
WasmStore16::emit(this, pointer, value, offset);
break;
case StoreOpType::I64Store32:
case StoreOpType::I32Store:
case StoreOpType::F32Store:
WasmStore32::emit(this, pointer, value, offset);
break;
case StoreOpType::I64Store:
case StoreOpType::F64Store:
WasmStore64::emit(this, pointer, value, offset);
break;
}
return { };
}
auto LLIntGenerator::atomicLoad(ExtAtomicOpType op, Type, ExpressionType pointer, ExpressionType& result, uint32_t offset) -> PartialResult
{
result = push();
switch (op) {
case ExtAtomicOpType::I32AtomicLoad8U:
case ExtAtomicOpType::I64AtomicLoad8U:
WasmI64AtomicRmw8AddU::emit(this, result, pointer, offset, zeroConstant());
break;
case ExtAtomicOpType::I32AtomicLoad16U:
case ExtAtomicOpType::I64AtomicLoad16U:
WasmI64AtomicRmw16AddU::emit(this, result, pointer, offset, zeroConstant());
break;
case ExtAtomicOpType::I32AtomicLoad:
case ExtAtomicOpType::I64AtomicLoad32U:
WasmI64AtomicRmw32AddU::emit(this, result, pointer, offset, zeroConstant());
break;
case ExtAtomicOpType::I64AtomicLoad:
WasmI64AtomicRmwAdd::emit(this, result, pointer, offset, zeroConstant());
break;
default:
RELEASE_ASSERT_NOT_REACHED();
}
return { };
}
auto LLIntGenerator::atomicStore(ExtAtomicOpType op, Type, ExpressionType pointer, ExpressionType value, uint32_t offset) -> PartialResult
{
auto result = push();
switch (op) {
case ExtAtomicOpType::I32AtomicStore8U:
case ExtAtomicOpType::I64AtomicStore8U:
WasmI64AtomicRmw8XchgU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicStore16U:
case ExtAtomicOpType::I64AtomicStore16U:
WasmI64AtomicRmw16XchgU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicStore:
case ExtAtomicOpType::I64AtomicStore32U:
WasmI64AtomicRmw32XchgU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I64AtomicStore:
WasmI64AtomicRmwXchg::emit(this, result, pointer, offset, value);
break;
default:
RELEASE_ASSERT_NOT_REACHED();
}
didPopValueFromStack(); // Ignore the result.
return { };
}
auto LLIntGenerator::atomicBinaryRMW(ExtAtomicOpType op, Type, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset) -> PartialResult
{
result = push();
switch (op) {
case ExtAtomicOpType::I32AtomicRmw8AddU:
case ExtAtomicOpType::I64AtomicRmw8AddU:
WasmI64AtomicRmw8AddU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmw16AddU:
case ExtAtomicOpType::I64AtomicRmw16AddU:
WasmI64AtomicRmw16AddU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmwAdd:
case ExtAtomicOpType::I64AtomicRmw32AddU:
WasmI64AtomicRmw32AddU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I64AtomicRmwAdd:
WasmI64AtomicRmwAdd::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmw8SubU:
case ExtAtomicOpType::I64AtomicRmw8SubU:
WasmI64AtomicRmw8SubU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmw16SubU:
case ExtAtomicOpType::I64AtomicRmw16SubU:
WasmI64AtomicRmw16SubU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmwSub:
case ExtAtomicOpType::I64AtomicRmw32SubU:
WasmI64AtomicRmw32SubU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I64AtomicRmwSub:
WasmI64AtomicRmwSub::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmw8AndU:
case ExtAtomicOpType::I64AtomicRmw8AndU:
WasmI64AtomicRmw8AndU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmw16AndU:
case ExtAtomicOpType::I64AtomicRmw16AndU:
WasmI64AtomicRmw16AndU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmwAnd:
case ExtAtomicOpType::I64AtomicRmw32AndU:
WasmI64AtomicRmw32AndU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I64AtomicRmwAnd:
WasmI64AtomicRmwAnd::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmw8OrU:
case ExtAtomicOpType::I64AtomicRmw8OrU:
WasmI64AtomicRmw8OrU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmw16OrU:
case ExtAtomicOpType::I64AtomicRmw16OrU:
WasmI64AtomicRmw16OrU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmwOr:
case ExtAtomicOpType::I64AtomicRmw32OrU:
WasmI64AtomicRmw32OrU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I64AtomicRmwOr:
WasmI64AtomicRmwOr::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmw8XorU:
case ExtAtomicOpType::I64AtomicRmw8XorU:
WasmI64AtomicRmw8XorU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmw16XorU:
case ExtAtomicOpType::I64AtomicRmw16XorU:
WasmI64AtomicRmw16XorU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmwXor:
case ExtAtomicOpType::I64AtomicRmw32XorU:
WasmI64AtomicRmw32XorU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I64AtomicRmwXor:
WasmI64AtomicRmwXor::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmw8XchgU:
case ExtAtomicOpType::I64AtomicRmw8XchgU:
WasmI64AtomicRmw8XchgU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmw16XchgU:
case ExtAtomicOpType::I64AtomicRmw16XchgU:
WasmI64AtomicRmw16XchgU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I32AtomicRmwXchg:
case ExtAtomicOpType::I64AtomicRmw32XchgU:
WasmI64AtomicRmw32XchgU::emit(this, result, pointer, offset, value);
break;
case ExtAtomicOpType::I64AtomicRmwXchg:
WasmI64AtomicRmwXchg::emit(this, result, pointer, offset, value);
break;
default:
RELEASE_ASSERT_NOT_REACHED();
break;
}
return { };
}
auto LLIntGenerator::atomicCompareExchange(ExtAtomicOpType op, Type, ExpressionType pointer, ExpressionType expected, ExpressionType value, ExpressionType& result, uint32_t offset) -> PartialResult
{
result = push();
switch (op) {
case ExtAtomicOpType::I32AtomicRmw8CmpxchgU:
case ExtAtomicOpType::I64AtomicRmw8CmpxchgU:
WasmI64AtomicRmw8CmpxchgU::emit(this, result, pointer, offset, expected, value);
break;
case ExtAtomicOpType::I32AtomicRmw16CmpxchgU:
case ExtAtomicOpType::I64AtomicRmw16CmpxchgU:
WasmI64AtomicRmw16CmpxchgU::emit(this, result, pointer, offset, expected, value);
break;
case ExtAtomicOpType::I32AtomicRmwCmpxchg:
case ExtAtomicOpType::I64AtomicRmw32CmpxchgU:
WasmI64AtomicRmw32CmpxchgU::emit(this, result, pointer, offset, expected, value);
break;
case ExtAtomicOpType::I64AtomicRmwCmpxchg:
WasmI64AtomicRmwCmpxchg::emit(this, result, pointer, offset, expected, value);
break;
default:
RELEASE_ASSERT_NOT_REACHED();
break;
}
return { };
}
auto LLIntGenerator::atomicWait(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, ExpressionType timeout, ExpressionType& result, uint32_t offset) -> PartialResult
{
result = push();
switch (op) {
case ExtAtomicOpType::MemoryAtomicWait32:
WasmMemoryAtomicWait32::emit(this, result, pointer, offset, value, timeout);
break;
case ExtAtomicOpType::MemoryAtomicWait64:
WasmMemoryAtomicWait64::emit(this, result, pointer, offset, value, timeout);
break;
default:
RELEASE_ASSERT_NOT_REACHED();
break;
}
return { };
}
auto LLIntGenerator::atomicNotify(ExtAtomicOpType op, ExpressionType pointer, ExpressionType count, ExpressionType& result, uint32_t offset) -> PartialResult
{
result = push();
RELEASE_ASSERT(op == ExtAtomicOpType::MemoryAtomicNotify);
WasmMemoryAtomicNotify::emit(this, result, pointer, offset, count);
return { };
}
auto LLIntGenerator::atomicFence(ExtAtomicOpType, uint8_t) -> PartialResult
{
WasmAtomicFence::emit(this);
return { };
}
auto LLIntGenerator::truncSaturated(Ext1OpType op, ExpressionType operand, ExpressionType& result, Type, Type) -> PartialResult
{
result = push();
switch (op) {
case Ext1OpType::I32TruncSatF32S:
WasmI32TruncSatF32S::emit(this, result, operand);
break;
case Ext1OpType::I32TruncSatF32U:
WasmI32TruncSatF32U::emit(this, result, operand);
break;
case Ext1OpType::I32TruncSatF64S:
WasmI32TruncSatF64S::emit(this, result, operand);
break;
case Ext1OpType::I32TruncSatF64U:
WasmI32TruncSatF64U::emit(this, result, operand);
break;
case Ext1OpType::I64TruncSatF32S:
WasmI64TruncSatF32S::emit(this, result, operand);
break;
case Ext1OpType::I64TruncSatF32U:
WasmI64TruncSatF32U::emit(this, result, operand);
break;
case Ext1OpType::I64TruncSatF64S:
WasmI64TruncSatF64S::emit(this, result, operand);
break;
case Ext1OpType::I64TruncSatF64U:
WasmI64TruncSatF64U::emit(this, result, operand);
break;
default:
RELEASE_ASSERT_NOT_REACHED();
break;
}
return { };
}
void LLIntGenerator::linkSwitchTargets(Label& label, unsigned location)
{
auto it = m_switches.find(&label);
if (it != m_switches.end()) {
for (const auto& entry : it->value) {
ASSERT(!*entry.jumpTarget);
*entry.jumpTarget = location - entry.offset;
}
m_switches.remove(it);
}
}
}
template<>
void GenericLabel<Wasm::GeneratorTraits>::setLocation(BytecodeGeneratorBase<Wasm::GeneratorTraits>& generator, unsigned location)
{
RELEASE_ASSERT(isForward());
m_location = location;
Wasm::LLIntGenerator* llintGenerator = static_cast<Wasm::LLIntGenerator*>(&generator);
llintGenerator->linkSwitchTargets(*this, m_location);
for (auto offset : m_unresolvedJumps) {
auto instruction = generator.m_writer.ref(offset);
int target = m_location - offset;
#define CASE(__op) \
case __op::opcodeID: \
instruction->cast<__op, WasmOpcodeTraits>()->setTargetLabel(BoundLabel(target), [&]() { \
generator.m_codeBlock->addOutOfLineJumpTarget(instruction.offset(), target); \
return BoundLabel(); \
}); \
break;
switch (instruction->opcodeID<WasmOpcodeTraits>()) {
CASE(WasmJmp)
CASE(WasmJtrue)
CASE(WasmJfalse)
default:
RELEASE_ASSERT_NOT_REACHED();
}
#undef CASE
}
}
} // namespace JSC::Wasm
#endif // ENABLE(WEBASSEMBLY)