diff options
Diffstat (limited to 'js/src/wasm/WasmCompile.cpp')
| -rw-r--r-- | js/src/wasm/WasmCompile.cpp | 967 |
1 files changed, 967 insertions, 0 deletions
diff --git a/js/src/wasm/WasmCompile.cpp b/js/src/wasm/WasmCompile.cpp new file mode 100644 index 000000000..890a480c5 --- /dev/null +++ b/js/src/wasm/WasmCompile.cpp @@ -0,0 +1,967 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * vim: set ts=8 sts=4 et sw=4 tw=99: + * + * Copyright 2015 Mozilla Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "wasm/WasmCompile.h" + +#include "mozilla/CheckedInt.h" + +#include "jsprf.h" + +#include "wasm/WasmBinaryFormat.h" +#include "wasm/WasmBinaryIterator.h" +#include "wasm/WasmGenerator.h" +#include "wasm/WasmSignalHandlers.h" + +using namespace js; +using namespace js::jit; +using namespace js::wasm; + +using mozilla::CheckedInt; +using mozilla::IsNaN; + +namespace { + +struct ValidatingPolicy : OpIterPolicy +{ + // Validation is what we're all about here. + static const bool Validate = true; +}; + +typedef OpIter<ValidatingPolicy> ValidatingOpIter; + +class FunctionDecoder +{ + const ModuleGenerator& mg_; + const ValTypeVector& locals_; + ValidatingOpIter iter_; + + public: + FunctionDecoder(const ModuleGenerator& mg, const ValTypeVector& locals, Decoder& d) + : mg_(mg), locals_(locals), iter_(d) + {} + const ModuleGenerator& mg() const { return mg_; } + ValidatingOpIter& iter() { return iter_; } + const ValTypeVector& locals() const { return locals_; } + + bool checkHasMemory() { + if (!mg().usesMemory()) + return iter().fail("can't touch memory without memory"); + return true; + } +}; + +} // end anonymous namespace + +static bool +DecodeCallArgs(FunctionDecoder& f, const Sig& sig) +{ + const ValTypeVector& args = sig.args(); + uint32_t numArgs = args.length(); + for (size_t i = 0; i < numArgs; ++i) { + ValType argType = args[i]; + if (!f.iter().readCallArg(argType, numArgs, i, nullptr)) + return false; + } + + return f.iter().readCallArgsEnd(numArgs); +} + +static bool +DecodeCallReturn(FunctionDecoder& f, const Sig& sig) +{ + return f.iter().readCallReturn(sig.ret()); +} + +static bool +DecodeCall(FunctionDecoder& f) +{ + uint32_t funcIndex; + if (!f.iter().readCall(&funcIndex)) + return false; + + if (funcIndex >= f.mg().numFuncs()) + return f.iter().fail("callee index out of range"); + + if (!f.iter().inReachableCode()) + return true; + + const Sig* sig = &f.mg().funcSig(funcIndex); + + return DecodeCallArgs(f, *sig) && + DecodeCallReturn(f, *sig); +} + +static bool +DecodeCallIndirect(FunctionDecoder& f) +{ + if (!f.mg().numTables()) + return f.iter().fail("can't call_indirect without a table"); + + uint32_t sigIndex; + if (!f.iter().readCallIndirect(&sigIndex, nullptr)) + return false; + + if (sigIndex >= f.mg().numSigs()) + return f.iter().fail("signature index out of range"); + + if (!f.iter().inReachableCode()) + return true; + + const Sig& sig = f.mg().sig(sigIndex); + if (!DecodeCallArgs(f, sig)) + return false; + + return DecodeCallReturn(f, sig); +} + +static bool +DecodeBrTable(FunctionDecoder& f) +{ + uint32_t tableLength; + ExprType type = ExprType::Limit; + if (!f.iter().readBrTable(&tableLength, &type, nullptr, nullptr)) + return false; + + uint32_t depth; + for (size_t i = 0, e = tableLength; i < e; ++i) { + if (!f.iter().readBrTableEntry(&type, nullptr, &depth)) + return false; + } + + // Read the default label. + return f.iter().readBrTableDefault(&type, nullptr, &depth); +} + +static bool +DecodeFunctionBodyExprs(FunctionDecoder& f) +{ +#define CHECK(c) if (!(c)) return false; break + + while (true) { + uint16_t op; + if (!f.iter().readOp(&op)) + return false; + + switch (op) { + case uint16_t(Op::End): + if (!f.iter().readEnd(nullptr, nullptr, nullptr)) + return false; + if (f.iter().controlStackEmpty()) + return true; + break; + case uint16_t(Op::Nop): + CHECK(f.iter().readNop()); + case uint16_t(Op::Drop): + CHECK(f.iter().readDrop()); + case uint16_t(Op::Call): + CHECK(DecodeCall(f)); + case uint16_t(Op::CallIndirect): + CHECK(DecodeCallIndirect(f)); + case uint16_t(Op::I32Const): + CHECK(f.iter().readI32Const(nullptr)); + case uint16_t(Op::I64Const): + CHECK(f.iter().readI64Const(nullptr)); + case uint16_t(Op::F32Const): + CHECK(f.iter().readF32Const(nullptr)); + case uint16_t(Op::F64Const): + CHECK(f.iter().readF64Const(nullptr)); + case uint16_t(Op::GetLocal): + CHECK(f.iter().readGetLocal(f.locals(), nullptr)); + case uint16_t(Op::SetLocal): + CHECK(f.iter().readSetLocal(f.locals(), nullptr, nullptr)); + case uint16_t(Op::TeeLocal): + CHECK(f.iter().readTeeLocal(f.locals(), nullptr, nullptr)); + case uint16_t(Op::GetGlobal): + CHECK(f.iter().readGetGlobal(f.mg().globals(), nullptr)); + case uint16_t(Op::SetGlobal): + CHECK(f.iter().readSetGlobal(f.mg().globals(), nullptr, nullptr)); + case uint16_t(Op::Select): + CHECK(f.iter().readSelect(nullptr, nullptr, nullptr, nullptr)); + case uint16_t(Op::Block): + CHECK(f.iter().readBlock()); + case uint16_t(Op::Loop): + CHECK(f.iter().readLoop()); + case uint16_t(Op::If): + CHECK(f.iter().readIf(nullptr)); + case uint16_t(Op::Else): + CHECK(f.iter().readElse(nullptr, nullptr)); + case uint16_t(Op::I32Clz): + case uint16_t(Op::I32Ctz): + case uint16_t(Op::I32Popcnt): + CHECK(f.iter().readUnary(ValType::I32, nullptr)); + case uint16_t(Op::I64Clz): + case uint16_t(Op::I64Ctz): + case uint16_t(Op::I64Popcnt): + CHECK(f.iter().readUnary(ValType::I64, nullptr)); + case uint16_t(Op::F32Abs): + case uint16_t(Op::F32Neg): + case uint16_t(Op::F32Ceil): + case uint16_t(Op::F32Floor): + case uint16_t(Op::F32Sqrt): + case uint16_t(Op::F32Trunc): + case uint16_t(Op::F32Nearest): + CHECK(f.iter().readUnary(ValType::F32, nullptr)); + case uint16_t(Op::F64Abs): + case uint16_t(Op::F64Neg): + case uint16_t(Op::F64Ceil): + case uint16_t(Op::F64Floor): + case uint16_t(Op::F64Sqrt): + case uint16_t(Op::F64Trunc): + case uint16_t(Op::F64Nearest): + CHECK(f.iter().readUnary(ValType::F64, nullptr)); + case uint16_t(Op::I32Add): + case uint16_t(Op::I32Sub): + case uint16_t(Op::I32Mul): + case uint16_t(Op::I32DivS): + case uint16_t(Op::I32DivU): + case uint16_t(Op::I32RemS): + case uint16_t(Op::I32RemU): + case uint16_t(Op::I32And): + case uint16_t(Op::I32Or): + case uint16_t(Op::I32Xor): + case uint16_t(Op::I32Shl): + case uint16_t(Op::I32ShrS): + case uint16_t(Op::I32ShrU): + case uint16_t(Op::I32Rotl): + case uint16_t(Op::I32Rotr): + CHECK(f.iter().readBinary(ValType::I32, nullptr, nullptr)); + case uint16_t(Op::I64Add): + case uint16_t(Op::I64Sub): + case uint16_t(Op::I64Mul): + case uint16_t(Op::I64DivS): + case uint16_t(Op::I64DivU): + case uint16_t(Op::I64RemS): + case uint16_t(Op::I64RemU): + case uint16_t(Op::I64And): + case uint16_t(Op::I64Or): + case uint16_t(Op::I64Xor): + case uint16_t(Op::I64Shl): + case uint16_t(Op::I64ShrS): + case uint16_t(Op::I64ShrU): + case uint16_t(Op::I64Rotl): + case uint16_t(Op::I64Rotr): + CHECK(f.iter().readBinary(ValType::I64, nullptr, nullptr)); + case uint16_t(Op::F32Add): + case uint16_t(Op::F32Sub): + case uint16_t(Op::F32Mul): + case uint16_t(Op::F32Div): + case uint16_t(Op::F32Min): + case uint16_t(Op::F32Max): + case uint16_t(Op::F32CopySign): + CHECK(f.iter().readBinary(ValType::F32, nullptr, nullptr)); + case uint16_t(Op::F64Add): + case uint16_t(Op::F64Sub): + case uint16_t(Op::F64Mul): + case uint16_t(Op::F64Div): + case uint16_t(Op::F64Min): + case uint16_t(Op::F64Max): + case uint16_t(Op::F64CopySign): + CHECK(f.iter().readBinary(ValType::F64, nullptr, nullptr)); + case uint16_t(Op::I32Eq): + case uint16_t(Op::I32Ne): + case uint16_t(Op::I32LtS): + case uint16_t(Op::I32LtU): + case uint16_t(Op::I32LeS): + case uint16_t(Op::I32LeU): + case uint16_t(Op::I32GtS): + case uint16_t(Op::I32GtU): + case uint16_t(Op::I32GeS): + case uint16_t(Op::I32GeU): + CHECK(f.iter().readComparison(ValType::I32, nullptr, nullptr)); + case uint16_t(Op::I64Eq): + case uint16_t(Op::I64Ne): + case uint16_t(Op::I64LtS): + case uint16_t(Op::I64LtU): + case uint16_t(Op::I64LeS): + case uint16_t(Op::I64LeU): + case uint16_t(Op::I64GtS): + case uint16_t(Op::I64GtU): + case uint16_t(Op::I64GeS): + case uint16_t(Op::I64GeU): + CHECK(f.iter().readComparison(ValType::I64, nullptr, nullptr)); + case uint16_t(Op::F32Eq): + case uint16_t(Op::F32Ne): + case uint16_t(Op::F32Lt): + case uint16_t(Op::F32Le): + case uint16_t(Op::F32Gt): + case uint16_t(Op::F32Ge): + CHECK(f.iter().readComparison(ValType::F32, nullptr, nullptr)); + case uint16_t(Op::F64Eq): + case uint16_t(Op::F64Ne): + case uint16_t(Op::F64Lt): + case uint16_t(Op::F64Le): + case uint16_t(Op::F64Gt): + case uint16_t(Op::F64Ge): + CHECK(f.iter().readComparison(ValType::F64, nullptr, nullptr)); + case uint16_t(Op::I32Eqz): + CHECK(f.iter().readConversion(ValType::I32, ValType::I32, nullptr)); + case uint16_t(Op::I64Eqz): + case uint16_t(Op::I32WrapI64): + CHECK(f.iter().readConversion(ValType::I64, ValType::I32, nullptr)); + case uint16_t(Op::I32TruncSF32): + case uint16_t(Op::I32TruncUF32): + case uint16_t(Op::I32ReinterpretF32): + CHECK(f.iter().readConversion(ValType::F32, ValType::I32, nullptr)); + case uint16_t(Op::I32TruncSF64): + case uint16_t(Op::I32TruncUF64): + CHECK(f.iter().readConversion(ValType::F64, ValType::I32, nullptr)); + case uint16_t(Op::I64ExtendSI32): + case uint16_t(Op::I64ExtendUI32): + CHECK(f.iter().readConversion(ValType::I32, ValType::I64, nullptr)); + case uint16_t(Op::I64TruncSF32): + case uint16_t(Op::I64TruncUF32): + CHECK(f.iter().readConversion(ValType::F32, ValType::I64, nullptr)); + case uint16_t(Op::I64TruncSF64): + case uint16_t(Op::I64TruncUF64): + case uint16_t(Op::I64ReinterpretF64): + CHECK(f.iter().readConversion(ValType::F64, ValType::I64, nullptr)); + case uint16_t(Op::F32ConvertSI32): + case uint16_t(Op::F32ConvertUI32): + case uint16_t(Op::F32ReinterpretI32): + CHECK(f.iter().readConversion(ValType::I32, ValType::F32, nullptr)); + case uint16_t(Op::F32ConvertSI64): + case uint16_t(Op::F32ConvertUI64): + CHECK(f.iter().readConversion(ValType::I64, ValType::F32, nullptr)); + case uint16_t(Op::F32DemoteF64): + CHECK(f.iter().readConversion(ValType::F64, ValType::F32, nullptr)); + case uint16_t(Op::F64ConvertSI32): + case uint16_t(Op::F64ConvertUI32): + CHECK(f.iter().readConversion(ValType::I32, ValType::F64, nullptr)); + case uint16_t(Op::F64ConvertSI64): + case uint16_t(Op::F64ConvertUI64): + case uint16_t(Op::F64ReinterpretI64): + CHECK(f.iter().readConversion(ValType::I64, ValType::F64, nullptr)); + case uint16_t(Op::F64PromoteF32): + CHECK(f.iter().readConversion(ValType::F32, ValType::F64, nullptr)); + case uint16_t(Op::I32Load8S): + case uint16_t(Op::I32Load8U): + CHECK(f.checkHasMemory() && f.iter().readLoad(ValType::I32, 1, nullptr)); + case uint16_t(Op::I32Load16S): + case uint16_t(Op::I32Load16U): + CHECK(f.checkHasMemory() && f.iter().readLoad(ValType::I32, 2, nullptr)); + case uint16_t(Op::I32Load): + CHECK(f.checkHasMemory() && f.iter().readLoad(ValType::I32, 4, nullptr)); + case uint16_t(Op::I64Load8S): + case uint16_t(Op::I64Load8U): + CHECK(f.checkHasMemory() && f.iter().readLoad(ValType::I64, 1, nullptr)); + case uint16_t(Op::I64Load16S): + case uint16_t(Op::I64Load16U): + CHECK(f.checkHasMemory() && f.iter().readLoad(ValType::I64, 2, nullptr)); + case uint16_t(Op::I64Load32S): + case uint16_t(Op::I64Load32U): + CHECK(f.checkHasMemory() && f.iter().readLoad(ValType::I64, 4, nullptr)); + case uint16_t(Op::I64Load): + CHECK(f.checkHasMemory() && f.iter().readLoad(ValType::I64, 8, nullptr)); + case uint16_t(Op::F32Load): + CHECK(f.checkHasMemory() && f.iter().readLoad(ValType::F32, 4, nullptr)); + case uint16_t(Op::F64Load): + CHECK(f.checkHasMemory() && f.iter().readLoad(ValType::F64, 8, nullptr)); + case uint16_t(Op::I32Store8): + CHECK(f.checkHasMemory() && f.iter().readStore(ValType::I32, 1, nullptr, nullptr)); + case uint16_t(Op::I32Store16): + CHECK(f.checkHasMemory() && f.iter().readStore(ValType::I32, 2, nullptr, nullptr)); + case uint16_t(Op::I32Store): + CHECK(f.checkHasMemory() && f.iter().readStore(ValType::I32, 4, nullptr, nullptr)); + case uint16_t(Op::I64Store8): + CHECK(f.checkHasMemory() && f.iter().readStore(ValType::I64, 1, nullptr, nullptr)); + case uint16_t(Op::I64Store16): + CHECK(f.checkHasMemory() && f.iter().readStore(ValType::I64, 2, nullptr, nullptr)); + case uint16_t(Op::I64Store32): + CHECK(f.checkHasMemory() && f.iter().readStore(ValType::I64, 4, nullptr, nullptr)); + case uint16_t(Op::I64Store): + CHECK(f.checkHasMemory() && f.iter().readStore(ValType::I64, 8, nullptr, nullptr)); + case uint16_t(Op::F32Store): + CHECK(f.checkHasMemory() && f.iter().readStore(ValType::F32, 4, nullptr, nullptr)); + case uint16_t(Op::F64Store): + CHECK(f.checkHasMemory() && f.iter().readStore(ValType::F64, 8, nullptr, nullptr)); + case uint16_t(Op::GrowMemory): + CHECK(f.checkHasMemory() && f.iter().readGrowMemory(nullptr)); + case uint16_t(Op::CurrentMemory): + CHECK(f.checkHasMemory() && f.iter().readCurrentMemory()); + case uint16_t(Op::Br): + CHECK(f.iter().readBr(nullptr, nullptr, nullptr)); + case uint16_t(Op::BrIf): + CHECK(f.iter().readBrIf(nullptr, nullptr, nullptr, nullptr)); + case uint16_t(Op::BrTable): + CHECK(DecodeBrTable(f)); + case uint16_t(Op::Return): + CHECK(f.iter().readReturn(nullptr)); + case uint16_t(Op::Unreachable): + CHECK(f.iter().readUnreachable()); + default: + return f.iter().unrecognizedOpcode(op); + } + } + + MOZ_CRASH("unreachable"); + +#undef CHECK +} + +static bool +DecodeImportSection(Decoder& d, ModuleGeneratorData* init, ImportVector* imports) +{ + Maybe<Limits> memory; + Uint32Vector funcSigIndices; + if (!DecodeImportSection(d, init->sigs, &funcSigIndices, &init->globals, &init->tables, &memory, + imports)) + return false; + + for (uint32_t sigIndex : funcSigIndices) { + if (!init->funcSigs.append(&init->sigs[sigIndex])) + return false; + } + + // The global data offsets will be filled in by ModuleGenerator::init. + if (!init->funcImportGlobalDataOffsets.resize(init->funcSigs.length())) + return false; + + if (memory) { + init->memoryUsage = MemoryUsage::Unshared; + init->minMemoryLength = memory->initial; + init->maxMemoryLength = memory->maximum; + } + + return true; +} + +static bool +DecodeFunctionSection(Decoder& d, ModuleGeneratorData* init) +{ + Uint32Vector funcSigIndexes; + if (!DecodeFunctionSection(d, init->sigs, init->funcSigs.length(), &funcSigIndexes)) + return false; + + if (!init->funcSigs.reserve(init->funcSigs.length() + funcSigIndexes.length())) + return false; + + for (uint32_t sigIndex : funcSigIndexes) + init->funcSigs.infallibleAppend(&init->sigs[sigIndex]); + + return true; +} + +static bool +DecodeTableSection(Decoder& d, ModuleGeneratorData* init) +{ + uint32_t sectionStart, sectionSize; + if (!d.startSection(SectionId::Table, §ionStart, §ionSize, "table")) + return false; + if (sectionStart == Decoder::NotStarted) + return true; + + uint32_t numTables; + if (!d.readVarU32(&numTables)) + return d.fail("failed to read number of tables"); + + if (numTables != 1) + return d.fail("the number of tables must be exactly one"); + + if (!DecodeTableLimits(d, &init->tables)) + return false; + + if (!d.finishSection(sectionStart, sectionSize, "table")) + return false; + + return true; +} + +static bool +DecodeMemorySection(Decoder& d, ModuleGeneratorData* init) +{ + bool present; + Limits memory; + if (!DecodeMemorySection(d, UsesMemory(init->memoryUsage), &memory, &present)) + return false; + + if (present) { + init->memoryUsage = MemoryUsage::Unshared; + init->minMemoryLength = memory.initial; + init->maxMemoryLength = memory.maximum; + } + + return true; +} + +static bool +DecodeGlobalSection(Decoder& d, ModuleGeneratorData* init) +{ + uint32_t sectionStart, sectionSize; + if (!d.startSection(SectionId::Global, §ionStart, §ionSize, "global")) + return false; + if (sectionStart == Decoder::NotStarted) + return true; + + uint32_t numDefs; + if (!d.readVarU32(&numDefs)) + return d.fail("expected number of globals"); + + CheckedInt<uint32_t> numGlobals = init->globals.length(); + numGlobals += numDefs; + if (!numGlobals.isValid() || numGlobals.value() > MaxGlobals) + return d.fail("too many globals"); + + for (uint32_t i = 0; i < numDefs; i++) { + ValType type; + bool isMutable; + if (!DecodeGlobalType(d, &type, &isMutable)) + return false; + + InitExpr initializer; + if (!DecodeInitializerExpression(d, init->globals, type, &initializer)) + return false; + + if (!init->globals.append(GlobalDesc(initializer, isMutable))) + return false; + } + + if (!d.finishSection(sectionStart, sectionSize, "global")) + return false; + + return true; +} + +typedef HashSet<const char*, CStringHasher, SystemAllocPolicy> CStringSet; + +static UniqueChars +DecodeExportName(Decoder& d, CStringSet* dupSet) +{ + UniqueChars exportName = DecodeName(d); + if (!exportName) { + d.fail("expected valid export name"); + return nullptr; + } + + CStringSet::AddPtr p = dupSet->lookupForAdd(exportName.get()); + if (p) { + d.fail("duplicate export"); + return nullptr; + } + + if (!dupSet->add(p, exportName.get())) + return nullptr; + + return Move(exportName); +} + +static bool +DecodeExport(Decoder& d, ModuleGenerator& mg, CStringSet* dupSet) +{ + UniqueChars fieldName = DecodeExportName(d, dupSet); + if (!fieldName) + return false; + + uint32_t exportKind; + if (!d.readVarU32(&exportKind)) + return d.fail("failed to read export kind"); + + switch (DefinitionKind(exportKind)) { + case DefinitionKind::Function: { + uint32_t funcIndex; + if (!d.readVarU32(&funcIndex)) + return d.fail("expected export internal index"); + + if (funcIndex >= mg.numFuncs()) + return d.fail("exported function index out of bounds"); + + return mg.addFuncExport(Move(fieldName), funcIndex); + } + case DefinitionKind::Table: { + uint32_t tableIndex; + if (!d.readVarU32(&tableIndex)) + return d.fail("expected table index"); + + if (tableIndex >= mg.tables().length()) + return d.fail("exported table index out of bounds"); + + return mg.addTableExport(Move(fieldName)); + } + case DefinitionKind::Memory: { + uint32_t memoryIndex; + if (!d.readVarU32(&memoryIndex)) + return d.fail("expected memory index"); + + if (memoryIndex > 0 || !mg.usesMemory()) + return d.fail("exported memory index out of bounds"); + + return mg.addMemoryExport(Move(fieldName)); + } + case DefinitionKind::Global: { + uint32_t globalIndex; + if (!d.readVarU32(&globalIndex)) + return d.fail("expected global index"); + + if (globalIndex >= mg.globals().length()) + return d.fail("exported global index out of bounds"); + + const GlobalDesc& global = mg.globals()[globalIndex]; + if (!GlobalIsJSCompatible(d, global.type(), global.isMutable())) + return false; + + return mg.addGlobalExport(Move(fieldName), globalIndex); + } + default: + return d.fail("unexpected export kind"); + } + + MOZ_CRASH("unreachable"); +} + +static bool +DecodeExportSection(Decoder& d, ModuleGenerator& mg) +{ + uint32_t sectionStart, sectionSize; + if (!d.startSection(SectionId::Export, §ionStart, §ionSize, "export")) + return false; + if (sectionStart == Decoder::NotStarted) + return true; + + CStringSet dupSet; + if (!dupSet.init()) + return false; + + uint32_t numExports; + if (!d.readVarU32(&numExports)) + return d.fail("failed to read number of exports"); + + if (numExports > MaxExports) + return d.fail("too many exports"); + + for (uint32_t i = 0; i < numExports; i++) { + if (!DecodeExport(d, mg, &dupSet)) + return false; + } + + if (!d.finishSection(sectionStart, sectionSize, "export")) + return false; + + return true; +} + +static bool +DecodeFunctionBody(Decoder& d, ModuleGenerator& mg, uint32_t funcIndex) +{ + uint32_t bodySize; + if (!d.readVarU32(&bodySize)) + return d.fail("expected number of function body bytes"); + + if (d.bytesRemain() < bodySize) + return d.fail("function body length too big"); + + const uint8_t* bodyBegin = d.currentPosition(); + const size_t offsetInModule = d.currentOffset(); + + FunctionGenerator fg; + if (!mg.startFuncDef(offsetInModule, &fg)) + return false; + + ValTypeVector locals; + const Sig& sig = mg.funcSig(funcIndex); + if (!locals.appendAll(sig.args())) + return false; + + if (!DecodeLocalEntries(d, ModuleKind::Wasm, &locals)) + return false; + + FunctionDecoder f(mg, locals, d); + + if (!f.iter().readFunctionStart(sig.ret())) + return false; + + if (!DecodeFunctionBodyExprs(f)) + return false; + + if (!f.iter().readFunctionEnd()) + return false; + + if (d.currentPosition() != bodyBegin + bodySize) + return d.fail("function body length mismatch"); + + if (!fg.bytes().resize(bodySize)) + return false; + + memcpy(fg.bytes().begin(), bodyBegin, bodySize); + + return mg.finishFuncDef(funcIndex, &fg); +} + +static bool +DecodeStartSection(Decoder& d, ModuleGenerator& mg) +{ + uint32_t sectionStart, sectionSize; + if (!d.startSection(SectionId::Start, §ionStart, §ionSize, "start")) + return false; + if (sectionStart == Decoder::NotStarted) + return true; + + uint32_t funcIndex; + if (!d.readVarU32(&funcIndex)) + return d.fail("failed to read start func index"); + + if (funcIndex >= mg.numFuncs()) + return d.fail("unknown start function"); + + const Sig& sig = mg.funcSig(funcIndex); + if (!IsVoid(sig.ret())) + return d.fail("start function must not return anything"); + + if (sig.args().length()) + return d.fail("start function must be nullary"); + + if (!mg.setStartFunction(funcIndex)) + return false; + + if (!d.finishSection(sectionStart, sectionSize, "start")) + return false; + + return true; +} + +static bool +DecodeCodeSection(Decoder& d, ModuleGenerator& mg) +{ + if (!mg.startFuncDefs()) + return false; + + uint32_t sectionStart, sectionSize; + if (!d.startSection(SectionId::Code, §ionStart, §ionSize, "code")) + return false; + + if (sectionStart == Decoder::NotStarted) { + if (mg.numFuncDefs() != 0) + return d.fail("expected function bodies"); + + return mg.finishFuncDefs(); + } + + uint32_t numFuncDefs; + if (!d.readVarU32(&numFuncDefs)) + return d.fail("expected function body count"); + + if (numFuncDefs != mg.numFuncDefs()) + return d.fail("function body count does not match function signature count"); + + for (uint32_t funcDefIndex = 0; funcDefIndex < numFuncDefs; funcDefIndex++) { + if (!DecodeFunctionBody(d, mg, mg.numFuncImports() + funcDefIndex)) + return false; + } + + if (!d.finishSection(sectionStart, sectionSize, "code")) + return false; + + return mg.finishFuncDefs(); +} + +static bool +DecodeElemSection(Decoder& d, ModuleGenerator& mg) +{ + uint32_t sectionStart, sectionSize; + if (!d.startSection(SectionId::Elem, §ionStart, §ionSize, "elem")) + return false; + if (sectionStart == Decoder::NotStarted) + return true; + + uint32_t numSegments; + if (!d.readVarU32(&numSegments)) + return d.fail("failed to read number of elem segments"); + + if (numSegments > MaxElemSegments) + return d.fail("too many elem segments"); + + for (uint32_t i = 0; i < numSegments; i++) { + uint32_t tableIndex; + if (!d.readVarU32(&tableIndex)) + return d.fail("expected table index"); + + MOZ_ASSERT(mg.tables().length() <= 1); + if (tableIndex >= mg.tables().length()) + return d.fail("table index out of range"); + + InitExpr offset; + if (!DecodeInitializerExpression(d, mg.globals(), ValType::I32, &offset)) + return false; + + uint32_t numElems; + if (!d.readVarU32(&numElems)) + return d.fail("expected segment size"); + + Uint32Vector elemFuncIndices; + if (!elemFuncIndices.resize(numElems)) + return false; + + for (uint32_t i = 0; i < numElems; i++) { + if (!d.readVarU32(&elemFuncIndices[i])) + return d.fail("failed to read element function index"); + if (elemFuncIndices[i] >= mg.numFuncs()) + return d.fail("table element out of range"); + } + + if (!mg.addElemSegment(offset, Move(elemFuncIndices))) + return false; + } + + if (!d.finishSection(sectionStart, sectionSize, "elem")) + return false; + + return true; +} + +static void +MaybeDecodeNameSectionBody(Decoder& d, ModuleGenerator& mg) +{ + // For simplicity, ignore all failures, even OOM. Failure will simply result + // in the names section not being included for this module. + + uint32_t numFuncNames; + if (!d.readVarU32(&numFuncNames)) + return; + + if (numFuncNames > MaxFuncs) + return; + + NameInBytecodeVector funcNames; + if (!funcNames.resize(numFuncNames)) + return; + + for (uint32_t i = 0; i < numFuncNames; i++) { + uint32_t numBytes; + if (!d.readVarU32(&numBytes)) + return; + + NameInBytecode name; + name.offset = d.currentOffset(); + name.length = numBytes; + funcNames[i] = name; + + if (!d.readBytes(numBytes)) + return; + + // Skip local names for a function. + uint32_t numLocals; + if (!d.readVarU32(&numLocals)) + return; + for (uint32_t j = 0; j < numLocals; j++) { + uint32_t numBytes; + if (!d.readVarU32(&numBytes)) + return; + if (!d.readBytes(numBytes)) + return; + } + } + + mg.setFuncNames(Move(funcNames)); +} + +static bool +DecodeDataSection(Decoder& d, ModuleGenerator& mg) +{ + DataSegmentVector dataSegments; + if (!DecodeDataSection(d, mg.usesMemory(), mg.minMemoryLength(), mg.globals(), &dataSegments)) + return false; + + mg.setDataSegments(Move(dataSegments)); + return true; +} + +static bool +DecodeNameSection(Decoder& d, ModuleGenerator& mg) +{ + uint32_t sectionStart, sectionSize; + if (!d.startUserDefinedSection(NameSectionName, §ionStart, §ionSize)) + return false; + if (sectionStart == Decoder::NotStarted) + return true; + + // Once started, user-defined sections do not report validation errors. + + MaybeDecodeNameSectionBody(d, mg); + + d.finishUserDefinedSection(sectionStart, sectionSize); + return true; +} + +bool +CompileArgs::initFromContext(ExclusiveContext* cx, ScriptedCaller&& scriptedCaller) +{ + alwaysBaseline = cx->options().wasmAlwaysBaseline(); + this->scriptedCaller = Move(scriptedCaller); + return assumptions.initBuildIdFromContext(cx); +} + +SharedModule +wasm::Compile(const ShareableBytes& bytecode, const CompileArgs& args, UniqueChars* error) +{ + MOZ_RELEASE_ASSERT(wasm::HaveSignalHandlers()); + + Decoder d(bytecode.begin(), bytecode.end(), error); + + auto init = js::MakeUnique<ModuleGeneratorData>(); + if (!init) + return nullptr; + + if (!DecodePreamble(d)) + return nullptr; + + if (!DecodeTypeSection(d, &init->sigs)) + return nullptr; + + ImportVector imports; + if (!::DecodeImportSection(d, init.get(), &imports)) + return nullptr; + + if (!::DecodeFunctionSection(d, init.get())) + return nullptr; + + if (!DecodeTableSection(d, init.get())) + return nullptr; + + if (!::DecodeMemorySection(d, init.get())) + return nullptr; + + if (!DecodeGlobalSection(d, init.get())) + return nullptr; + + ModuleGenerator mg(Move(imports)); + if (!mg.init(Move(init), args)) + return nullptr; + + if (!DecodeExportSection(d, mg)) + return nullptr; + + if (!DecodeStartSection(d, mg)) + return nullptr; + + if (!DecodeElemSection(d, mg)) + return nullptr; + + if (!DecodeCodeSection(d, mg)) + return nullptr; + + if (!::DecodeDataSection(d, mg)) + return nullptr; + + if (!DecodeNameSection(d, mg)) + return nullptr; + + if (!DecodeUnknownSections(d)) + return nullptr; + + MOZ_ASSERT(!*error, "unreported error in decoding"); + + return mg.finish(bytecode); +} |