2019-03-11 03:26:37 -07:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
*
|
|
|
|
* Copyright 2014 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/AsmJS.h"
|
|
|
|
|
|
|
|
#include "mozilla/Attributes.h"
|
|
|
|
#include "mozilla/Compression.h"
|
|
|
|
#include "mozilla/MathAlgorithms.h"
|
|
|
|
#include "mozilla/Maybe.h"
|
|
|
|
|
|
|
|
#include "jsmath.h"
|
|
|
|
#include "jsprf.h"
|
|
|
|
#include "jsstr.h"
|
|
|
|
#include "jsutil.h"
|
|
|
|
|
|
|
|
#include "jswrapper.h"
|
|
|
|
|
|
|
|
#include "builtin/SIMD.h"
|
|
|
|
#include "frontend/Parser.h"
|
|
|
|
#include "gc/Policy.h"
|
|
|
|
#include "js/MemoryMetrics.h"
|
2019-09-05 10:05:43 -07:00
|
|
|
#include "vm/SelfHosting.h"
|
2019-03-11 03:26:37 -07:00
|
|
|
#include "vm/StringBuffer.h"
|
|
|
|
#include "vm/Time.h"
|
|
|
|
#include "vm/TypedArrayObject.h"
|
|
|
|
#include "wasm/WasmBinaryFormat.h"
|
|
|
|
#include "wasm/WasmGenerator.h"
|
|
|
|
#include "wasm/WasmInstance.h"
|
|
|
|
#include "wasm/WasmJS.h"
|
|
|
|
#include "wasm/WasmSerialize.h"
|
|
|
|
|
|
|
|
#include "jsobjinlines.h"
|
|
|
|
|
|
|
|
#include "frontend/ParseNode-inl.h"
|
|
|
|
#include "vm/ArrayBufferObject-inl.h"
|
|
|
|
|
|
|
|
using namespace js;
|
|
|
|
using namespace js::frontend;
|
|
|
|
using namespace js::jit;
|
|
|
|
using namespace js::wasm;
|
|
|
|
|
|
|
|
using mozilla::CeilingLog2;
|
|
|
|
using mozilla::Compression::LZ4;
|
|
|
|
using mozilla::HashGeneric;
|
|
|
|
using mozilla::IsNaN;
|
|
|
|
using mozilla::IsNegativeZero;
|
|
|
|
using mozilla::IsPowerOfTwo;
|
|
|
|
using mozilla::Maybe;
|
|
|
|
using mozilla::Move;
|
|
|
|
using mozilla::PodCopy;
|
|
|
|
using mozilla::PodEqual;
|
|
|
|
using mozilla::PodZero;
|
|
|
|
using mozilla::PositiveInfinity;
|
|
|
|
using JS::AsmJSOption;
|
|
|
|
using JS::GenericNaN;
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
// The asm.js valid heap lengths are precisely the WASM valid heap lengths for ARM
|
|
|
|
// greater or equal to MinHeapLength
|
|
|
|
static const size_t MinHeapLength = PageSize;
|
|
|
|
|
|
|
|
static uint32_t
|
|
|
|
RoundUpToNextValidAsmJSHeapLength(uint32_t length)
|
|
|
|
{
|
|
|
|
if (length <= MinHeapLength)
|
|
|
|
return MinHeapLength;
|
|
|
|
|
|
|
|
return wasm::RoundUpToNextValidARMImmediate(length);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
// asm.js module object
|
|
|
|
|
|
|
|
// The asm.js spec recognizes this set of builtin Math functions.
|
|
|
|
enum AsmJSMathBuiltinFunction
|
|
|
|
{
|
|
|
|
AsmJSMathBuiltin_sin, AsmJSMathBuiltin_cos, AsmJSMathBuiltin_tan,
|
|
|
|
AsmJSMathBuiltin_asin, AsmJSMathBuiltin_acos, AsmJSMathBuiltin_atan,
|
|
|
|
AsmJSMathBuiltin_ceil, AsmJSMathBuiltin_floor, AsmJSMathBuiltin_exp,
|
|
|
|
AsmJSMathBuiltin_log, AsmJSMathBuiltin_pow, AsmJSMathBuiltin_sqrt,
|
|
|
|
AsmJSMathBuiltin_abs, AsmJSMathBuiltin_atan2, AsmJSMathBuiltin_imul,
|
|
|
|
AsmJSMathBuiltin_fround, AsmJSMathBuiltin_min, AsmJSMathBuiltin_max,
|
|
|
|
AsmJSMathBuiltin_clz32
|
|
|
|
};
|
|
|
|
|
|
|
|
// The asm.js spec will recognize this set of builtin Atomics functions.
|
|
|
|
enum AsmJSAtomicsBuiltinFunction
|
|
|
|
{
|
|
|
|
AsmJSAtomicsBuiltin_compareExchange,
|
|
|
|
AsmJSAtomicsBuiltin_exchange,
|
|
|
|
AsmJSAtomicsBuiltin_load,
|
|
|
|
AsmJSAtomicsBuiltin_store,
|
|
|
|
AsmJSAtomicsBuiltin_add,
|
|
|
|
AsmJSAtomicsBuiltin_sub,
|
|
|
|
AsmJSAtomicsBuiltin_and,
|
|
|
|
AsmJSAtomicsBuiltin_or,
|
|
|
|
AsmJSAtomicsBuiltin_xor,
|
|
|
|
AsmJSAtomicsBuiltin_isLockFree
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// An AsmJSGlobal represents a JS global variable in the asm.js module function.
|
|
|
|
class AsmJSGlobal
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
enum Which { Variable, FFI, ArrayView, ArrayViewCtor, MathBuiltinFunction,
|
|
|
|
AtomicsBuiltinFunction, Constant, SimdCtor, SimdOp };
|
|
|
|
enum VarInitKind { InitConstant, InitImport };
|
|
|
|
enum ConstantKind { GlobalConstant, MathConstant };
|
|
|
|
|
|
|
|
private:
|
|
|
|
struct CacheablePod {
|
|
|
|
Which which_;
|
|
|
|
union V {
|
|
|
|
struct {
|
|
|
|
VarInitKind initKind_;
|
|
|
|
union U {
|
|
|
|
ValType importType_;
|
|
|
|
Val val_;
|
|
|
|
U() {}
|
|
|
|
} u;
|
|
|
|
} var;
|
|
|
|
uint32_t ffiIndex_;
|
|
|
|
Scalar::Type viewType_;
|
|
|
|
AsmJSMathBuiltinFunction mathBuiltinFunc_;
|
|
|
|
AsmJSAtomicsBuiltinFunction atomicsBuiltinFunc_;
|
|
|
|
SimdType simdCtorType_;
|
|
|
|
struct {
|
|
|
|
SimdType type_;
|
|
|
|
SimdOperation which_;
|
|
|
|
} simdOp;
|
|
|
|
struct {
|
|
|
|
ConstantKind kind_;
|
|
|
|
double value_;
|
|
|
|
} constant;
|
|
|
|
V() {}
|
|
|
|
} u;
|
|
|
|
} pod;
|
|
|
|
CacheableChars field_;
|
|
|
|
|
|
|
|
friend class ModuleValidator;
|
|
|
|
|
|
|
|
public:
|
|
|
|
AsmJSGlobal() = default;
|
|
|
|
AsmJSGlobal(Which which, UniqueChars field) {
|
|
|
|
mozilla::PodZero(&pod); // zero padding for Valgrind
|
|
|
|
pod.which_ = which;
|
|
|
|
field_ = Move(field);
|
|
|
|
}
|
|
|
|
const char* field() const {
|
|
|
|
return field_.get();
|
|
|
|
}
|
|
|
|
Which which() const {
|
|
|
|
return pod.which_;
|
|
|
|
}
|
|
|
|
VarInitKind varInitKind() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == Variable);
|
|
|
|
return pod.u.var.initKind_;
|
|
|
|
}
|
|
|
|
Val varInitVal() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == Variable);
|
|
|
|
MOZ_ASSERT(pod.u.var.initKind_ == InitConstant);
|
|
|
|
return pod.u.var.u.val_;
|
|
|
|
}
|
|
|
|
ValType varInitImportType() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == Variable);
|
|
|
|
MOZ_ASSERT(pod.u.var.initKind_ == InitImport);
|
|
|
|
return pod.u.var.u.importType_;
|
|
|
|
}
|
|
|
|
uint32_t ffiIndex() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == FFI);
|
|
|
|
return pod.u.ffiIndex_;
|
|
|
|
}
|
|
|
|
// When a view is created from an imported constructor:
|
|
|
|
// var I32 = stdlib.Int32Array;
|
|
|
|
// var i32 = new I32(buffer);
|
|
|
|
// the second import has nothing to validate and thus has a null field.
|
|
|
|
Scalar::Type viewType() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == ArrayView || pod.which_ == ArrayViewCtor);
|
|
|
|
return pod.u.viewType_;
|
|
|
|
}
|
|
|
|
AsmJSMathBuiltinFunction mathBuiltinFunction() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == MathBuiltinFunction);
|
|
|
|
return pod.u.mathBuiltinFunc_;
|
|
|
|
}
|
|
|
|
AsmJSAtomicsBuiltinFunction atomicsBuiltinFunction() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == AtomicsBuiltinFunction);
|
|
|
|
return pod.u.atomicsBuiltinFunc_;
|
|
|
|
}
|
|
|
|
SimdType simdCtorType() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == SimdCtor);
|
|
|
|
return pod.u.simdCtorType_;
|
|
|
|
}
|
|
|
|
SimdOperation simdOperation() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == SimdOp);
|
|
|
|
return pod.u.simdOp.which_;
|
|
|
|
}
|
|
|
|
SimdType simdOperationType() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == SimdOp);
|
|
|
|
return pod.u.simdOp.type_;
|
|
|
|
}
|
|
|
|
ConstantKind constantKind() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == Constant);
|
|
|
|
return pod.u.constant.kind_;
|
|
|
|
}
|
|
|
|
double constantValue() const {
|
|
|
|
MOZ_ASSERT(pod.which_ == Constant);
|
|
|
|
return pod.u.constant.value_;
|
|
|
|
}
|
|
|
|
|
|
|
|
WASM_DECLARE_SERIALIZABLE(AsmJSGlobal);
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef Vector<AsmJSGlobal, 0, SystemAllocPolicy> AsmJSGlobalVector;
|
|
|
|
|
|
|
|
// An AsmJSImport is slightly different than an asm.js FFI function: a single
|
|
|
|
// asm.js FFI function can be called with many different signatures. When
|
|
|
|
// compiled to wasm, each unique FFI function paired with signature generates a
|
|
|
|
// wasm import.
|
|
|
|
class AsmJSImport
|
|
|
|
{
|
|
|
|
uint32_t ffiIndex_;
|
|
|
|
public:
|
|
|
|
AsmJSImport() = default;
|
|
|
|
explicit AsmJSImport(uint32_t ffiIndex) : ffiIndex_(ffiIndex) {}
|
|
|
|
uint32_t ffiIndex() const { return ffiIndex_; }
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef Vector<AsmJSImport, 0, SystemAllocPolicy> AsmJSImportVector;
|
|
|
|
|
|
|
|
// An AsmJSExport logically extends Export with the extra information needed for
|
|
|
|
// an asm.js exported function, viz., the offsets in module's source chars in
|
|
|
|
// case the function is toString()ed.
|
|
|
|
class AsmJSExport
|
|
|
|
{
|
|
|
|
uint32_t funcIndex_ = 0;
|
|
|
|
|
|
|
|
// All fields are treated as cacheable POD:
|
|
|
|
uint32_t startOffsetInModule_ = 0; // Store module-start-relative offsets
|
|
|
|
uint32_t endOffsetInModule_ = 0; // so preserved by serialization.
|
|
|
|
|
|
|
|
public:
|
|
|
|
AsmJSExport() = default;
|
|
|
|
AsmJSExport(uint32_t funcIndex, uint32_t startOffsetInModule, uint32_t endOffsetInModule)
|
|
|
|
: funcIndex_(funcIndex),
|
|
|
|
startOffsetInModule_(startOffsetInModule),
|
|
|
|
endOffsetInModule_(endOffsetInModule)
|
|
|
|
{}
|
|
|
|
uint32_t funcIndex() const {
|
|
|
|
return funcIndex_;
|
|
|
|
}
|
|
|
|
uint32_t startOffsetInModule() const {
|
|
|
|
return startOffsetInModule_;
|
|
|
|
}
|
|
|
|
uint32_t endOffsetInModule() const {
|
|
|
|
return endOffsetInModule_;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef Vector<AsmJSExport, 0, SystemAllocPolicy> AsmJSExportVector;
|
|
|
|
|
|
|
|
enum class CacheResult
|
|
|
|
{
|
|
|
|
Hit,
|
|
|
|
Miss
|
|
|
|
};
|
|
|
|
|
|
|
|
// Holds the immutable guts of an AsmJSModule.
|
|
|
|
//
|
|
|
|
// AsmJSMetadata is built incrementally by ModuleValidator and then shared
|
|
|
|
// immutably between AsmJSModules.
|
|
|
|
|
|
|
|
struct AsmJSMetadataCacheablePod
|
|
|
|
{
|
|
|
|
uint32_t numFFIs = 0;
|
|
|
|
uint32_t srcLength = 0;
|
|
|
|
uint32_t srcLengthWithRightBrace = 0;
|
|
|
|
bool usesSimd = false;
|
|
|
|
|
|
|
|
AsmJSMetadataCacheablePod() = default;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct js::AsmJSMetadata : Metadata, AsmJSMetadataCacheablePod
|
|
|
|
{
|
|
|
|
AsmJSGlobalVector asmJSGlobals;
|
|
|
|
AsmJSImportVector asmJSImports;
|
|
|
|
AsmJSExportVector asmJSExports;
|
|
|
|
CacheableCharsVector asmJSFuncNames;
|
|
|
|
CacheableChars globalArgumentName;
|
|
|
|
CacheableChars importArgumentName;
|
|
|
|
CacheableChars bufferArgumentName;
|
|
|
|
|
|
|
|
CacheResult cacheResult;
|
|
|
|
|
|
|
|
// These values are not serialized since they are relative to the
|
|
|
|
// containing script which can be different between serialization and
|
|
|
|
// deserialization contexts. Thus, they must be set explicitly using the
|
|
|
|
// ambient Parser/ScriptSource after deserialization.
|
|
|
|
//
|
|
|
|
// srcStart refers to the offset in the ScriptSource to the beginning of
|
|
|
|
// the asm.js module function. If the function has been created with the
|
|
|
|
// Function constructor, this will be the first character in the function
|
|
|
|
// source. Otherwise, it will be the opening parenthesis of the arguments
|
|
|
|
// list.
|
2019-09-05 10:06:35 -07:00
|
|
|
uint32_t toStringStart;
|
2019-03-11 03:26:37 -07:00
|
|
|
uint32_t srcStart;
|
|
|
|
uint32_t srcBodyStart;
|
|
|
|
bool strict;
|
|
|
|
ScriptSourceHolder scriptSource;
|
|
|
|
|
|
|
|
uint32_t srcEndBeforeCurly() const {
|
|
|
|
return srcStart + srcLength;
|
|
|
|
}
|
|
|
|
uint32_t srcEndAfterCurly() const {
|
|
|
|
return srcStart + srcLengthWithRightBrace;
|
|
|
|
}
|
|
|
|
|
|
|
|
AsmJSMetadata()
|
|
|
|
: Metadata(ModuleKind::AsmJS),
|
|
|
|
cacheResult(CacheResult::Miss),
|
|
|
|
srcStart(0),
|
|
|
|
srcBodyStart(0),
|
|
|
|
strict(false)
|
|
|
|
{}
|
|
|
|
~AsmJSMetadata() override {}
|
|
|
|
|
|
|
|
const AsmJSExport& lookupAsmJSExport(uint32_t funcIndex) const {
|
|
|
|
// The AsmJSExportVector isn't stored in sorted order so do a linear
|
|
|
|
// search. This is for the super-cold and already-expensive toString()
|
|
|
|
// path and the number of exports is generally small.
|
|
|
|
for (const AsmJSExport& exp : asmJSExports) {
|
|
|
|
if (exp.funcIndex() == funcIndex)
|
|
|
|
return exp;
|
|
|
|
}
|
|
|
|
MOZ_CRASH("missing asm.js func export");
|
|
|
|
}
|
|
|
|
|
|
|
|
bool mutedErrors() const override {
|
|
|
|
return scriptSource.get()->mutedErrors();
|
|
|
|
}
|
|
|
|
const char16_t* displayURL() const override {
|
|
|
|
return scriptSource.get()->hasDisplayURL() ? scriptSource.get()->displayURL() : nullptr;
|
|
|
|
}
|
|
|
|
ScriptSource* maybeScriptSource() const override {
|
|
|
|
return scriptSource.get();
|
|
|
|
}
|
|
|
|
bool getFuncName(JSContext* cx, const Bytes*, uint32_t funcIndex,
|
|
|
|
TwoByteName* name) const override
|
|
|
|
{
|
|
|
|
// asm.js doesn't allow exporting imports or putting imports in tables
|
|
|
|
MOZ_ASSERT(funcIndex >= AsmJSFirstDefFuncIndex);
|
|
|
|
|
|
|
|
const char* p = asmJSFuncNames[funcIndex - AsmJSFirstDefFuncIndex].get();
|
|
|
|
UTF8Chars utf8(p, strlen(p));
|
|
|
|
|
|
|
|
size_t twoByteLength;
|
|
|
|
UniqueTwoByteChars chars(JS::UTF8CharsToNewTwoByteCharsZ(cx, utf8, &twoByteLength).get());
|
|
|
|
if (!chars)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!name->growByUninitialized(twoByteLength))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
PodCopy(name->begin(), chars.get(), twoByteLength);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
AsmJSMetadataCacheablePod& pod() { return *this; }
|
|
|
|
const AsmJSMetadataCacheablePod& pod() const { return *this; }
|
|
|
|
|
|
|
|
WASM_DECLARE_SERIALIZABLE_OVERRIDE(AsmJSMetadata)
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef RefPtr<AsmJSMetadata> MutableAsmJSMetadata;
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
// ParseNode utilities
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
NextNode(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return pn->pn_next;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
UnaryKid(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_UNARY));
|
|
|
|
return pn->pn_kid;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
BinaryRight(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_BINARY));
|
|
|
|
return pn->pn_right;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
BinaryLeft(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_BINARY));
|
|
|
|
return pn->pn_left;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
ReturnExpr(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_RETURN));
|
|
|
|
return UnaryKid(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
TernaryKid1(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_TERNARY));
|
|
|
|
return pn->pn_kid1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
TernaryKid2(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_TERNARY));
|
|
|
|
return pn->pn_kid2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
TernaryKid3(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_TERNARY));
|
|
|
|
return pn->pn_kid3;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
ListHead(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_LIST));
|
|
|
|
return pn->pn_head;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned
|
|
|
|
ListLength(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_LIST));
|
|
|
|
return pn->pn_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
CallCallee(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_CALL));
|
|
|
|
return ListHead(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned
|
|
|
|
CallArgListLength(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_CALL));
|
|
|
|
MOZ_ASSERT(ListLength(pn) >= 1);
|
|
|
|
return ListLength(pn) - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
CallArgList(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_CALL));
|
|
|
|
return NextNode(ListHead(pn));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
VarListHead(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_VAR) || pn->isKind(PNK_CONST));
|
|
|
|
return ListHead(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
IsDefaultCase(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return pn->as<CaseClause>().isDefault();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
CaseExpr(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return pn->as<CaseClause>().caseExpression();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
CaseBody(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return pn->as<CaseClause>().statementList();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
BinaryOpLeft(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isBinaryOperation());
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_LIST));
|
|
|
|
MOZ_ASSERT(pn->pn_count == 2);
|
|
|
|
return ListHead(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
BinaryOpRight(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isBinaryOperation());
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_LIST));
|
|
|
|
MOZ_ASSERT(pn->pn_count == 2);
|
|
|
|
return NextNode(ListHead(pn));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
BitwiseLeft(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return BinaryOpLeft(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
BitwiseRight(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return BinaryOpRight(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
MultiplyLeft(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_STAR));
|
|
|
|
return BinaryOpLeft(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
MultiplyRight(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_STAR));
|
|
|
|
return BinaryOpRight(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
AddSubLeft(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_ADD) || pn->isKind(PNK_SUB));
|
|
|
|
return BinaryOpLeft(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
AddSubRight(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_ADD) || pn->isKind(PNK_SUB));
|
|
|
|
return BinaryOpRight(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
DivOrModLeft(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_DIV) || pn->isKind(PNK_MOD));
|
|
|
|
return BinaryOpLeft(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
DivOrModRight(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_DIV) || pn->isKind(PNK_MOD));
|
|
|
|
return BinaryOpRight(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
ComparisonLeft(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return BinaryOpLeft(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
ComparisonRight(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return BinaryOpRight(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
IsExpressionStatement(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return pn->isKind(PNK_SEMI);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
ExpressionStatementExpr(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_SEMI));
|
|
|
|
return UnaryKid(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline PropertyName*
|
|
|
|
LoopControlMaybeLabel(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_BREAK) || pn->isKind(PNK_CONTINUE));
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_NULLARY));
|
|
|
|
return pn->as<LoopControlStatement>().label();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline PropertyName*
|
|
|
|
LabeledStatementLabel(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return pn->as<LabeledStatement>().label();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
LabeledStatementStatement(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return pn->as<LabeledStatement>().statement();
|
|
|
|
}
|
|
|
|
|
|
|
|
static double
|
|
|
|
NumberNodeValue(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_NUMBER));
|
|
|
|
return pn->pn_dval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
NumberNodeHasFrac(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_NUMBER));
|
|
|
|
return pn->pn_u.number.decimalPoint == HasDecimal;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ParseNode*
|
|
|
|
DotBase(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_DOT));
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_NAME));
|
|
|
|
return pn->expr();
|
|
|
|
}
|
|
|
|
|
|
|
|
static PropertyName*
|
|
|
|
DotMember(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_DOT));
|
|
|
|
MOZ_ASSERT(pn->isArity(PN_NAME));
|
|
|
|
return pn->pn_atom->asPropertyName();
|
|
|
|
}
|
|
|
|
|
|
|
|
static ParseNode*
|
|
|
|
ElemBase(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_ELEM));
|
|
|
|
return BinaryLeft(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ParseNode*
|
|
|
|
ElemIndex(ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pn->isKind(PNK_ELEM));
|
|
|
|
return BinaryRight(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline JSFunction*
|
|
|
|
FunctionObject(ParseNode* fn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(fn->isKind(PNK_FUNCTION));
|
|
|
|
MOZ_ASSERT(fn->isArity(PN_CODE));
|
|
|
|
return fn->pn_funbox->function();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline PropertyName*
|
|
|
|
FunctionName(ParseNode* fn)
|
|
|
|
{
|
|
|
|
if (JSAtom* name = FunctionObject(fn)->explicitName())
|
|
|
|
return name->asPropertyName();
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
FunctionStatementList(ParseNode* fn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(fn->pn_body->isKind(PNK_PARAMSBODY));
|
|
|
|
ParseNode* last = fn->pn_body->last();
|
|
|
|
MOZ_ASSERT(last->isKind(PNK_LEXICALSCOPE));
|
|
|
|
MOZ_ASSERT(last->isEmptyScope());
|
|
|
|
ParseNode* body = last->scopeBody();
|
|
|
|
MOZ_ASSERT(body->isKind(PNK_STATEMENTLIST));
|
|
|
|
return body;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
IsNormalObjectField(ExclusiveContext* cx, ParseNode* pn)
|
|
|
|
{
|
|
|
|
return pn->isKind(PNK_COLON) &&
|
|
|
|
pn->getOp() == JSOP_INITPROP &&
|
|
|
|
BinaryLeft(pn)->isKind(PNK_OBJECT_PROPERTY_NAME);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline PropertyName*
|
|
|
|
ObjectNormalFieldName(ExclusiveContext* cx, ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(IsNormalObjectField(cx, pn));
|
|
|
|
MOZ_ASSERT(BinaryLeft(pn)->isKind(PNK_OBJECT_PROPERTY_NAME));
|
|
|
|
return BinaryLeft(pn)->pn_atom->asPropertyName();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
ObjectNormalFieldInitializer(ExclusiveContext* cx, ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(IsNormalObjectField(cx, pn));
|
|
|
|
return BinaryRight(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
MaybeInitializer(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return pn->expr();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
IsUseOfName(ParseNode* pn, PropertyName* name)
|
|
|
|
{
|
|
|
|
return pn->isKind(PNK_NAME) && pn->name() == name;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
IsIgnoredDirectiveName(ExclusiveContext* cx, JSAtom* atom)
|
|
|
|
{
|
|
|
|
return atom != cx->names().useStrict;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
IsIgnoredDirective(ExclusiveContext* cx, ParseNode* pn)
|
|
|
|
{
|
|
|
|
return pn->isKind(PNK_SEMI) &&
|
|
|
|
UnaryKid(pn) &&
|
|
|
|
UnaryKid(pn)->isKind(PNK_STRING) &&
|
|
|
|
IsIgnoredDirectiveName(cx, UnaryKid(pn)->pn_atom);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
IsEmptyStatement(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return pn->isKind(PNK_SEMI) && !UnaryKid(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
SkipEmptyStatements(ParseNode* pn)
|
|
|
|
{
|
|
|
|
while (pn && IsEmptyStatement(pn))
|
|
|
|
pn = pn->pn_next;
|
|
|
|
return pn;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ParseNode*
|
|
|
|
NextNonEmptyStatement(ParseNode* pn)
|
|
|
|
{
|
|
|
|
return SkipEmptyStatements(pn->pn_next);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
GetToken(AsmJSParser& parser, TokenKind* tkp)
|
|
|
|
{
|
|
|
|
TokenStream& ts = parser.tokenStream;
|
|
|
|
TokenKind tk;
|
|
|
|
while (true) {
|
|
|
|
if (!ts.getToken(&tk, TokenStream::Operand))
|
|
|
|
return false;
|
|
|
|
if (tk != TOK_SEMI)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
*tkp = tk;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
PeekToken(AsmJSParser& parser, TokenKind* tkp)
|
|
|
|
{
|
|
|
|
TokenStream& ts = parser.tokenStream;
|
|
|
|
TokenKind tk;
|
|
|
|
while (true) {
|
|
|
|
if (!ts.peekToken(&tk, TokenStream::Operand))
|
|
|
|
return false;
|
|
|
|
if (tk != TOK_SEMI)
|
|
|
|
break;
|
|
|
|
ts.consumeKnownToken(TOK_SEMI, TokenStream::Operand);
|
|
|
|
}
|
|
|
|
*tkp = tk;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ParseVarOrConstStatement(AsmJSParser& parser, ParseNode** var)
|
|
|
|
{
|
|
|
|
TokenKind tk;
|
|
|
|
if (!PeekToken(parser, &tk))
|
|
|
|
return false;
|
|
|
|
if (tk != TOK_VAR && tk != TOK_CONST) {
|
|
|
|
*var = nullptr;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
*var = parser.statementListItem(YieldIsName);
|
|
|
|
if (!*var)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
MOZ_ASSERT((*var)->isKind(PNK_VAR) || (*var)->isKind(PNK_CONST));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
// Represents the type and value of an asm.js numeric literal.
|
|
|
|
//
|
|
|
|
// A literal is a double iff the literal contains a decimal point (even if the
|
|
|
|
// fractional part is 0). Otherwise, integers may be classified:
|
|
|
|
// fixnum: [0, 2^31)
|
|
|
|
// negative int: [-2^31, 0)
|
|
|
|
// big unsigned: [2^31, 2^32)
|
|
|
|
// out of range: otherwise
|
|
|
|
// Lastly, a literal may be a float literal which is any double or integer
|
|
|
|
// literal coerced with Math.fround.
|
|
|
|
//
|
|
|
|
// This class distinguishes between signed and unsigned integer SIMD types like
|
|
|
|
// Int32x4 and Uint32x4, and so does Type below. The wasm ValType and ExprType
|
|
|
|
// enums, and the wasm::Val class do not.
|
|
|
|
class NumLit
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
enum Which {
|
|
|
|
Fixnum,
|
|
|
|
NegativeInt,
|
|
|
|
BigUnsigned,
|
|
|
|
Double,
|
|
|
|
Float,
|
|
|
|
Int8x16,
|
|
|
|
Int16x8,
|
|
|
|
Int32x4,
|
|
|
|
Uint8x16,
|
|
|
|
Uint16x8,
|
|
|
|
Uint32x4,
|
|
|
|
Float32x4,
|
|
|
|
Bool8x16,
|
|
|
|
Bool16x8,
|
|
|
|
Bool32x4,
|
|
|
|
OutOfRangeInt = -1
|
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
|
|
|
Which which_;
|
|
|
|
union {
|
|
|
|
JS::UninitializedValue scalar_;
|
|
|
|
SimdConstant simd_;
|
|
|
|
} u;
|
|
|
|
|
|
|
|
public:
|
|
|
|
NumLit() = default;
|
|
|
|
|
|
|
|
NumLit(Which w, const Value& v) : which_(w) {
|
|
|
|
u.scalar_ = v;
|
|
|
|
MOZ_ASSERT(!isSimd());
|
|
|
|
}
|
|
|
|
|
|
|
|
NumLit(Which w, SimdConstant c) : which_(w) {
|
|
|
|
u.simd_ = c;
|
|
|
|
MOZ_ASSERT(isSimd());
|
|
|
|
}
|
|
|
|
|
|
|
|
Which which() const {
|
|
|
|
return which_;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t toInt32() const {
|
|
|
|
MOZ_ASSERT(which_ == Fixnum || which_ == NegativeInt || which_ == BigUnsigned);
|
|
|
|
return u.scalar_.asValueRef().toInt32();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t toUint32() const {
|
|
|
|
return (uint32_t)toInt32();
|
|
|
|
}
|
|
|
|
|
|
|
|
RawF64 toDouble() const {
|
|
|
|
MOZ_ASSERT(which_ == Double);
|
|
|
|
return RawF64(u.scalar_.asValueRef().toDouble());
|
|
|
|
}
|
|
|
|
|
|
|
|
RawF32 toFloat() const {
|
|
|
|
MOZ_ASSERT(which_ == Float);
|
|
|
|
return RawF32(float(u.scalar_.asValueRef().toDouble()));
|
|
|
|
}
|
|
|
|
|
|
|
|
Value scalarValue() const {
|
|
|
|
MOZ_ASSERT(which_ != OutOfRangeInt);
|
|
|
|
return u.scalar_.asValueRef();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isSimd() const
|
|
|
|
{
|
|
|
|
return which_ == Int8x16 || which_ == Uint8x16 || which_ == Int16x8 ||
|
|
|
|
which_ == Uint16x8 || which_ == Int32x4 || which_ == Uint32x4 ||
|
|
|
|
which_ == Float32x4 || which_ == Bool8x16 || which_ == Bool16x8 ||
|
|
|
|
which_ == Bool32x4;
|
|
|
|
}
|
|
|
|
|
|
|
|
const SimdConstant& simdValue() const {
|
|
|
|
MOZ_ASSERT(isSimd());
|
|
|
|
return u.simd_;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool valid() const {
|
|
|
|
return which_ != OutOfRangeInt;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isZeroBits() const {
|
|
|
|
MOZ_ASSERT(valid());
|
|
|
|
switch (which()) {
|
|
|
|
case NumLit::Fixnum:
|
|
|
|
case NumLit::NegativeInt:
|
|
|
|
case NumLit::BigUnsigned:
|
|
|
|
return toInt32() == 0;
|
|
|
|
case NumLit::Double:
|
|
|
|
return toDouble().bits() == 0;
|
|
|
|
case NumLit::Float:
|
|
|
|
return toFloat().bits() == 0;
|
|
|
|
case NumLit::Int8x16:
|
|
|
|
case NumLit::Uint8x16:
|
|
|
|
case NumLit::Bool8x16:
|
|
|
|
return simdValue() == SimdConstant::SplatX16(0);
|
|
|
|
case NumLit::Int16x8:
|
|
|
|
case NumLit::Uint16x8:
|
|
|
|
case NumLit::Bool16x8:
|
|
|
|
return simdValue() == SimdConstant::SplatX8(0);
|
|
|
|
case NumLit::Int32x4:
|
|
|
|
case NumLit::Uint32x4:
|
|
|
|
case NumLit::Bool32x4:
|
|
|
|
return simdValue() == SimdConstant::SplatX4(0);
|
|
|
|
case NumLit::Float32x4:
|
|
|
|
return simdValue() == SimdConstant::SplatX4(0.f);
|
|
|
|
case NumLit::OutOfRangeInt:
|
|
|
|
MOZ_CRASH("can't be here because of valid() check above");
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Val value() const {
|
|
|
|
switch (which_) {
|
|
|
|
case NumLit::Fixnum:
|
|
|
|
case NumLit::NegativeInt:
|
|
|
|
case NumLit::BigUnsigned:
|
|
|
|
return Val(toUint32());
|
|
|
|
case NumLit::Float:
|
|
|
|
return Val(toFloat());
|
|
|
|
case NumLit::Double:
|
|
|
|
return Val(toDouble());
|
|
|
|
case NumLit::Int8x16:
|
|
|
|
case NumLit::Uint8x16:
|
|
|
|
return Val(simdValue().asInt8x16());
|
|
|
|
case NumLit::Int16x8:
|
|
|
|
case NumLit::Uint16x8:
|
|
|
|
return Val(simdValue().asInt16x8());
|
|
|
|
case NumLit::Int32x4:
|
|
|
|
case NumLit::Uint32x4:
|
|
|
|
return Val(simdValue().asInt32x4());
|
|
|
|
case NumLit::Float32x4:
|
|
|
|
return Val(simdValue().asFloat32x4());
|
|
|
|
case NumLit::Bool8x16:
|
|
|
|
return Val(simdValue().asInt8x16(), ValType::B8x16);
|
|
|
|
case NumLit::Bool16x8:
|
|
|
|
return Val(simdValue().asInt16x8(), ValType::B16x8);
|
|
|
|
case NumLit::Bool32x4:
|
|
|
|
return Val(simdValue().asInt32x4(), ValType::B32x4);
|
|
|
|
case NumLit::OutOfRangeInt:;
|
|
|
|
}
|
|
|
|
MOZ_CRASH("bad literal");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Represents the type of a general asm.js expression.
|
|
|
|
//
|
|
|
|
// A canonical subset of types representing the coercion targets: Int, Float,
|
|
|
|
// Double, and the SIMD types. This is almost equivalent to wasm::ValType,
|
|
|
|
// except the integer SIMD types have signed/unsigned variants.
|
|
|
|
//
|
|
|
|
// Void is also part of the canonical subset which then maps to wasm::ExprType.
|
|
|
|
//
|
|
|
|
// Note that while the canonical subset distinguishes signed and unsigned SIMD
|
|
|
|
// types, it only uses |Int| to represent signed and unsigned 32-bit integers.
|
|
|
|
// This is because the scalar coersions x|0 and x>>>0 work with any kind of
|
|
|
|
// integer input, while the SIMD check functions throw a TypeError if the passed
|
|
|
|
// type doesn't match.
|
|
|
|
//
|
|
|
|
class Type
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
enum Which {
|
|
|
|
Fixnum = NumLit::Fixnum,
|
|
|
|
Signed = NumLit::NegativeInt,
|
|
|
|
Unsigned = NumLit::BigUnsigned,
|
|
|
|
DoubleLit = NumLit::Double,
|
|
|
|
Float = NumLit::Float,
|
|
|
|
Int8x16 = NumLit::Int8x16,
|
|
|
|
Int16x8 = NumLit::Int16x8,
|
|
|
|
Int32x4 = NumLit::Int32x4,
|
|
|
|
Uint8x16 = NumLit::Uint8x16,
|
|
|
|
Uint16x8 = NumLit::Uint16x8,
|
|
|
|
Uint32x4 = NumLit::Uint32x4,
|
|
|
|
Float32x4 = NumLit::Float32x4,
|
|
|
|
Bool8x16 = NumLit::Bool8x16,
|
|
|
|
Bool16x8 = NumLit::Bool16x8,
|
|
|
|
Bool32x4 = NumLit::Bool32x4,
|
|
|
|
Double,
|
|
|
|
MaybeDouble,
|
|
|
|
MaybeFloat,
|
|
|
|
Floatish,
|
|
|
|
Int,
|
|
|
|
Intish,
|
|
|
|
Void
|
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
|
|
|
Which which_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
Type() = default;
|
|
|
|
MOZ_IMPLICIT Type(Which w) : which_(w) {}
|
|
|
|
MOZ_IMPLICIT Type(SimdType type) {
|
|
|
|
switch (type) {
|
|
|
|
case SimdType::Int8x16: which_ = Int8x16; return;
|
|
|
|
case SimdType::Int16x8: which_ = Int16x8; return;
|
|
|
|
case SimdType::Int32x4: which_ = Int32x4; return;
|
|
|
|
case SimdType::Uint8x16: which_ = Uint8x16; return;
|
|
|
|
case SimdType::Uint16x8: which_ = Uint16x8; return;
|
|
|
|
case SimdType::Uint32x4: which_ = Uint32x4; return;
|
|
|
|
case SimdType::Float32x4: which_ = Float32x4; return;
|
|
|
|
case SimdType::Bool8x16: which_ = Bool8x16; return;
|
|
|
|
case SimdType::Bool16x8: which_ = Bool16x8; return;
|
|
|
|
case SimdType::Bool32x4: which_ = Bool32x4; return;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("bad SimdType");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Map an already canonicalized Type to the return type of a function call.
|
|
|
|
static Type ret(Type t) {
|
|
|
|
MOZ_ASSERT(t.isCanonical());
|
|
|
|
// The 32-bit external type is Signed, not Int.
|
|
|
|
return t.isInt() ? Signed: t;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Type lit(const NumLit& lit) {
|
|
|
|
MOZ_ASSERT(lit.valid());
|
|
|
|
Which which = Type::Which(lit.which());
|
|
|
|
MOZ_ASSERT(which >= Fixnum && which <= Bool32x4);
|
|
|
|
Type t;
|
|
|
|
t.which_ = which;
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Map |t| to one of the canonical vartype representations of a
|
|
|
|
// wasm::ExprType.
|
|
|
|
static Type canonicalize(Type t) {
|
|
|
|
switch(t.which()) {
|
|
|
|
case Fixnum:
|
|
|
|
case Signed:
|
|
|
|
case Unsigned:
|
|
|
|
case Int:
|
|
|
|
return Int;
|
|
|
|
|
|
|
|
case Float:
|
|
|
|
return Float;
|
|
|
|
|
|
|
|
case DoubleLit:
|
|
|
|
case Double:
|
|
|
|
return Double;
|
|
|
|
|
|
|
|
case Void:
|
|
|
|
return Void;
|
|
|
|
|
|
|
|
case Int8x16:
|
|
|
|
case Int16x8:
|
|
|
|
case Int32x4:
|
|
|
|
case Uint8x16:
|
|
|
|
case Uint16x8:
|
|
|
|
case Uint32x4:
|
|
|
|
case Float32x4:
|
|
|
|
case Bool8x16:
|
|
|
|
case Bool16x8:
|
|
|
|
case Bool32x4:
|
|
|
|
return t;
|
|
|
|
|
|
|
|
case MaybeDouble:
|
|
|
|
case MaybeFloat:
|
|
|
|
case Floatish:
|
|
|
|
case Intish:
|
|
|
|
// These types need some kind of coercion, they can't be mapped
|
|
|
|
// to an ExprType.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
MOZ_CRASH("Invalid vartype");
|
|
|
|
}
|
|
|
|
|
|
|
|
Which which() const { return which_; }
|
|
|
|
|
|
|
|
bool operator==(Type rhs) const { return which_ == rhs.which_; }
|
|
|
|
bool operator!=(Type rhs) const { return which_ != rhs.which_; }
|
|
|
|
|
|
|
|
bool operator<=(Type rhs) const {
|
|
|
|
switch (rhs.which_) {
|
|
|
|
case Signed: return isSigned();
|
|
|
|
case Unsigned: return isUnsigned();
|
|
|
|
case DoubleLit: return isDoubleLit();
|
|
|
|
case Double: return isDouble();
|
|
|
|
case Float: return isFloat();
|
|
|
|
case Int8x16: return isInt8x16();
|
|
|
|
case Int16x8: return isInt16x8();
|
|
|
|
case Int32x4: return isInt32x4();
|
|
|
|
case Uint8x16: return isUint8x16();
|
|
|
|
case Uint16x8: return isUint16x8();
|
|
|
|
case Uint32x4: return isUint32x4();
|
|
|
|
case Float32x4: return isFloat32x4();
|
|
|
|
case Bool8x16: return isBool8x16();
|
|
|
|
case Bool16x8: return isBool16x8();
|
|
|
|
case Bool32x4: return isBool32x4();
|
|
|
|
case MaybeDouble: return isMaybeDouble();
|
|
|
|
case MaybeFloat: return isMaybeFloat();
|
|
|
|
case Floatish: return isFloatish();
|
|
|
|
case Int: return isInt();
|
|
|
|
case Intish: return isIntish();
|
|
|
|
case Fixnum: return isFixnum();
|
|
|
|
case Void: return isVoid();
|
|
|
|
}
|
|
|
|
MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("unexpected rhs type");
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isFixnum() const {
|
|
|
|
return which_ == Fixnum;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isSigned() const {
|
|
|
|
return which_ == Signed || which_ == Fixnum;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isUnsigned() const {
|
|
|
|
return which_ == Unsigned || which_ == Fixnum;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isInt() const {
|
|
|
|
return isSigned() || isUnsigned() || which_ == Int;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isIntish() const {
|
|
|
|
return isInt() || which_ == Intish;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isDoubleLit() const {
|
|
|
|
return which_ == DoubleLit;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isDouble() const {
|
|
|
|
return isDoubleLit() || which_ == Double;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isMaybeDouble() const {
|
|
|
|
return isDouble() || which_ == MaybeDouble;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isFloat() const {
|
|
|
|
return which_ == Float;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isMaybeFloat() const {
|
|
|
|
return isFloat() || which_ == MaybeFloat;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isFloatish() const {
|
|
|
|
return isMaybeFloat() || which_ == Floatish;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isVoid() const {
|
|
|
|
return which_ == Void;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isExtern() const {
|
|
|
|
return isDouble() || isSigned();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isInt8x16() const {
|
|
|
|
return which_ == Int8x16;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isInt16x8() const {
|
|
|
|
return which_ == Int16x8;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isInt32x4() const {
|
|
|
|
return which_ == Int32x4;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isUint8x16() const {
|
|
|
|
return which_ == Uint8x16;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isUint16x8() const {
|
|
|
|
return which_ == Uint16x8;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isUint32x4() const {
|
|
|
|
return which_ == Uint32x4;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isFloat32x4() const {
|
|
|
|
return which_ == Float32x4;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isBool8x16() const {
|
|
|
|
return which_ == Bool8x16;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isBool16x8() const {
|
|
|
|
return which_ == Bool16x8;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isBool32x4() const {
|
|
|
|
return which_ == Bool32x4;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isSimd() const {
|
|
|
|
return isInt8x16() || isInt16x8() || isInt32x4() || isUint8x16() || isUint16x8() ||
|
|
|
|
isUint32x4() || isFloat32x4() || isBool8x16() || isBool16x8() || isBool32x4();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isUnsignedSimd() const {
|
|
|
|
return isUint8x16() || isUint16x8() || isUint32x4();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if this is one of the valid types for a function argument.
|
|
|
|
bool isArgType() const {
|
|
|
|
return isInt() || isFloat() || isDouble() || (isSimd() && !isUnsignedSimd());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if this is one of the valid types for a function return value.
|
|
|
|
bool isReturnType() const {
|
|
|
|
return isSigned() || isFloat() || isDouble() || (isSimd() && !isUnsignedSimd()) ||
|
|
|
|
isVoid();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if this is one of the valid types for a global variable.
|
|
|
|
bool isGlobalVarType() const {
|
|
|
|
return isArgType();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if this is one of the canonical vartype representations of a
|
|
|
|
// wasm::ExprType. See Type::canonicalize().
|
|
|
|
bool isCanonical() const {
|
|
|
|
switch (which()) {
|
|
|
|
case Int:
|
|
|
|
case Float:
|
|
|
|
case Double:
|
|
|
|
case Void:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return isSimd();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if this is a canonical representation of a wasm::ValType.
|
|
|
|
bool isCanonicalValType() const {
|
|
|
|
return !isVoid() && isCanonical();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert this canonical type to a wasm::ExprType.
|
|
|
|
ExprType canonicalToExprType() const {
|
|
|
|
switch (which()) {
|
|
|
|
case Int: return ExprType::I32;
|
|
|
|
case Float: return ExprType::F32;
|
|
|
|
case Double: return ExprType::F64;
|
|
|
|
case Void: return ExprType::Void;
|
|
|
|
case Uint8x16:
|
|
|
|
case Int8x16: return ExprType::I8x16;
|
|
|
|
case Uint16x8:
|
|
|
|
case Int16x8: return ExprType::I16x8;
|
|
|
|
case Uint32x4:
|
|
|
|
case Int32x4: return ExprType::I32x4;
|
|
|
|
case Float32x4: return ExprType::F32x4;
|
|
|
|
case Bool8x16: return ExprType::B8x16;
|
|
|
|
case Bool16x8: return ExprType::B16x8;
|
|
|
|
case Bool32x4: return ExprType::B32x4;
|
|
|
|
default: MOZ_CRASH("Need canonical type");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert this canonical type to a wasm::ValType.
|
|
|
|
ValType canonicalToValType() const {
|
|
|
|
return NonVoidToValType(canonicalToExprType());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert this type to a wasm::ExprType for use in a wasm
|
|
|
|
// block signature. This works for all types, including non-canonical
|
|
|
|
// ones. Consequently, the type isn't valid for subsequent asm.js
|
|
|
|
// validation; it's only valid for use in producing wasm.
|
|
|
|
ExprType toWasmBlockSignatureType() const {
|
|
|
|
switch (which()) {
|
|
|
|
case Fixnum:
|
|
|
|
case Signed:
|
|
|
|
case Unsigned:
|
|
|
|
case Int:
|
|
|
|
case Intish:
|
|
|
|
return ExprType::I32;
|
|
|
|
|
|
|
|
case Float:
|
|
|
|
case MaybeFloat:
|
|
|
|
case Floatish:
|
|
|
|
return ExprType::F32;
|
|
|
|
|
|
|
|
case DoubleLit:
|
|
|
|
case Double:
|
|
|
|
case MaybeDouble:
|
|
|
|
return ExprType::F64;
|
|
|
|
|
|
|
|
case Void:
|
|
|
|
return ExprType::Void;
|
|
|
|
|
|
|
|
case Uint8x16:
|
|
|
|
case Int8x16: return ExprType::I8x16;
|
|
|
|
case Uint16x8:
|
|
|
|
case Int16x8: return ExprType::I16x8;
|
|
|
|
case Uint32x4:
|
|
|
|
case Int32x4: return ExprType::I32x4;
|
|
|
|
case Float32x4: return ExprType::F32x4;
|
|
|
|
case Bool8x16: return ExprType::B8x16;
|
|
|
|
case Bool16x8: return ExprType::B16x8;
|
|
|
|
case Bool32x4: return ExprType::B32x4;
|
|
|
|
}
|
|
|
|
MOZ_CRASH("Invalid Type");
|
|
|
|
}
|
|
|
|
|
|
|
|
const char* toChars() const {
|
|
|
|
switch (which_) {
|
|
|
|
case Double: return "double";
|
|
|
|
case DoubleLit: return "doublelit";
|
|
|
|
case MaybeDouble: return "double?";
|
|
|
|
case Float: return "float";
|
|
|
|
case Floatish: return "floatish";
|
|
|
|
case MaybeFloat: return "float?";
|
|
|
|
case Fixnum: return "fixnum";
|
|
|
|
case Int: return "int";
|
|
|
|
case Signed: return "signed";
|
|
|
|
case Unsigned: return "unsigned";
|
|
|
|
case Intish: return "intish";
|
|
|
|
case Int8x16: return "int8x16";
|
|
|
|
case Int16x8: return "int16x8";
|
|
|
|
case Int32x4: return "int32x4";
|
|
|
|
case Uint8x16: return "uint8x16";
|
|
|
|
case Uint16x8: return "uint16x8";
|
|
|
|
case Uint32x4: return "uint32x4";
|
|
|
|
case Float32x4: return "float32x4";
|
|
|
|
case Bool8x16: return "bool8x16";
|
|
|
|
case Bool16x8: return "bool16x8";
|
|
|
|
case Bool32x4: return "bool32x4";
|
|
|
|
case Void: return "void";
|
|
|
|
}
|
|
|
|
MOZ_CRASH("Invalid Type");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const unsigned VALIDATION_LIFO_DEFAULT_CHUNK_SIZE = 4 * 1024;
|
|
|
|
|
|
|
|
// The ModuleValidator encapsulates the entire validation of an asm.js module.
|
|
|
|
// Its lifetime goes from the validation of the top components of an asm.js
|
|
|
|
// module (all the globals), the emission of bytecode for all the functions in
|
|
|
|
// the module and the validation of function's pointer tables. It also finishes
|
|
|
|
// the compilation of all the module's stubs.
|
|
|
|
//
|
|
|
|
// Rooting note: ModuleValidator is a stack class that contains unrooted
|
|
|
|
// PropertyName (JSAtom) pointers. This is safe because it cannot be
|
|
|
|
// constructed without a TokenStream reference. TokenStream is itself a stack
|
|
|
|
// class that cannot be constructed without an AutoKeepAtoms being live on the
|
|
|
|
// stack, which prevents collection of atoms.
|
|
|
|
//
|
|
|
|
// ModuleValidator is marked as rooted in the rooting analysis. Don't add
|
|
|
|
// non-JSAtom pointers, or this will break!
|
|
|
|
class MOZ_STACK_CLASS ModuleValidator
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
class Func
|
|
|
|
{
|
|
|
|
PropertyName* name_;
|
|
|
|
uint32_t firstUse_;
|
|
|
|
uint32_t index_;
|
|
|
|
uint32_t srcBegin_;
|
|
|
|
uint32_t srcEnd_;
|
|
|
|
bool defined_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
Func(PropertyName* name, uint32_t firstUse, uint32_t index)
|
|
|
|
: name_(name), firstUse_(firstUse), index_(index),
|
|
|
|
srcBegin_(0), srcEnd_(0), defined_(false)
|
|
|
|
{}
|
|
|
|
|
|
|
|
PropertyName* name() const { return name_; }
|
|
|
|
uint32_t firstUse() const { return firstUse_; }
|
|
|
|
bool defined() const { return defined_; }
|
|
|
|
uint32_t index() const { return index_; }
|
|
|
|
|
|
|
|
void define(ParseNode* fn) {
|
|
|
|
MOZ_ASSERT(!defined_);
|
|
|
|
defined_ = true;
|
|
|
|
srcBegin_ = fn->pn_pos.begin;
|
|
|
|
srcEnd_ = fn->pn_pos.end;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t srcBegin() const { MOZ_ASSERT(defined_); return srcBegin_; }
|
|
|
|
uint32_t srcEnd() const { MOZ_ASSERT(defined_); return srcEnd_; }
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef Vector<const Func*> ConstFuncVector;
|
|
|
|
typedef Vector<Func*> FuncVector;
|
|
|
|
|
|
|
|
class FuncPtrTable
|
|
|
|
{
|
|
|
|
uint32_t sigIndex_;
|
|
|
|
PropertyName* name_;
|
|
|
|
uint32_t firstUse_;
|
|
|
|
uint32_t mask_;
|
|
|
|
bool defined_;
|
|
|
|
|
|
|
|
FuncPtrTable(FuncPtrTable&& rhs) = delete;
|
|
|
|
|
|
|
|
public:
|
|
|
|
FuncPtrTable(uint32_t sigIndex, PropertyName* name, uint32_t firstUse, uint32_t mask)
|
|
|
|
: sigIndex_(sigIndex), name_(name), firstUse_(firstUse), mask_(mask), defined_(false)
|
|
|
|
{}
|
|
|
|
|
|
|
|
uint32_t sigIndex() const { return sigIndex_; }
|
|
|
|
PropertyName* name() const { return name_; }
|
|
|
|
uint32_t firstUse() const { return firstUse_; }
|
|
|
|
unsigned mask() const { return mask_; }
|
|
|
|
bool defined() const { return defined_; }
|
|
|
|
void define() { MOZ_ASSERT(!defined_); defined_ = true; }
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef Vector<FuncPtrTable*> FuncPtrTableVector;
|
|
|
|
|
|
|
|
class Global
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
enum Which {
|
|
|
|
Variable,
|
|
|
|
ConstantLiteral,
|
|
|
|
ConstantImport,
|
|
|
|
Function,
|
|
|
|
FuncPtrTable,
|
|
|
|
FFI,
|
|
|
|
ArrayView,
|
|
|
|
ArrayViewCtor,
|
|
|
|
MathBuiltinFunction,
|
|
|
|
AtomicsBuiltinFunction,
|
|
|
|
SimdCtor,
|
|
|
|
SimdOp
|
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
|
|
|
Which which_;
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
Type::Which type_;
|
|
|
|
unsigned index_;
|
|
|
|
NumLit literalValue_;
|
|
|
|
} varOrConst;
|
|
|
|
uint32_t funcIndex_;
|
|
|
|
uint32_t funcPtrTableIndex_;
|
|
|
|
uint32_t ffiIndex_;
|
|
|
|
struct {
|
|
|
|
Scalar::Type viewType_;
|
|
|
|
} viewInfo;
|
|
|
|
AsmJSMathBuiltinFunction mathBuiltinFunc_;
|
|
|
|
AsmJSAtomicsBuiltinFunction atomicsBuiltinFunc_;
|
|
|
|
SimdType simdCtorType_;
|
|
|
|
struct {
|
|
|
|
SimdType type_;
|
|
|
|
SimdOperation which_;
|
|
|
|
} simdOp;
|
|
|
|
} u;
|
|
|
|
|
|
|
|
friend class ModuleValidator;
|
|
|
|
friend class js::LifoAlloc;
|
|
|
|
|
|
|
|
explicit Global(Which which) : which_(which) {}
|
|
|
|
|
|
|
|
public:
|
|
|
|
Which which() const {
|
|
|
|
return which_;
|
|
|
|
}
|
|
|
|
Type varOrConstType() const {
|
|
|
|
MOZ_ASSERT(which_ == Variable || which_ == ConstantLiteral || which_ == ConstantImport);
|
|
|
|
return u.varOrConst.type_;
|
|
|
|
}
|
|
|
|
unsigned varOrConstIndex() const {
|
|
|
|
MOZ_ASSERT(which_ == Variable || which_ == ConstantImport);
|
|
|
|
return u.varOrConst.index_;
|
|
|
|
}
|
|
|
|
bool isConst() const {
|
|
|
|
return which_ == ConstantLiteral || which_ == ConstantImport;
|
|
|
|
}
|
|
|
|
NumLit constLiteralValue() const {
|
|
|
|
MOZ_ASSERT(which_ == ConstantLiteral);
|
|
|
|
return u.varOrConst.literalValue_;
|
|
|
|
}
|
|
|
|
uint32_t funcIndex() const {
|
|
|
|
MOZ_ASSERT(which_ == Function);
|
|
|
|
return u.funcIndex_;
|
|
|
|
}
|
|
|
|
uint32_t funcPtrTableIndex() const {
|
|
|
|
MOZ_ASSERT(which_ == FuncPtrTable);
|
|
|
|
return u.funcPtrTableIndex_;
|
|
|
|
}
|
|
|
|
unsigned ffiIndex() const {
|
|
|
|
MOZ_ASSERT(which_ == FFI);
|
|
|
|
return u.ffiIndex_;
|
|
|
|
}
|
|
|
|
bool isAnyArrayView() const {
|
|
|
|
return which_ == ArrayView || which_ == ArrayViewCtor;
|
|
|
|
}
|
|
|
|
Scalar::Type viewType() const {
|
|
|
|
MOZ_ASSERT(isAnyArrayView());
|
|
|
|
return u.viewInfo.viewType_;
|
|
|
|
}
|
|
|
|
bool isMathFunction() const {
|
|
|
|
return which_ == MathBuiltinFunction;
|
|
|
|
}
|
|
|
|
AsmJSMathBuiltinFunction mathBuiltinFunction() const {
|
|
|
|
MOZ_ASSERT(which_ == MathBuiltinFunction);
|
|
|
|
return u.mathBuiltinFunc_;
|
|
|
|
}
|
|
|
|
bool isAtomicsFunction() const {
|
|
|
|
return which_ == AtomicsBuiltinFunction;
|
|
|
|
}
|
|
|
|
AsmJSAtomicsBuiltinFunction atomicsBuiltinFunction() const {
|
|
|
|
MOZ_ASSERT(which_ == AtomicsBuiltinFunction);
|
|
|
|
return u.atomicsBuiltinFunc_;
|
|
|
|
}
|
|
|
|
bool isSimdCtor() const {
|
|
|
|
return which_ == SimdCtor;
|
|
|
|
}
|
|
|
|
SimdType simdCtorType() const {
|
|
|
|
MOZ_ASSERT(which_ == SimdCtor);
|
|
|
|
return u.simdCtorType_;
|
|
|
|
}
|
|
|
|
bool isSimdOperation() const {
|
|
|
|
return which_ == SimdOp;
|
|
|
|
}
|
|
|
|
SimdOperation simdOperation() const {
|
|
|
|
MOZ_ASSERT(which_ == SimdOp);
|
|
|
|
return u.simdOp.which_;
|
|
|
|
}
|
|
|
|
SimdType simdOperationType() const {
|
|
|
|
MOZ_ASSERT(which_ == SimdOp);
|
|
|
|
return u.simdOp.type_;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct MathBuiltin
|
|
|
|
{
|
|
|
|
enum Kind { Function, Constant };
|
|
|
|
Kind kind;
|
|
|
|
|
|
|
|
union {
|
|
|
|
double cst;
|
|
|
|
AsmJSMathBuiltinFunction func;
|
|
|
|
} u;
|
|
|
|
|
|
|
|
MathBuiltin() : kind(Kind(-1)) {}
|
|
|
|
explicit MathBuiltin(double cst) : kind(Constant) {
|
|
|
|
u.cst = cst;
|
|
|
|
}
|
|
|
|
explicit MathBuiltin(AsmJSMathBuiltinFunction func) : kind(Function) {
|
|
|
|
u.func = func;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ArrayView
|
|
|
|
{
|
|
|
|
ArrayView(PropertyName* name, Scalar::Type type)
|
|
|
|
: name(name), type(type)
|
|
|
|
{}
|
|
|
|
|
|
|
|
PropertyName* name;
|
|
|
|
Scalar::Type type;
|
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
|
|
|
class NamedSig
|
|
|
|
{
|
|
|
|
PropertyName* name_;
|
|
|
|
const SigWithId* sig_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
NamedSig(PropertyName* name, const SigWithId& sig)
|
|
|
|
: name_(name), sig_(&sig)
|
|
|
|
{}
|
|
|
|
PropertyName* name() const {
|
|
|
|
return name_;
|
|
|
|
}
|
|
|
|
const Sig& sig() const {
|
|
|
|
return *sig_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Implement HashPolicy:
|
|
|
|
struct Lookup {
|
|
|
|
PropertyName* name;
|
|
|
|
const Sig& sig;
|
|
|
|
Lookup(PropertyName* name, const Sig& sig) : name(name), sig(sig) {}
|
|
|
|
};
|
|
|
|
static HashNumber hash(Lookup l) {
|
|
|
|
return HashGeneric(l.name, l.sig.hash());
|
|
|
|
}
|
|
|
|
static bool match(NamedSig lhs, Lookup rhs) {
|
|
|
|
return lhs.name_ == rhs.name && *lhs.sig_ == rhs.sig;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
typedef HashMap<NamedSig, uint32_t, NamedSig> ImportMap;
|
|
|
|
typedef HashMap<const SigWithId*, uint32_t, SigHashPolicy> SigMap;
|
|
|
|
typedef HashMap<PropertyName*, Global*> GlobalMap;
|
|
|
|
typedef HashMap<PropertyName*, MathBuiltin> MathNameMap;
|
|
|
|
typedef HashMap<PropertyName*, AsmJSAtomicsBuiltinFunction> AtomicsNameMap;
|
|
|
|
typedef HashMap<PropertyName*, SimdOperation> SimdOperationNameMap;
|
|
|
|
typedef Vector<ArrayView> ArrayViewVector;
|
|
|
|
|
|
|
|
ExclusiveContext* cx_;
|
|
|
|
AsmJSParser& parser_;
|
|
|
|
ParseNode* moduleFunctionNode_;
|
|
|
|
PropertyName* moduleFunctionName_;
|
|
|
|
PropertyName* globalArgumentName_;
|
|
|
|
PropertyName* importArgumentName_;
|
|
|
|
PropertyName* bufferArgumentName_;
|
|
|
|
MathNameMap standardLibraryMathNames_;
|
|
|
|
AtomicsNameMap standardLibraryAtomicsNames_;
|
|
|
|
SimdOperationNameMap standardLibrarySimdOpNames_;
|
|
|
|
RootedFunction dummyFunction_;
|
|
|
|
|
|
|
|
// Validation-internal state:
|
|
|
|
LifoAlloc validationLifo_;
|
|
|
|
FuncVector functions_;
|
|
|
|
FuncPtrTableVector funcPtrTables_;
|
|
|
|
GlobalMap globalMap_;
|
|
|
|
SigMap sigMap_;
|
|
|
|
ImportMap importMap_;
|
|
|
|
ArrayViewVector arrayViews_;
|
|
|
|
bool atomicsPresent_;
|
|
|
|
bool simdPresent_;
|
|
|
|
|
|
|
|
// State used to build the AsmJSModule in finish():
|
|
|
|
ModuleGenerator mg_;
|
|
|
|
MutableAsmJSMetadata asmJSMetadata_;
|
|
|
|
|
|
|
|
// Error reporting:
|
|
|
|
UniqueChars errorString_;
|
|
|
|
uint32_t errorOffset_;
|
|
|
|
bool errorOverRecursed_;
|
|
|
|
|
|
|
|
// Helpers:
|
|
|
|
bool addStandardLibraryMathName(const char* name, AsmJSMathBuiltinFunction func) {
|
|
|
|
JSAtom* atom = Atomize(cx_, name, strlen(name));
|
|
|
|
if (!atom)
|
|
|
|
return false;
|
|
|
|
MathBuiltin builtin(func);
|
|
|
|
return standardLibraryMathNames_.putNew(atom->asPropertyName(), builtin);
|
|
|
|
}
|
|
|
|
bool addStandardLibraryMathName(const char* name, double cst) {
|
|
|
|
JSAtom* atom = Atomize(cx_, name, strlen(name));
|
|
|
|
if (!atom)
|
|
|
|
return false;
|
|
|
|
MathBuiltin builtin(cst);
|
|
|
|
return standardLibraryMathNames_.putNew(atom->asPropertyName(), builtin);
|
|
|
|
}
|
|
|
|
bool addStandardLibraryAtomicsName(const char* name, AsmJSAtomicsBuiltinFunction func) {
|
|
|
|
JSAtom* atom = Atomize(cx_, name, strlen(name));
|
|
|
|
if (!atom)
|
|
|
|
return false;
|
|
|
|
return standardLibraryAtomicsNames_.putNew(atom->asPropertyName(), func);
|
|
|
|
}
|
|
|
|
bool addStandardLibrarySimdOpName(const char* name, SimdOperation op) {
|
|
|
|
JSAtom* atom = Atomize(cx_, name, strlen(name));
|
|
|
|
if (!atom)
|
|
|
|
return false;
|
|
|
|
return standardLibrarySimdOpNames_.putNew(atom->asPropertyName(), op);
|
|
|
|
}
|
|
|
|
bool newSig(Sig&& sig, uint32_t* sigIndex) {
|
|
|
|
*sigIndex = 0;
|
|
|
|
if (mg_.numSigs() >= MaxSigs)
|
|
|
|
return failCurrentOffset("too many signatures");
|
|
|
|
|
|
|
|
*sigIndex = mg_.numSigs();
|
|
|
|
mg_.initSig(*sigIndex, Move(sig));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool declareSig(Sig&& sig, uint32_t* sigIndex) {
|
|
|
|
SigMap::AddPtr p = sigMap_.lookupForAdd(sig);
|
|
|
|
if (p) {
|
|
|
|
*sigIndex = p->value();
|
|
|
|
MOZ_ASSERT(mg_.sig(*sigIndex) == sig);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return newSig(Move(sig), sigIndex) &&
|
|
|
|
sigMap_.add(p, &mg_.sig(*sigIndex), *sigIndex);
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
ModuleValidator(ExclusiveContext* cx, AsmJSParser& parser, ParseNode* moduleFunctionNode)
|
|
|
|
: cx_(cx),
|
|
|
|
parser_(parser),
|
|
|
|
moduleFunctionNode_(moduleFunctionNode),
|
|
|
|
moduleFunctionName_(FunctionName(moduleFunctionNode)),
|
|
|
|
globalArgumentName_(nullptr),
|
|
|
|
importArgumentName_(nullptr),
|
|
|
|
bufferArgumentName_(nullptr),
|
|
|
|
standardLibraryMathNames_(cx),
|
|
|
|
standardLibraryAtomicsNames_(cx),
|
|
|
|
standardLibrarySimdOpNames_(cx),
|
|
|
|
dummyFunction_(cx),
|
|
|
|
validationLifo_(VALIDATION_LIFO_DEFAULT_CHUNK_SIZE),
|
|
|
|
functions_(cx),
|
|
|
|
funcPtrTables_(cx),
|
|
|
|
globalMap_(cx),
|
|
|
|
sigMap_(cx),
|
|
|
|
importMap_(cx),
|
|
|
|
arrayViews_(cx),
|
|
|
|
atomicsPresent_(false),
|
|
|
|
simdPresent_(false),
|
|
|
|
mg_(ImportVector()),
|
|
|
|
errorString_(nullptr),
|
|
|
|
errorOffset_(UINT32_MAX),
|
|
|
|
errorOverRecursed_(false)
|
|
|
|
{}
|
|
|
|
|
|
|
|
~ModuleValidator() {
|
|
|
|
if (errorString_) {
|
|
|
|
MOZ_ASSERT(errorOffset_ != UINT32_MAX);
|
|
|
|
tokenStream().reportAsmJSError(errorOffset_,
|
|
|
|
JSMSG_USE_ASM_TYPE_FAIL,
|
|
|
|
errorString_.get());
|
|
|
|
}
|
|
|
|
if (errorOverRecursed_)
|
|
|
|
ReportOverRecursed(cx_);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool init() {
|
|
|
|
asmJSMetadata_ = cx_->new_<AsmJSMetadata>();
|
|
|
|
if (!asmJSMetadata_)
|
|
|
|
return false;
|
|
|
|
|
2019-09-05 10:06:35 -07:00
|
|
|
asmJSMetadata_->toStringStart = moduleFunctionNode_->pn_funbox->toStringStart;
|
2019-03-11 03:26:37 -07:00
|
|
|
asmJSMetadata_->srcStart = moduleFunctionNode_->pn_body->pn_pos.begin;
|
|
|
|
asmJSMetadata_->srcBodyStart = parser_.tokenStream.currentToken().pos.end;
|
|
|
|
asmJSMetadata_->strict = parser_.pc->sc()->strict() &&
|
|
|
|
!parser_.pc->sc()->hasExplicitUseStrict();
|
|
|
|
asmJSMetadata_->scriptSource.reset(parser_.ss);
|
|
|
|
|
|
|
|
if (!globalMap_.init() || !sigMap_.init() || !importMap_.init())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!standardLibraryMathNames_.init() ||
|
|
|
|
!addStandardLibraryMathName("sin", AsmJSMathBuiltin_sin) ||
|
|
|
|
!addStandardLibraryMathName("cos", AsmJSMathBuiltin_cos) ||
|
|
|
|
!addStandardLibraryMathName("tan", AsmJSMathBuiltin_tan) ||
|
|
|
|
!addStandardLibraryMathName("asin", AsmJSMathBuiltin_asin) ||
|
|
|
|
!addStandardLibraryMathName("acos", AsmJSMathBuiltin_acos) ||
|
|
|
|
!addStandardLibraryMathName("atan", AsmJSMathBuiltin_atan) ||
|
|
|
|
!addStandardLibraryMathName("ceil", AsmJSMathBuiltin_ceil) ||
|
|
|
|
!addStandardLibraryMathName("floor", AsmJSMathBuiltin_floor) ||
|
|
|
|
!addStandardLibraryMathName("exp", AsmJSMathBuiltin_exp) ||
|
|
|
|
!addStandardLibraryMathName("log", AsmJSMathBuiltin_log) ||
|
|
|
|
!addStandardLibraryMathName("pow", AsmJSMathBuiltin_pow) ||
|
|
|
|
!addStandardLibraryMathName("sqrt", AsmJSMathBuiltin_sqrt) ||
|
|
|
|
!addStandardLibraryMathName("abs", AsmJSMathBuiltin_abs) ||
|
|
|
|
!addStandardLibraryMathName("atan2", AsmJSMathBuiltin_atan2) ||
|
|
|
|
!addStandardLibraryMathName("imul", AsmJSMathBuiltin_imul) ||
|
|
|
|
!addStandardLibraryMathName("clz32", AsmJSMathBuiltin_clz32) ||
|
|
|
|
!addStandardLibraryMathName("fround", AsmJSMathBuiltin_fround) ||
|
|
|
|
!addStandardLibraryMathName("min", AsmJSMathBuiltin_min) ||
|
|
|
|
!addStandardLibraryMathName("max", AsmJSMathBuiltin_max) ||
|
|
|
|
!addStandardLibraryMathName("E", M_E) ||
|
|
|
|
!addStandardLibraryMathName("LN10", M_LN10) ||
|
|
|
|
!addStandardLibraryMathName("LN2", M_LN2) ||
|
|
|
|
!addStandardLibraryMathName("LOG2E", M_LOG2E) ||
|
|
|
|
!addStandardLibraryMathName("LOG10E", M_LOG10E) ||
|
|
|
|
!addStandardLibraryMathName("PI", M_PI) ||
|
|
|
|
!addStandardLibraryMathName("SQRT1_2", M_SQRT1_2) ||
|
|
|
|
!addStandardLibraryMathName("SQRT2", M_SQRT2))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!standardLibraryAtomicsNames_.init() ||
|
|
|
|
!addStandardLibraryAtomicsName("compareExchange", AsmJSAtomicsBuiltin_compareExchange) ||
|
|
|
|
!addStandardLibraryAtomicsName("exchange", AsmJSAtomicsBuiltin_exchange) ||
|
|
|
|
!addStandardLibraryAtomicsName("load", AsmJSAtomicsBuiltin_load) ||
|
|
|
|
!addStandardLibraryAtomicsName("store", AsmJSAtomicsBuiltin_store) ||
|
|
|
|
!addStandardLibraryAtomicsName("add", AsmJSAtomicsBuiltin_add) ||
|
|
|
|
!addStandardLibraryAtomicsName("sub", AsmJSAtomicsBuiltin_sub) ||
|
|
|
|
!addStandardLibraryAtomicsName("and", AsmJSAtomicsBuiltin_and) ||
|
|
|
|
!addStandardLibraryAtomicsName("or", AsmJSAtomicsBuiltin_or) ||
|
|
|
|
!addStandardLibraryAtomicsName("xor", AsmJSAtomicsBuiltin_xor) ||
|
|
|
|
!addStandardLibraryAtomicsName("isLockFree", AsmJSAtomicsBuiltin_isLockFree))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ADDSTDLIBSIMDOPNAME(op) || !addStandardLibrarySimdOpName(#op, SimdOperation::Fn_##op)
|
|
|
|
if (!standardLibrarySimdOpNames_.init()
|
|
|
|
FORALL_SIMD_ASMJS_OP(ADDSTDLIBSIMDOPNAME))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#undef ADDSTDLIBSIMDOPNAME
|
|
|
|
|
|
|
|
// This flows into FunctionBox, so must be tenured.
|
|
|
|
dummyFunction_ = NewScriptedFunction(cx_, 0, JSFunction::INTERPRETED, nullptr,
|
|
|
|
/* proto = */ nullptr, gc::AllocKind::FUNCTION,
|
|
|
|
TenuredObject);
|
|
|
|
if (!dummyFunction_)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ScriptedCaller scriptedCaller;
|
|
|
|
if (parser_.ss->filename()) {
|
|
|
|
scriptedCaller.line = scriptedCaller.column = 0; // unused
|
|
|
|
scriptedCaller.filename = DuplicateString(parser_.ss->filename());
|
|
|
|
if (!scriptedCaller.filename)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
CompileArgs args;
|
|
|
|
if (!args.initFromContext(cx_, Move(scriptedCaller)))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
auto genData = MakeUnique<ModuleGeneratorData>(ModuleKind::AsmJS);
|
|
|
|
if (!genData ||
|
|
|
|
!genData->sigs.resize(MaxSigs) ||
|
|
|
|
!genData->funcSigs.resize(MaxFuncs) ||
|
|
|
|
!genData->funcImportGlobalDataOffsets.resize(AsmJSMaxImports) ||
|
|
|
|
!genData->tables.resize(MaxTables) ||
|
|
|
|
!genData->asmJSSigToTableIndex.resize(MaxSigs))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
genData->minMemoryLength = RoundUpToNextValidAsmJSHeapLength(0);
|
|
|
|
|
|
|
|
if (!mg_.init(Move(genData), args, asmJSMetadata_.get()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
ExclusiveContext* cx() const { return cx_; }
|
|
|
|
PropertyName* moduleFunctionName() const { return moduleFunctionName_; }
|
|
|
|
PropertyName* globalArgumentName() const { return globalArgumentName_; }
|
|
|
|
PropertyName* importArgumentName() const { return importArgumentName_; }
|
|
|
|
PropertyName* bufferArgumentName() const { return bufferArgumentName_; }
|
|
|
|
ModuleGenerator& mg() { return mg_; }
|
|
|
|
AsmJSParser& parser() const { return parser_; }
|
|
|
|
TokenStream& tokenStream() const { return parser_.tokenStream; }
|
|
|
|
RootedFunction& dummyFunction() { return dummyFunction_; }
|
|
|
|
bool supportsSimd() const { return cx_->jitSupportsSimd(); }
|
|
|
|
bool atomicsPresent() const { return atomicsPresent_; }
|
|
|
|
uint32_t minMemoryLength() const { return mg_.minMemoryLength(); }
|
|
|
|
|
|
|
|
void initModuleFunctionName(PropertyName* name) {
|
|
|
|
MOZ_ASSERT(!moduleFunctionName_);
|
|
|
|
moduleFunctionName_ = name;
|
|
|
|
}
|
|
|
|
MOZ_MUST_USE bool initGlobalArgumentName(PropertyName* n) {
|
|
|
|
MOZ_ASSERT(n->isTenured());
|
|
|
|
globalArgumentName_ = n;
|
|
|
|
if (n) {
|
|
|
|
asmJSMetadata_->globalArgumentName = StringToNewUTF8CharsZ(cx_, *n);
|
|
|
|
if (!asmJSMetadata_->globalArgumentName)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
MOZ_MUST_USE bool initImportArgumentName(PropertyName* n) {
|
|
|
|
MOZ_ASSERT(n->isTenured());
|
|
|
|
importArgumentName_ = n;
|
|
|
|
if (n) {
|
|
|
|
asmJSMetadata_->importArgumentName = StringToNewUTF8CharsZ(cx_, *n);
|
|
|
|
if (!asmJSMetadata_->importArgumentName)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
MOZ_MUST_USE bool initBufferArgumentName(PropertyName* n) {
|
|
|
|
MOZ_ASSERT(n->isTenured());
|
|
|
|
bufferArgumentName_ = n;
|
|
|
|
if (n) {
|
|
|
|
asmJSMetadata_->bufferArgumentName = StringToNewUTF8CharsZ(cx_, *n);
|
|
|
|
if (!asmJSMetadata_->bufferArgumentName)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool addGlobalVarInit(PropertyName* var, const NumLit& lit, Type type, bool isConst) {
|
|
|
|
MOZ_ASSERT(type.isGlobalVarType());
|
|
|
|
MOZ_ASSERT(type == Type::canonicalize(Type::lit(lit)));
|
|
|
|
|
|
|
|
uint32_t index;
|
|
|
|
if (!mg_.addGlobal(type.canonicalToValType(), isConst, &index))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Global::Which which = isConst ? Global::ConstantLiteral : Global::Variable;
|
|
|
|
Global* global = validationLifo_.new_<Global>(which);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.varOrConst.index_ = index;
|
|
|
|
global->u.varOrConst.type_ = (isConst ? Type::lit(lit) : type).which();
|
|
|
|
if (isConst)
|
|
|
|
global->u.varOrConst.literalValue_ = lit;
|
|
|
|
if (!globalMap_.putNew(var, global))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
AsmJSGlobal g(AsmJSGlobal::Variable, nullptr);
|
|
|
|
g.pod.u.var.initKind_ = AsmJSGlobal::InitConstant;
|
|
|
|
g.pod.u.var.u.val_ = lit.value();
|
|
|
|
return asmJSMetadata_->asmJSGlobals.append(Move(g));
|
|
|
|
}
|
|
|
|
bool addGlobalVarImport(PropertyName* var, PropertyName* field, Type type, bool isConst) {
|
|
|
|
MOZ_ASSERT(type.isGlobalVarType());
|
|
|
|
|
|
|
|
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
|
|
|
|
if (!fieldChars)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
uint32_t index;
|
|
|
|
ValType valType = type.canonicalToValType();
|
|
|
|
if (!mg_.addGlobal(valType, isConst, &index))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Global::Which which = isConst ? Global::ConstantImport : Global::Variable;
|
|
|
|
Global* global = validationLifo_.new_<Global>(which);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.varOrConst.index_ = index;
|
|
|
|
global->u.varOrConst.type_ = type.which();
|
|
|
|
if (!globalMap_.putNew(var, global))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
AsmJSGlobal g(AsmJSGlobal::Variable, Move(fieldChars));
|
|
|
|
g.pod.u.var.initKind_ = AsmJSGlobal::InitImport;
|
|
|
|
g.pod.u.var.u.importType_ = valType;
|
|
|
|
return asmJSMetadata_->asmJSGlobals.append(Move(g));
|
|
|
|
}
|
|
|
|
bool addArrayView(PropertyName* var, Scalar::Type vt, PropertyName* maybeField) {
|
|
|
|
UniqueChars fieldChars;
|
|
|
|
if (maybeField) {
|
|
|
|
fieldChars = StringToNewUTF8CharsZ(cx_, *maybeField);
|
|
|
|
if (!fieldChars)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!arrayViews_.append(ArrayView(var, vt)))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Global* global = validationLifo_.new_<Global>(Global::ArrayView);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.viewInfo.viewType_ = vt;
|
|
|
|
if (!globalMap_.putNew(var, global))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
AsmJSGlobal g(AsmJSGlobal::ArrayView, Move(fieldChars));
|
|
|
|
g.pod.u.viewType_ = vt;
|
|
|
|
return asmJSMetadata_->asmJSGlobals.append(Move(g));
|
|
|
|
}
|
|
|
|
bool addMathBuiltinFunction(PropertyName* var, AsmJSMathBuiltinFunction func,
|
|
|
|
PropertyName* field)
|
|
|
|
{
|
|
|
|
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
|
|
|
|
if (!fieldChars)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Global* global = validationLifo_.new_<Global>(Global::MathBuiltinFunction);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.mathBuiltinFunc_ = func;
|
|
|
|
if (!globalMap_.putNew(var, global))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
AsmJSGlobal g(AsmJSGlobal::MathBuiltinFunction, Move(fieldChars));
|
|
|
|
g.pod.u.mathBuiltinFunc_ = func;
|
|
|
|
return asmJSMetadata_->asmJSGlobals.append(Move(g));
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
bool addGlobalDoubleConstant(PropertyName* var, double constant) {
|
|
|
|
Global* global = validationLifo_.new_<Global>(Global::ConstantLiteral);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.varOrConst.type_ = Type::Double;
|
|
|
|
global->u.varOrConst.literalValue_ = NumLit(NumLit::Double, DoubleValue(constant));
|
|
|
|
return globalMap_.putNew(var, global);
|
|
|
|
}
|
|
|
|
public:
|
|
|
|
bool addMathBuiltinConstant(PropertyName* var, double constant, PropertyName* field) {
|
|
|
|
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
|
|
|
|
if (!fieldChars)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!addGlobalDoubleConstant(var, constant))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
AsmJSGlobal g(AsmJSGlobal::Constant, Move(fieldChars));
|
|
|
|
g.pod.u.constant.value_ = constant;
|
|
|
|
g.pod.u.constant.kind_ = AsmJSGlobal::MathConstant;
|
|
|
|
return asmJSMetadata_->asmJSGlobals.append(Move(g));
|
|
|
|
}
|
|
|
|
bool addGlobalConstant(PropertyName* var, double constant, PropertyName* field) {
|
|
|
|
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
|
|
|
|
if (!fieldChars)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!addGlobalDoubleConstant(var, constant))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
AsmJSGlobal g(AsmJSGlobal::Constant, Move(fieldChars));
|
|
|
|
g.pod.u.constant.value_ = constant;
|
|
|
|
g.pod.u.constant.kind_ = AsmJSGlobal::GlobalConstant;
|
|
|
|
return asmJSMetadata_->asmJSGlobals.append(Move(g));
|
|
|
|
}
|
|
|
|
bool addAtomicsBuiltinFunction(PropertyName* var, AsmJSAtomicsBuiltinFunction func,
|
|
|
|
PropertyName* field)
|
|
|
|
{
|
|
|
|
if (!JitOptions.asmJSAtomicsEnable)
|
|
|
|
return failCurrentOffset("asm.js Atomics only enabled in wasm test mode");
|
|
|
|
|
|
|
|
atomicsPresent_ = true;
|
|
|
|
|
|
|
|
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
|
|
|
|
if (!fieldChars)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Global* global = validationLifo_.new_<Global>(Global::AtomicsBuiltinFunction);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.atomicsBuiltinFunc_ = func;
|
|
|
|
if (!globalMap_.putNew(var, global))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
AsmJSGlobal g(AsmJSGlobal::AtomicsBuiltinFunction, Move(fieldChars));
|
|
|
|
g.pod.u.atomicsBuiltinFunc_ = func;
|
|
|
|
return asmJSMetadata_->asmJSGlobals.append(Move(g));
|
|
|
|
}
|
|
|
|
bool addSimdCtor(PropertyName* var, SimdType type, PropertyName* field) {
|
|
|
|
simdPresent_ = true;
|
|
|
|
|
|
|
|
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
|
|
|
|
if (!fieldChars)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Global* global = validationLifo_.new_<Global>(Global::SimdCtor);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.simdCtorType_ = type;
|
|
|
|
if (!globalMap_.putNew(var, global))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
AsmJSGlobal g(AsmJSGlobal::SimdCtor, Move(fieldChars));
|
|
|
|
g.pod.u.simdCtorType_ = type;
|
|
|
|
return asmJSMetadata_->asmJSGlobals.append(Move(g));
|
|
|
|
}
|
|
|
|
bool addSimdOperation(PropertyName* var, SimdType type, SimdOperation op, PropertyName* field) {
|
|
|
|
simdPresent_ = true;
|
|
|
|
|
|
|
|
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
|
|
|
|
if (!fieldChars)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Global* global = validationLifo_.new_<Global>(Global::SimdOp);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.simdOp.type_ = type;
|
|
|
|
global->u.simdOp.which_ = op;
|
|
|
|
if (!globalMap_.putNew(var, global))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
AsmJSGlobal g(AsmJSGlobal::SimdOp, Move(fieldChars));
|
|
|
|
g.pod.u.simdOp.type_ = type;
|
|
|
|
g.pod.u.simdOp.which_ = op;
|
|
|
|
return asmJSMetadata_->asmJSGlobals.append(Move(g));
|
|
|
|
}
|
|
|
|
bool addArrayViewCtor(PropertyName* var, Scalar::Type vt, PropertyName* field) {
|
|
|
|
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
|
|
|
|
if (!fieldChars)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Global* global = validationLifo_.new_<Global>(Global::ArrayViewCtor);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.viewInfo.viewType_ = vt;
|
|
|
|
if (!globalMap_.putNew(var, global))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
AsmJSGlobal g(AsmJSGlobal::ArrayViewCtor, Move(fieldChars));
|
|
|
|
g.pod.u.viewType_ = vt;
|
|
|
|
return asmJSMetadata_->asmJSGlobals.append(Move(g));
|
|
|
|
}
|
|
|
|
bool addFFI(PropertyName* var, PropertyName* field) {
|
|
|
|
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
|
|
|
|
if (!fieldChars)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (asmJSMetadata_->numFFIs == UINT32_MAX)
|
|
|
|
return false;
|
|
|
|
uint32_t ffiIndex = asmJSMetadata_->numFFIs++;
|
|
|
|
|
|
|
|
Global* global = validationLifo_.new_<Global>(Global::FFI);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.ffiIndex_ = ffiIndex;
|
|
|
|
if (!globalMap_.putNew(var, global))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
AsmJSGlobal g(AsmJSGlobal::FFI, Move(fieldChars));
|
|
|
|
g.pod.u.ffiIndex_ = ffiIndex;
|
|
|
|
return asmJSMetadata_->asmJSGlobals.append(Move(g));
|
|
|
|
}
|
|
|
|
bool addExportField(ParseNode* pn, const Func& func, PropertyName* maybeField) {
|
|
|
|
// Record the field name of this export.
|
|
|
|
CacheableChars fieldChars;
|
|
|
|
if (maybeField)
|
|
|
|
fieldChars = StringToNewUTF8CharsZ(cx_, *maybeField);
|
|
|
|
else
|
|
|
|
fieldChars = DuplicateString("");
|
|
|
|
if (!fieldChars)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Declare which function is exported which gives us an index into the
|
|
|
|
// module FuncExportVector.
|
|
|
|
if (!mg_.addFuncExport(Move(fieldChars), func.index()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// The exported function might have already been exported in which case
|
|
|
|
// the index will refer into the range of AsmJSExports.
|
|
|
|
return asmJSMetadata_->asmJSExports.emplaceBack(func.index(),
|
|
|
|
func.srcBegin() - asmJSMetadata_->srcStart,
|
|
|
|
func.srcEnd() - asmJSMetadata_->srcStart);
|
|
|
|
}
|
|
|
|
bool addFunction(PropertyName* name, uint32_t firstUse, Sig&& sig, Func** func) {
|
|
|
|
uint32_t sigIndex;
|
|
|
|
if (!declareSig(Move(sig), &sigIndex))
|
|
|
|
return false;
|
|
|
|
uint32_t funcIndex = AsmJSFirstDefFuncIndex + numFunctions();
|
|
|
|
if (funcIndex >= MaxFuncs)
|
|
|
|
return failCurrentOffset("too many functions");
|
|
|
|
mg_.initFuncSig(funcIndex, sigIndex);
|
|
|
|
Global* global = validationLifo_.new_<Global>(Global::Function);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.funcIndex_ = funcIndex;
|
|
|
|
if (!globalMap_.putNew(name, global))
|
|
|
|
return false;
|
|
|
|
*func = validationLifo_.new_<Func>(name, firstUse, funcIndex);
|
|
|
|
return *func && functions_.append(*func);
|
|
|
|
}
|
|
|
|
bool declareFuncPtrTable(Sig&& sig, PropertyName* name, uint32_t firstUse, uint32_t mask,
|
|
|
|
uint32_t* index)
|
|
|
|
{
|
|
|
|
if (mask > MaxTableElems)
|
|
|
|
return failCurrentOffset("function pointer table too big");
|
|
|
|
uint32_t sigIndex;
|
|
|
|
if (!newSig(Move(sig), &sigIndex))
|
|
|
|
return false;
|
|
|
|
if (!mg_.initSigTableLength(sigIndex, mask + 1))
|
|
|
|
return false;
|
|
|
|
Global* global = validationLifo_.new_<Global>(Global::FuncPtrTable);
|
|
|
|
if (!global)
|
|
|
|
return false;
|
|
|
|
global->u.funcPtrTableIndex_ = *index = funcPtrTables_.length();
|
|
|
|
if (!globalMap_.putNew(name, global))
|
|
|
|
return false;
|
|
|
|
FuncPtrTable* t = validationLifo_.new_<FuncPtrTable>(sigIndex, name, firstUse, mask);
|
|
|
|
return t && funcPtrTables_.append(t);
|
|
|
|
}
|
|
|
|
bool defineFuncPtrTable(uint32_t funcPtrTableIndex, Uint32Vector&& elems) {
|
|
|
|
FuncPtrTable& table = *funcPtrTables_[funcPtrTableIndex];
|
|
|
|
if (table.defined())
|
|
|
|
return false;
|
|
|
|
table.define();
|
|
|
|
return mg_.initSigTableElems(table.sigIndex(), Move(elems));
|
|
|
|
}
|
|
|
|
bool declareImport(PropertyName* name, Sig&& sig, unsigned ffiIndex, uint32_t* funcIndex) {
|
|
|
|
ImportMap::AddPtr p = importMap_.lookupForAdd(NamedSig::Lookup(name, sig));
|
|
|
|
if (p) {
|
|
|
|
*funcIndex = p->value();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
*funcIndex = asmJSMetadata_->asmJSImports.length();
|
|
|
|
if (*funcIndex > AsmJSMaxImports)
|
|
|
|
return failCurrentOffset("too many imports");
|
|
|
|
if (!asmJSMetadata_->asmJSImports.emplaceBack(ffiIndex))
|
|
|
|
return false;
|
|
|
|
uint32_t sigIndex;
|
|
|
|
if (!declareSig(Move(sig), &sigIndex))
|
|
|
|
return false;
|
|
|
|
if (!mg_.initImport(*funcIndex, sigIndex))
|
|
|
|
return false;
|
|
|
|
return importMap_.add(p, NamedSig(name, mg_.sig(sigIndex)), *funcIndex);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool tryConstantAccess(uint64_t start, uint64_t width) {
|
|
|
|
MOZ_ASSERT(UINT64_MAX - start > width);
|
|
|
|
uint64_t len = start + width;
|
|
|
|
if (len > uint64_t(INT32_MAX) + 1)
|
|
|
|
return false;
|
|
|
|
len = RoundUpToNextValidAsmJSHeapLength(len);
|
|
|
|
if (len > mg_.minMemoryLength())
|
|
|
|
mg_.bumpMinMemoryLength(len);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Error handling.
|
|
|
|
bool hasAlreadyFailed() const {
|
|
|
|
return !!errorString_;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool failOffset(uint32_t offset, const char* str) {
|
|
|
|
MOZ_ASSERT(!hasAlreadyFailed());
|
|
|
|
MOZ_ASSERT(errorOffset_ == UINT32_MAX);
|
|
|
|
MOZ_ASSERT(str);
|
|
|
|
errorOffset_ = offset;
|
|
|
|
errorString_ = DuplicateString(str);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool failCurrentOffset(const char* str) {
|
|
|
|
return failOffset(tokenStream().currentToken().pos.begin, str);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool fail(ParseNode* pn, const char* str) {
|
|
|
|
return failOffset(pn->pn_pos.begin, str);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool failfVAOffset(uint32_t offset, const char* fmt, va_list ap) {
|
|
|
|
MOZ_ASSERT(!hasAlreadyFailed());
|
|
|
|
MOZ_ASSERT(errorOffset_ == UINT32_MAX);
|
|
|
|
MOZ_ASSERT(fmt);
|
|
|
|
errorOffset_ = offset;
|
|
|
|
errorString_.reset(JS_vsmprintf(fmt, ap));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool failfOffset(uint32_t offset, const char* fmt, ...) MOZ_FORMAT_PRINTF(3, 4) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
failfVAOffset(offset, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool failf(ParseNode* pn, const char* fmt, ...) MOZ_FORMAT_PRINTF(3, 4) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
failfVAOffset(pn->pn_pos.begin, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool failNameOffset(uint32_t offset, const char* fmt, PropertyName* name) {
|
|
|
|
// This function is invoked without the caller properly rooting its locals.
|
|
|
|
gc::AutoSuppressGC suppress(cx_);
|
|
|
|
JSAutoByteString bytes;
|
|
|
|
if (AtomToPrintableString(cx_, name, &bytes))
|
|
|
|
failfOffset(offset, fmt, bytes.ptr());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool failName(ParseNode* pn, const char* fmt, PropertyName* name) {
|
|
|
|
return failNameOffset(pn->pn_pos.begin, fmt, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool failOverRecursed() {
|
|
|
|
errorOverRecursed_ = true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned numArrayViews() const {
|
|
|
|
return arrayViews_.length();
|
|
|
|
}
|
|
|
|
const ArrayView& arrayView(unsigned i) const {
|
|
|
|
return arrayViews_[i];
|
|
|
|
}
|
|
|
|
unsigned numFunctions() const {
|
|
|
|
return functions_.length();
|
|
|
|
}
|
|
|
|
Func& function(unsigned i) const {
|
|
|
|
return *functions_[i];
|
|
|
|
}
|
|
|
|
unsigned numFuncPtrTables() const {
|
|
|
|
return funcPtrTables_.length();
|
|
|
|
}
|
|
|
|
FuncPtrTable& funcPtrTable(unsigned i) const {
|
|
|
|
return *funcPtrTables_[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
const Global* lookupGlobal(PropertyName* name) const {
|
|
|
|
if (GlobalMap::Ptr p = globalMap_.lookup(name))
|
|
|
|
return p->value();
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Func* lookupFunction(PropertyName* name) {
|
|
|
|
if (GlobalMap::Ptr p = globalMap_.lookup(name)) {
|
|
|
|
Global* value = p->value();
|
|
|
|
if (value->which() == Global::Function) {
|
|
|
|
MOZ_ASSERT(value->funcIndex() >= AsmJSFirstDefFuncIndex);
|
|
|
|
return functions_[value->funcIndex() - AsmJSFirstDefFuncIndex];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool lookupStandardLibraryMathName(PropertyName* name, MathBuiltin* mathBuiltin) const {
|
|
|
|
if (MathNameMap::Ptr p = standardLibraryMathNames_.lookup(name)) {
|
|
|
|
*mathBuiltin = p->value();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
bool lookupStandardLibraryAtomicsName(PropertyName* name, AsmJSAtomicsBuiltinFunction* atomicsBuiltin) const {
|
|
|
|
if (AtomicsNameMap::Ptr p = standardLibraryAtomicsNames_.lookup(name)) {
|
|
|
|
*atomicsBuiltin = p->value();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
bool lookupStandardSimdOpName(PropertyName* name, SimdOperation* op) const {
|
|
|
|
if (SimdOperationNameMap::Ptr p = standardLibrarySimdOpNames_.lookup(name)) {
|
|
|
|
*op = p->value();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool startFunctionBodies() {
|
|
|
|
return mg_.startFuncDefs();
|
|
|
|
}
|
|
|
|
bool finishFunctionBodies() {
|
|
|
|
return mg_.finishFuncDefs();
|
|
|
|
}
|
|
|
|
SharedModule finish() {
|
|
|
|
if (!arrayViews_.empty())
|
|
|
|
mg_.initMemoryUsage(atomicsPresent_ ? MemoryUsage::Shared : MemoryUsage::Unshared);
|
|
|
|
|
|
|
|
asmJSMetadata_->usesSimd = simdPresent_;
|
|
|
|
|
|
|
|
MOZ_ASSERT(asmJSMetadata_->asmJSFuncNames.empty());
|
|
|
|
for (const Func* func : functions_) {
|
|
|
|
CacheableChars funcName = StringToNewUTF8CharsZ(cx_, *func->name());
|
|
|
|
if (!funcName || !asmJSMetadata_->asmJSFuncNames.emplaceBack(Move(funcName)))
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t endBeforeCurly = tokenStream().currentToken().pos.end;
|
|
|
|
asmJSMetadata_->srcLength = endBeforeCurly - asmJSMetadata_->srcStart;
|
|
|
|
|
|
|
|
TokenPos pos;
|
|
|
|
JS_ALWAYS_TRUE(tokenStream().peekTokenPos(&pos, TokenStream::Operand));
|
|
|
|
uint32_t endAfterCurly = pos.end;
|
|
|
|
asmJSMetadata_->srcLengthWithRightBrace = endAfterCurly - asmJSMetadata_->srcStart;
|
|
|
|
|
|
|
|
// asm.js does not have any wasm bytecode to save; view-source is
|
|
|
|
// provided through the ScriptSource.
|
|
|
|
SharedBytes bytes = js_new<ShareableBytes>();
|
|
|
|
if (!bytes)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
return mg_.finish(*bytes);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
// Numeric literal utilities
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsNumericNonFloatLiteral(ParseNode* pn)
|
|
|
|
{
|
|
|
|
// Note: '-' is never rolled into the number; numbers are always positive
|
|
|
|
// and negations must be applied manually.
|
|
|
|
return pn->isKind(PNK_NUMBER) ||
|
|
|
|
(pn->isKind(PNK_NEG) && UnaryKid(pn)->isKind(PNK_NUMBER));
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsCallToGlobal(ModuleValidator& m, ParseNode* pn, const ModuleValidator::Global** global)
|
|
|
|
{
|
|
|
|
if (!pn->isKind(PNK_CALL))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ParseNode* callee = CallCallee(pn);
|
|
|
|
if (!callee->isKind(PNK_NAME))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*global = m.lookupGlobal(callee->name());
|
|
|
|
return !!*global;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsCoercionCall(ModuleValidator& m, ParseNode* pn, Type* coerceTo, ParseNode** coercedExpr)
|
|
|
|
{
|
|
|
|
const ModuleValidator::Global* global;
|
|
|
|
if (!IsCallToGlobal(m, pn, &global))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (CallArgListLength(pn) != 1)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (coercedExpr)
|
|
|
|
*coercedExpr = CallArgList(pn);
|
|
|
|
|
|
|
|
if (global->isMathFunction() && global->mathBuiltinFunction() == AsmJSMathBuiltin_fround) {
|
|
|
|
*coerceTo = Type::Float;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (global->isSimdOperation() && global->simdOperation() == SimdOperation::Fn_check) {
|
|
|
|
*coerceTo = global->simdOperationType();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsFloatLiteral(ModuleValidator& m, ParseNode* pn)
|
|
|
|
{
|
|
|
|
ParseNode* coercedExpr;
|
|
|
|
Type coerceTo;
|
|
|
|
if (!IsCoercionCall(m, pn, &coerceTo, &coercedExpr))
|
|
|
|
return false;
|
|
|
|
// Don't fold into || to avoid clang/memcheck bug (bug 1077031).
|
|
|
|
if (!coerceTo.isFloat())
|
|
|
|
return false;
|
|
|
|
return IsNumericNonFloatLiteral(coercedExpr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsSimdTuple(ModuleValidator& m, ParseNode* pn, SimdType* type)
|
|
|
|
{
|
|
|
|
const ModuleValidator::Global* global;
|
|
|
|
if (!IsCallToGlobal(m, pn, &global))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!global->isSimdCtor())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (CallArgListLength(pn) != GetSimdLanes(global->simdCtorType()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = global->simdCtorType();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsNumericLiteral(ModuleValidator& m, ParseNode* pn, bool* isSimd = nullptr);
|
|
|
|
|
|
|
|
static NumLit
|
|
|
|
ExtractNumericLiteral(ModuleValidator& m, ParseNode* pn);
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
IsLiteralInt(ModuleValidator& m, ParseNode* pn, uint32_t* u32);
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsSimdLiteral(ModuleValidator& m, ParseNode* pn)
|
|
|
|
{
|
|
|
|
SimdType type;
|
|
|
|
if (!IsSimdTuple(m, pn, &type))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ParseNode* arg = CallArgList(pn);
|
|
|
|
unsigned length = GetSimdLanes(type);
|
|
|
|
for (unsigned i = 0; i < length; i++) {
|
|
|
|
if (!IsNumericLiteral(m, arg))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
uint32_t _;
|
|
|
|
switch (type) {
|
|
|
|
case SimdType::Int8x16:
|
|
|
|
case SimdType::Int16x8:
|
|
|
|
case SimdType::Int32x4:
|
|
|
|
case SimdType::Uint8x16:
|
|
|
|
case SimdType::Uint16x8:
|
|
|
|
case SimdType::Uint32x4:
|
|
|
|
case SimdType::Bool8x16:
|
|
|
|
case SimdType::Bool16x8:
|
|
|
|
case SimdType::Bool32x4:
|
|
|
|
if (!IsLiteralInt(m, arg, &_))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case SimdType::Float32x4:
|
|
|
|
if (!IsNumericNonFloatLiteral(arg))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
MOZ_CRASH("unhandled simd type");
|
|
|
|
}
|
|
|
|
|
|
|
|
arg = NextNode(arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
MOZ_ASSERT(arg == nullptr);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsNumericLiteral(ModuleValidator& m, ParseNode* pn, bool* isSimd)
|
|
|
|
{
|
|
|
|
if (IsNumericNonFloatLiteral(pn) || IsFloatLiteral(m, pn))
|
|
|
|
return true;
|
|
|
|
if (IsSimdLiteral(m, pn)) {
|
|
|
|
if (isSimd)
|
|
|
|
*isSimd = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The JS grammar treats -42 as -(42) (i.e., with separate grammar
|
|
|
|
// productions) for the unary - and literal 42). However, the asm.js spec
|
|
|
|
// recognizes -42 (modulo parens, so -(42) and -((42))) as a single literal
|
|
|
|
// so fold the two potential parse nodes into a single double value.
|
|
|
|
static double
|
|
|
|
ExtractNumericNonFloatValue(ParseNode* pn, ParseNode** out = nullptr)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(IsNumericNonFloatLiteral(pn));
|
|
|
|
|
|
|
|
if (pn->isKind(PNK_NEG)) {
|
|
|
|
pn = UnaryKid(pn);
|
|
|
|
if (out)
|
|
|
|
*out = pn;
|
|
|
|
return -NumberNodeValue(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NumberNodeValue(pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static NumLit
|
|
|
|
ExtractSimdValue(ModuleValidator& m, ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(IsSimdLiteral(m, pn));
|
|
|
|
|
|
|
|
SimdType type = SimdType::Count;
|
|
|
|
JS_ALWAYS_TRUE(IsSimdTuple(m, pn, &type));
|
|
|
|
MOZ_ASSERT(CallArgListLength(pn) == GetSimdLanes(type));
|
|
|
|
|
|
|
|
ParseNode* arg = CallArgList(pn);
|
|
|
|
switch (type) {
|
|
|
|
case SimdType::Int8x16:
|
|
|
|
case SimdType::Uint8x16: {
|
|
|
|
MOZ_ASSERT(GetSimdLanes(type) == 16);
|
|
|
|
int8_t val[16];
|
|
|
|
for (size_t i = 0; i < 16; i++, arg = NextNode(arg)) {
|
|
|
|
uint32_t u32;
|
|
|
|
JS_ALWAYS_TRUE(IsLiteralInt(m, arg, &u32));
|
|
|
|
val[i] = int8_t(u32);
|
|
|
|
}
|
|
|
|
MOZ_ASSERT(arg == nullptr);
|
|
|
|
NumLit::Which w = type == SimdType::Uint8x16 ? NumLit::Uint8x16 : NumLit::Int8x16;
|
|
|
|
return NumLit(w, SimdConstant::CreateX16(val));
|
|
|
|
}
|
|
|
|
case SimdType::Int16x8:
|
|
|
|
case SimdType::Uint16x8: {
|
|
|
|
MOZ_ASSERT(GetSimdLanes(type) == 8);
|
|
|
|
int16_t val[8];
|
|
|
|
for (size_t i = 0; i < 8; i++, arg = NextNode(arg)) {
|
|
|
|
uint32_t u32;
|
|
|
|
JS_ALWAYS_TRUE(IsLiteralInt(m, arg, &u32));
|
|
|
|
val[i] = int16_t(u32);
|
|
|
|
}
|
|
|
|
MOZ_ASSERT(arg == nullptr);
|
|
|
|
NumLit::Which w = type == SimdType::Uint16x8 ? NumLit::Uint16x8 : NumLit::Int16x8;
|
|
|
|
return NumLit(w, SimdConstant::CreateX8(val));
|
|
|
|
}
|
|
|
|
case SimdType::Int32x4:
|
|
|
|
case SimdType::Uint32x4: {
|
|
|
|
MOZ_ASSERT(GetSimdLanes(type) == 4);
|
|
|
|
int32_t val[4];
|
|
|
|
for (size_t i = 0; i < 4; i++, arg = NextNode(arg)) {
|
|
|
|
uint32_t u32;
|
|
|
|
JS_ALWAYS_TRUE(IsLiteralInt(m, arg, &u32));
|
|
|
|
val[i] = int32_t(u32);
|
|
|
|
}
|
|
|
|
MOZ_ASSERT(arg == nullptr);
|
|
|
|
NumLit::Which w = type == SimdType::Uint32x4 ? NumLit::Uint32x4 : NumLit::Int32x4;
|
|
|
|
return NumLit(w, SimdConstant::CreateX4(val));
|
|
|
|
}
|
|
|
|
case SimdType::Float32x4: {
|
|
|
|
MOZ_ASSERT(GetSimdLanes(type) == 4);
|
|
|
|
float val[4];
|
|
|
|
for (size_t i = 0; i < 4; i++, arg = NextNode(arg))
|
|
|
|
val[i] = float(ExtractNumericNonFloatValue(arg));
|
|
|
|
MOZ_ASSERT(arg == nullptr);
|
|
|
|
return NumLit(NumLit::Float32x4, SimdConstant::CreateX4(val));
|
|
|
|
}
|
|
|
|
case SimdType::Bool8x16: {
|
|
|
|
MOZ_ASSERT(GetSimdLanes(type) == 16);
|
|
|
|
int8_t val[16];
|
|
|
|
for (size_t i = 0; i < 16; i++, arg = NextNode(arg)) {
|
|
|
|
uint32_t u32;
|
|
|
|
JS_ALWAYS_TRUE(IsLiteralInt(m, arg, &u32));
|
|
|
|
val[i] = u32 ? -1 : 0;
|
|
|
|
}
|
|
|
|
MOZ_ASSERT(arg == nullptr);
|
|
|
|
return NumLit(NumLit::Bool8x16, SimdConstant::CreateX16(val));
|
|
|
|
}
|
|
|
|
case SimdType::Bool16x8: {
|
|
|
|
MOZ_ASSERT(GetSimdLanes(type) == 8);
|
|
|
|
int16_t val[8];
|
|
|
|
for (size_t i = 0; i < 8; i++, arg = NextNode(arg)) {
|
|
|
|
uint32_t u32;
|
|
|
|
JS_ALWAYS_TRUE(IsLiteralInt(m, arg, &u32));
|
|
|
|
val[i] = u32 ? -1 : 0;
|
|
|
|
}
|
|
|
|
MOZ_ASSERT(arg == nullptr);
|
|
|
|
return NumLit(NumLit::Bool16x8, SimdConstant::CreateX8(val));
|
|
|
|
}
|
|
|
|
case SimdType::Bool32x4: {
|
|
|
|
MOZ_ASSERT(GetSimdLanes(type) == 4);
|
|
|
|
int32_t val[4];
|
|
|
|
for (size_t i = 0; i < 4; i++, arg = NextNode(arg)) {
|
|
|
|
uint32_t u32;
|
|
|
|
JS_ALWAYS_TRUE(IsLiteralInt(m, arg, &u32));
|
|
|
|
val[i] = u32 ? -1 : 0;
|
|
|
|
}
|
|
|
|
MOZ_ASSERT(arg == nullptr);
|
|
|
|
return NumLit(NumLit::Bool32x4, SimdConstant::CreateX4(val));
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
MOZ_CRASH("Unexpected SIMD type.");
|
|
|
|
}
|
|
|
|
|
|
|
|
static NumLit
|
|
|
|
ExtractNumericLiteral(ModuleValidator& m, ParseNode* pn)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(IsNumericLiteral(m, pn));
|
|
|
|
|
|
|
|
if (pn->isKind(PNK_CALL)) {
|
|
|
|
// Float literals are explicitly coerced and thus the coerced literal may be
|
|
|
|
// any valid (non-float) numeric literal.
|
|
|
|
if (CallArgListLength(pn) == 1) {
|
|
|
|
pn = CallArgList(pn);
|
|
|
|
double d = ExtractNumericNonFloatValue(pn);
|
|
|
|
return NumLit(NumLit::Float, DoubleValue(d));
|
|
|
|
}
|
|
|
|
|
|
|
|
return ExtractSimdValue(m, pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
double d = ExtractNumericNonFloatValue(pn, &pn);
|
|
|
|
|
|
|
|
// The asm.js spec syntactically distinguishes any literal containing a
|
|
|
|
// decimal point or the literal -0 as having double type.
|
|
|
|
if (NumberNodeHasFrac(pn) || IsNegativeZero(d))
|
|
|
|
return NumLit(NumLit::Double, DoubleValue(d));
|
|
|
|
|
|
|
|
// The syntactic checks above rule out these double values.
|
|
|
|
MOZ_ASSERT(!IsNegativeZero(d));
|
|
|
|
MOZ_ASSERT(!IsNaN(d));
|
|
|
|
|
|
|
|
// Although doubles can only *precisely* represent 53-bit integers, they
|
|
|
|
// can *imprecisely* represent integers much bigger than an int64_t.
|
|
|
|
// Furthermore, d may be inf or -inf. In both cases, casting to an int64_t
|
|
|
|
// is undefined, so test against the integer bounds using doubles.
|
|
|
|
if (d < double(INT32_MIN) || d > double(UINT32_MAX))
|
|
|
|
return NumLit(NumLit::OutOfRangeInt, UndefinedValue());
|
|
|
|
|
|
|
|
// With the above syntactic and range limitations, d is definitely an
|
|
|
|
// integer in the range [INT32_MIN, UINT32_MAX] range.
|
|
|
|
int64_t i64 = int64_t(d);
|
|
|
|
if (i64 >= 0) {
|
|
|
|
if (i64 <= INT32_MAX)
|
|
|
|
return NumLit(NumLit::Fixnum, Int32Value(i64));
|
|
|
|
MOZ_ASSERT(i64 <= UINT32_MAX);
|
|
|
|
return NumLit(NumLit::BigUnsigned, Int32Value(uint32_t(i64)));
|
|
|
|
}
|
|
|
|
MOZ_ASSERT(i64 >= INT32_MIN);
|
|
|
|
return NumLit(NumLit::NegativeInt, Int32Value(i64));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
IsLiteralInt(const NumLit& lit, uint32_t* u32)
|
|
|
|
{
|
|
|
|
switch (lit.which()) {
|
|
|
|
case NumLit::Fixnum:
|
|
|
|
case NumLit::BigUnsigned:
|
|
|
|
case NumLit::NegativeInt:
|
|
|
|
*u32 = lit.toUint32();
|
|
|
|
return true;
|
|
|
|
case NumLit::Double:
|
|
|
|
case NumLit::Float:
|
|
|
|
case NumLit::OutOfRangeInt:
|
|
|
|
case NumLit::Int8x16:
|
|
|
|
case NumLit::Uint8x16:
|
|
|
|
case NumLit::Int16x8:
|
|
|
|
case NumLit::Uint16x8:
|
|
|
|
case NumLit::Int32x4:
|
|
|
|
case NumLit::Uint32x4:
|
|
|
|
case NumLit::Float32x4:
|
|
|
|
case NumLit::Bool8x16:
|
|
|
|
case NumLit::Bool16x8:
|
|
|
|
case NumLit::Bool32x4:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Bad literal type");
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
IsLiteralInt(ModuleValidator& m, ParseNode* pn, uint32_t* u32)
|
|
|
|
{
|
|
|
|
return IsNumericLiteral(m, pn) &&
|
|
|
|
IsLiteralInt(ExtractNumericLiteral(m, pn), u32);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
#define CASE(TYPE, OP) case SimdOperation::Fn_##OP: return Op::TYPE##OP;
|
|
|
|
#define I8x16CASE(OP) CASE(I8x16, OP)
|
|
|
|
#define I16x8CASE(OP) CASE(I16x8, OP)
|
|
|
|
#define I32x4CASE(OP) CASE(I32x4, OP)
|
|
|
|
#define F32x4CASE(OP) CASE(F32x4, OP)
|
|
|
|
#define B8x16CASE(OP) CASE(B8x16, OP)
|
|
|
|
#define B16x8CASE(OP) CASE(B16x8, OP)
|
|
|
|
#define B32x4CASE(OP) CASE(B32x4, OP)
|
|
|
|
#define ENUMERATE(TYPE, FOR_ALL, DO) \
|
|
|
|
switch(op) { \
|
|
|
|
case SimdOperation::Constructor: return Op::TYPE##Constructor; \
|
|
|
|
FOR_ALL(DO) \
|
|
|
|
default: break; \
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline Op
|
|
|
|
SimdToOp(SimdType type, SimdOperation op)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case SimdType::Uint8x16:
|
|
|
|
// Handle the special unsigned opcodes, then fall through to Int8x16.
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Fn_addSaturate: return Op::I8x16addSaturateU;
|
|
|
|
case SimdOperation::Fn_subSaturate: return Op::I8x16subSaturateU;
|
|
|
|
case SimdOperation::Fn_extractLane: return Op::I8x16extractLaneU;
|
|
|
|
case SimdOperation::Fn_shiftRightByScalar: return Op::I8x16shiftRightByScalarU;
|
|
|
|
case SimdOperation::Fn_lessThan: return Op::I8x16lessThanU;
|
|
|
|
case SimdOperation::Fn_lessThanOrEqual: return Op::I8x16lessThanOrEqualU;
|
|
|
|
case SimdOperation::Fn_greaterThan: return Op::I8x16greaterThanU;
|
|
|
|
case SimdOperation::Fn_greaterThanOrEqual: return Op::I8x16greaterThanOrEqualU;
|
|
|
|
case SimdOperation::Fn_fromInt8x16Bits: return Op::Limit;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
MOZ_FALLTHROUGH;
|
|
|
|
case SimdType::Int8x16:
|
|
|
|
// Bitcasts Uint8x16 <--> Int8x16 become noops.
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Fn_fromUint8x16Bits: return Op::Limit;
|
|
|
|
case SimdOperation::Fn_fromUint16x8Bits: return Op::I8x16fromInt16x8Bits;
|
|
|
|
case SimdOperation::Fn_fromUint32x4Bits: return Op::I8x16fromInt32x4Bits;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
ENUMERATE(I8x16, FORALL_INT8X16_ASMJS_OP, I8x16CASE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SimdType::Uint16x8:
|
|
|
|
// Handle the special unsigned opcodes, then fall through to Int16x8.
|
|
|
|
switch(op) {
|
|
|
|
case SimdOperation::Fn_addSaturate: return Op::I16x8addSaturateU;
|
|
|
|
case SimdOperation::Fn_subSaturate: return Op::I16x8subSaturateU;
|
|
|
|
case SimdOperation::Fn_extractLane: return Op::I16x8extractLaneU;
|
|
|
|
case SimdOperation::Fn_shiftRightByScalar: return Op::I16x8shiftRightByScalarU;
|
|
|
|
case SimdOperation::Fn_lessThan: return Op::I16x8lessThanU;
|
|
|
|
case SimdOperation::Fn_lessThanOrEqual: return Op::I16x8lessThanOrEqualU;
|
|
|
|
case SimdOperation::Fn_greaterThan: return Op::I16x8greaterThanU;
|
|
|
|
case SimdOperation::Fn_greaterThanOrEqual: return Op::I16x8greaterThanOrEqualU;
|
|
|
|
case SimdOperation::Fn_fromInt16x8Bits: return Op::Limit;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
MOZ_FALLTHROUGH;
|
|
|
|
case SimdType::Int16x8:
|
|
|
|
// Bitcasts Uint16x8 <--> Int16x8 become noops.
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Fn_fromUint8x16Bits: return Op::I16x8fromInt8x16Bits;
|
|
|
|
case SimdOperation::Fn_fromUint16x8Bits: return Op::Limit;
|
|
|
|
case SimdOperation::Fn_fromUint32x4Bits: return Op::I16x8fromInt32x4Bits;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
ENUMERATE(I16x8, FORALL_INT16X8_ASMJS_OP, I16x8CASE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SimdType::Uint32x4:
|
|
|
|
// Handle the special unsigned opcodes, then fall through to Int32x4.
|
|
|
|
switch(op) {
|
|
|
|
case SimdOperation::Fn_shiftRightByScalar: return Op::I32x4shiftRightByScalarU;
|
|
|
|
case SimdOperation::Fn_lessThan: return Op::I32x4lessThanU;
|
|
|
|
case SimdOperation::Fn_lessThanOrEqual: return Op::I32x4lessThanOrEqualU;
|
|
|
|
case SimdOperation::Fn_greaterThan: return Op::I32x4greaterThanU;
|
|
|
|
case SimdOperation::Fn_greaterThanOrEqual: return Op::I32x4greaterThanOrEqualU;
|
|
|
|
case SimdOperation::Fn_fromFloat32x4: return Op::I32x4fromFloat32x4U;
|
|
|
|
case SimdOperation::Fn_fromInt32x4Bits: return Op::Limit;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
MOZ_FALLTHROUGH;
|
|
|
|
case SimdType::Int32x4:
|
|
|
|
// Bitcasts Uint32x4 <--> Int32x4 become noops.
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Fn_fromUint8x16Bits: return Op::I32x4fromInt8x16Bits;
|
|
|
|
case SimdOperation::Fn_fromUint16x8Bits: return Op::I32x4fromInt16x8Bits;
|
|
|
|
case SimdOperation::Fn_fromUint32x4Bits: return Op::Limit;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
ENUMERATE(I32x4, FORALL_INT32X4_ASMJS_OP, I32x4CASE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SimdType::Float32x4:
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Fn_fromUint8x16Bits: return Op::F32x4fromInt8x16Bits;
|
|
|
|
case SimdOperation::Fn_fromUint16x8Bits: return Op::F32x4fromInt16x8Bits;
|
|
|
|
case SimdOperation::Fn_fromUint32x4Bits: return Op::F32x4fromInt32x4Bits;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
ENUMERATE(F32x4, FORALL_FLOAT32X4_ASMJS_OP, F32x4CASE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SimdType::Bool8x16:
|
|
|
|
ENUMERATE(B8x16, FORALL_BOOL_SIMD_OP, B8x16CASE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SimdType::Bool16x8:
|
|
|
|
ENUMERATE(B16x8, FORALL_BOOL_SIMD_OP, B16x8CASE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SimdType::Bool32x4:
|
|
|
|
ENUMERATE(B32x4, FORALL_BOOL_SIMD_OP, B32x4CASE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
MOZ_CRASH("unexpected SIMD (type, operator) combination");
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef CASE
|
|
|
|
#undef I8x16CASE
|
|
|
|
#undef I16x8CASE
|
|
|
|
#undef I32x4CASE
|
|
|
|
#undef F32x4CASE
|
|
|
|
#undef B8x16CASE
|
|
|
|
#undef B16x8CASE
|
|
|
|
#undef B32x4CASE
|
|
|
|
#undef ENUMERATE
|
|
|
|
|
|
|
|
typedef Vector<PropertyName*, 4, SystemAllocPolicy> NameVector;
|
|
|
|
|
|
|
|
// Encapsulates the building of an asm bytecode function from an asm.js function
|
|
|
|
// source code, packing the asm.js code into the asm bytecode form that can
|
|
|
|
// be decoded and compiled with a FunctionCompiler.
|
|
|
|
class MOZ_STACK_CLASS FunctionValidator
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
struct Local
|
|
|
|
{
|
|
|
|
Type type;
|
|
|
|
unsigned slot;
|
|
|
|
Local(Type t, unsigned slot) : type(t), slot(slot) {
|
|
|
|
MOZ_ASSERT(type.isCanonicalValType());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
|
|
|
typedef HashMap<PropertyName*, Local> LocalMap;
|
|
|
|
typedef HashMap<PropertyName*, uint32_t> LabelMap;
|
|
|
|
|
|
|
|
ModuleValidator& m_;
|
|
|
|
ParseNode* fn_;
|
|
|
|
|
|
|
|
FunctionGenerator fg_;
|
|
|
|
Maybe<Encoder> encoder_;
|
|
|
|
|
|
|
|
LocalMap locals_;
|
|
|
|
|
|
|
|
// Labels
|
|
|
|
LabelMap breakLabels_;
|
|
|
|
LabelMap continueLabels_;
|
|
|
|
Uint32Vector breakableStack_;
|
|
|
|
Uint32Vector continuableStack_;
|
|
|
|
uint32_t blockDepth_;
|
|
|
|
|
|
|
|
bool hasAlreadyReturned_;
|
|
|
|
ExprType ret_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
FunctionValidator(ModuleValidator& m, ParseNode* fn)
|
|
|
|
: m_(m),
|
|
|
|
fn_(fn),
|
|
|
|
locals_(m.cx()),
|
|
|
|
breakLabels_(m.cx()),
|
|
|
|
continueLabels_(m.cx()),
|
|
|
|
blockDepth_(0),
|
|
|
|
hasAlreadyReturned_(false),
|
|
|
|
ret_(ExprType::Limit)
|
|
|
|
{}
|
|
|
|
|
|
|
|
ModuleValidator& m() const { return m_; }
|
|
|
|
ExclusiveContext* cx() const { return m_.cx(); }
|
|
|
|
ParseNode* fn() const { return fn_; }
|
|
|
|
|
|
|
|
bool init(PropertyName* name, unsigned line) {
|
|
|
|
if (!locals_.init() || !breakLabels_.init() || !continueLabels_.init())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!m_.mg().startFuncDef(line, &fg_))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
encoder_.emplace(fg_.bytes());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool finish(uint32_t funcIndex) {
|
|
|
|
MOZ_ASSERT(!blockDepth_);
|
|
|
|
MOZ_ASSERT(breakableStack_.empty());
|
|
|
|
MOZ_ASSERT(continuableStack_.empty());
|
|
|
|
MOZ_ASSERT(breakLabels_.empty());
|
|
|
|
MOZ_ASSERT(continueLabels_.empty());
|
|
|
|
for (auto iter = locals_.all(); !iter.empty(); iter.popFront()) {
|
|
|
|
if (iter.front().value().type.isSimd()) {
|
|
|
|
setUsesSimd();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_.mg().finishFuncDef(funcIndex, &fg_);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool fail(ParseNode* pn, const char* str) {
|
|
|
|
return m_.fail(pn, str);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool failf(ParseNode* pn, const char* fmt, ...) MOZ_FORMAT_PRINTF(3, 4) {
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
m_.failfVAOffset(pn->pn_pos.begin, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool failName(ParseNode* pn, const char* fmt, PropertyName* name) {
|
|
|
|
return m_.failName(pn, fmt, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/***************************************************** Attributes */
|
|
|
|
|
|
|
|
void setUsesSimd() {
|
|
|
|
fg_.setUsesSimd();
|
|
|
|
}
|
|
|
|
|
|
|
|
void setUsesAtomics() {
|
|
|
|
fg_.setUsesAtomics();
|
|
|
|
}
|
|
|
|
|
|
|
|
/***************************************************** Local scope setup */
|
|
|
|
|
|
|
|
bool addLocal(ParseNode* pn, PropertyName* name, Type type) {
|
|
|
|
LocalMap::AddPtr p = locals_.lookupForAdd(name);
|
|
|
|
if (p)
|
|
|
|
return failName(pn, "duplicate local name '%s' not allowed", name);
|
|
|
|
return locals_.add(p, name, Local(type, locals_.count()));
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************** For consistency of returns in a function */
|
|
|
|
|
|
|
|
bool hasAlreadyReturned() const {
|
|
|
|
return hasAlreadyReturned_;
|
|
|
|
}
|
|
|
|
|
|
|
|
ExprType returnedType() const {
|
|
|
|
return ret_;
|
|
|
|
}
|
|
|
|
|
|
|
|
void setReturnedType(ExprType ret) {
|
|
|
|
ret_ = ret;
|
|
|
|
hasAlreadyReturned_ = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************** Labels */
|
|
|
|
private:
|
|
|
|
bool writeBr(uint32_t absolute, Op op = Op::Br) {
|
|
|
|
MOZ_ASSERT(op == Op::Br || op == Op::BrIf);
|
|
|
|
MOZ_ASSERT(absolute < blockDepth_);
|
|
|
|
return encoder().writeOp(op) &&
|
|
|
|
encoder().writeVarU32(blockDepth_ - 1 - absolute);
|
|
|
|
}
|
|
|
|
void removeLabel(PropertyName* label, LabelMap* map) {
|
|
|
|
LabelMap::Ptr p = map->lookup(label);
|
|
|
|
MOZ_ASSERT(p);
|
|
|
|
map->remove(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
bool pushBreakableBlock() {
|
|
|
|
return encoder().writeOp(Op::Block) &&
|
|
|
|
encoder().writeFixedU8(uint8_t(ExprType::Void)) &&
|
|
|
|
breakableStack_.append(blockDepth_++);
|
|
|
|
}
|
|
|
|
bool popBreakableBlock() {
|
|
|
|
JS_ALWAYS_TRUE(breakableStack_.popCopy() == --blockDepth_);
|
|
|
|
return encoder().writeOp(Op::End);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool pushUnbreakableBlock(const NameVector* labels = nullptr) {
|
|
|
|
if (labels) {
|
|
|
|
for (PropertyName* label : *labels) {
|
|
|
|
if (!breakLabels_.putNew(label, blockDepth_))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
blockDepth_++;
|
|
|
|
return encoder().writeOp(Op::Block) &&
|
|
|
|
encoder().writeFixedU8(uint8_t(ExprType::Void));
|
|
|
|
}
|
|
|
|
bool popUnbreakableBlock(const NameVector* labels = nullptr) {
|
|
|
|
if (labels) {
|
|
|
|
for (PropertyName* label : *labels)
|
|
|
|
removeLabel(label, &breakLabels_);
|
|
|
|
}
|
|
|
|
--blockDepth_;
|
|
|
|
return encoder().writeOp(Op::End);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool pushContinuableBlock() {
|
|
|
|
return encoder().writeOp(Op::Block) &&
|
|
|
|
encoder().writeFixedU8(uint8_t(ExprType::Void)) &&
|
|
|
|
continuableStack_.append(blockDepth_++);
|
|
|
|
}
|
|
|
|
bool popContinuableBlock() {
|
|
|
|
JS_ALWAYS_TRUE(continuableStack_.popCopy() == --blockDepth_);
|
|
|
|
return encoder().writeOp(Op::End);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool pushLoop() {
|
|
|
|
return encoder().writeOp(Op::Block) &&
|
|
|
|
encoder().writeFixedU8(uint8_t(ExprType::Void)) &&
|
|
|
|
encoder().writeOp(Op::Loop) &&
|
|
|
|
encoder().writeFixedU8(uint8_t(ExprType::Void)) &&
|
|
|
|
breakableStack_.append(blockDepth_++) &&
|
|
|
|
continuableStack_.append(blockDepth_++);
|
|
|
|
}
|
|
|
|
bool popLoop() {
|
|
|
|
JS_ALWAYS_TRUE(continuableStack_.popCopy() == --blockDepth_);
|
|
|
|
JS_ALWAYS_TRUE(breakableStack_.popCopy() == --blockDepth_);
|
|
|
|
return encoder().writeOp(Op::End) &&
|
|
|
|
encoder().writeOp(Op::End);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool pushIf(size_t* typeAt) {
|
|
|
|
++blockDepth_;
|
|
|
|
return encoder().writeOp(Op::If) &&
|
|
|
|
encoder().writePatchableFixedU7(typeAt);
|
|
|
|
}
|
|
|
|
bool switchToElse() {
|
|
|
|
MOZ_ASSERT(blockDepth_ > 0);
|
|
|
|
return encoder().writeOp(Op::Else);
|
|
|
|
}
|
|
|
|
void setIfType(size_t typeAt, ExprType type) {
|
|
|
|
encoder().patchFixedU7(typeAt, uint8_t(type));
|
|
|
|
}
|
|
|
|
bool popIf() {
|
|
|
|
MOZ_ASSERT(blockDepth_ > 0);
|
|
|
|
--blockDepth_;
|
|
|
|
return encoder().writeOp(Op::End);
|
|
|
|
}
|
|
|
|
bool popIf(size_t typeAt, ExprType type) {
|
|
|
|
MOZ_ASSERT(blockDepth_ > 0);
|
|
|
|
--blockDepth_;
|
|
|
|
if (!encoder().writeOp(Op::End))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
setIfType(typeAt, type);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool writeBreakIf() {
|
|
|
|
return writeBr(breakableStack_.back(), Op::BrIf);
|
|
|
|
}
|
|
|
|
bool writeContinueIf() {
|
|
|
|
return writeBr(continuableStack_.back(), Op::BrIf);
|
|
|
|
}
|
|
|
|
bool writeUnlabeledBreakOrContinue(bool isBreak) {
|
|
|
|
return writeBr(isBreak? breakableStack_.back() : continuableStack_.back());
|
|
|
|
}
|
|
|
|
bool writeContinue() {
|
|
|
|
return writeBr(continuableStack_.back());
|
|
|
|
}
|
|
|
|
|
|
|
|
bool addLabels(const NameVector& labels, uint32_t relativeBreakDepth,
|
|
|
|
uint32_t relativeContinueDepth)
|
|
|
|
{
|
|
|
|
for (PropertyName* label : labels) {
|
|
|
|
if (!breakLabels_.putNew(label, blockDepth_ + relativeBreakDepth))
|
|
|
|
return false;
|
|
|
|
if (!continueLabels_.putNew(label, blockDepth_ + relativeContinueDepth))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
void removeLabels(const NameVector& labels) {
|
|
|
|
for (PropertyName* label : labels) {
|
|
|
|
removeLabel(label, &breakLabels_);
|
|
|
|
removeLabel(label, &continueLabels_);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bool writeLabeledBreakOrContinue(PropertyName* label, bool isBreak) {
|
|
|
|
LabelMap& map = isBreak ? breakLabels_ : continueLabels_;
|
|
|
|
if (LabelMap::Ptr p = map.lookup(label))
|
|
|
|
return writeBr(p->value());
|
|
|
|
MOZ_CRASH("nonexistent label");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*************************************************** Read-only interface */
|
|
|
|
|
|
|
|
const Local* lookupLocal(PropertyName* name) const {
|
|
|
|
if (auto p = locals_.lookup(name))
|
|
|
|
return &p->value();
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
const ModuleValidator::Global* lookupGlobal(PropertyName* name) const {
|
|
|
|
if (locals_.has(name))
|
|
|
|
return nullptr;
|
|
|
|
return m_.lookupGlobal(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t numLocals() const { return locals_.count(); }
|
|
|
|
|
|
|
|
/**************************************************** Encoding interface */
|
|
|
|
|
|
|
|
Encoder& encoder() { return *encoder_; }
|
|
|
|
|
|
|
|
MOZ_MUST_USE bool writeInt32Lit(int32_t i32) {
|
|
|
|
return encoder().writeOp(Op::I32Const) &&
|
|
|
|
encoder().writeVarS32(i32);
|
|
|
|
}
|
|
|
|
MOZ_MUST_USE bool writeConstExpr(const NumLit& lit) {
|
|
|
|
switch (lit.which()) {
|
|
|
|
case NumLit::Fixnum:
|
|
|
|
case NumLit::NegativeInt:
|
|
|
|
case NumLit::BigUnsigned:
|
|
|
|
return writeInt32Lit(lit.toInt32());
|
|
|
|
case NumLit::Float:
|
|
|
|
return encoder().writeOp(Op::F32Const) &&
|
|
|
|
encoder().writeFixedF32(lit.toFloat());
|
|
|
|
case NumLit::Double:
|
|
|
|
return encoder().writeOp(Op::F64Const) &&
|
|
|
|
encoder().writeFixedF64(lit.toDouble());
|
|
|
|
case NumLit::Int8x16:
|
|
|
|
case NumLit::Uint8x16:
|
|
|
|
return encoder().writeOp(Op::I8x16Const) &&
|
|
|
|
encoder().writeFixedI8x16(lit.simdValue().asInt8x16());
|
|
|
|
case NumLit::Int16x8:
|
|
|
|
case NumLit::Uint16x8:
|
|
|
|
return encoder().writeOp(Op::I16x8Const) &&
|
|
|
|
encoder().writeFixedI16x8(lit.simdValue().asInt16x8());
|
|
|
|
case NumLit::Int32x4:
|
|
|
|
case NumLit::Uint32x4:
|
|
|
|
return encoder().writeOp(Op::I32x4Const) &&
|
|
|
|
encoder().writeFixedI32x4(lit.simdValue().asInt32x4());
|
|
|
|
case NumLit::Float32x4:
|
|
|
|
return encoder().writeOp(Op::F32x4Const) &&
|
|
|
|
encoder().writeFixedF32x4(lit.simdValue().asFloat32x4());
|
|
|
|
case NumLit::Bool8x16:
|
|
|
|
// Boolean vectors use the Int8x16 memory representation.
|
|
|
|
return encoder().writeOp(Op::B8x16Const) &&
|
|
|
|
encoder().writeFixedI8x16(lit.simdValue().asInt8x16());
|
|
|
|
case NumLit::Bool16x8:
|
|
|
|
// Boolean vectors use the Int16x8 memory representation.
|
|
|
|
return encoder().writeOp(Op::B16x8Const) &&
|
|
|
|
encoder().writeFixedI16x8(lit.simdValue().asInt16x8());
|
|
|
|
case NumLit::Bool32x4:
|
|
|
|
// Boolean vectors use the Int32x4 memory representation.
|
|
|
|
return encoder().writeOp(Op::B32x4Const) &&
|
|
|
|
encoder().writeFixedI32x4(lit.simdValue().asInt32x4());
|
|
|
|
case NumLit::OutOfRangeInt:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
MOZ_CRASH("unexpected literal type");
|
|
|
|
}
|
|
|
|
MOZ_MUST_USE bool writeCall(ParseNode* pn, Op op) {
|
|
|
|
return encoder().writeOp(op) &&
|
|
|
|
fg_.addCallSiteLineNum(m().tokenStream().srcCoords.lineNum(pn->pn_pos.begin));
|
|
|
|
}
|
|
|
|
MOZ_MUST_USE bool prepareCall(ParseNode* pn) {
|
|
|
|
return fg_.addCallSiteLineNum(m().tokenStream().srcCoords.lineNum(pn->pn_pos.begin));
|
|
|
|
}
|
|
|
|
MOZ_MUST_USE bool writeSimdOp(SimdType simdType, SimdOperation simdOp) {
|
|
|
|
Op op = SimdToOp(simdType, simdOp);
|
|
|
|
if (op == Op::Limit)
|
|
|
|
return true;
|
|
|
|
return encoder().writeOp(op);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} /* anonymous namespace */
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
// asm.js type-checking and code-generation algorithm
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckIdentifier(ModuleValidator& m, ParseNode* usepn, PropertyName* name)
|
|
|
|
{
|
|
|
|
if (name == m.cx()->names().arguments || name == m.cx()->names().eval)
|
|
|
|
return m.failName(usepn, "'%s' is not an allowed identifier", name);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckModuleLevelName(ModuleValidator& m, ParseNode* usepn, PropertyName* name)
|
|
|
|
{
|
|
|
|
if (!CheckIdentifier(m, usepn, name))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (name == m.moduleFunctionName() ||
|
|
|
|
name == m.globalArgumentName() ||
|
|
|
|
name == m.importArgumentName() ||
|
|
|
|
name == m.bufferArgumentName() ||
|
|
|
|
m.lookupGlobal(name))
|
|
|
|
{
|
|
|
|
return m.failName(usepn, "duplicate name '%s' not allowed", name);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFunctionHead(ModuleValidator& m, ParseNode* fn)
|
|
|
|
{
|
|
|
|
if (fn->pn_funbox->hasRest())
|
|
|
|
return m.fail(fn, "rest args not allowed");
|
2019-09-05 10:05:17 -07:00
|
|
|
if (fn->pn_funbox->isExprBody())
|
2019-03-11 03:26:37 -07:00
|
|
|
return m.fail(fn, "expression closures not allowed");
|
|
|
|
if (fn->pn_funbox->hasDestructuringArgs)
|
|
|
|
return m.fail(fn, "destructuring args not allowed");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckArgument(ModuleValidator& m, ParseNode* arg, PropertyName** name)
|
|
|
|
{
|
|
|
|
*name = nullptr;
|
|
|
|
|
|
|
|
if (!arg->isKind(PNK_NAME))
|
|
|
|
return m.fail(arg, "argument is not a plain name");
|
|
|
|
|
|
|
|
if (!CheckIdentifier(m, arg, arg->name()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*name = arg->name();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckModuleArgument(ModuleValidator& m, ParseNode* arg, PropertyName** name)
|
|
|
|
{
|
|
|
|
if (!CheckArgument(m, arg, name))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!CheckModuleLevelName(m, arg, *name))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckModuleArguments(ModuleValidator& m, ParseNode* fn)
|
|
|
|
{
|
|
|
|
unsigned numFormals;
|
|
|
|
ParseNode* arg1 = FunctionFormalParametersList(fn, &numFormals);
|
|
|
|
ParseNode* arg2 = arg1 ? NextNode(arg1) : nullptr;
|
|
|
|
ParseNode* arg3 = arg2 ? NextNode(arg2) : nullptr;
|
|
|
|
|
|
|
|
if (numFormals > 3)
|
|
|
|
return m.fail(fn, "asm.js modules takes at most 3 argument");
|
|
|
|
|
|
|
|
PropertyName* arg1Name = nullptr;
|
|
|
|
if (arg1 && !CheckModuleArgument(m, arg1, &arg1Name))
|
|
|
|
return false;
|
|
|
|
if (!m.initGlobalArgumentName(arg1Name))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
PropertyName* arg2Name = nullptr;
|
|
|
|
if (arg2 && !CheckModuleArgument(m, arg2, &arg2Name))
|
|
|
|
return false;
|
|
|
|
if (!m.initImportArgumentName(arg2Name))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
PropertyName* arg3Name = nullptr;
|
|
|
|
if (arg3 && !CheckModuleArgument(m, arg3, &arg3Name))
|
|
|
|
return false;
|
|
|
|
if (!m.initBufferArgumentName(arg3Name))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckPrecedingStatements(ModuleValidator& m, ParseNode* stmtList)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(stmtList->isKind(PNK_STATEMENTLIST));
|
|
|
|
|
|
|
|
ParseNode* stmt = ListHead(stmtList);
|
|
|
|
for (unsigned i = 0, n = ListLength(stmtList); i < n; i++) {
|
|
|
|
if (!IsIgnoredDirective(m.cx(), stmt))
|
|
|
|
return m.fail(stmt, "invalid asm.js statement");
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckGlobalVariableInitConstant(ModuleValidator& m, PropertyName* varName, ParseNode* initNode,
|
|
|
|
bool isConst)
|
|
|
|
{
|
|
|
|
NumLit lit = ExtractNumericLiteral(m, initNode);
|
|
|
|
if (!lit.valid())
|
|
|
|
return m.fail(initNode, "global initializer is out of representable integer range");
|
|
|
|
|
|
|
|
Type canonicalType = Type::canonicalize(Type::lit(lit));
|
|
|
|
if (!canonicalType.isGlobalVarType())
|
|
|
|
return m.fail(initNode, "global variable type not allowed");
|
|
|
|
|
|
|
|
return m.addGlobalVarInit(varName, lit, canonicalType, isConst);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckTypeAnnotation(ModuleValidator& m, ParseNode* coercionNode, Type* coerceTo,
|
|
|
|
ParseNode** coercedExpr = nullptr)
|
|
|
|
{
|
|
|
|
switch (coercionNode->getKind()) {
|
|
|
|
case PNK_BITOR: {
|
|
|
|
ParseNode* rhs = BitwiseRight(coercionNode);
|
|
|
|
uint32_t i;
|
|
|
|
if (!IsLiteralInt(m, rhs, &i) || i != 0)
|
|
|
|
return m.fail(rhs, "must use |0 for argument/return coercion");
|
|
|
|
*coerceTo = Type::Int;
|
|
|
|
if (coercedExpr)
|
|
|
|
*coercedExpr = BitwiseLeft(coercionNode);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case PNK_POS: {
|
|
|
|
*coerceTo = Type::Double;
|
|
|
|
if (coercedExpr)
|
|
|
|
*coercedExpr = UnaryKid(coercionNode);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case PNK_CALL: {
|
|
|
|
if (IsCoercionCall(m, coercionNode, coerceTo, coercedExpr))
|
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:;
|
|
|
|
}
|
|
|
|
|
|
|
|
return m.fail(coercionNode, "must be of the form +x, x|0, fround(x), or a SIMD check(x)");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckGlobalVariableInitImport(ModuleValidator& m, PropertyName* varName, ParseNode* initNode,
|
|
|
|
bool isConst)
|
|
|
|
{
|
|
|
|
Type coerceTo;
|
|
|
|
ParseNode* coercedExpr;
|
|
|
|
if (!CheckTypeAnnotation(m, initNode, &coerceTo, &coercedExpr))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!coercedExpr->isKind(PNK_DOT))
|
|
|
|
return m.failName(coercedExpr, "invalid import expression for global '%s'", varName);
|
|
|
|
|
|
|
|
if (!coerceTo.isGlobalVarType())
|
|
|
|
return m.fail(initNode, "global variable type not allowed");
|
|
|
|
|
|
|
|
ParseNode* base = DotBase(coercedExpr);
|
|
|
|
PropertyName* field = DotMember(coercedExpr);
|
|
|
|
|
|
|
|
PropertyName* importName = m.importArgumentName();
|
|
|
|
if (!importName)
|
|
|
|
return m.fail(coercedExpr, "cannot import without an asm.js foreign parameter");
|
|
|
|
if (!IsUseOfName(base, importName))
|
|
|
|
return m.failName(coercedExpr, "base of import expression must be '%s'", importName);
|
|
|
|
|
|
|
|
return m.addGlobalVarImport(varName, field, coerceTo, isConst);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsArrayViewCtorName(ModuleValidator& m, PropertyName* name, Scalar::Type* type)
|
|
|
|
{
|
|
|
|
JSAtomState& names = m.cx()->names();
|
|
|
|
if (name == names.Int8Array) {
|
|
|
|
*type = Scalar::Int8;
|
|
|
|
} else if (name == names.Uint8Array) {
|
|
|
|
*type = Scalar::Uint8;
|
|
|
|
} else if (name == names.Int16Array) {
|
|
|
|
*type = Scalar::Int16;
|
|
|
|
} else if (name == names.Uint16Array) {
|
|
|
|
*type = Scalar::Uint16;
|
|
|
|
} else if (name == names.Int32Array) {
|
|
|
|
*type = Scalar::Int32;
|
|
|
|
} else if (name == names.Uint32Array) {
|
|
|
|
*type = Scalar::Uint32;
|
|
|
|
} else if (name == names.Float32Array) {
|
|
|
|
*type = Scalar::Float32;
|
|
|
|
} else if (name == names.Float64Array) {
|
|
|
|
*type = Scalar::Float64;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckNewArrayViewArgs(ModuleValidator& m, ParseNode* ctorExpr, PropertyName* bufferName)
|
|
|
|
{
|
|
|
|
ParseNode* bufArg = NextNode(ctorExpr);
|
|
|
|
if (!bufArg || NextNode(bufArg) != nullptr)
|
|
|
|
return m.fail(ctorExpr, "array view constructor takes exactly one argument");
|
|
|
|
|
|
|
|
if (!IsUseOfName(bufArg, bufferName))
|
|
|
|
return m.failName(bufArg, "argument to array view constructor must be '%s'", bufferName);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckNewArrayView(ModuleValidator& m, PropertyName* varName, ParseNode* newExpr)
|
|
|
|
{
|
|
|
|
PropertyName* globalName = m.globalArgumentName();
|
|
|
|
if (!globalName)
|
|
|
|
return m.fail(newExpr, "cannot create array view without an asm.js global parameter");
|
|
|
|
|
|
|
|
PropertyName* bufferName = m.bufferArgumentName();
|
|
|
|
if (!bufferName)
|
|
|
|
return m.fail(newExpr, "cannot create array view without an asm.js heap parameter");
|
|
|
|
|
|
|
|
ParseNode* ctorExpr = ListHead(newExpr);
|
|
|
|
|
|
|
|
PropertyName* field;
|
|
|
|
Scalar::Type type;
|
|
|
|
if (ctorExpr->isKind(PNK_DOT)) {
|
|
|
|
ParseNode* base = DotBase(ctorExpr);
|
|
|
|
|
|
|
|
if (!IsUseOfName(base, globalName))
|
|
|
|
return m.failName(base, "expecting '%s.*Array", globalName);
|
|
|
|
|
|
|
|
field = DotMember(ctorExpr);
|
|
|
|
if (!IsArrayViewCtorName(m, field, &type))
|
|
|
|
return m.fail(ctorExpr, "could not match typed array name");
|
|
|
|
} else {
|
|
|
|
if (!ctorExpr->isKind(PNK_NAME))
|
|
|
|
return m.fail(ctorExpr, "expecting name of imported array view constructor");
|
|
|
|
|
|
|
|
PropertyName* globalName = ctorExpr->name();
|
|
|
|
const ModuleValidator::Global* global = m.lookupGlobal(globalName);
|
|
|
|
if (!global)
|
|
|
|
return m.failName(ctorExpr, "%s not found in module global scope", globalName);
|
|
|
|
|
|
|
|
if (global->which() != ModuleValidator::Global::ArrayViewCtor)
|
|
|
|
return m.failName(ctorExpr, "%s must be an imported array view constructor", globalName);
|
|
|
|
|
|
|
|
field = nullptr;
|
|
|
|
type = global->viewType();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!CheckNewArrayViewArgs(m, ctorExpr, bufferName))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return m.addArrayView(varName, type, field);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsSimdValidOperationType(SimdType type, SimdOperation op)
|
|
|
|
{
|
|
|
|
#define CASE(op) case SimdOperation::Fn_##op:
|
|
|
|
switch(type) {
|
|
|
|
case SimdType::Int8x16:
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Constructor:
|
|
|
|
case SimdOperation::Fn_fromUint8x16Bits:
|
|
|
|
case SimdOperation::Fn_fromUint16x8Bits:
|
|
|
|
case SimdOperation::Fn_fromUint32x4Bits:
|
|
|
|
FORALL_INT8X16_ASMJS_OP(CASE) return true;
|
|
|
|
default: return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Int16x8:
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Constructor:
|
|
|
|
case SimdOperation::Fn_fromUint8x16Bits:
|
|
|
|
case SimdOperation::Fn_fromUint16x8Bits:
|
|
|
|
case SimdOperation::Fn_fromUint32x4Bits:
|
|
|
|
FORALL_INT16X8_ASMJS_OP(CASE) return true;
|
|
|
|
default: return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Int32x4:
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Constructor:
|
|
|
|
case SimdOperation::Fn_fromUint8x16Bits:
|
|
|
|
case SimdOperation::Fn_fromUint16x8Bits:
|
|
|
|
case SimdOperation::Fn_fromUint32x4Bits:
|
|
|
|
FORALL_INT32X4_ASMJS_OP(CASE) return true;
|
|
|
|
default: return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Uint8x16:
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Constructor:
|
|
|
|
case SimdOperation::Fn_fromInt8x16Bits:
|
|
|
|
case SimdOperation::Fn_fromUint16x8Bits:
|
|
|
|
case SimdOperation::Fn_fromUint32x4Bits:
|
|
|
|
FORALL_INT8X16_ASMJS_OP(CASE) return true;
|
|
|
|
default: return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Uint16x8:
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Constructor:
|
|
|
|
case SimdOperation::Fn_fromUint8x16Bits:
|
|
|
|
case SimdOperation::Fn_fromInt16x8Bits:
|
|
|
|
case SimdOperation::Fn_fromUint32x4Bits:
|
|
|
|
FORALL_INT16X8_ASMJS_OP(CASE) return true;
|
|
|
|
default: return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Uint32x4:
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Constructor:
|
|
|
|
case SimdOperation::Fn_fromUint8x16Bits:
|
|
|
|
case SimdOperation::Fn_fromUint16x8Bits:
|
|
|
|
case SimdOperation::Fn_fromInt32x4Bits:
|
|
|
|
FORALL_INT32X4_ASMJS_OP(CASE) return true;
|
|
|
|
default: return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Float32x4:
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Constructor:
|
|
|
|
case SimdOperation::Fn_fromUint8x16Bits:
|
|
|
|
case SimdOperation::Fn_fromUint16x8Bits:
|
|
|
|
case SimdOperation::Fn_fromUint32x4Bits:
|
|
|
|
FORALL_FLOAT32X4_ASMJS_OP(CASE) return true;
|
|
|
|
default: return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Bool8x16:
|
|
|
|
case SimdType::Bool16x8:
|
|
|
|
case SimdType::Bool32x4:
|
|
|
|
switch (op) {
|
|
|
|
case SimdOperation::Constructor:
|
|
|
|
FORALL_BOOL_SIMD_OP(CASE) return true;
|
|
|
|
default: return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// Unimplemented SIMD type.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#undef CASE
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckGlobalMathImport(ModuleValidator& m, ParseNode* initNode, PropertyName* varName,
|
|
|
|
PropertyName* field)
|
|
|
|
{
|
|
|
|
// Math builtin, with the form glob.Math.[[builtin]]
|
|
|
|
ModuleValidator::MathBuiltin mathBuiltin;
|
|
|
|
if (!m.lookupStandardLibraryMathName(field, &mathBuiltin))
|
|
|
|
return m.failName(initNode, "'%s' is not a standard Math builtin", field);
|
|
|
|
|
|
|
|
switch (mathBuiltin.kind) {
|
|
|
|
case ModuleValidator::MathBuiltin::Function:
|
|
|
|
return m.addMathBuiltinFunction(varName, mathBuiltin.u.func, field);
|
|
|
|
case ModuleValidator::MathBuiltin::Constant:
|
|
|
|
return m.addMathBuiltinConstant(varName, mathBuiltin.u.cst, field);
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
MOZ_CRASH("unexpected or uninitialized math builtin type");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckGlobalAtomicsImport(ModuleValidator& m, ParseNode* initNode, PropertyName* varName,
|
|
|
|
PropertyName* field)
|
|
|
|
{
|
|
|
|
// Atomics builtin, with the form glob.Atomics.[[builtin]]
|
|
|
|
AsmJSAtomicsBuiltinFunction func;
|
|
|
|
if (!m.lookupStandardLibraryAtomicsName(field, &func))
|
|
|
|
return m.failName(initNode, "'%s' is not a standard Atomics builtin", field);
|
|
|
|
|
|
|
|
return m.addAtomicsBuiltinFunction(varName, func, field);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckGlobalSimdImport(ModuleValidator& m, ParseNode* initNode, PropertyName* varName,
|
|
|
|
PropertyName* field)
|
|
|
|
{
|
|
|
|
if (!m.supportsSimd())
|
|
|
|
return m.fail(initNode, "SIMD is not supported on this platform");
|
|
|
|
|
|
|
|
// SIMD constructor, with the form glob.SIMD.[[type]]
|
|
|
|
SimdType simdType;
|
|
|
|
if (!IsSimdTypeName(m.cx()->names(), field, &simdType))
|
|
|
|
return m.failName(initNode, "'%s' is not a standard SIMD type", field);
|
|
|
|
|
|
|
|
// IsSimdTypeName will return true for any SIMD type supported by the VM.
|
|
|
|
//
|
|
|
|
// Since we may not support all of those SIMD types in asm.js, use the
|
|
|
|
// asm.js-specific IsSimdValidOperationType() to check if this specific
|
|
|
|
// constructor is supported in asm.js.
|
|
|
|
if (!IsSimdValidOperationType(simdType, SimdOperation::Constructor))
|
|
|
|
return m.failName(initNode, "'%s' is not a supported SIMD type", field);
|
|
|
|
|
|
|
|
return m.addSimdCtor(varName, simdType, field);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckGlobalSimdOperationImport(ModuleValidator& m, const ModuleValidator::Global* global,
|
|
|
|
ParseNode* initNode, PropertyName* varName, PropertyName* opName)
|
|
|
|
{
|
|
|
|
SimdType simdType = global->simdCtorType();
|
|
|
|
SimdOperation simdOp;
|
|
|
|
if (!m.lookupStandardSimdOpName(opName, &simdOp))
|
|
|
|
return m.failName(initNode, "'%s' is not a standard SIMD operation", opName);
|
|
|
|
if (!IsSimdValidOperationType(simdType, simdOp))
|
|
|
|
return m.failName(initNode, "'%s' is not an operation supported by the SIMD type", opName);
|
|
|
|
return m.addSimdOperation(varName, simdType, simdOp, opName);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckGlobalDotImport(ModuleValidator& m, PropertyName* varName, ParseNode* initNode)
|
|
|
|
{
|
|
|
|
ParseNode* base = DotBase(initNode);
|
|
|
|
PropertyName* field = DotMember(initNode);
|
|
|
|
|
|
|
|
if (base->isKind(PNK_DOT)) {
|
|
|
|
ParseNode* global = DotBase(base);
|
|
|
|
PropertyName* mathOrAtomicsOrSimd = DotMember(base);
|
|
|
|
|
|
|
|
PropertyName* globalName = m.globalArgumentName();
|
|
|
|
if (!globalName)
|
|
|
|
return m.fail(base, "import statement requires the module have a stdlib parameter");
|
|
|
|
|
|
|
|
if (!IsUseOfName(global, globalName)) {
|
|
|
|
if (global->isKind(PNK_DOT)) {
|
|
|
|
return m.failName(base, "imports can have at most two dot accesses "
|
|
|
|
"(e.g. %s.Math.sin)", globalName);
|
|
|
|
}
|
|
|
|
return m.failName(base, "expecting %s.*", globalName);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mathOrAtomicsOrSimd == m.cx()->names().Math)
|
|
|
|
return CheckGlobalMathImport(m, initNode, varName, field);
|
|
|
|
if (mathOrAtomicsOrSimd == m.cx()->names().Atomics)
|
|
|
|
return CheckGlobalAtomicsImport(m, initNode, varName, field);
|
|
|
|
if (mathOrAtomicsOrSimd == m.cx()->names().SIMD)
|
|
|
|
return CheckGlobalSimdImport(m, initNode, varName, field);
|
|
|
|
return m.failName(base, "expecting %s.{Math|SIMD}", globalName);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!base->isKind(PNK_NAME))
|
|
|
|
return m.fail(base, "expected name of variable or parameter");
|
|
|
|
|
|
|
|
if (base->name() == m.globalArgumentName()) {
|
|
|
|
if (field == m.cx()->names().NaN)
|
|
|
|
return m.addGlobalConstant(varName, GenericNaN(), field);
|
|
|
|
if (field == m.cx()->names().Infinity)
|
|
|
|
return m.addGlobalConstant(varName, PositiveInfinity<double>(), field);
|
|
|
|
|
|
|
|
Scalar::Type type;
|
|
|
|
if (IsArrayViewCtorName(m, field, &type))
|
|
|
|
return m.addArrayViewCtor(varName, type, field);
|
|
|
|
|
|
|
|
return m.failName(initNode, "'%s' is not a standard constant or typed array name", field);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (base->name() == m.importArgumentName())
|
|
|
|
return m.addFFI(varName, field);
|
|
|
|
|
|
|
|
const ModuleValidator::Global* global = m.lookupGlobal(base->name());
|
|
|
|
if (!global)
|
|
|
|
return m.failName(initNode, "%s not found in module global scope", base->name());
|
|
|
|
|
|
|
|
if (!global->isSimdCtor())
|
|
|
|
return m.failName(base, "expecting SIMD constructor name, got %s", field);
|
|
|
|
|
|
|
|
return CheckGlobalSimdOperationImport(m, global, initNode, varName, field);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckModuleGlobal(ModuleValidator& m, ParseNode* var, bool isConst)
|
|
|
|
{
|
|
|
|
if (!var->isKind(PNK_NAME))
|
|
|
|
return m.fail(var, "import variable is not a plain name");
|
|
|
|
|
|
|
|
if (!CheckModuleLevelName(m, var, var->name()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ParseNode* initNode = MaybeInitializer(var);
|
|
|
|
if (!initNode)
|
|
|
|
return m.fail(var, "module import needs initializer");
|
|
|
|
|
|
|
|
if (IsNumericLiteral(m, initNode))
|
|
|
|
return CheckGlobalVariableInitConstant(m, var->name(), initNode, isConst);
|
|
|
|
|
|
|
|
if (initNode->isKind(PNK_BITOR) || initNode->isKind(PNK_POS) || initNode->isKind(PNK_CALL))
|
|
|
|
return CheckGlobalVariableInitImport(m, var->name(), initNode, isConst);
|
|
|
|
|
|
|
|
if (initNode->isKind(PNK_NEW))
|
|
|
|
return CheckNewArrayView(m, var->name(), initNode);
|
|
|
|
|
|
|
|
if (initNode->isKind(PNK_DOT))
|
|
|
|
return CheckGlobalDotImport(m, var->name(), initNode);
|
|
|
|
|
|
|
|
return m.fail(initNode, "unsupported import expression");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckModuleProcessingDirectives(ModuleValidator& m)
|
|
|
|
{
|
|
|
|
TokenStream& ts = m.parser().tokenStream;
|
|
|
|
while (true) {
|
|
|
|
bool matched;
|
|
|
|
if (!ts.matchToken(&matched, TOK_STRING, TokenStream::Operand))
|
|
|
|
return false;
|
|
|
|
if (!matched)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (!IsIgnoredDirectiveName(m.cx(), ts.currentToken().atom()))
|
|
|
|
return m.failCurrentOffset("unsupported processing directive");
|
|
|
|
|
|
|
|
TokenKind tt;
|
|
|
|
if (!ts.getToken(&tt))
|
|
|
|
return false;
|
|
|
|
if (tt != TOK_SEMI)
|
|
|
|
return m.failCurrentOffset("expected semicolon after string literal");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckModuleGlobals(ModuleValidator& m)
|
|
|
|
{
|
|
|
|
while (true) {
|
|
|
|
ParseNode* varStmt;
|
|
|
|
if (!ParseVarOrConstStatement(m.parser(), &varStmt))
|
|
|
|
return false;
|
|
|
|
if (!varStmt)
|
|
|
|
break;
|
|
|
|
for (ParseNode* var = VarListHead(varStmt); var; var = NextNode(var)) {
|
|
|
|
if (!CheckModuleGlobal(m, var, varStmt->isKind(PNK_CONST)))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ArgFail(FunctionValidator& f, PropertyName* argName, ParseNode* stmt)
|
|
|
|
{
|
|
|
|
return f.failName(stmt, "expecting argument type declaration for '%s' of the "
|
|
|
|
"form 'arg = arg|0' or 'arg = +arg' or 'arg = fround(arg)'", argName);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckArgumentType(FunctionValidator& f, ParseNode* stmt, PropertyName* name, Type* type)
|
|
|
|
{
|
|
|
|
if (!stmt || !IsExpressionStatement(stmt))
|
|
|
|
return ArgFail(f, name, stmt ? stmt : f.fn());
|
|
|
|
|
|
|
|
ParseNode* initNode = ExpressionStatementExpr(stmt);
|
|
|
|
if (!initNode || !initNode->isKind(PNK_ASSIGN))
|
|
|
|
return ArgFail(f, name, stmt);
|
|
|
|
|
|
|
|
ParseNode* argNode = BinaryLeft(initNode);
|
|
|
|
ParseNode* coercionNode = BinaryRight(initNode);
|
|
|
|
|
|
|
|
if (!IsUseOfName(argNode, name))
|
|
|
|
return ArgFail(f, name, stmt);
|
|
|
|
|
|
|
|
ParseNode* coercedExpr;
|
|
|
|
if (!CheckTypeAnnotation(f.m(), coercionNode, type, &coercedExpr))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!type->isArgType())
|
|
|
|
return f.failName(stmt, "invalid type for argument '%s'", name);
|
|
|
|
|
|
|
|
if (!IsUseOfName(coercedExpr, name))
|
|
|
|
return ArgFail(f, name, stmt);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckProcessingDirectives(ModuleValidator& m, ParseNode** stmtIter)
|
|
|
|
{
|
|
|
|
ParseNode* stmt = *stmtIter;
|
|
|
|
|
|
|
|
while (stmt && IsIgnoredDirective(m.cx(), stmt))
|
|
|
|
stmt = NextNode(stmt);
|
|
|
|
|
|
|
|
*stmtIter = stmt;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckArguments(FunctionValidator& f, ParseNode** stmtIter, ValTypeVector* argTypes)
|
|
|
|
{
|
|
|
|
ParseNode* stmt = *stmtIter;
|
|
|
|
|
|
|
|
unsigned numFormals;
|
|
|
|
ParseNode* argpn = FunctionFormalParametersList(f.fn(), &numFormals);
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < numFormals; i++, argpn = NextNode(argpn), stmt = NextNode(stmt)) {
|
|
|
|
PropertyName* name;
|
|
|
|
if (!CheckArgument(f.m(), argpn, &name))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Type type;
|
|
|
|
if (!CheckArgumentType(f, stmt, name, &type))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!argTypes->append(type.canonicalToValType()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.addLocal(argpn, name, type))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*stmtIter = stmt;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsLiteralOrConst(FunctionValidator& f, ParseNode* pn, NumLit* lit)
|
|
|
|
{
|
|
|
|
if (pn->isKind(PNK_NAME)) {
|
|
|
|
const ModuleValidator::Global* global = f.lookupGlobal(pn->name());
|
|
|
|
if (!global || global->which() != ModuleValidator::Global::ConstantLiteral)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*lit = global->constLiteralValue();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isSimd = false;
|
|
|
|
if (!IsNumericLiteral(f.m(), pn, &isSimd))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (isSimd)
|
|
|
|
f.setUsesSimd();
|
|
|
|
|
|
|
|
*lit = ExtractNumericLiteral(f.m(), pn);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFinalReturn(FunctionValidator& f, ParseNode* lastNonEmptyStmt)
|
|
|
|
{
|
|
|
|
if (!f.encoder().writeOp(Op::End))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.hasAlreadyReturned()) {
|
|
|
|
f.setReturnedType(ExprType::Void);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!lastNonEmptyStmt->isKind(PNK_RETURN) && !IsVoid(f.returnedType()))
|
|
|
|
return f.fail(lastNonEmptyStmt, "void incompatible with previous return type");
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckVariable(FunctionValidator& f, ParseNode* var, ValTypeVector* types, Vector<NumLit>* inits)
|
|
|
|
{
|
|
|
|
if (!var->isKind(PNK_NAME))
|
|
|
|
return f.fail(var, "local variable is not a plain name");
|
|
|
|
|
|
|
|
PropertyName* name = var->name();
|
|
|
|
|
|
|
|
if (!CheckIdentifier(f.m(), var, name))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ParseNode* initNode = MaybeInitializer(var);
|
|
|
|
if (!initNode)
|
|
|
|
return f.failName(var, "var '%s' needs explicit type declaration via an initial value", name);
|
|
|
|
|
|
|
|
NumLit lit;
|
|
|
|
if (!IsLiteralOrConst(f, initNode, &lit))
|
|
|
|
return f.failName(var, "var '%s' initializer must be literal or const literal", name);
|
|
|
|
|
|
|
|
if (!lit.valid())
|
|
|
|
return f.failName(var, "var '%s' initializer out of range", name);
|
|
|
|
|
|
|
|
Type type = Type::canonicalize(Type::lit(lit));
|
|
|
|
|
|
|
|
return f.addLocal(var, name, type) &&
|
|
|
|
types->append(type.canonicalToValType()) &&
|
|
|
|
inits->append(lit);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckVariables(FunctionValidator& f, ParseNode** stmtIter)
|
|
|
|
{
|
|
|
|
ParseNode* stmt = *stmtIter;
|
|
|
|
|
|
|
|
uint32_t firstVar = f.numLocals();
|
|
|
|
|
|
|
|
ValTypeVector types;
|
|
|
|
Vector<NumLit> inits(f.cx());
|
|
|
|
|
|
|
|
for (; stmt && stmt->isKind(PNK_VAR); stmt = NextNonEmptyStatement(stmt)) {
|
|
|
|
for (ParseNode* var = VarListHead(stmt); var; var = NextNode(var)) {
|
|
|
|
if (!CheckVariable(f, var, &types, &inits))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
MOZ_ASSERT(f.encoder().empty());
|
|
|
|
|
|
|
|
if (!EncodeLocalEntries(f.encoder(), types))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (uint32_t i = 0; i < inits.length(); i++) {
|
|
|
|
NumLit lit = inits[i];
|
|
|
|
if (lit.isZeroBits())
|
|
|
|
continue;
|
|
|
|
if (!f.writeConstExpr(lit))
|
|
|
|
return false;
|
|
|
|
if (!f.encoder().writeOp(Op::SetLocal))
|
|
|
|
return false;
|
|
|
|
if (!f.encoder().writeVarU32(firstVar + i))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*stmtIter = stmt;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckExpr(FunctionValidator& f, ParseNode* op, Type* type);
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckNumericLiteral(FunctionValidator& f, ParseNode* num, Type* type)
|
|
|
|
{
|
|
|
|
NumLit lit = ExtractNumericLiteral(f.m(), num);
|
|
|
|
if (!lit.valid())
|
|
|
|
return f.fail(num, "numeric literal out of representable integer range");
|
|
|
|
*type = Type::lit(lit);
|
|
|
|
return f.writeConstExpr(lit);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckVarRef(FunctionValidator& f, ParseNode* varRef, Type* type)
|
|
|
|
{
|
|
|
|
PropertyName* name = varRef->name();
|
|
|
|
|
|
|
|
if (const FunctionValidator::Local* local = f.lookupLocal(name)) {
|
|
|
|
if (!f.encoder().writeOp(Op::GetLocal))
|
|
|
|
return false;
|
|
|
|
if (!f.encoder().writeVarU32(local->slot))
|
|
|
|
return false;
|
|
|
|
*type = local->type;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const ModuleValidator::Global* global = f.lookupGlobal(name)) {
|
|
|
|
switch (global->which()) {
|
|
|
|
case ModuleValidator::Global::ConstantLiteral:
|
|
|
|
*type = global->varOrConstType();
|
|
|
|
return f.writeConstExpr(global->constLiteralValue());
|
|
|
|
case ModuleValidator::Global::ConstantImport:
|
|
|
|
case ModuleValidator::Global::Variable: {
|
|
|
|
*type = global->varOrConstType();
|
|
|
|
return f.encoder().writeOp(Op::GetGlobal) &&
|
|
|
|
f.encoder().writeVarU32(global->varOrConstIndex());
|
|
|
|
}
|
|
|
|
case ModuleValidator::Global::Function:
|
|
|
|
case ModuleValidator::Global::FFI:
|
|
|
|
case ModuleValidator::Global::MathBuiltinFunction:
|
|
|
|
case ModuleValidator::Global::AtomicsBuiltinFunction:
|
|
|
|
case ModuleValidator::Global::FuncPtrTable:
|
|
|
|
case ModuleValidator::Global::ArrayView:
|
|
|
|
case ModuleValidator::Global::ArrayViewCtor:
|
|
|
|
case ModuleValidator::Global::SimdCtor:
|
|
|
|
case ModuleValidator::Global::SimdOp:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return f.failName(varRef, "'%s' may not be accessed by ordinary expressions", name);
|
|
|
|
}
|
|
|
|
|
|
|
|
return f.failName(varRef, "'%s' not found in local or asm.js module scope", name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
IsLiteralOrConstInt(FunctionValidator& f, ParseNode* pn, uint32_t* u32)
|
|
|
|
{
|
|
|
|
NumLit lit;
|
|
|
|
if (!IsLiteralOrConst(f, pn, &lit))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return IsLiteralInt(lit, u32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const int32_t NoMask = -1;
|
|
|
|
static const bool YesSimd = true;
|
|
|
|
static const bool NoSimd = false;
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckArrayAccess(FunctionValidator& f, ParseNode* viewName, ParseNode* indexExpr,
|
|
|
|
bool isSimd, Scalar::Type* viewType)
|
|
|
|
{
|
|
|
|
if (!viewName->isKind(PNK_NAME))
|
|
|
|
return f.fail(viewName, "base of array access must be a typed array view name");
|
|
|
|
|
|
|
|
const ModuleValidator::Global* global = f.lookupGlobal(viewName->name());
|
|
|
|
if (!global || !global->isAnyArrayView())
|
|
|
|
return f.fail(viewName, "base of array access must be a typed array view name");
|
|
|
|
|
|
|
|
*viewType = global->viewType();
|
|
|
|
|
|
|
|
uint32_t index;
|
|
|
|
if (IsLiteralOrConstInt(f, indexExpr, &index)) {
|
|
|
|
uint64_t byteOffset = uint64_t(index) << TypedArrayShift(*viewType);
|
|
|
|
uint64_t width = isSimd ? Simd128DataSize : TypedArrayElemSize(*viewType);
|
|
|
|
if (!f.m().tryConstantAccess(byteOffset, width))
|
|
|
|
return f.fail(indexExpr, "constant index out of range");
|
|
|
|
|
|
|
|
return f.writeInt32Lit(byteOffset);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Mask off the low bits to account for the clearing effect of a right shift
|
|
|
|
// followed by the left shift implicit in the array access. E.g., H32[i>>2]
|
|
|
|
// loses the low two bits.
|
|
|
|
int32_t mask = ~(TypedArrayElemSize(*viewType) - 1);
|
|
|
|
|
|
|
|
if (indexExpr->isKind(PNK_RSH)) {
|
|
|
|
ParseNode* shiftAmountNode = BitwiseRight(indexExpr);
|
|
|
|
|
|
|
|
uint32_t shift;
|
|
|
|
if (!IsLiteralInt(f.m(), shiftAmountNode, &shift))
|
|
|
|
return f.failf(shiftAmountNode, "shift amount must be constant");
|
|
|
|
|
|
|
|
unsigned requiredShift = TypedArrayShift(*viewType);
|
|
|
|
if (shift != requiredShift)
|
|
|
|
return f.failf(shiftAmountNode, "shift amount must be %u", requiredShift);
|
|
|
|
|
|
|
|
ParseNode* pointerNode = BitwiseLeft(indexExpr);
|
|
|
|
|
|
|
|
Type pointerType;
|
|
|
|
if (!CheckExpr(f, pointerNode, &pointerType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!pointerType.isIntish())
|
|
|
|
return f.failf(pointerNode, "%s is not a subtype of int", pointerType.toChars());
|
|
|
|
} else {
|
|
|
|
// For SIMD access, and legacy scalar access compatibility, accept
|
|
|
|
// Int8/Uint8 accesses with no shift.
|
|
|
|
if (TypedArrayShift(*viewType) != 0)
|
|
|
|
return f.fail(indexExpr, "index expression isn't shifted; must be an Int8/Uint8 access");
|
|
|
|
|
|
|
|
MOZ_ASSERT(mask == NoMask);
|
|
|
|
|
|
|
|
ParseNode* pointerNode = indexExpr;
|
|
|
|
|
|
|
|
Type pointerType;
|
|
|
|
if (!CheckExpr(f, pointerNode, &pointerType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (isSimd) {
|
|
|
|
if (!pointerType.isIntish())
|
|
|
|
return f.failf(pointerNode, "%s is not a subtype of intish", pointerType.toChars());
|
|
|
|
} else {
|
|
|
|
if (!pointerType.isInt())
|
|
|
|
return f.failf(pointerNode, "%s is not a subtype of int", pointerType.toChars());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Don't generate the mask op if there is no need for it which could happen for
|
|
|
|
// a shift of zero or a SIMD access.
|
|
|
|
if (mask != NoMask) {
|
|
|
|
return f.writeInt32Lit(mask) &&
|
|
|
|
f.encoder().writeOp(Op::I32And);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAndPrepareArrayAccess(FunctionValidator& f, ParseNode* viewName, ParseNode* indexExpr,
|
|
|
|
bool isSimd, Scalar::Type* viewType)
|
|
|
|
{
|
|
|
|
return CheckArrayAccess(f, viewName, indexExpr, isSimd, viewType);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
WriteArrayAccessFlags(FunctionValidator& f, Scalar::Type viewType)
|
|
|
|
{
|
|
|
|
// asm.js only has naturally-aligned accesses.
|
|
|
|
size_t align = TypedArrayElemSize(viewType);
|
|
|
|
MOZ_ASSERT(IsPowerOfTwo(align));
|
|
|
|
if (!f.encoder().writeFixedU8(CeilingLog2(align)))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// asm.js doesn't have constant offsets, so just encode a 0.
|
|
|
|
if (!f.encoder().writeVarU32(0))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckLoadArray(FunctionValidator& f, ParseNode* elem, Type* type)
|
|
|
|
{
|
|
|
|
Scalar::Type viewType;
|
|
|
|
|
|
|
|
if (!CheckAndPrepareArrayAccess(f, ElemBase(elem), ElemIndex(elem), NoSimd, &viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
switch (viewType) {
|
|
|
|
case Scalar::Int8: if (!f.encoder().writeOp(Op::I32Load8S)) return false; break;
|
|
|
|
case Scalar::Uint8: if (!f.encoder().writeOp(Op::I32Load8U)) return false; break;
|
|
|
|
case Scalar::Int16: if (!f.encoder().writeOp(Op::I32Load16S)) return false; break;
|
|
|
|
case Scalar::Uint16: if (!f.encoder().writeOp(Op::I32Load16U)) return false; break;
|
|
|
|
case Scalar::Uint32:
|
|
|
|
case Scalar::Int32: if (!f.encoder().writeOp(Op::I32Load)) return false; break;
|
|
|
|
case Scalar::Float32: if (!f.encoder().writeOp(Op::F32Load)) return false; break;
|
|
|
|
case Scalar::Float64: if (!f.encoder().writeOp(Op::F64Load)) return false; break;
|
|
|
|
default: MOZ_CRASH("unexpected scalar type");
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (viewType) {
|
|
|
|
case Scalar::Int8:
|
|
|
|
case Scalar::Int16:
|
|
|
|
case Scalar::Int32:
|
|
|
|
case Scalar::Uint8:
|
|
|
|
case Scalar::Uint16:
|
|
|
|
case Scalar::Uint32:
|
|
|
|
*type = Type::Intish;
|
|
|
|
break;
|
|
|
|
case Scalar::Float32:
|
|
|
|
*type = Type::MaybeFloat;
|
|
|
|
break;
|
|
|
|
case Scalar::Float64:
|
|
|
|
*type = Type::MaybeDouble;
|
|
|
|
break;
|
|
|
|
default: MOZ_CRASH("Unexpected array type");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!WriteArrayAccessFlags(f, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckStoreArray(FunctionValidator& f, ParseNode* lhs, ParseNode* rhs, Type* type)
|
|
|
|
{
|
|
|
|
Scalar::Type viewType;
|
|
|
|
if (!CheckAndPrepareArrayAccess(f, ElemBase(lhs), ElemIndex(lhs), NoSimd, &viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Type rhsType;
|
|
|
|
if (!CheckExpr(f, rhs, &rhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
switch (viewType) {
|
|
|
|
case Scalar::Int8:
|
|
|
|
case Scalar::Int16:
|
|
|
|
case Scalar::Int32:
|
|
|
|
case Scalar::Uint8:
|
|
|
|
case Scalar::Uint16:
|
|
|
|
case Scalar::Uint32:
|
|
|
|
if (!rhsType.isIntish())
|
|
|
|
return f.failf(lhs, "%s is not a subtype of intish", rhsType.toChars());
|
|
|
|
break;
|
|
|
|
case Scalar::Float32:
|
|
|
|
if (!rhsType.isMaybeDouble() && !rhsType.isFloatish())
|
|
|
|
return f.failf(lhs, "%s is not a subtype of double? or floatish", rhsType.toChars());
|
|
|
|
break;
|
|
|
|
case Scalar::Float64:
|
|
|
|
if (!rhsType.isMaybeFloat() && !rhsType.isMaybeDouble())
|
|
|
|
return f.failf(lhs, "%s is not a subtype of float? or double?", rhsType.toChars());
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
MOZ_CRASH("Unexpected view type");
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (viewType) {
|
|
|
|
case Scalar::Int8:
|
|
|
|
case Scalar::Uint8:
|
|
|
|
if (!f.encoder().writeOp(Op::I32TeeStore8))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case Scalar::Int16:
|
|
|
|
case Scalar::Uint16:
|
|
|
|
if (!f.encoder().writeOp(Op::I32TeeStore16))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case Scalar::Int32:
|
|
|
|
case Scalar::Uint32:
|
|
|
|
if (!f.encoder().writeOp(Op::I32TeeStore))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case Scalar::Float32:
|
|
|
|
if (rhsType.isFloatish()) {
|
|
|
|
if (!f.encoder().writeOp(Op::F32TeeStore))
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
if (!f.encoder().writeOp(Op::F64TeeStoreF32))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Scalar::Float64:
|
|
|
|
if (rhsType.isFloatish()) {
|
|
|
|
if (!f.encoder().writeOp(Op::F32TeeStoreF64))
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
if (!f.encoder().writeOp(Op::F64TeeStore))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default: MOZ_CRASH("unexpected scalar type");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!WriteArrayAccessFlags(f, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = rhsType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAssignName(FunctionValidator& f, ParseNode* lhs, ParseNode* rhs, Type* type)
|
|
|
|
{
|
|
|
|
RootedPropertyName name(f.cx(), lhs->name());
|
|
|
|
|
|
|
|
if (const FunctionValidator::Local* lhsVar = f.lookupLocal(name)) {
|
|
|
|
Type rhsType;
|
|
|
|
if (!CheckExpr(f, rhs, &rhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.encoder().writeOp(Op::TeeLocal))
|
|
|
|
return false;
|
|
|
|
if (!f.encoder().writeVarU32(lhsVar->slot))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!(rhsType <= lhsVar->type)) {
|
|
|
|
return f.failf(lhs, "%s is not a subtype of %s",
|
|
|
|
rhsType.toChars(), lhsVar->type.toChars());
|
|
|
|
}
|
|
|
|
*type = rhsType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const ModuleValidator::Global* global = f.lookupGlobal(name)) {
|
|
|
|
if (global->which() != ModuleValidator::Global::Variable)
|
|
|
|
return f.failName(lhs, "'%s' is not a mutable variable", name);
|
|
|
|
|
|
|
|
Type rhsType;
|
|
|
|
if (!CheckExpr(f, rhs, &rhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Type globType = global->varOrConstType();
|
|
|
|
if (!(rhsType <= globType))
|
|
|
|
return f.failf(lhs, "%s is not a subtype of %s", rhsType.toChars(), globType.toChars());
|
|
|
|
if (!f.encoder().writeOp(Op::TeeGlobal))
|
|
|
|
return false;
|
|
|
|
if (!f.encoder().writeVarU32(global->varOrConstIndex()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = rhsType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return f.failName(lhs, "'%s' not found in local or asm.js module scope", name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAssign(FunctionValidator& f, ParseNode* assign, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(assign->isKind(PNK_ASSIGN));
|
|
|
|
|
|
|
|
ParseNode* lhs = BinaryLeft(assign);
|
|
|
|
ParseNode* rhs = BinaryRight(assign);
|
|
|
|
|
|
|
|
if (lhs->getKind() == PNK_ELEM)
|
|
|
|
return CheckStoreArray(f, lhs, rhs, type);
|
|
|
|
|
|
|
|
if (lhs->getKind() == PNK_NAME)
|
|
|
|
return CheckAssignName(f, lhs, rhs, type);
|
|
|
|
|
|
|
|
return f.fail(assign, "left-hand side of assignment must be a variable or array access");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckMathIMul(FunctionValidator& f, ParseNode* call, Type* type)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(call) != 2)
|
|
|
|
return f.fail(call, "Math.imul must be passed 2 arguments");
|
|
|
|
|
|
|
|
ParseNode* lhs = CallArgList(call);
|
|
|
|
ParseNode* rhs = NextNode(lhs);
|
|
|
|
|
|
|
|
Type lhsType;
|
|
|
|
if (!CheckExpr(f, lhs, &lhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Type rhsType;
|
|
|
|
if (!CheckExpr(f, rhs, &rhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!lhsType.isIntish())
|
|
|
|
return f.failf(lhs, "%s is not a subtype of intish", lhsType.toChars());
|
|
|
|
if (!rhsType.isIntish())
|
|
|
|
return f.failf(rhs, "%s is not a subtype of intish", rhsType.toChars());
|
|
|
|
|
|
|
|
*type = Type::Signed;
|
|
|
|
return f.encoder().writeOp(Op::I32Mul);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckMathClz32(FunctionValidator& f, ParseNode* call, Type* type)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(call) != 1)
|
|
|
|
return f.fail(call, "Math.clz32 must be passed 1 argument");
|
|
|
|
|
|
|
|
ParseNode* arg = CallArgList(call);
|
|
|
|
|
|
|
|
Type argType;
|
|
|
|
if (!CheckExpr(f, arg, &argType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!argType.isIntish())
|
|
|
|
return f.failf(arg, "%s is not a subtype of intish", argType.toChars());
|
|
|
|
|
|
|
|
*type = Type::Fixnum;
|
|
|
|
return f.encoder().writeOp(Op::I32Clz);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckMathAbs(FunctionValidator& f, ParseNode* call, Type* type)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(call) != 1)
|
|
|
|
return f.fail(call, "Math.abs must be passed 1 argument");
|
|
|
|
|
|
|
|
ParseNode* arg = CallArgList(call);
|
|
|
|
|
|
|
|
Type argType;
|
|
|
|
if (!CheckExpr(f, arg, &argType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (argType.isSigned()) {
|
|
|
|
*type = Type::Unsigned;
|
|
|
|
return f.encoder().writeOp(Op::I32Abs);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (argType.isMaybeDouble()) {
|
|
|
|
*type = Type::Double;
|
|
|
|
return f.encoder().writeOp(Op::F64Abs);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (argType.isMaybeFloat()) {
|
|
|
|
*type = Type::Floatish;
|
|
|
|
return f.encoder().writeOp(Op::F32Abs);
|
|
|
|
}
|
|
|
|
|
|
|
|
return f.failf(call, "%s is not a subtype of signed, float? or double?", argType.toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckMathSqrt(FunctionValidator& f, ParseNode* call, Type* type)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(call) != 1)
|
|
|
|
return f.fail(call, "Math.sqrt must be passed 1 argument");
|
|
|
|
|
|
|
|
ParseNode* arg = CallArgList(call);
|
|
|
|
|
|
|
|
Type argType;
|
|
|
|
if (!CheckExpr(f, arg, &argType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (argType.isMaybeDouble()) {
|
|
|
|
*type = Type::Double;
|
|
|
|
return f.encoder().writeOp(Op::F64Sqrt);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (argType.isMaybeFloat()) {
|
|
|
|
*type = Type::Floatish;
|
|
|
|
return f.encoder().writeOp(Op::F32Sqrt);
|
|
|
|
}
|
|
|
|
|
|
|
|
return f.failf(call, "%s is neither a subtype of double? nor float?", argType.toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckMathMinMax(FunctionValidator& f, ParseNode* callNode, bool isMax, Type* type)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(callNode) < 2)
|
|
|
|
return f.fail(callNode, "Math.min/max must be passed at least 2 arguments");
|
|
|
|
|
|
|
|
ParseNode* firstArg = CallArgList(callNode);
|
|
|
|
Type firstType;
|
|
|
|
if (!CheckExpr(f, firstArg, &firstType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Op op;
|
|
|
|
if (firstType.isMaybeDouble()) {
|
|
|
|
*type = Type::Double;
|
|
|
|
firstType = Type::MaybeDouble;
|
|
|
|
op = isMax ? Op::F64Max : Op::F64Min;
|
|
|
|
} else if (firstType.isMaybeFloat()) {
|
|
|
|
*type = Type::Float;
|
|
|
|
firstType = Type::MaybeFloat;
|
|
|
|
op = isMax ? Op::F32Max : Op::F32Min;
|
|
|
|
} else if (firstType.isSigned()) {
|
|
|
|
*type = Type::Signed;
|
|
|
|
firstType = Type::Signed;
|
|
|
|
op = isMax ? Op::I32Max : Op::I32Min;
|
|
|
|
} else {
|
|
|
|
return f.failf(firstArg, "%s is not a subtype of double?, float? or signed",
|
|
|
|
firstType.toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned numArgs = CallArgListLength(callNode);
|
|
|
|
ParseNode* nextArg = NextNode(firstArg);
|
|
|
|
for (unsigned i = 1; i < numArgs; i++, nextArg = NextNode(nextArg)) {
|
|
|
|
Type nextType;
|
|
|
|
if (!CheckExpr(f, nextArg, &nextType))
|
|
|
|
return false;
|
|
|
|
if (!(nextType <= firstType))
|
|
|
|
return f.failf(nextArg, "%s is not a subtype of %s", nextType.toChars(), firstType.toChars());
|
|
|
|
|
|
|
|
if (!f.encoder().writeOp(op))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSharedArrayAtomicAccess(FunctionValidator& f, ParseNode* viewName, ParseNode* indexExpr,
|
|
|
|
Scalar::Type* viewType)
|
|
|
|
{
|
|
|
|
if (!CheckAndPrepareArrayAccess(f, viewName, indexExpr, NoSimd, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// The global will be sane, CheckArrayAccess checks it.
|
|
|
|
const ModuleValidator::Global* global = f.lookupGlobal(viewName->name());
|
|
|
|
if (global->which() != ModuleValidator::Global::ArrayView)
|
|
|
|
return f.fail(viewName, "base of array access must be a typed array view");
|
|
|
|
|
|
|
|
MOZ_ASSERT(f.m().atomicsPresent());
|
|
|
|
|
|
|
|
switch (*viewType) {
|
|
|
|
case Scalar::Int8:
|
|
|
|
case Scalar::Int16:
|
|
|
|
case Scalar::Int32:
|
|
|
|
case Scalar::Uint8:
|
|
|
|
case Scalar::Uint16:
|
|
|
|
case Scalar::Uint32:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return f.failf(viewName, "not an integer array");
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
WriteAtomicOperator(FunctionValidator& f, Op opcode, Scalar::Type viewType)
|
|
|
|
{
|
|
|
|
return f.encoder().writeOp(opcode) &&
|
|
|
|
f.encoder().writeFixedU8(viewType);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAtomicsLoad(FunctionValidator& f, ParseNode* call, Type* type)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(call) != 2)
|
|
|
|
return f.fail(call, "Atomics.load must be passed 2 arguments");
|
|
|
|
|
|
|
|
ParseNode* arrayArg = CallArgList(call);
|
|
|
|
ParseNode* indexArg = NextNode(arrayArg);
|
|
|
|
|
|
|
|
Scalar::Type viewType;
|
|
|
|
if (!CheckSharedArrayAtomicAccess(f, arrayArg, indexArg, &viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteAtomicOperator(f, Op::I32AtomicsLoad, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteArrayAccessFlags(f, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = Type::Int;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAtomicsStore(FunctionValidator& f, ParseNode* call, Type* type)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(call) != 3)
|
|
|
|
return f.fail(call, "Atomics.store must be passed 3 arguments");
|
|
|
|
|
|
|
|
ParseNode* arrayArg = CallArgList(call);
|
|
|
|
ParseNode* indexArg = NextNode(arrayArg);
|
|
|
|
ParseNode* valueArg = NextNode(indexArg);
|
|
|
|
|
|
|
|
Type rhsType;
|
|
|
|
if (!CheckExpr(f, valueArg, &rhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!rhsType.isIntish())
|
|
|
|
return f.failf(arrayArg, "%s is not a subtype of intish", rhsType.toChars());
|
|
|
|
|
|
|
|
Scalar::Type viewType;
|
|
|
|
if (!CheckSharedArrayAtomicAccess(f, arrayArg, indexArg, &viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteAtomicOperator(f, Op::I32AtomicsStore, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteArrayAccessFlags(f, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = rhsType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAtomicsBinop(FunctionValidator& f, ParseNode* call, Type* type, AtomicOp op)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(call) != 3)
|
|
|
|
return f.fail(call, "Atomics binary operator must be passed 3 arguments");
|
|
|
|
|
|
|
|
ParseNode* arrayArg = CallArgList(call);
|
|
|
|
ParseNode* indexArg = NextNode(arrayArg);
|
|
|
|
ParseNode* valueArg = NextNode(indexArg);
|
|
|
|
|
|
|
|
Type valueArgType;
|
|
|
|
if (!CheckExpr(f, valueArg, &valueArgType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!valueArgType.isIntish())
|
|
|
|
return f.failf(valueArg, "%s is not a subtype of intish", valueArgType.toChars());
|
|
|
|
|
|
|
|
Scalar::Type viewType;
|
|
|
|
if (!CheckSharedArrayAtomicAccess(f, arrayArg, indexArg, &viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteAtomicOperator(f, Op::I32AtomicsBinOp, viewType))
|
|
|
|
return false;
|
|
|
|
if (!f.encoder().writeFixedU8(uint8_t(op)))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteArrayAccessFlags(f, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = Type::Int;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAtomicsIsLockFree(FunctionValidator& f, ParseNode* call, Type* type)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(call) != 1)
|
|
|
|
return f.fail(call, "Atomics.isLockFree must be passed 1 argument");
|
|
|
|
|
|
|
|
ParseNode* sizeArg = CallArgList(call);
|
|
|
|
|
|
|
|
uint32_t size;
|
|
|
|
if (!IsLiteralInt(f.m(), sizeArg, &size))
|
|
|
|
return f.fail(sizeArg, "Atomics.isLockFree requires an integer literal argument");
|
|
|
|
|
|
|
|
*type = Type::Int;
|
|
|
|
return f.writeInt32Lit(AtomicOperations::isLockfree(size));
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAtomicsCompareExchange(FunctionValidator& f, ParseNode* call, Type* type)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(call) != 4)
|
|
|
|
return f.fail(call, "Atomics.compareExchange must be passed 4 arguments");
|
|
|
|
|
|
|
|
ParseNode* arrayArg = CallArgList(call);
|
|
|
|
ParseNode* indexArg = NextNode(arrayArg);
|
|
|
|
ParseNode* oldValueArg = NextNode(indexArg);
|
|
|
|
ParseNode* newValueArg = NextNode(oldValueArg);
|
|
|
|
|
|
|
|
Type oldValueArgType;
|
|
|
|
if (!CheckExpr(f, oldValueArg, &oldValueArgType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Type newValueArgType;
|
|
|
|
if (!CheckExpr(f, newValueArg, &newValueArgType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!oldValueArgType.isIntish())
|
|
|
|
return f.failf(oldValueArg, "%s is not a subtype of intish", oldValueArgType.toChars());
|
|
|
|
|
|
|
|
if (!newValueArgType.isIntish())
|
|
|
|
return f.failf(newValueArg, "%s is not a subtype of intish", newValueArgType.toChars());
|
|
|
|
|
|
|
|
Scalar::Type viewType;
|
|
|
|
if (!CheckSharedArrayAtomicAccess(f, arrayArg, indexArg, &viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteAtomicOperator(f, Op::I32AtomicsCompareExchange, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteArrayAccessFlags(f, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = Type::Int;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAtomicsExchange(FunctionValidator& f, ParseNode* call, Type* type)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(call) != 3)
|
|
|
|
return f.fail(call, "Atomics.exchange must be passed 3 arguments");
|
|
|
|
|
|
|
|
ParseNode* arrayArg = CallArgList(call);
|
|
|
|
ParseNode* indexArg = NextNode(arrayArg);
|
|
|
|
ParseNode* valueArg = NextNode(indexArg);
|
|
|
|
|
|
|
|
Type valueArgType;
|
|
|
|
if (!CheckExpr(f, valueArg, &valueArgType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!valueArgType.isIntish())
|
|
|
|
return f.failf(arrayArg, "%s is not a subtype of intish", valueArgType.toChars());
|
|
|
|
|
|
|
|
Scalar::Type viewType;
|
|
|
|
if (!CheckSharedArrayAtomicAccess(f, arrayArg, indexArg, &viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteAtomicOperator(f, Op::I32AtomicsExchange, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteArrayAccessFlags(f, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = Type::Int;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAtomicsBuiltinCall(FunctionValidator& f, ParseNode* callNode, AsmJSAtomicsBuiltinFunction func,
|
|
|
|
Type* type)
|
|
|
|
{
|
|
|
|
f.setUsesAtomics();
|
|
|
|
|
|
|
|
switch (func) {
|
|
|
|
case AsmJSAtomicsBuiltin_compareExchange:
|
|
|
|
return CheckAtomicsCompareExchange(f, callNode, type);
|
|
|
|
case AsmJSAtomicsBuiltin_exchange:
|
|
|
|
return CheckAtomicsExchange(f, callNode, type);
|
|
|
|
case AsmJSAtomicsBuiltin_load:
|
|
|
|
return CheckAtomicsLoad(f, callNode, type);
|
|
|
|
case AsmJSAtomicsBuiltin_store:
|
|
|
|
return CheckAtomicsStore(f, callNode, type);
|
|
|
|
case AsmJSAtomicsBuiltin_add:
|
|
|
|
return CheckAtomicsBinop(f, callNode, type, AtomicFetchAddOp);
|
|
|
|
case AsmJSAtomicsBuiltin_sub:
|
|
|
|
return CheckAtomicsBinop(f, callNode, type, AtomicFetchSubOp);
|
|
|
|
case AsmJSAtomicsBuiltin_and:
|
|
|
|
return CheckAtomicsBinop(f, callNode, type, AtomicFetchAndOp);
|
|
|
|
case AsmJSAtomicsBuiltin_or:
|
|
|
|
return CheckAtomicsBinop(f, callNode, type, AtomicFetchOrOp);
|
|
|
|
case AsmJSAtomicsBuiltin_xor:
|
|
|
|
return CheckAtomicsBinop(f, callNode, type, AtomicFetchXorOp);
|
|
|
|
case AsmJSAtomicsBuiltin_isLockFree:
|
|
|
|
return CheckAtomicsIsLockFree(f, callNode, type);
|
|
|
|
default:
|
|
|
|
MOZ_CRASH("unexpected atomicsBuiltin function");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef bool (*CheckArgType)(FunctionValidator& f, ParseNode* argNode, Type type);
|
|
|
|
|
|
|
|
template <CheckArgType checkArg>
|
|
|
|
static bool
|
|
|
|
CheckCallArgs(FunctionValidator& f, ParseNode* callNode, ValTypeVector* args)
|
|
|
|
{
|
|
|
|
ParseNode* argNode = CallArgList(callNode);
|
|
|
|
for (unsigned i = 0; i < CallArgListLength(callNode); i++, argNode = NextNode(argNode)) {
|
|
|
|
Type type;
|
|
|
|
if (!CheckExpr(f, argNode, &type))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!checkArg(f, argNode, type))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!args->append(Type::canonicalize(type).canonicalToValType()))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSignatureAgainstExisting(ModuleValidator& m, ParseNode* usepn, const Sig& sig, const Sig& existing)
|
|
|
|
{
|
|
|
|
if (sig.args().length() != existing.args().length()) {
|
|
|
|
return m.failf(usepn, "incompatible number of arguments (%" PRIuSIZE
|
|
|
|
" here vs. %" PRIuSIZE " before)",
|
|
|
|
sig.args().length(), existing.args().length());
|
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < sig.args().length(); i++) {
|
|
|
|
if (sig.arg(i) != existing.arg(i)) {
|
|
|
|
return m.failf(usepn, "incompatible type for argument %u: (%s here vs. %s before)", i,
|
|
|
|
ToCString(sig.arg(i)), ToCString(existing.arg(i)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sig.ret() != existing.ret()) {
|
|
|
|
return m.failf(usepn, "%s incompatible with previous return of type %s",
|
|
|
|
ToCString(sig.ret()), ToCString(existing.ret()));
|
|
|
|
}
|
|
|
|
|
|
|
|
MOZ_ASSERT(sig == existing);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFunctionSignature(ModuleValidator& m, ParseNode* usepn, Sig&& sig, PropertyName* name,
|
|
|
|
ModuleValidator::Func** func)
|
|
|
|
{
|
|
|
|
ModuleValidator::Func* existing = m.lookupFunction(name);
|
|
|
|
if (!existing) {
|
|
|
|
if (!CheckModuleLevelName(m, usepn, name))
|
|
|
|
return false;
|
|
|
|
return m.addFunction(name, usepn->pn_pos.begin, Move(sig), func);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!CheckSignatureAgainstExisting(m, usepn, sig, m.mg().funcSig(existing->index())))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*func = existing;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckIsArgType(FunctionValidator& f, ParseNode* argNode, Type type)
|
|
|
|
{
|
|
|
|
if (!type.isArgType())
|
|
|
|
return f.failf(argNode,
|
|
|
|
"%s is not a subtype of int, float, double, or an allowed SIMD type",
|
|
|
|
type.toChars());
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckInternalCall(FunctionValidator& f, ParseNode* callNode, PropertyName* calleeName,
|
|
|
|
Type ret, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(ret.isCanonical());
|
|
|
|
|
|
|
|
ValTypeVector args;
|
|
|
|
if (!CheckCallArgs<CheckIsArgType>(f, callNode, &args))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Sig sig(Move(args), ret.canonicalToExprType());
|
|
|
|
|
|
|
|
ModuleValidator::Func* callee;
|
|
|
|
if (!CheckFunctionSignature(f.m(), callNode, Move(sig), calleeName, &callee))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.writeCall(callNode, Op::Call))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.encoder().writeVarU32(callee->index()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = Type::ret(ret);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFuncPtrTableAgainstExisting(ModuleValidator& m, ParseNode* usepn, PropertyName* name,
|
|
|
|
Sig&& sig, unsigned mask, uint32_t* funcPtrTableIndex)
|
|
|
|
{
|
|
|
|
if (const ModuleValidator::Global* existing = m.lookupGlobal(name)) {
|
|
|
|
if (existing->which() != ModuleValidator::Global::FuncPtrTable)
|
|
|
|
return m.failName(usepn, "'%s' is not a function-pointer table", name);
|
|
|
|
|
|
|
|
ModuleValidator::FuncPtrTable& table = m.funcPtrTable(existing->funcPtrTableIndex());
|
|
|
|
if (mask != table.mask())
|
|
|
|
return m.failf(usepn, "mask does not match previous value (%u)", table.mask());
|
|
|
|
|
|
|
|
if (!CheckSignatureAgainstExisting(m, usepn, sig, m.mg().sig(table.sigIndex())))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*funcPtrTableIndex = existing->funcPtrTableIndex();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!CheckModuleLevelName(m, usepn, name))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!m.declareFuncPtrTable(Move(sig), name, usepn->pn_pos.begin, mask, funcPtrTableIndex))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFuncPtrCall(FunctionValidator& f, ParseNode* callNode, Type ret, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(ret.isCanonical());
|
|
|
|
|
|
|
|
ParseNode* callee = CallCallee(callNode);
|
|
|
|
ParseNode* tableNode = ElemBase(callee);
|
|
|
|
ParseNode* indexExpr = ElemIndex(callee);
|
|
|
|
|
|
|
|
if (!tableNode->isKind(PNK_NAME))
|
|
|
|
return f.fail(tableNode, "expecting name of function-pointer array");
|
|
|
|
|
|
|
|
PropertyName* name = tableNode->name();
|
|
|
|
if (const ModuleValidator::Global* existing = f.lookupGlobal(name)) {
|
|
|
|
if (existing->which() != ModuleValidator::Global::FuncPtrTable)
|
|
|
|
return f.failName(tableNode, "'%s' is not the name of a function-pointer array", name);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!indexExpr->isKind(PNK_BITAND))
|
|
|
|
return f.fail(indexExpr, "function-pointer table index expression needs & mask");
|
|
|
|
|
|
|
|
ParseNode* indexNode = BitwiseLeft(indexExpr);
|
|
|
|
ParseNode* maskNode = BitwiseRight(indexExpr);
|
|
|
|
|
|
|
|
uint32_t mask;
|
|
|
|
if (!IsLiteralInt(f.m(), maskNode, &mask) || mask == UINT32_MAX || !IsPowerOfTwo(mask + 1))
|
|
|
|
return f.fail(maskNode, "function-pointer table index mask value must be a power of two minus 1");
|
|
|
|
|
|
|
|
Type indexType;
|
|
|
|
if (!CheckExpr(f, indexNode, &indexType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!indexType.isIntish())
|
|
|
|
return f.failf(indexNode, "%s is not a subtype of intish", indexType.toChars());
|
|
|
|
|
|
|
|
ValTypeVector args;
|
|
|
|
if (!CheckCallArgs<CheckIsArgType>(f, callNode, &args))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Sig sig(Move(args), ret.canonicalToExprType());
|
|
|
|
|
|
|
|
uint32_t tableIndex;
|
|
|
|
if (!CheckFuncPtrTableAgainstExisting(f.m(), tableNode, name, Move(sig), mask, &tableIndex))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.writeCall(callNode, Op::OldCallIndirect))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Call signature
|
|
|
|
if (!f.encoder().writeVarU32(f.m().funcPtrTable(tableIndex).sigIndex()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = Type::ret(ret);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckIsExternType(FunctionValidator& f, ParseNode* argNode, Type type)
|
|
|
|
{
|
|
|
|
if (!type.isExtern())
|
|
|
|
return f.failf(argNode, "%s is not a subtype of extern", type.toChars());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFFICall(FunctionValidator& f, ParseNode* callNode, unsigned ffiIndex, Type ret, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(ret.isCanonical());
|
|
|
|
|
|
|
|
PropertyName* calleeName = CallCallee(callNode)->name();
|
|
|
|
|
|
|
|
if (ret.isFloat())
|
|
|
|
return f.fail(callNode, "FFI calls can't return float");
|
|
|
|
if (ret.isSimd())
|
|
|
|
return f.fail(callNode, "FFI calls can't return SIMD values");
|
|
|
|
|
|
|
|
ValTypeVector args;
|
|
|
|
if (!CheckCallArgs<CheckIsExternType>(f, callNode, &args))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Sig sig(Move(args), ret.canonicalToExprType());
|
|
|
|
|
|
|
|
uint32_t funcIndex;
|
|
|
|
if (!f.m().declareImport(calleeName, Move(sig), ffiIndex, &funcIndex))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.writeCall(callNode, Op::Call))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.encoder().writeVarU32(funcIndex))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = Type::ret(ret);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFloatCoercionArg(FunctionValidator& f, ParseNode* inputNode, Type inputType)
|
|
|
|
{
|
|
|
|
if (inputType.isMaybeDouble())
|
|
|
|
return f.encoder().writeOp(Op::F32DemoteF64);
|
|
|
|
if (inputType.isSigned())
|
|
|
|
return f.encoder().writeOp(Op::F32ConvertSI32);
|
|
|
|
if (inputType.isUnsigned())
|
|
|
|
return f.encoder().writeOp(Op::F32ConvertUI32);
|
|
|
|
if (inputType.isFloatish())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return f.failf(inputNode, "%s is not a subtype of signed, unsigned, double? or floatish",
|
|
|
|
inputType.toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckCoercedCall(FunctionValidator& f, ParseNode* call, Type ret, Type* type);
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckCoercionArg(FunctionValidator& f, ParseNode* arg, Type expected, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(expected.isCanonicalValType());
|
|
|
|
|
|
|
|
if (arg->isKind(PNK_CALL))
|
|
|
|
return CheckCoercedCall(f, arg, expected, type);
|
|
|
|
|
|
|
|
Type argType;
|
|
|
|
if (!CheckExpr(f, arg, &argType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (expected.isFloat()) {
|
|
|
|
if (!CheckFloatCoercionArg(f, arg, argType))
|
|
|
|
return false;
|
|
|
|
} else if (expected.isSimd()) {
|
|
|
|
if (!(argType <= expected))
|
|
|
|
return f.fail(arg, "argument to SIMD coercion isn't from the correct SIMD type");
|
|
|
|
} else {
|
|
|
|
MOZ_CRASH("not call coercions");
|
|
|
|
}
|
|
|
|
|
|
|
|
*type = Type::ret(expected);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckMathFRound(FunctionValidator& f, ParseNode* callNode, Type* type)
|
|
|
|
{
|
|
|
|
if (CallArgListLength(callNode) != 1)
|
|
|
|
return f.fail(callNode, "Math.fround must be passed 1 argument");
|
|
|
|
|
|
|
|
ParseNode* argNode = CallArgList(callNode);
|
|
|
|
Type argType;
|
|
|
|
if (!CheckCoercionArg(f, argNode, Type::Float, &argType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
MOZ_ASSERT(argType == Type::Float);
|
|
|
|
*type = Type::Float;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckMathBuiltinCall(FunctionValidator& f, ParseNode* callNode, AsmJSMathBuiltinFunction func,
|
|
|
|
Type* type)
|
|
|
|
{
|
|
|
|
unsigned arity = 0;
|
|
|
|
Op f32;
|
|
|
|
Op f64;
|
|
|
|
switch (func) {
|
|
|
|
case AsmJSMathBuiltin_imul: return CheckMathIMul(f, callNode, type);
|
|
|
|
case AsmJSMathBuiltin_clz32: return CheckMathClz32(f, callNode, type);
|
|
|
|
case AsmJSMathBuiltin_abs: return CheckMathAbs(f, callNode, type);
|
|
|
|
case AsmJSMathBuiltin_sqrt: return CheckMathSqrt(f, callNode, type);
|
|
|
|
case AsmJSMathBuiltin_fround: return CheckMathFRound(f, callNode, type);
|
|
|
|
case AsmJSMathBuiltin_min: return CheckMathMinMax(f, callNode, /* isMax = */ false, type);
|
|
|
|
case AsmJSMathBuiltin_max: return CheckMathMinMax(f, callNode, /* isMax = */ true, type);
|
|
|
|
case AsmJSMathBuiltin_ceil: arity = 1; f64 = Op::F64Ceil; f32 = Op::F32Ceil; break;
|
|
|
|
case AsmJSMathBuiltin_floor: arity = 1; f64 = Op::F64Floor; f32 = Op::F32Floor; break;
|
|
|
|
case AsmJSMathBuiltin_sin: arity = 1; f64 = Op::F64Sin; f32 = Op::Unreachable; break;
|
|
|
|
case AsmJSMathBuiltin_cos: arity = 1; f64 = Op::F64Cos; f32 = Op::Unreachable; break;
|
|
|
|
case AsmJSMathBuiltin_tan: arity = 1; f64 = Op::F64Tan; f32 = Op::Unreachable; break;
|
|
|
|
case AsmJSMathBuiltin_asin: arity = 1; f64 = Op::F64Asin; f32 = Op::Unreachable; break;
|
|
|
|
case AsmJSMathBuiltin_acos: arity = 1; f64 = Op::F64Acos; f32 = Op::Unreachable; break;
|
|
|
|
case AsmJSMathBuiltin_atan: arity = 1; f64 = Op::F64Atan; f32 = Op::Unreachable; break;
|
|
|
|
case AsmJSMathBuiltin_exp: arity = 1; f64 = Op::F64Exp; f32 = Op::Unreachable; break;
|
|
|
|
case AsmJSMathBuiltin_log: arity = 1; f64 = Op::F64Log; f32 = Op::Unreachable; break;
|
|
|
|
case AsmJSMathBuiltin_pow: arity = 2; f64 = Op::F64Pow; f32 = Op::Unreachable; break;
|
|
|
|
case AsmJSMathBuiltin_atan2: arity = 2; f64 = Op::F64Atan2; f32 = Op::Unreachable; break;
|
|
|
|
default: MOZ_CRASH("unexpected mathBuiltin function");
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned actualArity = CallArgListLength(callNode);
|
|
|
|
if (actualArity != arity)
|
|
|
|
return f.failf(callNode, "call passed %u arguments, expected %u", actualArity, arity);
|
|
|
|
|
|
|
|
if (!f.prepareCall(callNode))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Type firstType;
|
|
|
|
ParseNode* argNode = CallArgList(callNode);
|
|
|
|
if (!CheckExpr(f, argNode, &firstType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!firstType.isMaybeFloat() && !firstType.isMaybeDouble())
|
|
|
|
return f.fail(argNode, "arguments to math call should be a subtype of double? or float?");
|
|
|
|
|
|
|
|
bool opIsDouble = firstType.isMaybeDouble();
|
|
|
|
if (!opIsDouble && f32 == Op::Unreachable)
|
|
|
|
return f.fail(callNode, "math builtin cannot be used as float");
|
|
|
|
|
|
|
|
if (arity == 2) {
|
|
|
|
Type secondType;
|
|
|
|
argNode = NextNode(argNode);
|
|
|
|
if (!CheckExpr(f, argNode, &secondType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (firstType.isMaybeDouble() && !secondType.isMaybeDouble())
|
|
|
|
return f.fail(argNode, "both arguments to math builtin call should be the same type");
|
|
|
|
if (firstType.isMaybeFloat() && !secondType.isMaybeFloat())
|
|
|
|
return f.fail(argNode, "both arguments to math builtin call should be the same type");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (opIsDouble) {
|
|
|
|
if (!f.encoder().writeOp(f64))
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
if (!f.encoder().writeOp(f32))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*type = opIsDouble ? Type::Double : Type::Floatish;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
// Include CheckSimdCallArgs in unnamed namespace to avoid MSVC name lookup bug.
|
|
|
|
|
|
|
|
template<class CheckArgOp>
|
|
|
|
static bool
|
|
|
|
CheckSimdCallArgs(FunctionValidator& f, ParseNode* call, unsigned expectedArity,
|
|
|
|
const CheckArgOp& checkArg)
|
|
|
|
{
|
|
|
|
unsigned numArgs = CallArgListLength(call);
|
|
|
|
if (numArgs != expectedArity)
|
|
|
|
return f.failf(call, "expected %u arguments to SIMD call, got %u", expectedArity, numArgs);
|
|
|
|
|
|
|
|
ParseNode* arg = CallArgList(call);
|
|
|
|
for (size_t i = 0; i < numArgs; i++, arg = NextNode(arg)) {
|
|
|
|
MOZ_ASSERT(!!arg);
|
|
|
|
Type argType;
|
|
|
|
if (!CheckExpr(f, arg, &argType))
|
|
|
|
return false;
|
|
|
|
if (!checkArg(f, arg, i, argType))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
class CheckArgIsSubtypeOf
|
|
|
|
{
|
|
|
|
Type formalType_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit CheckArgIsSubtypeOf(SimdType t) : formalType_(t) {}
|
|
|
|
|
|
|
|
bool operator()(FunctionValidator& f, ParseNode* arg, unsigned argIndex, Type actualType) const
|
|
|
|
{
|
|
|
|
if (!(actualType <= formalType_)) {
|
|
|
|
return f.failf(arg, "%s is not a subtype of %s", actualType.toChars(),
|
|
|
|
formalType_.toChars());
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline Type
|
|
|
|
SimdToCoercedScalarType(SimdType t)
|
|
|
|
{
|
|
|
|
switch (t) {
|
|
|
|
case SimdType::Int8x16:
|
|
|
|
case SimdType::Int16x8:
|
|
|
|
case SimdType::Int32x4:
|
|
|
|
case SimdType::Uint8x16:
|
|
|
|
case SimdType::Uint16x8:
|
|
|
|
case SimdType::Uint32x4:
|
|
|
|
case SimdType::Bool8x16:
|
|
|
|
case SimdType::Bool16x8:
|
|
|
|
case SimdType::Bool32x4:
|
|
|
|
return Type::Intish;
|
|
|
|
case SimdType::Float32x4:
|
|
|
|
return Type::Floatish;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("unexpected SIMD type");
|
|
|
|
}
|
|
|
|
|
|
|
|
class CheckSimdScalarArgs
|
|
|
|
{
|
|
|
|
SimdType simdType_;
|
|
|
|
Type formalType_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit CheckSimdScalarArgs(SimdType simdType)
|
|
|
|
: simdType_(simdType), formalType_(SimdToCoercedScalarType(simdType))
|
|
|
|
{}
|
|
|
|
|
|
|
|
bool operator()(FunctionValidator& f, ParseNode* arg, unsigned argIndex, Type actualType) const
|
|
|
|
{
|
|
|
|
if (!(actualType <= formalType_)) {
|
|
|
|
// As a special case, accept doublelit arguments to float32x4 ops by
|
|
|
|
// re-emitting them as float32 constants.
|
|
|
|
if (simdType_ != SimdType::Float32x4 || !actualType.isDoubleLit()) {
|
|
|
|
return f.failf(arg, "%s is not a subtype of %s%s",
|
|
|
|
actualType.toChars(), formalType_.toChars(),
|
|
|
|
simdType_ == SimdType::Float32x4 ? " or doublelit" : "");
|
|
|
|
}
|
|
|
|
|
|
|
|
// We emitted a double literal and actually want a float32.
|
|
|
|
return f.encoder().writeOp(Op::F32DemoteF64);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class CheckSimdSelectArgs
|
|
|
|
{
|
|
|
|
Type formalType_;
|
|
|
|
Type maskType_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit CheckSimdSelectArgs(SimdType t) : formalType_(t), maskType_(GetBooleanSimdType(t)) {}
|
|
|
|
|
|
|
|
bool operator()(FunctionValidator& f, ParseNode* arg, unsigned argIndex, Type actualType) const
|
|
|
|
{
|
|
|
|
// The first argument is the boolean selector, the next two are the
|
|
|
|
// values to choose from.
|
|
|
|
Type wantedType = argIndex == 0 ? maskType_ : formalType_;
|
|
|
|
|
|
|
|
if (!(actualType <= wantedType)) {
|
|
|
|
return f.failf(arg, "%s is not a subtype of %s", actualType.toChars(),
|
|
|
|
wantedType.toChars());
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class CheckSimdVectorScalarArgs
|
|
|
|
{
|
|
|
|
SimdType formalSimdType_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit CheckSimdVectorScalarArgs(SimdType t) : formalSimdType_(t) {}
|
|
|
|
|
|
|
|
bool operator()(FunctionValidator& f, ParseNode* arg, unsigned argIndex, Type actualType) const
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(argIndex < 2);
|
|
|
|
if (argIndex == 0) {
|
|
|
|
// First argument is the vector
|
|
|
|
if (!(actualType <= Type(formalSimdType_))) {
|
|
|
|
return f.failf(arg, "%s is not a subtype of %s", actualType.toChars(),
|
|
|
|
Type(formalSimdType_).toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Second argument is the scalar
|
|
|
|
return CheckSimdScalarArgs(formalSimdType_)(f, arg, argIndex, actualType);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdUnary(FunctionValidator& f, ParseNode* call, SimdType opType, SimdOperation op,
|
|
|
|
Type* type)
|
|
|
|
{
|
|
|
|
if (!CheckSimdCallArgs(f, call, 1, CheckArgIsSubtypeOf(opType)))
|
|
|
|
return false;
|
|
|
|
if (!f.writeSimdOp(opType, op))
|
|
|
|
return false;
|
|
|
|
*type = opType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdBinaryShift(FunctionValidator& f, ParseNode* call, SimdType opType, SimdOperation op,
|
|
|
|
Type *type)
|
|
|
|
{
|
|
|
|
if (!CheckSimdCallArgs(f, call, 2, CheckSimdVectorScalarArgs(opType)))
|
|
|
|
return false;
|
|
|
|
if (!f.writeSimdOp(opType, op))
|
|
|
|
return false;
|
|
|
|
*type = opType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdBinaryComp(FunctionValidator& f, ParseNode* call, SimdType opType, SimdOperation op,
|
|
|
|
Type *type)
|
|
|
|
{
|
|
|
|
if (!CheckSimdCallArgs(f, call, 2, CheckArgIsSubtypeOf(opType)))
|
|
|
|
return false;
|
|
|
|
if (!f.writeSimdOp(opType, op))
|
|
|
|
return false;
|
|
|
|
*type = GetBooleanSimdType(opType);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdBinary(FunctionValidator& f, ParseNode* call, SimdType opType, SimdOperation op,
|
|
|
|
Type* type)
|
|
|
|
{
|
|
|
|
if (!CheckSimdCallArgs(f, call, 2, CheckArgIsSubtypeOf(opType)))
|
|
|
|
return false;
|
|
|
|
if (!f.writeSimdOp(opType, op))
|
|
|
|
return false;
|
|
|
|
*type = opType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdExtractLane(FunctionValidator& f, ParseNode* call, SimdType opType, Type* type)
|
|
|
|
{
|
|
|
|
switch (opType) {
|
|
|
|
case SimdType::Int8x16:
|
|
|
|
case SimdType::Int16x8:
|
|
|
|
case SimdType::Int32x4: *type = Type::Signed; break;
|
|
|
|
case SimdType::Uint8x16:
|
|
|
|
case SimdType::Uint16x8:
|
|
|
|
case SimdType::Uint32x4: *type = Type::Unsigned; break;
|
|
|
|
case SimdType::Float32x4: *type = Type::Float; break;
|
|
|
|
case SimdType::Bool8x16:
|
|
|
|
case SimdType::Bool16x8:
|
|
|
|
case SimdType::Bool32x4: *type = Type::Int; break;
|
|
|
|
default: MOZ_CRASH("unhandled simd type");
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned numArgs = CallArgListLength(call);
|
|
|
|
if (numArgs != 2)
|
|
|
|
return f.failf(call, "expected 2 arguments to SIMD extract, got %u", numArgs);
|
|
|
|
|
|
|
|
ParseNode* arg = CallArgList(call);
|
|
|
|
|
|
|
|
// First argument is the vector
|
|
|
|
Type vecType;
|
|
|
|
if (!CheckExpr(f, arg, &vecType))
|
|
|
|
return false;
|
|
|
|
if (!(vecType <= Type(opType))) {
|
|
|
|
return f.failf(arg, "%s is not a subtype of %s", vecType.toChars(),
|
|
|
|
Type(opType).toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
arg = NextNode(arg);
|
|
|
|
|
|
|
|
// Second argument is the lane < vector length
|
|
|
|
uint32_t lane;
|
|
|
|
if (!IsLiteralOrConstInt(f, arg, &lane))
|
|
|
|
return f.failf(arg, "lane selector should be a constant integer literal");
|
|
|
|
if (lane >= GetSimdLanes(opType))
|
|
|
|
return f.failf(arg, "lane selector should be in bounds");
|
|
|
|
|
|
|
|
if (!f.writeSimdOp(opType, SimdOperation::Fn_extractLane))
|
|
|
|
return false;
|
|
|
|
if (!f.encoder().writeVarU32(lane))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdReplaceLane(FunctionValidator& f, ParseNode* call, SimdType opType, Type* type)
|
|
|
|
{
|
|
|
|
unsigned numArgs = CallArgListLength(call);
|
|
|
|
if (numArgs != 3)
|
|
|
|
return f.failf(call, "expected 2 arguments to SIMD replace, got %u", numArgs);
|
|
|
|
|
|
|
|
ParseNode* arg = CallArgList(call);
|
|
|
|
|
|
|
|
// First argument is the vector
|
|
|
|
Type vecType;
|
|
|
|
if (!CheckExpr(f, arg, &vecType))
|
|
|
|
return false;
|
|
|
|
if (!(vecType <= Type(opType))) {
|
|
|
|
return f.failf(arg, "%s is not a subtype of %s", vecType.toChars(),
|
|
|
|
Type(opType).toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
arg = NextNode(arg);
|
|
|
|
|
|
|
|
// Second argument is the lane < vector length
|
|
|
|
uint32_t lane;
|
|
|
|
if (!IsLiteralOrConstInt(f, arg, &lane))
|
|
|
|
return f.failf(arg, "lane selector should be a constant integer literal");
|
|
|
|
if (lane >= GetSimdLanes(opType))
|
|
|
|
return f.failf(arg, "lane selector should be in bounds");
|
|
|
|
|
|
|
|
arg = NextNode(arg);
|
|
|
|
|
|
|
|
// Third argument is the scalar
|
|
|
|
Type scalarType;
|
|
|
|
if (!CheckExpr(f, arg, &scalarType))
|
|
|
|
return false;
|
|
|
|
if (!(scalarType <= SimdToCoercedScalarType(opType))) {
|
|
|
|
if (opType == SimdType::Float32x4 && scalarType.isDoubleLit()) {
|
|
|
|
if (!f.encoder().writeOp(Op::F32DemoteF64))
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
return f.failf(arg, "%s is not the correct type to replace an element of %s",
|
|
|
|
scalarType.toChars(), vecType.toChars());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!f.writeSimdOp(opType, SimdOperation::Fn_replaceLane))
|
|
|
|
return false;
|
|
|
|
if (!f.encoder().writeVarU32(lane))
|
|
|
|
return false;
|
|
|
|
*type = opType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef bool Bitcast;
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
// Include CheckSimdCast in unnamed namespace to avoid MSVC name lookup bug (due to the use of Type).
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdCast(FunctionValidator& f, ParseNode* call, SimdType fromType, SimdType toType,
|
|
|
|
SimdOperation op, Type* type)
|
|
|
|
{
|
|
|
|
if (!CheckSimdCallArgs(f, call, 1, CheckArgIsSubtypeOf(fromType)))
|
|
|
|
return false;
|
|
|
|
if (!f.writeSimdOp(toType, op))
|
|
|
|
return false;
|
|
|
|
*type = toType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdShuffleSelectors(FunctionValidator& f, ParseNode* lane,
|
|
|
|
mozilla::Array<uint8_t, 16>& lanes, unsigned numLanes, unsigned maxLane)
|
|
|
|
{
|
|
|
|
for (unsigned i = 0; i < numLanes; i++, lane = NextNode(lane)) {
|
|
|
|
uint32_t u32;
|
|
|
|
if (!IsLiteralInt(f.m(), lane, &u32))
|
|
|
|
return f.failf(lane, "lane selector should be a constant integer literal");
|
|
|
|
if (u32 >= maxLane)
|
|
|
|
return f.failf(lane, "lane selector should be less than %u", maxLane);
|
|
|
|
lanes[i] = uint8_t(u32);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdSwizzle(FunctionValidator& f, ParseNode* call, SimdType opType, Type* type)
|
|
|
|
{
|
|
|
|
const unsigned numLanes = GetSimdLanes(opType);
|
|
|
|
unsigned numArgs = CallArgListLength(call);
|
|
|
|
if (numArgs != 1 + numLanes)
|
|
|
|
return f.failf(call, "expected %u arguments to SIMD swizzle, got %u", 1 + numLanes,
|
|
|
|
numArgs);
|
|
|
|
|
|
|
|
Type retType = opType;
|
|
|
|
ParseNode* vec = CallArgList(call);
|
|
|
|
Type vecType;
|
|
|
|
if (!CheckExpr(f, vec, &vecType))
|
|
|
|
return false;
|
|
|
|
if (!(vecType <= retType))
|
|
|
|
return f.failf(vec, "%s is not a subtype of %s", vecType.toChars(), retType.toChars());
|
|
|
|
|
|
|
|
if (!f.writeSimdOp(opType, SimdOperation::Fn_swizzle))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
mozilla::Array<uint8_t, 16> lanes;
|
|
|
|
if (!CheckSimdShuffleSelectors(f, NextNode(vec), lanes, numLanes, numLanes))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < numLanes; i++) {
|
|
|
|
if (!f.encoder().writeFixedU8(lanes[i]))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*type = retType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdShuffle(FunctionValidator& f, ParseNode* call, SimdType opType, Type* type)
|
|
|
|
{
|
|
|
|
const unsigned numLanes = GetSimdLanes(opType);
|
|
|
|
unsigned numArgs = CallArgListLength(call);
|
|
|
|
if (numArgs != 2 + numLanes)
|
|
|
|
return f.failf(call, "expected %u arguments to SIMD shuffle, got %u", 2 + numLanes,
|
|
|
|
numArgs);
|
|
|
|
|
|
|
|
Type retType = opType;
|
|
|
|
ParseNode* arg = CallArgList(call);
|
|
|
|
for (unsigned i = 0; i < 2; i++, arg = NextNode(arg)) {
|
|
|
|
Type type;
|
|
|
|
if (!CheckExpr(f, arg, &type))
|
|
|
|
return false;
|
|
|
|
if (!(type <= retType))
|
|
|
|
return f.failf(arg, "%s is not a subtype of %s", type.toChars(), retType.toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!f.writeSimdOp(opType, SimdOperation::Fn_shuffle))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
mozilla::Array<uint8_t, 16> lanes;
|
|
|
|
if (!CheckSimdShuffleSelectors(f, arg, lanes, numLanes, 2 * numLanes))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < numLanes; i++) {
|
|
|
|
if (!f.encoder().writeFixedU8(uint8_t(lanes[i])))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*type = retType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdLoadStoreArgs(FunctionValidator& f, ParseNode* call, Scalar::Type* viewType)
|
|
|
|
{
|
|
|
|
ParseNode* view = CallArgList(call);
|
|
|
|
if (!view->isKind(PNK_NAME))
|
|
|
|
return f.fail(view, "expected Uint8Array view as SIMD.*.load/store first argument");
|
|
|
|
|
|
|
|
ParseNode* indexExpr = NextNode(view);
|
|
|
|
|
|
|
|
if (!CheckAndPrepareArrayAccess(f, view, indexExpr, YesSimd, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (*viewType != Scalar::Uint8)
|
|
|
|
return f.fail(view, "expected Uint8Array view as SIMD.*.load/store first argument");
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdLoad(FunctionValidator& f, ParseNode* call, SimdType opType, SimdOperation op,
|
|
|
|
Type* type)
|
|
|
|
{
|
|
|
|
unsigned numArgs = CallArgListLength(call);
|
|
|
|
if (numArgs != 2)
|
|
|
|
return f.failf(call, "expected 2 arguments to SIMD load, got %u", numArgs);
|
|
|
|
|
|
|
|
Scalar::Type viewType;
|
|
|
|
if (!CheckSimdLoadStoreArgs(f, call, &viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.writeSimdOp(opType, op))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteArrayAccessFlags(f, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = opType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdStore(FunctionValidator& f, ParseNode* call, SimdType opType, SimdOperation op,
|
|
|
|
Type* type)
|
|
|
|
{
|
|
|
|
unsigned numArgs = CallArgListLength(call);
|
|
|
|
if (numArgs != 3)
|
|
|
|
return f.failf(call, "expected 3 arguments to SIMD store, got %u", numArgs);
|
|
|
|
|
|
|
|
Scalar::Type viewType;
|
|
|
|
if (!CheckSimdLoadStoreArgs(f, call, &viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Type retType = opType;
|
|
|
|
ParseNode* vecExpr = NextNode(NextNode(CallArgList(call)));
|
|
|
|
Type vecType;
|
|
|
|
if (!CheckExpr(f, vecExpr, &vecType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.writeSimdOp(opType, op))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!WriteArrayAccessFlags(f, viewType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!(vecType <= retType))
|
|
|
|
return f.failf(vecExpr, "%s is not a subtype of %s", vecType.toChars(), retType.toChars());
|
|
|
|
|
|
|
|
*type = vecType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdSelect(FunctionValidator& f, ParseNode* call, SimdType opType, Type* type)
|
|
|
|
{
|
|
|
|
if (!CheckSimdCallArgs(f, call, 3, CheckSimdSelectArgs(opType)))
|
|
|
|
return false;
|
|
|
|
if (!f.writeSimdOp(opType, SimdOperation::Fn_select))
|
|
|
|
return false;
|
|
|
|
*type = opType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdAllTrue(FunctionValidator& f, ParseNode* call, SimdType opType, Type* type)
|
|
|
|
{
|
|
|
|
if (!CheckSimdCallArgs(f, call, 1, CheckArgIsSubtypeOf(opType)))
|
|
|
|
return false;
|
|
|
|
if (!f.writeSimdOp(opType, SimdOperation::Fn_allTrue))
|
|
|
|
return false;
|
|
|
|
*type = Type::Int;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdAnyTrue(FunctionValidator& f, ParseNode* call, SimdType opType, Type* type)
|
|
|
|
{
|
|
|
|
if (!CheckSimdCallArgs(f, call, 1, CheckArgIsSubtypeOf(opType)))
|
|
|
|
return false;
|
|
|
|
if (!f.writeSimdOp(opType, SimdOperation::Fn_anyTrue))
|
|
|
|
return false;
|
|
|
|
*type = Type::Int;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdCheck(FunctionValidator& f, ParseNode* call, SimdType opType, Type* type)
|
|
|
|
{
|
|
|
|
Type coerceTo;
|
|
|
|
ParseNode* argNode;
|
|
|
|
if (!IsCoercionCall(f.m(), call, &coerceTo, &argNode))
|
|
|
|
return f.failf(call, "expected 1 argument in call to check");
|
|
|
|
return CheckCoercionArg(f, argNode, coerceTo, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdSplat(FunctionValidator& f, ParseNode* call, SimdType opType, Type* type)
|
|
|
|
{
|
|
|
|
if (!CheckSimdCallArgs(f, call, 1, CheckSimdScalarArgs(opType)))
|
|
|
|
return false;
|
|
|
|
if (!f.writeSimdOp(opType, SimdOperation::Fn_splat))
|
|
|
|
return false;
|
|
|
|
*type = opType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdOperationCall(FunctionValidator& f, ParseNode* call, const ModuleValidator::Global* global,
|
|
|
|
Type* type)
|
|
|
|
{
|
|
|
|
f.setUsesSimd();
|
|
|
|
|
|
|
|
MOZ_ASSERT(global->isSimdOperation());
|
|
|
|
|
|
|
|
SimdType opType = global->simdOperationType();
|
|
|
|
|
|
|
|
switch (SimdOperation op = global->simdOperation()) {
|
|
|
|
case SimdOperation::Fn_check:
|
|
|
|
return CheckSimdCheck(f, call, opType, type);
|
|
|
|
|
|
|
|
#define _CASE(OP) case SimdOperation::Fn_##OP:
|
|
|
|
FOREACH_SHIFT_SIMD_OP(_CASE)
|
|
|
|
return CheckSimdBinaryShift(f, call, opType, op, type);
|
|
|
|
|
|
|
|
FOREACH_COMP_SIMD_OP(_CASE)
|
|
|
|
return CheckSimdBinaryComp(f, call, opType, op, type);
|
|
|
|
|
|
|
|
FOREACH_NUMERIC_SIMD_BINOP(_CASE)
|
|
|
|
FOREACH_FLOAT_SIMD_BINOP(_CASE)
|
|
|
|
FOREACH_BITWISE_SIMD_BINOP(_CASE)
|
|
|
|
FOREACH_SMINT_SIMD_BINOP(_CASE)
|
|
|
|
return CheckSimdBinary(f, call, opType, op, type);
|
|
|
|
#undef _CASE
|
|
|
|
|
|
|
|
case SimdOperation::Fn_extractLane:
|
|
|
|
return CheckSimdExtractLane(f, call, opType, type);
|
|
|
|
case SimdOperation::Fn_replaceLane:
|
|
|
|
return CheckSimdReplaceLane(f, call, opType, type);
|
|
|
|
|
|
|
|
case SimdOperation::Fn_fromInt8x16Bits:
|
|
|
|
return CheckSimdCast(f, call, SimdType::Int8x16, opType, op, type);
|
|
|
|
case SimdOperation::Fn_fromUint8x16Bits:
|
|
|
|
return CheckSimdCast(f, call, SimdType::Uint8x16, opType, op, type);
|
|
|
|
case SimdOperation::Fn_fromInt16x8Bits:
|
|
|
|
return CheckSimdCast(f, call, SimdType::Int16x8, opType, op, type);
|
|
|
|
case SimdOperation::Fn_fromUint16x8Bits:
|
|
|
|
return CheckSimdCast(f, call, SimdType::Uint16x8, opType, op, type);
|
|
|
|
case SimdOperation::Fn_fromInt32x4:
|
|
|
|
case SimdOperation::Fn_fromInt32x4Bits:
|
|
|
|
return CheckSimdCast(f, call, SimdType::Int32x4, opType, op, type);
|
|
|
|
case SimdOperation::Fn_fromUint32x4:
|
|
|
|
case SimdOperation::Fn_fromUint32x4Bits:
|
|
|
|
return CheckSimdCast(f, call, SimdType::Uint32x4, opType, op, type);
|
|
|
|
case SimdOperation::Fn_fromFloat32x4:
|
|
|
|
case SimdOperation::Fn_fromFloat32x4Bits:
|
|
|
|
return CheckSimdCast(f, call, SimdType::Float32x4, opType, op, type);
|
|
|
|
|
|
|
|
case SimdOperation::Fn_abs:
|
|
|
|
case SimdOperation::Fn_neg:
|
|
|
|
case SimdOperation::Fn_not:
|
|
|
|
case SimdOperation::Fn_sqrt:
|
|
|
|
case SimdOperation::Fn_reciprocalApproximation:
|
|
|
|
case SimdOperation::Fn_reciprocalSqrtApproximation:
|
|
|
|
return CheckSimdUnary(f, call, opType, op, type);
|
|
|
|
|
|
|
|
case SimdOperation::Fn_swizzle:
|
|
|
|
return CheckSimdSwizzle(f, call, opType, type);
|
|
|
|
case SimdOperation::Fn_shuffle:
|
|
|
|
return CheckSimdShuffle(f, call, opType, type);
|
|
|
|
|
|
|
|
case SimdOperation::Fn_load:
|
|
|
|
case SimdOperation::Fn_load1:
|
|
|
|
case SimdOperation::Fn_load2:
|
|
|
|
return CheckSimdLoad(f, call, opType, op, type);
|
|
|
|
case SimdOperation::Fn_store:
|
|
|
|
case SimdOperation::Fn_store1:
|
|
|
|
case SimdOperation::Fn_store2:
|
|
|
|
return CheckSimdStore(f, call, opType, op, type);
|
|
|
|
|
|
|
|
case SimdOperation::Fn_select:
|
|
|
|
return CheckSimdSelect(f, call, opType, type);
|
|
|
|
|
|
|
|
case SimdOperation::Fn_splat:
|
|
|
|
return CheckSimdSplat(f, call, opType, type);
|
|
|
|
|
|
|
|
case SimdOperation::Fn_allTrue:
|
|
|
|
return CheckSimdAllTrue(f, call, opType, type);
|
|
|
|
case SimdOperation::Fn_anyTrue:
|
|
|
|
return CheckSimdAnyTrue(f, call, opType, type);
|
|
|
|
|
|
|
|
case SimdOperation::Fn_load3:
|
|
|
|
case SimdOperation::Fn_store3:
|
|
|
|
return f.fail(call, "asm.js does not support 3-element SIMD loads or stores");
|
|
|
|
|
|
|
|
case SimdOperation::Constructor:
|
|
|
|
MOZ_CRASH("constructors are handled in CheckSimdCtorCall");
|
|
|
|
case SimdOperation::Fn_fromFloat64x2Bits:
|
|
|
|
MOZ_CRASH("NYI");
|
|
|
|
}
|
|
|
|
MOZ_CRASH("unexpected simd operation in CheckSimdOperationCall");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSimdCtorCall(FunctionValidator& f, ParseNode* call, const ModuleValidator::Global* global,
|
|
|
|
Type* type)
|
|
|
|
{
|
|
|
|
f.setUsesSimd();
|
|
|
|
|
|
|
|
MOZ_ASSERT(call->isKind(PNK_CALL));
|
|
|
|
|
|
|
|
SimdType simdType = global->simdCtorType();
|
|
|
|
unsigned length = GetSimdLanes(simdType);
|
|
|
|
if (!CheckSimdCallArgs(f, call, length, CheckSimdScalarArgs(simdType)))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.writeSimdOp(simdType, SimdOperation::Constructor))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = simdType;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckUncoercedCall(FunctionValidator& f, ParseNode* expr, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(expr->isKind(PNK_CALL));
|
|
|
|
|
|
|
|
const ModuleValidator::Global* global;
|
|
|
|
if (IsCallToGlobal(f.m(), expr, &global)) {
|
|
|
|
if (global->isMathFunction())
|
|
|
|
return CheckMathBuiltinCall(f, expr, global->mathBuiltinFunction(), type);
|
|
|
|
if (global->isAtomicsFunction())
|
|
|
|
return CheckAtomicsBuiltinCall(f, expr, global->atomicsBuiltinFunction(), type);
|
|
|
|
if (global->isSimdCtor())
|
|
|
|
return CheckSimdCtorCall(f, expr, global, type);
|
|
|
|
if (global->isSimdOperation())
|
|
|
|
return CheckSimdOperationCall(f, expr, global, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
return f.fail(expr, "all function calls must either be calls to standard lib math functions, "
|
|
|
|
"standard atomic functions, standard SIMD constructors or operations, "
|
|
|
|
"ignored (via f(); or comma-expression), coerced to signed (via f()|0), "
|
|
|
|
"coerced to float (via fround(f())) or coerced to double (via +f())");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CoerceResult(FunctionValidator& f, ParseNode* expr, Type expected, Type actual,
|
|
|
|
Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(expected.isCanonical());
|
|
|
|
|
|
|
|
// At this point, the bytecode resembles this:
|
|
|
|
// | the thing we wanted to coerce | current position |>
|
|
|
|
switch (expected.which()) {
|
|
|
|
case Type::Void:
|
|
|
|
if (!actual.isVoid()) {
|
|
|
|
if (!f.encoder().writeOp(Op::Drop))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Type::Int:
|
|
|
|
if (!actual.isIntish())
|
|
|
|
return f.failf(expr, "%s is not a subtype of intish", actual.toChars());
|
|
|
|
break;
|
|
|
|
case Type::Float:
|
|
|
|
if (!CheckFloatCoercionArg(f, expr, actual))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case Type::Double:
|
|
|
|
if (actual.isMaybeDouble()) {
|
|
|
|
// No conversion necessary.
|
|
|
|
} else if (actual.isMaybeFloat()) {
|
|
|
|
if (!f.encoder().writeOp(Op::F64PromoteF32))
|
|
|
|
return false;
|
|
|
|
} else if (actual.isSigned()) {
|
|
|
|
if (!f.encoder().writeOp(Op::F64ConvertSI32))
|
|
|
|
return false;
|
|
|
|
} else if (actual.isUnsigned()) {
|
|
|
|
if (!f.encoder().writeOp(Op::F64ConvertUI32))
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
return f.failf(expr, "%s is not a subtype of double?, float?, signed or unsigned", actual.toChars());
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
MOZ_ASSERT(expected.isSimd(), "Incomplete switch");
|
|
|
|
if (actual != expected)
|
|
|
|
return f.failf(expr, "got type %s, expected %s", actual.toChars(), expected.toChars());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
*type = Type::ret(expected);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckCoercedMathBuiltinCall(FunctionValidator& f, ParseNode* callNode, AsmJSMathBuiltinFunction func,
|
|
|
|
Type ret, Type* type)
|
|
|
|
{
|
|
|
|
Type actual;
|
|
|
|
if (!CheckMathBuiltinCall(f, callNode, func, &actual))
|
|
|
|
return false;
|
|
|
|
return CoerceResult(f, callNode, ret, actual, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckCoercedSimdCall(FunctionValidator& f, ParseNode* call, const ModuleValidator::Global* global,
|
|
|
|
Type ret, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(ret.isCanonical());
|
|
|
|
|
|
|
|
Type actual;
|
|
|
|
if (global->isSimdCtor()) {
|
|
|
|
if (!CheckSimdCtorCall(f, call, global, &actual))
|
|
|
|
return false;
|
|
|
|
MOZ_ASSERT(actual.isSimd());
|
|
|
|
} else {
|
|
|
|
MOZ_ASSERT(global->isSimdOperation());
|
|
|
|
if (!CheckSimdOperationCall(f, call, global, &actual))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return CoerceResult(f, call, ret, actual, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckCoercedAtomicsBuiltinCall(FunctionValidator& f, ParseNode* callNode,
|
|
|
|
AsmJSAtomicsBuiltinFunction func, Type ret, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(ret.isCanonical());
|
|
|
|
|
|
|
|
Type actual;
|
|
|
|
if (!CheckAtomicsBuiltinCall(f, callNode, func, &actual))
|
|
|
|
return false;
|
|
|
|
return CoerceResult(f, callNode, ret, actual, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckCoercedCall(FunctionValidator& f, ParseNode* call, Type ret, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(ret.isCanonical());
|
|
|
|
|
|
|
|
JS_CHECK_RECURSION_DONT_REPORT(f.cx(), return f.m().failOverRecursed());
|
|
|
|
|
|
|
|
bool isSimd = false;
|
|
|
|
if (IsNumericLiteral(f.m(), call, &isSimd)) {
|
|
|
|
if (isSimd)
|
|
|
|
f.setUsesSimd();
|
|
|
|
NumLit lit = ExtractNumericLiteral(f.m(), call);
|
|
|
|
if (!f.writeConstExpr(lit))
|
|
|
|
return false;
|
|
|
|
return CoerceResult(f, call, ret, Type::lit(lit), type);
|
|
|
|
}
|
|
|
|
|
|
|
|
ParseNode* callee = CallCallee(call);
|
|
|
|
|
|
|
|
if (callee->isKind(PNK_ELEM))
|
|
|
|
return CheckFuncPtrCall(f, call, ret, type);
|
|
|
|
|
|
|
|
if (!callee->isKind(PNK_NAME))
|
|
|
|
return f.fail(callee, "unexpected callee expression type");
|
|
|
|
|
|
|
|
PropertyName* calleeName = callee->name();
|
|
|
|
|
|
|
|
if (const ModuleValidator::Global* global = f.lookupGlobal(calleeName)) {
|
|
|
|
switch (global->which()) {
|
|
|
|
case ModuleValidator::Global::FFI:
|
|
|
|
return CheckFFICall(f, call, global->ffiIndex(), ret, type);
|
|
|
|
case ModuleValidator::Global::MathBuiltinFunction:
|
|
|
|
return CheckCoercedMathBuiltinCall(f, call, global->mathBuiltinFunction(), ret, type);
|
|
|
|
case ModuleValidator::Global::AtomicsBuiltinFunction:
|
|
|
|
return CheckCoercedAtomicsBuiltinCall(f, call, global->atomicsBuiltinFunction(), ret, type);
|
|
|
|
case ModuleValidator::Global::ConstantLiteral:
|
|
|
|
case ModuleValidator::Global::ConstantImport:
|
|
|
|
case ModuleValidator::Global::Variable:
|
|
|
|
case ModuleValidator::Global::FuncPtrTable:
|
|
|
|
case ModuleValidator::Global::ArrayView:
|
|
|
|
case ModuleValidator::Global::ArrayViewCtor:
|
|
|
|
return f.failName(callee, "'%s' is not callable function", callee->name());
|
|
|
|
case ModuleValidator::Global::SimdCtor:
|
|
|
|
case ModuleValidator::Global::SimdOp:
|
|
|
|
return CheckCoercedSimdCall(f, call, global, ret, type);
|
|
|
|
case ModuleValidator::Global::Function:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return CheckInternalCall(f, call, calleeName, ret, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckPos(FunctionValidator& f, ParseNode* pos, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(pos->isKind(PNK_POS));
|
|
|
|
ParseNode* operand = UnaryKid(pos);
|
|
|
|
|
|
|
|
if (operand->isKind(PNK_CALL))
|
|
|
|
return CheckCoercedCall(f, operand, Type::Double, type);
|
|
|
|
|
|
|
|
Type actual;
|
|
|
|
if (!CheckExpr(f, operand, &actual))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return CoerceResult(f, operand, Type::Double, actual, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckNot(FunctionValidator& f, ParseNode* expr, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(expr->isKind(PNK_NOT));
|
|
|
|
ParseNode* operand = UnaryKid(expr);
|
|
|
|
|
|
|
|
Type operandType;
|
|
|
|
if (!CheckExpr(f, operand, &operandType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!operandType.isInt())
|
|
|
|
return f.failf(operand, "%s is not a subtype of int", operandType.toChars());
|
|
|
|
|
|
|
|
*type = Type::Int;
|
|
|
|
return f.encoder().writeOp(Op::I32Eqz);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckNeg(FunctionValidator& f, ParseNode* expr, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(expr->isKind(PNK_NEG));
|
|
|
|
ParseNode* operand = UnaryKid(expr);
|
|
|
|
|
|
|
|
Type operandType;
|
|
|
|
if (!CheckExpr(f, operand, &operandType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (operandType.isInt()) {
|
|
|
|
*type = Type::Intish;
|
|
|
|
return f.encoder().writeOp(Op::I32Neg);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (operandType.isMaybeDouble()) {
|
|
|
|
*type = Type::Double;
|
|
|
|
return f.encoder().writeOp(Op::F64Neg);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (operandType.isMaybeFloat()) {
|
|
|
|
*type = Type::Floatish;
|
|
|
|
return f.encoder().writeOp(Op::F32Neg);
|
|
|
|
}
|
|
|
|
|
|
|
|
return f.failf(operand, "%s is not a subtype of int, float? or double?", operandType.toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckCoerceToInt(FunctionValidator& f, ParseNode* expr, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(expr->isKind(PNK_BITNOT));
|
|
|
|
ParseNode* operand = UnaryKid(expr);
|
|
|
|
|
|
|
|
Type operandType;
|
|
|
|
if (!CheckExpr(f, operand, &operandType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (operandType.isMaybeDouble() || operandType.isMaybeFloat()) {
|
|
|
|
*type = Type::Signed;
|
|
|
|
Op opcode = operandType.isMaybeDouble() ? Op::I32TruncSF64 : Op::I32TruncSF32;
|
|
|
|
return f.encoder().writeOp(opcode);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!operandType.isIntish())
|
|
|
|
return f.failf(operand, "%s is not a subtype of double?, float? or intish", operandType.toChars());
|
|
|
|
|
|
|
|
*type = Type::Signed;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckBitNot(FunctionValidator& f, ParseNode* neg, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(neg->isKind(PNK_BITNOT));
|
|
|
|
ParseNode* operand = UnaryKid(neg);
|
|
|
|
|
|
|
|
if (operand->isKind(PNK_BITNOT))
|
|
|
|
return CheckCoerceToInt(f, operand, type);
|
|
|
|
|
|
|
|
Type operandType;
|
|
|
|
if (!CheckExpr(f, operand, &operandType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!operandType.isIntish())
|
|
|
|
return f.failf(operand, "%s is not a subtype of intish", operandType.toChars());
|
|
|
|
|
|
|
|
if (!f.encoder().writeOp(Op::I32BitNot))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*type = Type::Signed;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAsExprStatement(FunctionValidator& f, ParseNode* exprStmt);
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckComma(FunctionValidator& f, ParseNode* comma, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(comma->isKind(PNK_COMMA));
|
|
|
|
ParseNode* operands = ListHead(comma);
|
|
|
|
|
|
|
|
// The block depth isn't taken into account here, because a comma list can't
|
|
|
|
// contain breaks and continues and nested control flow structures.
|
|
|
|
if (!f.encoder().writeOp(Op::Block))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
size_t typeAt;
|
|
|
|
if (!f.encoder().writePatchableFixedU7(&typeAt))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ParseNode* pn = operands;
|
|
|
|
for (; NextNode(pn); pn = NextNode(pn)) {
|
|
|
|
if (!CheckAsExprStatement(f, pn))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!CheckExpr(f, pn, type))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
f.encoder().patchFixedU7(typeAt, uint8_t(type->toWasmBlockSignatureType()));
|
|
|
|
|
|
|
|
return f.encoder().writeOp(Op::End);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckConditional(FunctionValidator& f, ParseNode* ternary, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(ternary->isKind(PNK_CONDITIONAL));
|
|
|
|
|
|
|
|
ParseNode* cond = TernaryKid1(ternary);
|
|
|
|
ParseNode* thenExpr = TernaryKid2(ternary);
|
|
|
|
ParseNode* elseExpr = TernaryKid3(ternary);
|
|
|
|
|
|
|
|
Type condType;
|
|
|
|
if (!CheckExpr(f, cond, &condType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!condType.isInt())
|
|
|
|
return f.failf(cond, "%s is not a subtype of int", condType.toChars());
|
|
|
|
|
|
|
|
size_t typeAt;
|
|
|
|
if (!f.pushIf(&typeAt))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Type thenType;
|
|
|
|
if (!CheckExpr(f, thenExpr, &thenType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.switchToElse())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Type elseType;
|
|
|
|
if (!CheckExpr(f, elseExpr, &elseType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (thenType.isInt() && elseType.isInt()) {
|
|
|
|
*type = Type::Int;
|
|
|
|
} else if (thenType.isDouble() && elseType.isDouble()) {
|
|
|
|
*type = Type::Double;
|
|
|
|
} else if (thenType.isFloat() && elseType.isFloat()) {
|
|
|
|
*type = Type::Float;
|
|
|
|
} else if (thenType.isSimd() && elseType == thenType) {
|
|
|
|
*type = thenType;
|
|
|
|
} else {
|
|
|
|
return f.failf(ternary, "then/else branches of conditional must both produce int, float, "
|
|
|
|
"double or SIMD types, current types are %s and %s",
|
|
|
|
thenType.toChars(), elseType.toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!f.popIf(typeAt, type->toWasmBlockSignatureType()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsValidIntMultiplyConstant(ModuleValidator& m, ParseNode* expr)
|
|
|
|
{
|
|
|
|
if (!IsNumericLiteral(m, expr))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
NumLit lit = ExtractNumericLiteral(m, expr);
|
|
|
|
switch (lit.which()) {
|
|
|
|
case NumLit::Fixnum:
|
|
|
|
case NumLit::NegativeInt:
|
|
|
|
if (abs(lit.toInt32()) < (1<<20))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
case NumLit::BigUnsigned:
|
|
|
|
case NumLit::Double:
|
|
|
|
case NumLit::Float:
|
|
|
|
case NumLit::OutOfRangeInt:
|
|
|
|
case NumLit::Int8x16:
|
|
|
|
case NumLit::Uint8x16:
|
|
|
|
case NumLit::Int16x8:
|
|
|
|
case NumLit::Uint16x8:
|
|
|
|
case NumLit::Int32x4:
|
|
|
|
case NumLit::Uint32x4:
|
|
|
|
case NumLit::Float32x4:
|
|
|
|
case NumLit::Bool8x16:
|
|
|
|
case NumLit::Bool16x8:
|
|
|
|
case NumLit::Bool32x4:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Bad literal");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckMultiply(FunctionValidator& f, ParseNode* star, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(star->isKind(PNK_STAR));
|
|
|
|
ParseNode* lhs = MultiplyLeft(star);
|
|
|
|
ParseNode* rhs = MultiplyRight(star);
|
|
|
|
|
|
|
|
Type lhsType;
|
|
|
|
if (!CheckExpr(f, lhs, &lhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Type rhsType;
|
|
|
|
if (!CheckExpr(f, rhs, &rhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (lhsType.isInt() && rhsType.isInt()) {
|
|
|
|
if (!IsValidIntMultiplyConstant(f.m(), lhs) && !IsValidIntMultiplyConstant(f.m(), rhs))
|
|
|
|
return f.fail(star, "one arg to int multiply must be a small (-2^20, 2^20) int literal");
|
|
|
|
*type = Type::Intish;
|
|
|
|
return f.encoder().writeOp(Op::I32Mul);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lhsType.isMaybeDouble() && rhsType.isMaybeDouble()) {
|
|
|
|
*type = Type::Double;
|
|
|
|
return f.encoder().writeOp(Op::F64Mul);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lhsType.isMaybeFloat() && rhsType.isMaybeFloat()) {
|
|
|
|
*type = Type::Floatish;
|
|
|
|
return f.encoder().writeOp(Op::F32Mul);
|
|
|
|
}
|
|
|
|
|
|
|
|
return f.fail(star, "multiply operands must be both int, both double? or both float?");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAddOrSub(FunctionValidator& f, ParseNode* expr, Type* type, unsigned* numAddOrSubOut = nullptr)
|
|
|
|
{
|
|
|
|
JS_CHECK_RECURSION_DONT_REPORT(f.cx(), return f.m().failOverRecursed());
|
|
|
|
|
|
|
|
MOZ_ASSERT(expr->isKind(PNK_ADD) || expr->isKind(PNK_SUB));
|
|
|
|
ParseNode* lhs = AddSubLeft(expr);
|
|
|
|
ParseNode* rhs = AddSubRight(expr);
|
|
|
|
|
|
|
|
Type lhsType, rhsType;
|
|
|
|
unsigned lhsNumAddOrSub, rhsNumAddOrSub;
|
|
|
|
|
|
|
|
if (lhs->isKind(PNK_ADD) || lhs->isKind(PNK_SUB)) {
|
|
|
|
if (!CheckAddOrSub(f, lhs, &lhsType, &lhsNumAddOrSub))
|
|
|
|
return false;
|
|
|
|
if (lhsType == Type::Intish)
|
|
|
|
lhsType = Type::Int;
|
|
|
|
} else {
|
|
|
|
if (!CheckExpr(f, lhs, &lhsType))
|
|
|
|
return false;
|
|
|
|
lhsNumAddOrSub = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rhs->isKind(PNK_ADD) || rhs->isKind(PNK_SUB)) {
|
|
|
|
if (!CheckAddOrSub(f, rhs, &rhsType, &rhsNumAddOrSub))
|
|
|
|
return false;
|
|
|
|
if (rhsType == Type::Intish)
|
|
|
|
rhsType = Type::Int;
|
|
|
|
} else {
|
|
|
|
if (!CheckExpr(f, rhs, &rhsType))
|
|
|
|
return false;
|
|
|
|
rhsNumAddOrSub = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned numAddOrSub = lhsNumAddOrSub + rhsNumAddOrSub + 1;
|
|
|
|
if (numAddOrSub > (1<<20))
|
|
|
|
return f.fail(expr, "too many + or - without intervening coercion");
|
|
|
|
|
|
|
|
if (lhsType.isInt() && rhsType.isInt()) {
|
|
|
|
if (!f.encoder().writeOp(expr->isKind(PNK_ADD) ? Op::I32Add : Op::I32Sub))
|
|
|
|
return false;
|
|
|
|
*type = Type::Intish;
|
|
|
|
} else if (lhsType.isMaybeDouble() && rhsType.isMaybeDouble()) {
|
|
|
|
if (!f.encoder().writeOp(expr->isKind(PNK_ADD) ? Op::F64Add : Op::F64Sub))
|
|
|
|
return false;
|
|
|
|
*type = Type::Double;
|
|
|
|
} else if (lhsType.isMaybeFloat() && rhsType.isMaybeFloat()) {
|
|
|
|
if (!f.encoder().writeOp(expr->isKind(PNK_ADD) ? Op::F32Add : Op::F32Sub))
|
|
|
|
return false;
|
|
|
|
*type = Type::Floatish;
|
|
|
|
} else {
|
|
|
|
return f.failf(expr, "operands to + or - must both be int, float? or double?, got %s and %s",
|
|
|
|
lhsType.toChars(), rhsType.toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (numAddOrSubOut)
|
|
|
|
*numAddOrSubOut = numAddOrSub;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckDivOrMod(FunctionValidator& f, ParseNode* expr, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(expr->isKind(PNK_DIV) || expr->isKind(PNK_MOD));
|
|
|
|
|
|
|
|
ParseNode* lhs = DivOrModLeft(expr);
|
|
|
|
ParseNode* rhs = DivOrModRight(expr);
|
|
|
|
|
|
|
|
Type lhsType, rhsType;
|
|
|
|
if (!CheckExpr(f, lhs, &lhsType))
|
|
|
|
return false;
|
|
|
|
if (!CheckExpr(f, rhs, &rhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (lhsType.isMaybeDouble() && rhsType.isMaybeDouble()) {
|
|
|
|
*type = Type::Double;
|
|
|
|
return f.encoder().writeOp(expr->isKind(PNK_DIV) ? Op::F64Div : Op::F64Mod);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lhsType.isMaybeFloat() && rhsType.isMaybeFloat()) {
|
|
|
|
*type = Type::Floatish;
|
|
|
|
if (expr->isKind(PNK_DIV))
|
|
|
|
return f.encoder().writeOp(Op::F32Div);
|
|
|
|
else
|
|
|
|
return f.fail(expr, "modulo cannot receive float arguments");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lhsType.isSigned() && rhsType.isSigned()) {
|
|
|
|
*type = Type::Intish;
|
|
|
|
return f.encoder().writeOp(expr->isKind(PNK_DIV) ? Op::I32DivS : Op::I32RemS);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lhsType.isUnsigned() && rhsType.isUnsigned()) {
|
|
|
|
*type = Type::Intish;
|
|
|
|
return f.encoder().writeOp(expr->isKind(PNK_DIV) ? Op::I32DivU : Op::I32RemU);
|
|
|
|
}
|
|
|
|
|
|
|
|
return f.failf(expr, "arguments to / or %% must both be double?, float?, signed, or unsigned; "
|
|
|
|
"%s and %s are given", lhsType.toChars(), rhsType.toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckComparison(FunctionValidator& f, ParseNode* comp, Type* type)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(comp->isKind(PNK_LT) || comp->isKind(PNK_LE) || comp->isKind(PNK_GT) ||
|
|
|
|
comp->isKind(PNK_GE) || comp->isKind(PNK_EQ) || comp->isKind(PNK_NE));
|
|
|
|
|
|
|
|
ParseNode* lhs = ComparisonLeft(comp);
|
|
|
|
ParseNode* rhs = ComparisonRight(comp);
|
|
|
|
|
|
|
|
Type lhsType, rhsType;
|
|
|
|
if (!CheckExpr(f, lhs, &lhsType))
|
|
|
|
return false;
|
|
|
|
if (!CheckExpr(f, rhs, &rhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!(lhsType.isSigned() && rhsType.isSigned()) &&
|
|
|
|
!(lhsType.isUnsigned() && rhsType.isUnsigned()) &&
|
|
|
|
!(lhsType.isDouble() && rhsType.isDouble()) &&
|
|
|
|
!(lhsType.isFloat() && rhsType.isFloat()))
|
|
|
|
{
|
|
|
|
return f.failf(comp, "arguments to a comparison must both be signed, unsigned, floats or doubles; "
|
|
|
|
"%s and %s are given", lhsType.toChars(), rhsType.toChars());
|
|
|
|
}
|
|
|
|
|
|
|
|
Op stmt;
|
|
|
|
if (lhsType.isSigned() && rhsType.isSigned()) {
|
|
|
|
switch (comp->getOp()) {
|
|
|
|
case JSOP_EQ: stmt = Op::I32Eq; break;
|
|
|
|
case JSOP_NE: stmt = Op::I32Ne; break;
|
|
|
|
case JSOP_LT: stmt = Op::I32LtS; break;
|
|
|
|
case JSOP_LE: stmt = Op::I32LeS; break;
|
|
|
|
case JSOP_GT: stmt = Op::I32GtS; break;
|
|
|
|
case JSOP_GE: stmt = Op::I32GeS; break;
|
|
|
|
default: MOZ_CRASH("unexpected comparison op");
|
|
|
|
}
|
|
|
|
} else if (lhsType.isUnsigned() && rhsType.isUnsigned()) {
|
|
|
|
switch (comp->getOp()) {
|
|
|
|
case JSOP_EQ: stmt = Op::I32Eq; break;
|
|
|
|
case JSOP_NE: stmt = Op::I32Ne; break;
|
|
|
|
case JSOP_LT: stmt = Op::I32LtU; break;
|
|
|
|
case JSOP_LE: stmt = Op::I32LeU; break;
|
|
|
|
case JSOP_GT: stmt = Op::I32GtU; break;
|
|
|
|
case JSOP_GE: stmt = Op::I32GeU; break;
|
|
|
|
default: MOZ_CRASH("unexpected comparison op");
|
|
|
|
}
|
|
|
|
} else if (lhsType.isDouble()) {
|
|
|
|
switch (comp->getOp()) {
|
|
|
|
case JSOP_EQ: stmt = Op::F64Eq; break;
|
|
|
|
case JSOP_NE: stmt = Op::F64Ne; break;
|
|
|
|
case JSOP_LT: stmt = Op::F64Lt; break;
|
|
|
|
case JSOP_LE: stmt = Op::F64Le; break;
|
|
|
|
case JSOP_GT: stmt = Op::F64Gt; break;
|
|
|
|
case JSOP_GE: stmt = Op::F64Ge; break;
|
|
|
|
default: MOZ_CRASH("unexpected comparison op");
|
|
|
|
}
|
|
|
|
} else if (lhsType.isFloat()) {
|
|
|
|
switch (comp->getOp()) {
|
|
|
|
case JSOP_EQ: stmt = Op::F32Eq; break;
|
|
|
|
case JSOP_NE: stmt = Op::F32Ne; break;
|
|
|
|
case JSOP_LT: stmt = Op::F32Lt; break;
|
|
|
|
case JSOP_LE: stmt = Op::F32Le; break;
|
|
|
|
case JSOP_GT: stmt = Op::F32Gt; break;
|
|
|
|
case JSOP_GE: stmt = Op::F32Ge; break;
|
|
|
|
default: MOZ_CRASH("unexpected comparison op");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
MOZ_CRASH("unexpected type");
|
|
|
|
}
|
|
|
|
|
|
|
|
*type = Type::Int;
|
|
|
|
return f.encoder().writeOp(stmt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckBitwise(FunctionValidator& f, ParseNode* bitwise, Type* type)
|
|
|
|
{
|
|
|
|
ParseNode* lhs = BitwiseLeft(bitwise);
|
|
|
|
ParseNode* rhs = BitwiseRight(bitwise);
|
|
|
|
|
|
|
|
int32_t identityElement;
|
|
|
|
bool onlyOnRight;
|
|
|
|
switch (bitwise->getKind()) {
|
|
|
|
case PNK_BITOR: identityElement = 0; onlyOnRight = false; *type = Type::Signed; break;
|
|
|
|
case PNK_BITAND: identityElement = -1; onlyOnRight = false; *type = Type::Signed; break;
|
|
|
|
case PNK_BITXOR: identityElement = 0; onlyOnRight = false; *type = Type::Signed; break;
|
|
|
|
case PNK_LSH: identityElement = 0; onlyOnRight = true; *type = Type::Signed; break;
|
|
|
|
case PNK_RSH: identityElement = 0; onlyOnRight = true; *type = Type::Signed; break;
|
|
|
|
case PNK_URSH: identityElement = 0; onlyOnRight = true; *type = Type::Unsigned; break;
|
|
|
|
default: MOZ_CRASH("not a bitwise op");
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t i;
|
|
|
|
if (!onlyOnRight && IsLiteralInt(f.m(), lhs, &i) && i == uint32_t(identityElement)) {
|
|
|
|
Type rhsType;
|
|
|
|
if (!CheckExpr(f, rhs, &rhsType))
|
|
|
|
return false;
|
|
|
|
if (!rhsType.isIntish())
|
|
|
|
return f.failf(bitwise, "%s is not a subtype of intish", rhsType.toChars());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (IsLiteralInt(f.m(), rhs, &i) && i == uint32_t(identityElement)) {
|
|
|
|
if (bitwise->isKind(PNK_BITOR) && lhs->isKind(PNK_CALL))
|
|
|
|
return CheckCoercedCall(f, lhs, Type::Int, type);
|
|
|
|
|
|
|
|
Type lhsType;
|
|
|
|
if (!CheckExpr(f, lhs, &lhsType))
|
|
|
|
return false;
|
|
|
|
if (!lhsType.isIntish())
|
|
|
|
return f.failf(bitwise, "%s is not a subtype of intish", lhsType.toChars());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
Type lhsType;
|
|
|
|
if (!CheckExpr(f, lhs, &lhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Type rhsType;
|
|
|
|
if (!CheckExpr(f, rhs, &rhsType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!lhsType.isIntish())
|
|
|
|
return f.failf(lhs, "%s is not a subtype of intish", lhsType.toChars());
|
|
|
|
if (!rhsType.isIntish())
|
|
|
|
return f.failf(rhs, "%s is not a subtype of intish", rhsType.toChars());
|
|
|
|
|
|
|
|
switch (bitwise->getKind()) {
|
|
|
|
case PNK_BITOR: if (!f.encoder().writeOp(Op::I32Or)) return false; break;
|
|
|
|
case PNK_BITAND: if (!f.encoder().writeOp(Op::I32And)) return false; break;
|
|
|
|
case PNK_BITXOR: if (!f.encoder().writeOp(Op::I32Xor)) return false; break;
|
|
|
|
case PNK_LSH: if (!f.encoder().writeOp(Op::I32Shl)) return false; break;
|
|
|
|
case PNK_RSH: if (!f.encoder().writeOp(Op::I32ShrS)) return false; break;
|
|
|
|
case PNK_URSH: if (!f.encoder().writeOp(Op::I32ShrU)) return false; break;
|
|
|
|
default: MOZ_CRASH("not a bitwise op");
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckExpr(FunctionValidator& f, ParseNode* expr, Type* type)
|
|
|
|
{
|
|
|
|
JS_CHECK_RECURSION_DONT_REPORT(f.cx(), return f.m().failOverRecursed());
|
|
|
|
|
|
|
|
bool isSimd = false;
|
|
|
|
if (IsNumericLiteral(f.m(), expr, &isSimd)) {
|
|
|
|
if (isSimd)
|
|
|
|
f.setUsesSimd();
|
|
|
|
return CheckNumericLiteral(f, expr, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (expr->getKind()) {
|
|
|
|
case PNK_NAME: return CheckVarRef(f, expr, type);
|
|
|
|
case PNK_ELEM: return CheckLoadArray(f, expr, type);
|
|
|
|
case PNK_ASSIGN: return CheckAssign(f, expr, type);
|
|
|
|
case PNK_POS: return CheckPos(f, expr, type);
|
|
|
|
case PNK_NOT: return CheckNot(f, expr, type);
|
|
|
|
case PNK_NEG: return CheckNeg(f, expr, type);
|
|
|
|
case PNK_BITNOT: return CheckBitNot(f, expr, type);
|
|
|
|
case PNK_COMMA: return CheckComma(f, expr, type);
|
|
|
|
case PNK_CONDITIONAL: return CheckConditional(f, expr, type);
|
|
|
|
case PNK_STAR: return CheckMultiply(f, expr, type);
|
|
|
|
case PNK_CALL: return CheckUncoercedCall(f, expr, type);
|
|
|
|
|
|
|
|
case PNK_ADD:
|
|
|
|
case PNK_SUB: return CheckAddOrSub(f, expr, type);
|
|
|
|
|
|
|
|
case PNK_DIV:
|
|
|
|
case PNK_MOD: return CheckDivOrMod(f, expr, type);
|
|
|
|
|
|
|
|
case PNK_LT:
|
|
|
|
case PNK_LE:
|
|
|
|
case PNK_GT:
|
|
|
|
case PNK_GE:
|
|
|
|
case PNK_EQ:
|
|
|
|
case PNK_NE: return CheckComparison(f, expr, type);
|
|
|
|
|
|
|
|
case PNK_BITOR:
|
|
|
|
case PNK_BITAND:
|
|
|
|
case PNK_BITXOR:
|
|
|
|
case PNK_LSH:
|
|
|
|
case PNK_RSH:
|
|
|
|
case PNK_URSH: return CheckBitwise(f, expr, type);
|
|
|
|
|
|
|
|
default:;
|
|
|
|
}
|
|
|
|
|
|
|
|
return f.fail(expr, "unsupported expression");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckStatement(FunctionValidator& f, ParseNode* stmt);
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAsExprStatement(FunctionValidator& f, ParseNode* expr)
|
|
|
|
{
|
|
|
|
if (expr->isKind(PNK_CALL)) {
|
|
|
|
Type ignored;
|
|
|
|
return CheckCoercedCall(f, expr, Type::Void, &ignored);
|
|
|
|
}
|
|
|
|
|
|
|
|
Type resultType;
|
|
|
|
if (!CheckExpr(f, expr, &resultType))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!resultType.isVoid()) {
|
|
|
|
if (!f.encoder().writeOp(Op::Drop))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckExprStatement(FunctionValidator& f, ParseNode* exprStmt)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(exprStmt->isKind(PNK_SEMI));
|
|
|
|
ParseNode* expr = UnaryKid(exprStmt);
|
|
|
|
if (!expr)
|
|
|
|
return true;
|
|
|
|
return CheckAsExprStatement(f, expr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckLoopConditionOnEntry(FunctionValidator& f, ParseNode* cond)
|
|
|
|
{
|
|
|
|
uint32_t maybeLit;
|
|
|
|
if (IsLiteralInt(f.m(), cond, &maybeLit) && maybeLit)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
Type condType;
|
|
|
|
if (!CheckExpr(f, cond, &condType))
|
|
|
|
return false;
|
|
|
|
if (!condType.isInt())
|
|
|
|
return f.failf(cond, "%s is not a subtype of int", condType.toChars());
|
|
|
|
|
|
|
|
// TODO change this to i32.eqz
|
|
|
|
// i32.eq 0 $f
|
|
|
|
if (!f.writeInt32Lit(0))
|
|
|
|
return false;
|
|
|
|
if (!f.encoder().writeOp(Op::I32Eq))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// brIf (i32.eq 0 $f) $out
|
|
|
|
if (!f.writeBreakIf())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckWhile(FunctionValidator& f, ParseNode* whileStmt, const NameVector* labels = nullptr)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(whileStmt->isKind(PNK_WHILE));
|
|
|
|
ParseNode* cond = BinaryLeft(whileStmt);
|
|
|
|
ParseNode* body = BinaryRight(whileStmt);
|
|
|
|
|
|
|
|
// A while loop `while(#cond) #body` is equivalent to:
|
|
|
|
// (block $after_loop
|
|
|
|
// (loop $top
|
|
|
|
// (brIf $after_loop (i32.eq 0 #cond))
|
|
|
|
// #body
|
|
|
|
// (br $top)
|
|
|
|
// )
|
|
|
|
// )
|
|
|
|
if (labels && !f.addLabels(*labels, 0, 1))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.pushLoop())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!CheckLoopConditionOnEntry(f, cond))
|
|
|
|
return false;
|
|
|
|
if (!CheckStatement(f, body))
|
|
|
|
return false;
|
|
|
|
if (!f.writeContinue())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.popLoop())
|
|
|
|
return false;
|
|
|
|
if (labels)
|
|
|
|
f.removeLabels(*labels);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFor(FunctionValidator& f, ParseNode* forStmt, const NameVector* labels = nullptr)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(forStmt->isKind(PNK_FOR));
|
|
|
|
ParseNode* forHead = BinaryLeft(forStmt);
|
|
|
|
ParseNode* body = BinaryRight(forStmt);
|
|
|
|
|
|
|
|
if (!forHead->isKind(PNK_FORHEAD))
|
|
|
|
return f.fail(forHead, "unsupported for-loop statement");
|
|
|
|
|
|
|
|
ParseNode* maybeInit = TernaryKid1(forHead);
|
|
|
|
ParseNode* maybeCond = TernaryKid2(forHead);
|
|
|
|
ParseNode* maybeInc = TernaryKid3(forHead);
|
|
|
|
|
|
|
|
// A for-loop `for (#init; #cond; #inc) #body` is equivalent to:
|
|
|
|
// (block // depth X
|
|
|
|
// (#init)
|
|
|
|
// (block $after_loop // depth X+1 (block)
|
|
|
|
// (loop $loop_top // depth X+2 (loop)
|
|
|
|
// (brIf $after (eq 0 #cond))
|
|
|
|
// (block $after_body #body) // depth X+3
|
|
|
|
// #inc
|
|
|
|
// (br $loop_top)
|
|
|
|
// )
|
|
|
|
// )
|
|
|
|
// )
|
|
|
|
// A break in the body should break out to $after_loop, i.e. depth + 1.
|
|
|
|
// A continue in the body should break out to $after_body, i.e. depth + 3.
|
|
|
|
if (labels && !f.addLabels(*labels, 1, 3))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.pushUnbreakableBlock())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (maybeInit && !CheckAsExprStatement(f, maybeInit))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
{
|
|
|
|
if (!f.pushLoop())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (maybeCond && !CheckLoopConditionOnEntry(f, maybeCond))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
{
|
|
|
|
// Continuing in the body should just break out to the increment.
|
|
|
|
if (!f.pushContinuableBlock())
|
|
|
|
return false;
|
|
|
|
if (!CheckStatement(f, body))
|
|
|
|
return false;
|
|
|
|
if (!f.popContinuableBlock())
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (maybeInc && !CheckAsExprStatement(f, maybeInc))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.writeContinue())
|
|
|
|
return false;
|
|
|
|
if (!f.popLoop())
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!f.popUnbreakableBlock())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (labels)
|
|
|
|
f.removeLabels(*labels);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckDoWhile(FunctionValidator& f, ParseNode* whileStmt, const NameVector* labels = nullptr)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(whileStmt->isKind(PNK_DOWHILE));
|
|
|
|
ParseNode* body = BinaryLeft(whileStmt);
|
|
|
|
ParseNode* cond = BinaryRight(whileStmt);
|
|
|
|
|
|
|
|
// A do-while loop `do { #body } while (#cond)` is equivalent to:
|
|
|
|
// (block $after_loop // depth X
|
|
|
|
// (loop $top // depth X+1
|
|
|
|
// (block #body) // depth X+2
|
|
|
|
// (brIf #cond $top)
|
|
|
|
// )
|
|
|
|
// )
|
|
|
|
// A break should break out of the entire loop, i.e. at depth 0.
|
|
|
|
// A continue should break out to the condition, i.e. at depth 2.
|
|
|
|
if (labels && !f.addLabels(*labels, 0, 2))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.pushLoop())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
{
|
|
|
|
// An unlabeled continue in the body should break out to the condition.
|
|
|
|
if (!f.pushContinuableBlock())
|
|
|
|
return false;
|
|
|
|
if (!CheckStatement(f, body))
|
|
|
|
return false;
|
|
|
|
if (!f.popContinuableBlock())
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Type condType;
|
|
|
|
if (!CheckExpr(f, cond, &condType))
|
|
|
|
return false;
|
|
|
|
if (!condType.isInt())
|
|
|
|
return f.failf(cond, "%s is not a subtype of int", condType.toChars());
|
|
|
|
|
|
|
|
if (!f.writeContinueIf())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.popLoop())
|
|
|
|
return false;
|
|
|
|
if (labels)
|
|
|
|
f.removeLabels(*labels);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool CheckStatementList(FunctionValidator& f, ParseNode*, const NameVector* = nullptr);
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckLabel(FunctionValidator& f, ParseNode* labeledStmt)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(labeledStmt->isKind(PNK_LABEL));
|
|
|
|
|
|
|
|
NameVector labels;
|
|
|
|
ParseNode* innermost = labeledStmt;
|
|
|
|
do {
|
|
|
|
if (!labels.append(LabeledStatementLabel(innermost)))
|
|
|
|
return false;
|
|
|
|
innermost = LabeledStatementStatement(innermost);
|
|
|
|
} while (innermost->getKind() == PNK_LABEL);
|
|
|
|
|
|
|
|
switch (innermost->getKind()) {
|
|
|
|
case PNK_FOR:
|
|
|
|
return CheckFor(f, innermost, &labels);
|
|
|
|
case PNK_DOWHILE:
|
|
|
|
return CheckDoWhile(f, innermost, &labels);
|
|
|
|
case PNK_WHILE:
|
|
|
|
return CheckWhile(f, innermost, &labels);
|
|
|
|
case PNK_STATEMENTLIST:
|
|
|
|
return CheckStatementList(f, innermost, &labels);
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!f.pushUnbreakableBlock(&labels))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!CheckStatement(f, innermost))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!f.popUnbreakableBlock(&labels))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckIf(FunctionValidator& f, ParseNode* ifStmt)
|
|
|
|
{
|
|
|
|
uint32_t numIfEnd = 1;
|
|
|
|
|
|
|
|
recurse:
|
|
|
|
MOZ_ASSERT(ifStmt->isKind(PNK_IF));
|
|
|
|
ParseNode* cond = TernaryKid1(ifStmt);
|
|
|
|
ParseNode* thenStmt = TernaryKid2(ifStmt);
|
|
|
|
ParseNode* elseStmt = TernaryKid3(ifStmt);
|
|
|
|
|
|
|
|
Type condType;
|
|
|
|
if (!CheckExpr(f, cond, &condType))
|
|
|
|
return false;
|
|
|
|
if (!condType.isInt())
|
|
|
|
return f.failf(cond, "%s is not a subtype of int", condType.toChars());
|
|
|
|
|
|
|
|
size_t typeAt;
|
|
|
|
if (!f.pushIf(&typeAt))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
f.setIfType(typeAt, ExprType::Void);
|
|
|
|
|
|
|
|
if (!CheckStatement(f, thenStmt))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (elseStmt) {
|
|
|
|
if (!f.switchToElse())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (elseStmt->isKind(PNK_IF)) {
|
|
|
|
ifStmt = elseStmt;
|
|
|
|
if (numIfEnd++ == UINT32_MAX)
|
|
|
|
return false;
|
|
|
|
goto recurse;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!CheckStatement(f, elseStmt))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (uint32_t i = 0; i != numIfEnd; ++i) {
|
|
|
|
if (!f.popIf())
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckCaseExpr(FunctionValidator& f, ParseNode* caseExpr, int32_t* value)
|
|
|
|
{
|
|
|
|
if (!IsNumericLiteral(f.m(), caseExpr))
|
|
|
|
return f.fail(caseExpr, "switch case expression must be an integer literal");
|
|
|
|
|
|
|
|
NumLit lit = ExtractNumericLiteral(f.m(), caseExpr);
|
|
|
|
switch (lit.which()) {
|
|
|
|
case NumLit::Fixnum:
|
|
|
|
case NumLit::NegativeInt:
|
|
|
|
*value = lit.toInt32();
|
|
|
|
break;
|
|
|
|
case NumLit::OutOfRangeInt:
|
|
|
|
case NumLit::BigUnsigned:
|
|
|
|
return f.fail(caseExpr, "switch case expression out of integer range");
|
|
|
|
case NumLit::Double:
|
|
|
|
case NumLit::Float:
|
|
|
|
case NumLit::Int8x16:
|
|
|
|
case NumLit::Uint8x16:
|
|
|
|
case NumLit::Int16x8:
|
|
|
|
case NumLit::Uint16x8:
|
|
|
|
case NumLit::Int32x4:
|
|
|
|
case NumLit::Uint32x4:
|
|
|
|
case NumLit::Float32x4:
|
|
|
|
case NumLit::Bool8x16:
|
|
|
|
case NumLit::Bool16x8:
|
|
|
|
case NumLit::Bool32x4:
|
|
|
|
return f.fail(caseExpr, "switch case expression must be an integer literal");
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckDefaultAtEnd(FunctionValidator& f, ParseNode* stmt)
|
|
|
|
{
|
|
|
|
for (; stmt; stmt = NextNode(stmt)) {
|
|
|
|
if (IsDefaultCase(stmt) && NextNode(stmt) != nullptr)
|
|
|
|
return f.fail(stmt, "default label must be at the end");
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSwitchRange(FunctionValidator& f, ParseNode* stmt, int32_t* low, int32_t* high,
|
|
|
|
uint32_t* tableLength)
|
|
|
|
{
|
|
|
|
if (IsDefaultCase(stmt)) {
|
|
|
|
*low = 0;
|
|
|
|
*high = -1;
|
|
|
|
*tableLength = 0;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t i = 0;
|
|
|
|
if (!CheckCaseExpr(f, CaseExpr(stmt), &i))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*low = *high = i;
|
|
|
|
|
|
|
|
ParseNode* initialStmt = stmt;
|
|
|
|
for (stmt = NextNode(stmt); stmt && !IsDefaultCase(stmt); stmt = NextNode(stmt)) {
|
|
|
|
int32_t i = 0;
|
|
|
|
if (!CheckCaseExpr(f, CaseExpr(stmt), &i))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*low = Min(*low, i);
|
|
|
|
*high = Max(*high, i);
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t i64 = (int64_t(*high) - int64_t(*low)) + 1;
|
|
|
|
if (i64 > MaxBrTableElems)
|
|
|
|
return f.fail(initialStmt, "all switch statements generate tables; this table would be too big");
|
|
|
|
|
|
|
|
*tableLength = uint32_t(i64);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckSwitchExpr(FunctionValidator& f, ParseNode* switchExpr)
|
|
|
|
{
|
|
|
|
Type exprType;
|
|
|
|
if (!CheckExpr(f, switchExpr, &exprType))
|
|
|
|
return false;
|
|
|
|
if (!exprType.isSigned())
|
|
|
|
return f.failf(switchExpr, "%s is not a subtype of signed", exprType.toChars());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// A switch will be constructed as:
|
|
|
|
// - the default block wrapping all the other blocks, to be able to break
|
|
|
|
// out of the switch with an unlabeled break statement. It has two statements
|
|
|
|
// (an inner block and the default expr). asm.js rules require default to be at
|
|
|
|
// the end, so the default block always encloses all the cases blocks.
|
|
|
|
// - one block per case between low and high; undefined cases just jump to the
|
|
|
|
// default case. Each of these blocks contain two statements: the next case's
|
|
|
|
// block and the possibly empty statement list comprising the case body. The
|
|
|
|
// last block pushed is the first case so the (relative) branch target therefore
|
|
|
|
// matches the sequential order of cases.
|
|
|
|
// - one block for the br_table, so that the first break goes to the first
|
|
|
|
// case's block.
|
|
|
|
static bool
|
|
|
|
CheckSwitch(FunctionValidator& f, ParseNode* switchStmt)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(switchStmt->isKind(PNK_SWITCH));
|
|
|
|
|
|
|
|
ParseNode* switchExpr = BinaryLeft(switchStmt);
|
|
|
|
ParseNode* switchBody = BinaryRight(switchStmt);
|
|
|
|
|
|
|
|
if (switchBody->isKind(PNK_LEXICALSCOPE)) {
|
|
|
|
if (!switchBody->isEmptyScope())
|
|
|
|
return f.fail(switchBody, "switch body may not contain lexical declarations");
|
|
|
|
switchBody = switchBody->scopeBody();
|
|
|
|
}
|
|
|
|
|
|
|
|
ParseNode* stmt = ListHead(switchBody);
|
|
|
|
if (!stmt) {
|
|
|
|
if (!CheckSwitchExpr(f, switchExpr))
|
|
|
|
return false;
|
|
|
|
if (!f.encoder().writeOp(Op::Drop))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!CheckDefaultAtEnd(f, stmt))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
int32_t low = 0, high = 0;
|
|
|
|
uint32_t tableLength = 0;
|
|
|
|
if (!CheckSwitchRange(f, stmt, &low, &high, &tableLength))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
static const uint32_t CASE_NOT_DEFINED = UINT32_MAX;
|
|
|
|
|
|
|
|
Uint32Vector caseDepths;
|
|
|
|
if (!caseDepths.appendN(CASE_NOT_DEFINED, tableLength))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
uint32_t numCases = 0;
|
|
|
|
for (ParseNode* s = stmt; s && !IsDefaultCase(s); s = NextNode(s)) {
|
|
|
|
int32_t caseValue = ExtractNumericLiteral(f.m(), CaseExpr(s)).toInt32();
|
|
|
|
|
|
|
|
MOZ_ASSERT(caseValue >= low);
|
|
|
|
unsigned i = caseValue - low;
|
|
|
|
if (caseDepths[i] != CASE_NOT_DEFINED)
|
|
|
|
return f.fail(s, "no duplicate case labels");
|
|
|
|
|
|
|
|
MOZ_ASSERT(numCases != CASE_NOT_DEFINED);
|
|
|
|
caseDepths[i] = numCases++;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Open the wrapping breakable default block.
|
|
|
|
if (!f.pushBreakableBlock())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Open all the case blocks.
|
|
|
|
for (uint32_t i = 0; i < numCases; i++) {
|
|
|
|
if (!f.pushUnbreakableBlock())
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Open the br_table block.
|
|
|
|
if (!f.pushUnbreakableBlock())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// The default block is the last one.
|
|
|
|
uint32_t defaultDepth = numCases;
|
|
|
|
|
|
|
|
// Subtract lowest case value, so that all the cases start from 0.
|
|
|
|
if (low) {
|
|
|
|
if (!CheckSwitchExpr(f, switchExpr))
|
|
|
|
return false;
|
|
|
|
if (!f.writeInt32Lit(low))
|
|
|
|
return false;
|
|
|
|
if (!f.encoder().writeOp(Op::I32Sub))
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
if (!CheckSwitchExpr(f, switchExpr))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Start the br_table block.
|
|
|
|
if (!f.encoder().writeOp(Op::BrTable))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Write the number of cases (tableLength - 1 + 1 (default)).
|
|
|
|
// Write the number of cases (tableLength - 1 + 1 (default)).
|
|
|
|
if (!f.encoder().writeVarU32(tableLength))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Each case value describes the relative depth to the actual block. When
|
|
|
|
// a case is not explicitly defined, it goes to the default.
|
|
|
|
for (size_t i = 0; i < tableLength; i++) {
|
|
|
|
uint32_t target = caseDepths[i] == CASE_NOT_DEFINED ? defaultDepth : caseDepths[i];
|
|
|
|
if (!f.encoder().writeVarU32(target))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write the default depth.
|
|
|
|
if (!f.encoder().writeVarU32(defaultDepth))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Our br_table is done. Close its block, write the cases down in order.
|
|
|
|
if (!f.popUnbreakableBlock())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (; stmt && !IsDefaultCase(stmt); stmt = NextNode(stmt)) {
|
|
|
|
if (!CheckStatement(f, CaseBody(stmt)))
|
|
|
|
return false;
|
|
|
|
if (!f.popUnbreakableBlock())
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write the default block.
|
|
|
|
if (stmt && IsDefaultCase(stmt)) {
|
|
|
|
if (!CheckStatement(f, CaseBody(stmt)))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Close the wrapping block.
|
|
|
|
if (!f.popBreakableBlock())
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckReturnType(FunctionValidator& f, ParseNode* usepn, Type ret)
|
|
|
|
{
|
|
|
|
if (!f.hasAlreadyReturned()) {
|
|
|
|
f.setReturnedType(ret.canonicalToExprType());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (f.returnedType() != ret.canonicalToExprType()) {
|
|
|
|
return f.failf(usepn, "%s incompatible with previous return of type %s",
|
|
|
|
Type::ret(ret).toChars(), ToCString(f.returnedType()));
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckReturn(FunctionValidator& f, ParseNode* returnStmt)
|
|
|
|
{
|
|
|
|
ParseNode* expr = ReturnExpr(returnStmt);
|
|
|
|
|
|
|
|
if (!expr) {
|
|
|
|
if (!CheckReturnType(f, returnStmt, Type::Void))
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
Type type;
|
|
|
|
if (!CheckExpr(f, expr, &type))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!type.isReturnType())
|
|
|
|
return f.failf(expr, "%s is not a valid return type", type.toChars());
|
|
|
|
|
|
|
|
if (!CheckReturnType(f, expr, Type::canonicalize(type)))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!f.encoder().writeOp(Op::Return))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckStatementList(FunctionValidator& f, ParseNode* stmtList, const NameVector* labels /*= nullptr */)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(stmtList->isKind(PNK_STATEMENTLIST));
|
|
|
|
|
|
|
|
if (!f.pushUnbreakableBlock(labels))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (ParseNode* stmt = ListHead(stmtList); stmt; stmt = NextNode(stmt)) {
|
|
|
|
if (!CheckStatement(f, stmt))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!f.popUnbreakableBlock(labels))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckLexicalScope(FunctionValidator& f, ParseNode* lexicalScope)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(lexicalScope->isKind(PNK_LEXICALSCOPE));
|
|
|
|
|
|
|
|
if (!lexicalScope->isEmptyScope())
|
|
|
|
return f.fail(lexicalScope, "cannot have 'let' or 'const' declarations");
|
|
|
|
|
|
|
|
return CheckStatement(f, lexicalScope->scopeBody());
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckBreakOrContinue(FunctionValidator& f, bool isBreak, ParseNode* stmt)
|
|
|
|
{
|
|
|
|
if (PropertyName* maybeLabel = LoopControlMaybeLabel(stmt))
|
|
|
|
return f.writeLabeledBreakOrContinue(maybeLabel, isBreak);
|
|
|
|
return f.writeUnlabeledBreakOrContinue(isBreak);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckStatement(FunctionValidator& f, ParseNode* stmt)
|
|
|
|
{
|
|
|
|
JS_CHECK_RECURSION_DONT_REPORT(f.cx(), return f.m().failOverRecursed());
|
|
|
|
|
|
|
|
switch (stmt->getKind()) {
|
|
|
|
case PNK_SEMI: return CheckExprStatement(f, stmt);
|
|
|
|
case PNK_WHILE: return CheckWhile(f, stmt);
|
|
|
|
case PNK_FOR: return CheckFor(f, stmt);
|
|
|
|
case PNK_DOWHILE: return CheckDoWhile(f, stmt);
|
|
|
|
case PNK_LABEL: return CheckLabel(f, stmt);
|
|
|
|
case PNK_IF: return CheckIf(f, stmt);
|
|
|
|
case PNK_SWITCH: return CheckSwitch(f, stmt);
|
|
|
|
case PNK_RETURN: return CheckReturn(f, stmt);
|
|
|
|
case PNK_STATEMENTLIST: return CheckStatementList(f, stmt);
|
|
|
|
case PNK_BREAK: return CheckBreakOrContinue(f, true, stmt);
|
|
|
|
case PNK_CONTINUE: return CheckBreakOrContinue(f, false, stmt);
|
|
|
|
case PNK_LEXICALSCOPE: return CheckLexicalScope(f, stmt);
|
|
|
|
default:;
|
|
|
|
}
|
|
|
|
|
|
|
|
return f.fail(stmt, "unexpected statement kind");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ParseFunction(ModuleValidator& m, ParseNode** fnOut, unsigned* line)
|
|
|
|
{
|
|
|
|
TokenStream& tokenStream = m.tokenStream();
|
|
|
|
|
|
|
|
tokenStream.consumeKnownToken(TOK_FUNCTION, TokenStream::Operand);
|
2019-09-05 10:06:35 -07:00
|
|
|
uint32_t toStringStart = tokenStream.currentToken().pos.begin;
|
2019-03-11 03:26:37 -07:00
|
|
|
*line = tokenStream.srcCoords.lineNum(tokenStream.currentToken().pos.end);
|
|
|
|
|
|
|
|
TokenKind tk;
|
|
|
|
if (!tokenStream.getToken(&tk, TokenStream::Operand))
|
|
|
|
return false;
|
2019-09-05 10:06:12 -07:00
|
|
|
if (!TokenKindIsPossibleIdentifier(tk))
|
2019-03-11 03:26:37 -07:00
|
|
|
return false; // The regular parser will throw a SyntaxError, no need to m.fail.
|
|
|
|
|
|
|
|
RootedPropertyName name(m.cx(), m.parser().bindingIdentifier(YieldIsName));
|
|
|
|
if (!name)
|
|
|
|
return false;
|
|
|
|
|
2019-05-19 23:02:17 -07:00
|
|
|
ParseNode* fn = m.parser().handler.newFunctionStatement();
|
2019-03-11 03:26:37 -07:00
|
|
|
if (!fn)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
RootedFunction& fun = m.dummyFunction();
|
|
|
|
fun->setAtom(name);
|
|
|
|
fun->setArgCount(0);
|
|
|
|
|
|
|
|
ParseContext* outerpc = m.parser().pc;
|
|
|
|
Directives directives(outerpc);
|
2019-09-05 10:06:35 -07:00
|
|
|
FunctionBox* funbox = m.parser().newFunctionBox(fn, fun, toStringStart, directives, NotGenerator,
|
2019-03-11 03:26:37 -07:00
|
|
|
SyncFunction, /* tryAnnexB = */ false);
|
|
|
|
if (!funbox)
|
|
|
|
return false;
|
|
|
|
funbox->initWithEnclosingParseContext(outerpc, frontend::Statement);
|
|
|
|
|
|
|
|
Directives newDirectives = directives;
|
|
|
|
ParseContext funpc(&m.parser(), funbox, &newDirectives);
|
|
|
|
if (!funpc.init())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!m.parser().functionFormalParametersAndBody(InAllowed, YieldIsName, fn, Statement)) {
|
|
|
|
if (tokenStream.hadError() || directives == newDirectives)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return m.fail(fn, "encountered new directive in function");
|
|
|
|
}
|
|
|
|
|
|
|
|
MOZ_ASSERT(!tokenStream.hadError());
|
|
|
|
MOZ_ASSERT(directives == newDirectives);
|
|
|
|
|
|
|
|
*fnOut = fn;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFunction(ModuleValidator& m)
|
|
|
|
{
|
|
|
|
// asm.js modules can be quite large when represented as parse trees so pop
|
|
|
|
// the backing LifoAlloc after parsing/compiling each function.
|
|
|
|
AsmJSParser::Mark mark = m.parser().mark();
|
|
|
|
|
|
|
|
ParseNode* fn = nullptr;
|
|
|
|
unsigned line = 0;
|
|
|
|
if (!ParseFunction(m, &fn, &line))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!CheckFunctionHead(m, fn))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
FunctionValidator f(m, fn);
|
|
|
|
if (!f.init(FunctionName(fn), line))
|
|
|
|
return m.fail(fn, "internal compiler failure (probably out of memory)");
|
|
|
|
|
|
|
|
ParseNode* stmtIter = ListHead(FunctionStatementList(fn));
|
|
|
|
|
|
|
|
if (!CheckProcessingDirectives(m, &stmtIter))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ValTypeVector args;
|
|
|
|
if (!CheckArguments(f, &stmtIter, &args))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!CheckVariables(f, &stmtIter))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ParseNode* lastNonEmptyStmt = nullptr;
|
|
|
|
for (; stmtIter; stmtIter = NextNonEmptyStatement(stmtIter)) {
|
|
|
|
lastNonEmptyStmt = stmtIter;
|
|
|
|
if (!CheckStatement(f, stmtIter))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!CheckFinalReturn(f, lastNonEmptyStmt))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ModuleValidator::Func* func = nullptr;
|
|
|
|
if (!CheckFunctionSignature(m, fn, Sig(Move(args), f.returnedType()), FunctionName(fn), &func))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (func->defined())
|
|
|
|
return m.failName(fn, "function '%s' already defined", FunctionName(fn));
|
|
|
|
|
|
|
|
func->define(fn);
|
|
|
|
|
|
|
|
if (!f.finish(func->index()))
|
|
|
|
return m.fail(fn, "internal compiler failure (probably out of memory)");
|
|
|
|
|
|
|
|
// Release the parser's lifo memory only after the last use of a parse node.
|
|
|
|
m.parser().release(mark);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckAllFunctionsDefined(ModuleValidator& m)
|
|
|
|
{
|
|
|
|
for (unsigned i = 0; i < m.numFunctions(); i++) {
|
|
|
|
ModuleValidator::Func& f = m.function(i);
|
|
|
|
if (!f.defined())
|
|
|
|
return m.failNameOffset(f.firstUse(), "missing definition of function %s", f.name());
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFunctions(ModuleValidator& m)
|
|
|
|
{
|
|
|
|
while (true) {
|
|
|
|
TokenKind tk;
|
|
|
|
if (!PeekToken(m.parser(), &tk))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (tk != TOK_FUNCTION)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!CheckFunction(m))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return CheckAllFunctionsDefined(m);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFuncPtrTable(ModuleValidator& m, ParseNode* var)
|
|
|
|
{
|
|
|
|
if (!var->isKind(PNK_NAME))
|
|
|
|
return m.fail(var, "function-pointer table name is not a plain name");
|
|
|
|
|
|
|
|
ParseNode* arrayLiteral = MaybeInitializer(var);
|
|
|
|
if (!arrayLiteral || !arrayLiteral->isKind(PNK_ARRAY))
|
|
|
|
return m.fail(var, "function-pointer table's initializer must be an array literal");
|
|
|
|
|
|
|
|
unsigned length = ListLength(arrayLiteral);
|
|
|
|
|
|
|
|
if (!IsPowerOfTwo(length))
|
|
|
|
return m.failf(arrayLiteral, "function-pointer table length must be a power of 2 (is %u)", length);
|
|
|
|
|
|
|
|
unsigned mask = length - 1;
|
|
|
|
|
|
|
|
Uint32Vector elemFuncIndices;
|
|
|
|
const Sig* sig = nullptr;
|
|
|
|
for (ParseNode* elem = ListHead(arrayLiteral); elem; elem = NextNode(elem)) {
|
|
|
|
if (!elem->isKind(PNK_NAME))
|
|
|
|
return m.fail(elem, "function-pointer table's elements must be names of functions");
|
|
|
|
|
|
|
|
PropertyName* funcName = elem->name();
|
|
|
|
const ModuleValidator::Func* func = m.lookupFunction(funcName);
|
|
|
|
if (!func)
|
|
|
|
return m.fail(elem, "function-pointer table's elements must be names of functions");
|
|
|
|
|
|
|
|
const Sig& funcSig = m.mg().funcSig(func->index());
|
|
|
|
if (sig) {
|
|
|
|
if (*sig != funcSig)
|
|
|
|
return m.fail(elem, "all functions in table must have same signature");
|
|
|
|
} else {
|
|
|
|
sig = &funcSig;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!elemFuncIndices.append(func->index()))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Sig copy;
|
|
|
|
if (!copy.clone(*sig))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
uint32_t tableIndex;
|
|
|
|
if (!CheckFuncPtrTableAgainstExisting(m, var, var->name(), Move(copy), mask, &tableIndex))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!m.defineFuncPtrTable(tableIndex, Move(elemFuncIndices)))
|
|
|
|
return m.fail(var, "duplicate function-pointer definition");
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckFuncPtrTables(ModuleValidator& m)
|
|
|
|
{
|
|
|
|
while (true) {
|
|
|
|
ParseNode* varStmt;
|
|
|
|
if (!ParseVarOrConstStatement(m.parser(), &varStmt))
|
|
|
|
return false;
|
|
|
|
if (!varStmt)
|
|
|
|
break;
|
|
|
|
for (ParseNode* var = VarListHead(varStmt); var; var = NextNode(var)) {
|
|
|
|
if (!CheckFuncPtrTable(m, var))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < m.numFuncPtrTables(); i++) {
|
|
|
|
ModuleValidator::FuncPtrTable& funcPtrTable = m.funcPtrTable(i);
|
|
|
|
if (!funcPtrTable.defined()) {
|
|
|
|
return m.failNameOffset(funcPtrTable.firstUse(),
|
|
|
|
"function-pointer table %s wasn't defined",
|
|
|
|
funcPtrTable.name());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckModuleExportFunction(ModuleValidator& m, ParseNode* pn, PropertyName* maybeFieldName = nullptr)
|
|
|
|
{
|
|
|
|
if (!pn->isKind(PNK_NAME))
|
|
|
|
return m.fail(pn, "expected name of exported function");
|
|
|
|
|
|
|
|
PropertyName* funcName = pn->name();
|
|
|
|
const ModuleValidator::Func* func = m.lookupFunction(funcName);
|
|
|
|
if (!func)
|
|
|
|
return m.failName(pn, "function '%s' not found", funcName);
|
|
|
|
|
|
|
|
return m.addExportField(pn, *func, maybeFieldName);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckModuleExportObject(ModuleValidator& m, ParseNode* object)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(object->isKind(PNK_OBJECT));
|
|
|
|
|
|
|
|
for (ParseNode* pn = ListHead(object); pn; pn = NextNode(pn)) {
|
|
|
|
if (!IsNormalObjectField(m.cx(), pn))
|
|
|
|
return m.fail(pn, "only normal object properties may be used in the export object literal");
|
|
|
|
|
|
|
|
PropertyName* fieldName = ObjectNormalFieldName(m.cx(), pn);
|
|
|
|
|
|
|
|
ParseNode* initNode = ObjectNormalFieldInitializer(m.cx(), pn);
|
|
|
|
if (!initNode->isKind(PNK_NAME))
|
|
|
|
return m.fail(initNode, "initializer of exported object literal must be name of function");
|
|
|
|
|
|
|
|
if (!CheckModuleExportFunction(m, initNode, fieldName))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckModuleReturn(ModuleValidator& m)
|
|
|
|
{
|
|
|
|
TokenKind tk;
|
|
|
|
if (!GetToken(m.parser(), &tk))
|
|
|
|
return false;
|
|
|
|
TokenStream& ts = m.parser().tokenStream;
|
|
|
|
if (tk != TOK_RETURN) {
|
|
|
|
return m.failCurrentOffset((tk == TOK_RC || tk == TOK_EOF)
|
|
|
|
? "expecting return statement"
|
|
|
|
: "invalid asm.js. statement");
|
|
|
|
}
|
|
|
|
ts.ungetToken();
|
|
|
|
|
|
|
|
ParseNode* returnStmt = m.parser().statementListItem(YieldIsName);
|
|
|
|
if (!returnStmt)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ParseNode* returnExpr = ReturnExpr(returnStmt);
|
|
|
|
if (!returnExpr)
|
|
|
|
return m.fail(returnStmt, "export statement must return something");
|
|
|
|
|
|
|
|
if (returnExpr->isKind(PNK_OBJECT)) {
|
|
|
|
if (!CheckModuleExportObject(m, returnExpr))
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
if (!CheckModuleExportFunction(m, returnExpr))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckModuleEnd(ModuleValidator &m)
|
|
|
|
{
|
|
|
|
TokenKind tk;
|
|
|
|
if (!GetToken(m.parser(), &tk))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (tk != TOK_EOF && tk != TOK_RC)
|
|
|
|
return m.failCurrentOffset("top-level export (return) must be the last statement");
|
|
|
|
|
|
|
|
m.parser().tokenStream.ungetToken();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static SharedModule
|
|
|
|
CheckModule(ExclusiveContext* cx, AsmJSParser& parser, ParseNode* stmtList, unsigned* time)
|
|
|
|
{
|
|
|
|
int64_t before = PRMJ_Now();
|
|
|
|
|
|
|
|
ParseNode* moduleFunctionNode = parser.pc->functionBox()->functionNode;
|
|
|
|
MOZ_ASSERT(moduleFunctionNode);
|
|
|
|
|
|
|
|
ModuleValidator m(cx, parser, moduleFunctionNode);
|
|
|
|
if (!m.init())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!CheckFunctionHead(m, moduleFunctionNode))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!CheckModuleArguments(m, moduleFunctionNode))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!CheckPrecedingStatements(m, stmtList))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!CheckModuleProcessingDirectives(m))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!CheckModuleGlobals(m))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!m.startFunctionBodies())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!CheckFunctions(m))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!m.finishFunctionBodies())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!CheckFuncPtrTables(m))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!CheckModuleReturn(m))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!CheckModuleEnd(m))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
SharedModule module = m.finish();
|
|
|
|
if (!module)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
*time = (PRMJ_Now() - before) / PRMJ_USEC_PER_MSEC;
|
|
|
|
return module;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
// Link-time validation
|
|
|
|
|
|
|
|
static bool
|
|
|
|
LinkFail(JSContext* cx, const char* str)
|
|
|
|
{
|
|
|
|
JS_ReportErrorFlagsAndNumberASCII(cx, JSREPORT_WARNING, GetErrorMessage, nullptr,
|
|
|
|
JSMSG_USE_ASM_LINK_FAIL, str);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
IsMaybeWrappedScriptedProxy(JSObject* obj)
|
|
|
|
{
|
|
|
|
JSObject* unwrapped = UncheckedUnwrap(obj);
|
|
|
|
return unwrapped && IsScriptedProxy(unwrapped);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
GetDataProperty(JSContext* cx, HandleValue objVal, HandleAtom field, MutableHandleValue v)
|
|
|
|
{
|
|
|
|
if (!objVal.isObject())
|
|
|
|
return LinkFail(cx, "accessing property of non-object");
|
|
|
|
|
|
|
|
RootedObject obj(cx, &objVal.toObject());
|
|
|
|
if (IsMaybeWrappedScriptedProxy(obj))
|
|
|
|
return LinkFail(cx, "accessing property of a Proxy");
|
|
|
|
|
|
|
|
Rooted<PropertyDescriptor> desc(cx);
|
|
|
|
RootedId id(cx, AtomToId(field));
|
|
|
|
if (!GetPropertyDescriptor(cx, obj, id, &desc))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!desc.object())
|
|
|
|
return LinkFail(cx, "property not present on object");
|
|
|
|
|
|
|
|
if (!desc.isDataDescriptor())
|
|
|
|
return LinkFail(cx, "property is not a data property");
|
|
|
|
|
|
|
|
v.set(desc.value());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
GetDataProperty(JSContext* cx, HandleValue objVal, const char* fieldChars, MutableHandleValue v)
|
|
|
|
{
|
|
|
|
RootedAtom field(cx, AtomizeUTF8Chars(cx, fieldChars, strlen(fieldChars)));
|
|
|
|
if (!field)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return GetDataProperty(cx, objVal, field, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
GetDataProperty(JSContext* cx, HandleValue objVal, ImmutablePropertyNamePtr field, MutableHandleValue v)
|
|
|
|
{
|
|
|
|
// Help the conversion along for all the cx->names().* users.
|
|
|
|
HandlePropertyName fieldHandle = field;
|
|
|
|
return GetDataProperty(cx, objVal, fieldHandle, v);
|
|
|
|
}
|
|
|
|
|
2019-09-05 10:05:43 -07:00
|
|
|
static bool
|
|
|
|
HasObjectValueOfMethodPure(JSObject* obj, JSContext* cx)
|
|
|
|
{
|
|
|
|
Value v;
|
|
|
|
if (!GetPropertyPure(cx, obj, NameToId(cx->names().valueOf), &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
JSFunction* fun;
|
|
|
|
if (!IsFunctionObject(v, &fun))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return IsSelfHostedFunctionWithName(fun, cx->names().Object_valueOf);
|
|
|
|
}
|
|
|
|
|
2019-03-11 03:26:37 -07:00
|
|
|
static bool
|
|
|
|
HasPureCoercion(JSContext* cx, HandleValue v)
|
|
|
|
{
|
|
|
|
// Unsigned SIMD types are not allowed in function signatures.
|
|
|
|
if (IsVectorObject<Int32x4>(v) || IsVectorObject<Float32x4>(v) || IsVectorObject<Bool32x4>(v))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Ideally, we'd reject all non-SIMD non-primitives, but Emscripten has a
|
|
|
|
// bug that generates code that passes functions for some imports. To avoid
|
|
|
|
// breaking all the code that contains this bug, we make an exception for
|
|
|
|
// functions that don't have user-defined valueOf or toString, for their
|
|
|
|
// coercions are not observable and coercion via ToNumber/ToInt32
|
|
|
|
// definitely produces NaN/0. We should remove this special case later once
|
|
|
|
// most apps have been built with newer Emscripten.
|
|
|
|
if (v.toObject().is<JSFunction>() &&
|
2019-09-05 10:05:41 -07:00
|
|
|
HasNoToPrimitiveMethodPure(&v.toObject(), cx) &&
|
2019-09-05 10:05:43 -07:00
|
|
|
HasObjectValueOfMethodPure(&v.toObject(), cx) &&
|
2019-09-05 10:05:41 -07:00
|
|
|
HasNativeMethodPure(&v.toObject(), cx->names().toString, fun_toString, cx))
|
2019-03-11 03:26:37 -07:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ValidateGlobalVariable(JSContext* cx, const AsmJSGlobal& global, HandleValue importVal, Val* val)
|
|
|
|
{
|
|
|
|
switch (global.varInitKind()) {
|
|
|
|
case AsmJSGlobal::InitConstant:
|
|
|
|
*val = global.varInitVal();
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case AsmJSGlobal::InitImport: {
|
|
|
|
RootedValue v(cx);
|
|
|
|
if (!GetDataProperty(cx, importVal, global.field(), &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!v.isPrimitive() && !HasPureCoercion(cx, v))
|
|
|
|
return LinkFail(cx, "Imported values must be primitives");
|
|
|
|
|
|
|
|
switch (global.varInitImportType()) {
|
|
|
|
case ValType::I32: {
|
|
|
|
int32_t i32;
|
|
|
|
if (!ToInt32(cx, v, &i32))
|
|
|
|
return false;
|
|
|
|
*val = Val(uint32_t(i32));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case ValType::I64:
|
|
|
|
MOZ_CRASH("int64");
|
|
|
|
case ValType::F32: {
|
|
|
|
float f;
|
|
|
|
if (!RoundFloat32(cx, v, &f))
|
|
|
|
return false;
|
|
|
|
*val = Val(RawF32(f));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case ValType::F64: {
|
|
|
|
double d;
|
|
|
|
if (!ToNumber(cx, v, &d))
|
|
|
|
return false;
|
|
|
|
*val = Val(RawF64(d));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case ValType::I8x16: {
|
|
|
|
SimdConstant simdConstant;
|
|
|
|
if (!ToSimdConstant<Int8x16>(cx, v, &simdConstant))
|
|
|
|
return false;
|
|
|
|
*val = Val(simdConstant.asInt8x16());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case ValType::I16x8: {
|
|
|
|
SimdConstant simdConstant;
|
|
|
|
if (!ToSimdConstant<Int16x8>(cx, v, &simdConstant))
|
|
|
|
return false;
|
|
|
|
*val = Val(simdConstant.asInt16x8());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case ValType::I32x4: {
|
|
|
|
SimdConstant simdConstant;
|
|
|
|
if (!ToSimdConstant<Int32x4>(cx, v, &simdConstant))
|
|
|
|
return false;
|
|
|
|
*val = Val(simdConstant.asInt32x4());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case ValType::F32x4: {
|
|
|
|
SimdConstant simdConstant;
|
|
|
|
if (!ToSimdConstant<Float32x4>(cx, v, &simdConstant))
|
|
|
|
return false;
|
|
|
|
*val = Val(simdConstant.asFloat32x4());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case ValType::B8x16: {
|
|
|
|
SimdConstant simdConstant;
|
|
|
|
if (!ToSimdConstant<Bool8x16>(cx, v, &simdConstant))
|
|
|
|
return false;
|
|
|
|
// Bool8x16 uses the same data layout as Int8x16.
|
|
|
|
*val = Val(simdConstant.asInt8x16());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case ValType::B16x8: {
|
|
|
|
SimdConstant simdConstant;
|
|
|
|
if (!ToSimdConstant<Bool16x8>(cx, v, &simdConstant))
|
|
|
|
return false;
|
|
|
|
// Bool16x8 uses the same data layout as Int16x8.
|
|
|
|
*val = Val(simdConstant.asInt16x8());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case ValType::B32x4: {
|
|
|
|
SimdConstant simdConstant;
|
|
|
|
if (!ToSimdConstant<Bool32x4>(cx, v, &simdConstant))
|
|
|
|
return false;
|
|
|
|
// Bool32x4 uses the same data layout as Int32x4.
|
|
|
|
*val = Val(simdConstant.asInt32x4());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
MOZ_CRASH("unreachable");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ValidateFFI(JSContext* cx, const AsmJSGlobal& global, HandleValue importVal,
|
|
|
|
MutableHandle<FunctionVector> ffis)
|
|
|
|
{
|
|
|
|
RootedValue v(cx);
|
|
|
|
if (!GetDataProperty(cx, importVal, global.field(), &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!IsFunctionObject(v))
|
|
|
|
return LinkFail(cx, "FFI imports must be functions");
|
|
|
|
|
|
|
|
ffis[global.ffiIndex()].set(&v.toObject().as<JSFunction>());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ValidateArrayView(JSContext* cx, const AsmJSGlobal& global, HandleValue globalVal)
|
|
|
|
{
|
|
|
|
if (!global.field())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
RootedValue v(cx);
|
|
|
|
if (!GetDataProperty(cx, globalVal, global.field(), &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
bool tac = IsTypedArrayConstructor(v, global.viewType());
|
|
|
|
if (!tac)
|
|
|
|
return LinkFail(cx, "bad typed array constructor");
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ValidateMathBuiltinFunction(JSContext* cx, const AsmJSGlobal& global, HandleValue globalVal)
|
|
|
|
{
|
|
|
|
RootedValue v(cx);
|
|
|
|
if (!GetDataProperty(cx, globalVal, cx->names().Math, &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!GetDataProperty(cx, v, global.field(), &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Native native = nullptr;
|
|
|
|
switch (global.mathBuiltinFunction()) {
|
|
|
|
case AsmJSMathBuiltin_sin: native = math_sin; break;
|
|
|
|
case AsmJSMathBuiltin_cos: native = math_cos; break;
|
|
|
|
case AsmJSMathBuiltin_tan: native = math_tan; break;
|
|
|
|
case AsmJSMathBuiltin_asin: native = math_asin; break;
|
|
|
|
case AsmJSMathBuiltin_acos: native = math_acos; break;
|
|
|
|
case AsmJSMathBuiltin_atan: native = math_atan; break;
|
|
|
|
case AsmJSMathBuiltin_ceil: native = math_ceil; break;
|
|
|
|
case AsmJSMathBuiltin_floor: native = math_floor; break;
|
|
|
|
case AsmJSMathBuiltin_exp: native = math_exp; break;
|
|
|
|
case AsmJSMathBuiltin_log: native = math_log; break;
|
|
|
|
case AsmJSMathBuiltin_pow: native = math_pow; break;
|
|
|
|
case AsmJSMathBuiltin_sqrt: native = math_sqrt; break;
|
|
|
|
case AsmJSMathBuiltin_min: native = math_min; break;
|
|
|
|
case AsmJSMathBuiltin_max: native = math_max; break;
|
|
|
|
case AsmJSMathBuiltin_abs: native = math_abs; break;
|
|
|
|
case AsmJSMathBuiltin_atan2: native = math_atan2; break;
|
|
|
|
case AsmJSMathBuiltin_imul: native = math_imul; break;
|
|
|
|
case AsmJSMathBuiltin_clz32: native = math_clz32; break;
|
|
|
|
case AsmJSMathBuiltin_fround: native = math_fround; break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!IsNativeFunction(v, native))
|
|
|
|
return LinkFail(cx, "bad Math.* builtin function");
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ValidateSimdType(JSContext* cx, const AsmJSGlobal& global, HandleValue globalVal,
|
|
|
|
MutableHandleValue out)
|
|
|
|
{
|
|
|
|
RootedValue v(cx);
|
|
|
|
if (!GetDataProperty(cx, globalVal, cx->names().SIMD, &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
SimdType type;
|
|
|
|
if (global.which() == AsmJSGlobal::SimdCtor)
|
|
|
|
type = global.simdCtorType();
|
|
|
|
else
|
|
|
|
type = global.simdOperationType();
|
|
|
|
|
|
|
|
RootedPropertyName simdTypeName(cx, SimdTypeToName(cx->names(), type));
|
|
|
|
if (!GetDataProperty(cx, v, simdTypeName, &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!v.isObject())
|
|
|
|
return LinkFail(cx, "bad SIMD type");
|
|
|
|
|
|
|
|
RootedObject simdDesc(cx, &v.toObject());
|
|
|
|
if (!simdDesc->is<SimdTypeDescr>())
|
|
|
|
return LinkFail(cx, "bad SIMD type");
|
|
|
|
|
|
|
|
if (type != simdDesc->as<SimdTypeDescr>().type())
|
|
|
|
return LinkFail(cx, "bad SIMD type");
|
|
|
|
|
|
|
|
out.set(v);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ValidateSimdType(JSContext* cx, const AsmJSGlobal& global, HandleValue globalVal)
|
|
|
|
{
|
|
|
|
RootedValue _(cx);
|
|
|
|
return ValidateSimdType(cx, global, globalVal, &_);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ValidateSimdOperation(JSContext* cx, const AsmJSGlobal& global, HandleValue globalVal)
|
|
|
|
{
|
|
|
|
RootedValue v(cx);
|
|
|
|
JS_ALWAYS_TRUE(ValidateSimdType(cx, global, globalVal, &v));
|
|
|
|
|
|
|
|
if (!GetDataProperty(cx, v, global.field(), &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Native native = nullptr;
|
|
|
|
switch (global.simdOperationType()) {
|
|
|
|
#define SET_NATIVE_INT8X16(op) case SimdOperation::Fn_##op: native = simd_int8x16_##op; break;
|
|
|
|
#define SET_NATIVE_INT16X8(op) case SimdOperation::Fn_##op: native = simd_int16x8_##op; break;
|
|
|
|
#define SET_NATIVE_INT32X4(op) case SimdOperation::Fn_##op: native = simd_int32x4_##op; break;
|
|
|
|
#define SET_NATIVE_UINT8X16(op) case SimdOperation::Fn_##op: native = simd_uint8x16_##op; break;
|
|
|
|
#define SET_NATIVE_UINT16X8(op) case SimdOperation::Fn_##op: native = simd_uint16x8_##op; break;
|
|
|
|
#define SET_NATIVE_UINT32X4(op) case SimdOperation::Fn_##op: native = simd_uint32x4_##op; break;
|
|
|
|
#define SET_NATIVE_FLOAT32X4(op) case SimdOperation::Fn_##op: native = simd_float32x4_##op; break;
|
|
|
|
#define SET_NATIVE_BOOL8X16(op) case SimdOperation::Fn_##op: native = simd_bool8x16_##op; break;
|
|
|
|
#define SET_NATIVE_BOOL16X8(op) case SimdOperation::Fn_##op: native = simd_bool16x8_##op; break;
|
|
|
|
#define SET_NATIVE_BOOL32X4(op) case SimdOperation::Fn_##op: native = simd_bool32x4_##op; break;
|
|
|
|
#define FALLTHROUGH(op) case SimdOperation::Fn_##op:
|
|
|
|
case SimdType::Int8x16:
|
|
|
|
switch (global.simdOperation()) {
|
|
|
|
FORALL_INT8X16_ASMJS_OP(SET_NATIVE_INT8X16)
|
|
|
|
SET_NATIVE_INT8X16(fromUint8x16Bits)
|
|
|
|
SET_NATIVE_INT8X16(fromUint16x8Bits)
|
|
|
|
SET_NATIVE_INT8X16(fromUint32x4Bits)
|
|
|
|
default: MOZ_CRASH("shouldn't have been validated in the first place");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Int16x8:
|
|
|
|
switch (global.simdOperation()) {
|
|
|
|
FORALL_INT16X8_ASMJS_OP(SET_NATIVE_INT16X8)
|
|
|
|
SET_NATIVE_INT16X8(fromUint8x16Bits)
|
|
|
|
SET_NATIVE_INT16X8(fromUint16x8Bits)
|
|
|
|
SET_NATIVE_INT16X8(fromUint32x4Bits)
|
|
|
|
default: MOZ_CRASH("shouldn't have been validated in the first place");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Int32x4:
|
|
|
|
switch (global.simdOperation()) {
|
|
|
|
FORALL_INT32X4_ASMJS_OP(SET_NATIVE_INT32X4)
|
|
|
|
SET_NATIVE_INT32X4(fromUint8x16Bits)
|
|
|
|
SET_NATIVE_INT32X4(fromUint16x8Bits)
|
|
|
|
SET_NATIVE_INT32X4(fromUint32x4Bits)
|
|
|
|
default: MOZ_CRASH("shouldn't have been validated in the first place");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Uint8x16:
|
|
|
|
switch (global.simdOperation()) {
|
|
|
|
FORALL_INT8X16_ASMJS_OP(SET_NATIVE_UINT8X16)
|
|
|
|
SET_NATIVE_UINT8X16(fromInt8x16Bits)
|
|
|
|
SET_NATIVE_UINT8X16(fromUint16x8Bits)
|
|
|
|
SET_NATIVE_UINT8X16(fromUint32x4Bits)
|
|
|
|
default: MOZ_CRASH("shouldn't have been validated in the first place");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Uint16x8:
|
|
|
|
switch (global.simdOperation()) {
|
|
|
|
FORALL_INT16X8_ASMJS_OP(SET_NATIVE_UINT16X8)
|
|
|
|
SET_NATIVE_UINT16X8(fromUint8x16Bits)
|
|
|
|
SET_NATIVE_UINT16X8(fromInt16x8Bits)
|
|
|
|
SET_NATIVE_UINT16X8(fromUint32x4Bits)
|
|
|
|
default: MOZ_CRASH("shouldn't have been validated in the first place");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Uint32x4:
|
|
|
|
switch (global.simdOperation()) {
|
|
|
|
FORALL_INT32X4_ASMJS_OP(SET_NATIVE_UINT32X4)
|
|
|
|
SET_NATIVE_UINT32X4(fromUint8x16Bits)
|
|
|
|
SET_NATIVE_UINT32X4(fromUint16x8Bits)
|
|
|
|
SET_NATIVE_UINT32X4(fromInt32x4Bits)
|
|
|
|
default: MOZ_CRASH("shouldn't have been validated in the first place");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Float32x4:
|
|
|
|
switch (global.simdOperation()) {
|
|
|
|
FORALL_FLOAT32X4_ASMJS_OP(SET_NATIVE_FLOAT32X4)
|
|
|
|
SET_NATIVE_FLOAT32X4(fromUint8x16Bits)
|
|
|
|
SET_NATIVE_FLOAT32X4(fromUint16x8Bits)
|
|
|
|
SET_NATIVE_FLOAT32X4(fromUint32x4Bits)
|
|
|
|
default: MOZ_CRASH("shouldn't have been validated in the first place");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Bool8x16:
|
|
|
|
switch (global.simdOperation()) {
|
|
|
|
FORALL_BOOL_SIMD_OP(SET_NATIVE_BOOL8X16)
|
|
|
|
default: MOZ_CRASH("shouldn't have been validated in the first place");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Bool16x8:
|
|
|
|
switch (global.simdOperation()) {
|
|
|
|
FORALL_BOOL_SIMD_OP(SET_NATIVE_BOOL16X8)
|
|
|
|
default: MOZ_CRASH("shouldn't have been validated in the first place");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SimdType::Bool32x4:
|
|
|
|
switch (global.simdOperation()) {
|
|
|
|
FORALL_BOOL_SIMD_OP(SET_NATIVE_BOOL32X4)
|
|
|
|
default: MOZ_CRASH("shouldn't have been validated in the first place");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default: MOZ_CRASH("unhandled simd type");
|
|
|
|
#undef FALLTHROUGH
|
|
|
|
#undef SET_NATIVE_INT8X16
|
|
|
|
#undef SET_NATIVE_INT16X8
|
|
|
|
#undef SET_NATIVE_INT32X4
|
|
|
|
#undef SET_NATIVE_UINT8X16
|
|
|
|
#undef SET_NATIVE_UINT16X8
|
|
|
|
#undef SET_NATIVE_UINT32X4
|
|
|
|
#undef SET_NATIVE_FLOAT32X4
|
|
|
|
#undef SET_NATIVE_BOOL8X16
|
|
|
|
#undef SET_NATIVE_BOOL16X8
|
|
|
|
#undef SET_NATIVE_BOOL32X4
|
|
|
|
#undef SET_NATIVE
|
|
|
|
}
|
|
|
|
if (!native || !IsNativeFunction(v, native))
|
|
|
|
return LinkFail(cx, "bad SIMD.type.* operation");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ValidateAtomicsBuiltinFunction(JSContext* cx, const AsmJSGlobal& global, HandleValue globalVal)
|
|
|
|
{
|
|
|
|
RootedValue v(cx);
|
|
|
|
if (!GetDataProperty(cx, globalVal, cx->names().Atomics, &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!GetDataProperty(cx, v, global.field(), &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Native native = nullptr;
|
|
|
|
switch (global.atomicsBuiltinFunction()) {
|
|
|
|
case AsmJSAtomicsBuiltin_compareExchange: native = atomics_compareExchange; break;
|
|
|
|
case AsmJSAtomicsBuiltin_exchange: native = atomics_exchange; break;
|
|
|
|
case AsmJSAtomicsBuiltin_load: native = atomics_load; break;
|
|
|
|
case AsmJSAtomicsBuiltin_store: native = atomics_store; break;
|
|
|
|
case AsmJSAtomicsBuiltin_add: native = atomics_add; break;
|
|
|
|
case AsmJSAtomicsBuiltin_sub: native = atomics_sub; break;
|
|
|
|
case AsmJSAtomicsBuiltin_and: native = atomics_and; break;
|
|
|
|
case AsmJSAtomicsBuiltin_or: native = atomics_or; break;
|
|
|
|
case AsmJSAtomicsBuiltin_xor: native = atomics_xor; break;
|
|
|
|
case AsmJSAtomicsBuiltin_isLockFree: native = atomics_isLockFree; break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!IsNativeFunction(v, native))
|
|
|
|
return LinkFail(cx, "bad Atomics.* builtin function");
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ValidateConstant(JSContext* cx, const AsmJSGlobal& global, HandleValue globalVal)
|
|
|
|
{
|
|
|
|
RootedValue v(cx, globalVal);
|
|
|
|
|
|
|
|
if (global.constantKind() == AsmJSGlobal::MathConstant) {
|
|
|
|
if (!GetDataProperty(cx, v, cx->names().Math, &v))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!GetDataProperty(cx, v, global.field(), &v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!v.isNumber())
|
|
|
|
return LinkFail(cx, "math / global constant value needs to be a number");
|
|
|
|
|
|
|
|
// NaN != NaN
|
|
|
|
if (IsNaN(global.constantValue())) {
|
|
|
|
if (!IsNaN(v.toNumber()))
|
|
|
|
return LinkFail(cx, "global constant value needs to be NaN");
|
|
|
|
} else {
|
|
|
|
if (v.toNumber() != global.constantValue())
|
|
|
|
return LinkFail(cx, "global constant value mismatch");
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
CheckBuffer(JSContext* cx, const AsmJSMetadata& metadata, HandleValue bufferVal,
|
|
|
|
MutableHandle<ArrayBufferObjectMaybeShared*> buffer)
|
|
|
|
{
|
|
|
|
if (metadata.memoryUsage == MemoryUsage::Shared) {
|
|
|
|
if (!IsSharedArrayBuffer(bufferVal))
|
|
|
|
return LinkFail(cx, "shared views can only be constructed onto SharedArrayBuffer");
|
|
|
|
} else {
|
|
|
|
if (!IsArrayBuffer(bufferVal))
|
|
|
|
return LinkFail(cx, "unshared views can only be constructed onto ArrayBuffer");
|
|
|
|
}
|
|
|
|
|
|
|
|
buffer.set(&AsAnyArrayBuffer(bufferVal));
|
|
|
|
uint32_t memoryLength = buffer->byteLength();
|
|
|
|
|
|
|
|
if (!IsValidAsmJSHeapLength(memoryLength)) {
|
|
|
|
UniqueChars msg(
|
|
|
|
JS_smprintf("ArrayBuffer byteLength 0x%x is not a valid heap length. The next "
|
|
|
|
"valid length is 0x%x",
|
|
|
|
memoryLength,
|
|
|
|
RoundUpToNextValidAsmJSHeapLength(memoryLength)));
|
|
|
|
if (!msg)
|
|
|
|
return false;
|
|
|
|
return LinkFail(cx, msg.get());
|
|
|
|
}
|
|
|
|
|
|
|
|
// This check is sufficient without considering the size of the loaded datum because heap
|
|
|
|
// loads and stores start on an aligned boundary and the heap byteLength has larger alignment.
|
|
|
|
MOZ_ASSERT((metadata.minMemoryLength - 1) <= INT32_MAX);
|
|
|
|
if (memoryLength < metadata.minMemoryLength) {
|
|
|
|
UniqueChars msg(
|
|
|
|
JS_smprintf("ArrayBuffer byteLength of 0x%x is less than 0x%x (the size implied "
|
|
|
|
"by const heap accesses).",
|
|
|
|
memoryLength,
|
|
|
|
metadata.minMemoryLength));
|
|
|
|
if (!msg)
|
|
|
|
return false;
|
|
|
|
return LinkFail(cx, msg.get());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (buffer->is<ArrayBufferObject>()) {
|
|
|
|
// On 64-bit, bounds checks are statically removed so the huge guard
|
|
|
|
// region is always necessary. On 32-bit, allocating a guard page
|
|
|
|
// requires reallocating the incoming ArrayBuffer which could trigger
|
|
|
|
// OOM. Thus, only ask for a guard page when SIMD is used since SIMD
|
|
|
|
// allows unaligned memory access (see MaxMemoryAccessSize comment);
|
|
|
|
#ifdef WASM_HUGE_MEMORY
|
|
|
|
bool needGuard = true;
|
|
|
|
#else
|
|
|
|
bool needGuard = metadata.usesSimd;
|
|
|
|
#endif
|
|
|
|
Rooted<ArrayBufferObject*> arrayBuffer(cx, &buffer->as<ArrayBufferObject>());
|
|
|
|
if (!ArrayBufferObject::prepareForAsmJS(cx, arrayBuffer, needGuard))
|
|
|
|
return LinkFail(cx, "Unable to prepare ArrayBuffer for asm.js use");
|
|
|
|
} else {
|
|
|
|
if (!buffer->as<SharedArrayBufferObject>().isPreparedForAsmJS())
|
|
|
|
return LinkFail(cx, "SharedArrayBuffer must be created with wasm test mode enabled");
|
|
|
|
}
|
|
|
|
|
|
|
|
MOZ_ASSERT(buffer->isPreparedForAsmJS());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
GetImports(JSContext* cx, const AsmJSMetadata& metadata, HandleValue globalVal,
|
|
|
|
HandleValue importVal, MutableHandle<FunctionVector> funcImports, ValVector* valImports)
|
|
|
|
{
|
|
|
|
Rooted<FunctionVector> ffis(cx, FunctionVector(cx));
|
|
|
|
if (!ffis.resize(metadata.numFFIs))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (const AsmJSGlobal& global : metadata.asmJSGlobals) {
|
|
|
|
switch (global.which()) {
|
|
|
|
case AsmJSGlobal::Variable: {
|
|
|
|
Val val;
|
|
|
|
if (!ValidateGlobalVariable(cx, global, importVal, &val))
|
|
|
|
return false;
|
|
|
|
if (!valImports->append(val))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case AsmJSGlobal::FFI:
|
|
|
|
if (!ValidateFFI(cx, global, importVal, &ffis))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case AsmJSGlobal::ArrayView:
|
|
|
|
case AsmJSGlobal::ArrayViewCtor:
|
|
|
|
if (!ValidateArrayView(cx, global, globalVal))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case AsmJSGlobal::MathBuiltinFunction:
|
|
|
|
if (!ValidateMathBuiltinFunction(cx, global, globalVal))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case AsmJSGlobal::AtomicsBuiltinFunction:
|
|
|
|
if (!ValidateAtomicsBuiltinFunction(cx, global, globalVal))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case AsmJSGlobal::Constant:
|
|
|
|
if (!ValidateConstant(cx, global, globalVal))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case AsmJSGlobal::SimdCtor:
|
|
|
|
if (!ValidateSimdType(cx, global, globalVal))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case AsmJSGlobal::SimdOp:
|
|
|
|
if (!ValidateSimdOperation(cx, global, globalVal))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const AsmJSImport& import : metadata.asmJSImports) {
|
|
|
|
if (!funcImports.append(ffis[import.ffiIndex()]))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
TryInstantiate(JSContext* cx, CallArgs args, Module& module, const AsmJSMetadata& metadata,
|
|
|
|
MutableHandleWasmInstanceObject instanceObj, MutableHandleObject exportObj)
|
|
|
|
{
|
|
|
|
HandleValue globalVal = args.get(0);
|
|
|
|
HandleValue importVal = args.get(1);
|
|
|
|
HandleValue bufferVal = args.get(2);
|
|
|
|
|
|
|
|
RootedArrayBufferObjectMaybeShared buffer(cx);
|
|
|
|
RootedWasmMemoryObject memory(cx);
|
|
|
|
if (module.metadata().usesMemory()) {
|
|
|
|
if (!CheckBuffer(cx, metadata, bufferVal, &buffer))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
memory = WasmMemoryObject::create(cx, buffer, nullptr);
|
|
|
|
if (!memory)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
ValVector valImports;
|
|
|
|
Rooted<FunctionVector> funcs(cx, FunctionVector(cx));
|
|
|
|
if (!GetImports(cx, metadata, globalVal, importVal, &funcs, &valImports))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
RootedWasmTableObject table(cx);
|
|
|
|
if (!module.instantiate(cx, funcs, table, memory, valImports, nullptr, instanceObj))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
RootedValue exportObjVal(cx);
|
|
|
|
if (!JS_GetProperty(cx, instanceObj, InstanceExportField, &exportObjVal))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
MOZ_RELEASE_ASSERT(exportObjVal.isObject());
|
|
|
|
exportObj.set(&exportObjVal.toObject());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
HandleInstantiationFailure(JSContext* cx, CallArgs args, const AsmJSMetadata& metadata)
|
|
|
|
{
|
|
|
|
RootedAtom name(cx, args.callee().as<JSFunction>().explicitName());
|
|
|
|
|
|
|
|
if (cx->isExceptionPending())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ScriptSource* source = metadata.scriptSource.get();
|
|
|
|
|
|
|
|
// Source discarding is allowed to affect JS semantics because it is never
|
|
|
|
// enabled for normal JS content.
|
|
|
|
bool haveSource = source->hasSourceData();
|
|
|
|
if (!haveSource && !JSScript::loadSource(cx, source, &haveSource))
|
|
|
|
return false;
|
|
|
|
if (!haveSource) {
|
|
|
|
JS_ReportErrorASCII(cx, "asm.js link failure with source discarding enabled");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-09-05 10:06:35 -07:00
|
|
|
uint32_t begin = metadata.toStringStart;
|
2019-03-11 03:26:37 -07:00
|
|
|
uint32_t end = metadata.srcEndAfterCurly();
|
|
|
|
Rooted<JSFlatString*> src(cx, source->substringDontDeflate(cx, begin, end));
|
|
|
|
if (!src)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
RootedFunction fun(cx, NewScriptedFunction(cx, 0, JSFunction::INTERPRETED_NORMAL,
|
|
|
|
name, /* proto = */ nullptr, gc::AllocKind::FUNCTION,
|
|
|
|
TenuredObject));
|
|
|
|
if (!fun)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
CompileOptions options(cx);
|
|
|
|
options.setMutedErrors(source->mutedErrors())
|
|
|
|
.setFile(source->filename())
|
|
|
|
.setNoScriptRval(false);
|
|
|
|
options.asmJSOption = AsmJSOption::Disabled;
|
|
|
|
|
|
|
|
// The exported function inherits an implicit strict context if the module
|
|
|
|
// also inherited it somehow.
|
|
|
|
if (metadata.strict)
|
|
|
|
options.strictOption = true;
|
|
|
|
|
|
|
|
AutoStableStringChars stableChars(cx);
|
|
|
|
if (!stableChars.initTwoByte(cx, src))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
const char16_t* chars = stableChars.twoByteRange().begin().get();
|
|
|
|
SourceBufferHolder::Ownership ownership = stableChars.maybeGiveOwnershipToCaller()
|
|
|
|
? SourceBufferHolder::GiveOwnership
|
|
|
|
: SourceBufferHolder::NoOwnership;
|
2019-05-19 23:02:17 -07:00
|
|
|
SourceBufferHolder srcBuf(chars, end - begin, ownership);
|
2019-03-11 03:26:37 -07:00
|
|
|
if (!frontend::CompileStandaloneFunction(cx, &fun, options, srcBuf, Nothing()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Call the function we just recompiled.
|
|
|
|
args.setCallee(ObjectValue(*fun));
|
|
|
|
return InternalCallOrConstruct(cx, args, args.isConstructing() ? CONSTRUCT : NO_CONSTRUCT);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Module&
|
|
|
|
AsmJSModuleFunctionToModule(JSFunction* fun)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(IsAsmJSModule(fun));
|
|
|
|
const Value& v = fun->getExtendedSlot(FunctionExtended::ASMJS_MODULE_SLOT);
|
|
|
|
return v.toObject().as<WasmModuleObject>().module();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Implements the semantics of an asm.js module function that has been successfully validated.
|
|
|
|
static bool
|
|
|
|
InstantiateAsmJS(JSContext* cx, unsigned argc, JS::Value* vp)
|
|
|
|
{
|
|
|
|
CallArgs args = CallArgsFromVp(argc, vp);
|
|
|
|
|
|
|
|
JSFunction* callee = &args.callee().as<JSFunction>();
|
|
|
|
Module& module = AsmJSModuleFunctionToModule(callee);
|
|
|
|
const AsmJSMetadata& metadata = module.metadata().asAsmJS();
|
|
|
|
|
|
|
|
RootedWasmInstanceObject instanceObj(cx);
|
|
|
|
RootedObject exportObj(cx);
|
|
|
|
if (!TryInstantiate(cx, args, module, metadata, &instanceObj, &exportObj)) {
|
|
|
|
// Link-time validation checks failed, so reparse the entire asm.js
|
|
|
|
// module from scratch to get normal interpreted bytecode which we can
|
|
|
|
// simply Invoke. Very slow.
|
|
|
|
return HandleInstantiationFailure(cx, args, metadata);
|
|
|
|
}
|
|
|
|
|
|
|
|
args.rval().set(ObjectValue(*exportObj));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static JSFunction*
|
|
|
|
NewAsmJSModuleFunction(ExclusiveContext* cx, JSFunction* origFun, HandleObject moduleObj)
|
|
|
|
{
|
|
|
|
RootedAtom name(cx, origFun->explicitName());
|
|
|
|
|
|
|
|
JSFunction::Flags flags = origFun->isLambda() ? JSFunction::ASMJS_LAMBDA_CTOR
|
|
|
|
: JSFunction::ASMJS_CTOR;
|
|
|
|
JSFunction* moduleFun =
|
|
|
|
NewNativeConstructor(cx, InstantiateAsmJS, origFun->nargs(), name,
|
|
|
|
gc::AllocKind::FUNCTION_EXTENDED, TenuredObject,
|
|
|
|
flags);
|
|
|
|
if (!moduleFun)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
moduleFun->setExtendedSlot(FunctionExtended::ASMJS_MODULE_SLOT, ObjectValue(*moduleObj));
|
|
|
|
|
|
|
|
MOZ_ASSERT(IsAsmJSModule(moduleFun));
|
|
|
|
return moduleFun;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
// Caching and cloning
|
|
|
|
|
|
|
|
size_t
|
|
|
|
AsmJSGlobal::serializedSize() const
|
|
|
|
{
|
|
|
|
return sizeof(pod) +
|
|
|
|
field_.serializedSize();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t*
|
|
|
|
AsmJSGlobal::serialize(uint8_t* cursor) const
|
|
|
|
{
|
|
|
|
cursor = WriteBytes(cursor, &pod, sizeof(pod));
|
|
|
|
cursor = field_.serialize(cursor);
|
|
|
|
return cursor;
|
|
|
|
}
|
|
|
|
|
|
|
|
const uint8_t*
|
|
|
|
AsmJSGlobal::deserialize(const uint8_t* cursor)
|
|
|
|
{
|
|
|
|
(cursor = ReadBytes(cursor, &pod, sizeof(pod))) &&
|
|
|
|
(cursor = field_.deserialize(cursor));
|
|
|
|
return cursor;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t
|
|
|
|
AsmJSGlobal::sizeOfExcludingThis(MallocSizeOf mallocSizeOf) const
|
|
|
|
{
|
|
|
|
return field_.sizeOfExcludingThis(mallocSizeOf);
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t
|
|
|
|
AsmJSMetadata::serializedSize() const
|
|
|
|
{
|
|
|
|
return Metadata::serializedSize() +
|
|
|
|
sizeof(pod()) +
|
|
|
|
SerializedVectorSize(asmJSGlobals) +
|
|
|
|
SerializedPodVectorSize(asmJSImports) +
|
|
|
|
SerializedPodVectorSize(asmJSExports) +
|
|
|
|
SerializedVectorSize(asmJSFuncNames) +
|
|
|
|
globalArgumentName.serializedSize() +
|
|
|
|
importArgumentName.serializedSize() +
|
|
|
|
bufferArgumentName.serializedSize();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t*
|
|
|
|
AsmJSMetadata::serialize(uint8_t* cursor) const
|
|
|
|
{
|
|
|
|
cursor = Metadata::serialize(cursor);
|
|
|
|
cursor = WriteBytes(cursor, &pod(), sizeof(pod()));
|
|
|
|
cursor = SerializeVector(cursor, asmJSGlobals);
|
|
|
|
cursor = SerializePodVector(cursor, asmJSImports);
|
|
|
|
cursor = SerializePodVector(cursor, asmJSExports);
|
|
|
|
cursor = SerializeVector(cursor, asmJSFuncNames);
|
|
|
|
cursor = globalArgumentName.serialize(cursor);
|
|
|
|
cursor = importArgumentName.serialize(cursor);
|
|
|
|
cursor = bufferArgumentName.serialize(cursor);
|
|
|
|
return cursor;
|
|
|
|
}
|
|
|
|
|
|
|
|
const uint8_t*
|
|
|
|
AsmJSMetadata::deserialize(const uint8_t* cursor)
|
|
|
|
{
|
|
|
|
(cursor = Metadata::deserialize(cursor)) &&
|
|
|
|
(cursor = ReadBytes(cursor, &pod(), sizeof(pod()))) &&
|
|
|
|
(cursor = DeserializeVector(cursor, &asmJSGlobals)) &&
|
|
|
|
(cursor = DeserializePodVector(cursor, &asmJSImports)) &&
|
|
|
|
(cursor = DeserializePodVector(cursor, &asmJSExports)) &&
|
|
|
|
(cursor = DeserializeVector(cursor, &asmJSFuncNames)) &&
|
|
|
|
(cursor = globalArgumentName.deserialize(cursor)) &&
|
|
|
|
(cursor = importArgumentName.deserialize(cursor)) &&
|
|
|
|
(cursor = bufferArgumentName.deserialize(cursor));
|
|
|
|
cacheResult = CacheResult::Hit;
|
|
|
|
return cursor;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t
|
|
|
|
AsmJSMetadata::sizeOfExcludingThis(MallocSizeOf mallocSizeOf) const
|
|
|
|
{
|
|
|
|
return Metadata::sizeOfExcludingThis(mallocSizeOf) +
|
|
|
|
SizeOfVectorExcludingThis(asmJSGlobals, mallocSizeOf) +
|
|
|
|
asmJSImports.sizeOfExcludingThis(mallocSizeOf) +
|
|
|
|
asmJSExports.sizeOfExcludingThis(mallocSizeOf) +
|
|
|
|
SizeOfVectorExcludingThis(asmJSFuncNames, mallocSizeOf) +
|
|
|
|
globalArgumentName.sizeOfExcludingThis(mallocSizeOf) +
|
|
|
|
importArgumentName.sizeOfExcludingThis(mallocSizeOf) +
|
|
|
|
bufferArgumentName.sizeOfExcludingThis(mallocSizeOf);
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class ModuleChars
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
uint32_t isFunCtor_;
|
|
|
|
Vector<CacheableChars, 0, SystemAllocPolicy> funCtorArgs_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
static uint32_t beginOffset(AsmJSParser& parser) {
|
|
|
|
return parser.pc->functionBox()->functionNode->pn_pos.begin;
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t endOffset(AsmJSParser& parser) {
|
|
|
|
TokenPos pos(0, 0); // initialize to silence GCC warning
|
|
|
|
MOZ_ALWAYS_TRUE(parser.tokenStream.peekTokenPos(&pos, TokenStream::Operand));
|
|
|
|
return pos.end;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class ModuleCharsForStore : ModuleChars
|
|
|
|
{
|
|
|
|
uint32_t uncompressedSize_;
|
|
|
|
uint32_t compressedSize_;
|
|
|
|
Vector<char, 0, SystemAllocPolicy> compressedBuffer_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
bool init(AsmJSParser& parser) {
|
|
|
|
MOZ_ASSERT(beginOffset(parser) < endOffset(parser));
|
|
|
|
|
|
|
|
uncompressedSize_ = (endOffset(parser) - beginOffset(parser)) * sizeof(char16_t);
|
|
|
|
size_t maxCompressedSize = LZ4::maxCompressedSize(uncompressedSize_);
|
|
|
|
if (maxCompressedSize < uncompressedSize_)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!compressedBuffer_.resize(maxCompressedSize))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
const char16_t* chars = parser.tokenStream.rawCharPtrAt(beginOffset(parser));
|
|
|
|
const char* source = reinterpret_cast<const char*>(chars);
|
|
|
|
size_t compressedSize = LZ4::compress(source, uncompressedSize_, compressedBuffer_.begin());
|
|
|
|
if (!compressedSize || compressedSize > UINT32_MAX)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
compressedSize_ = compressedSize;
|
|
|
|
|
|
|
|
// For a function statement or named function expression:
|
|
|
|
// function f(x,y,z) { abc }
|
|
|
|
// the range [beginOffset, endOffset) captures the source:
|
|
|
|
// f(x,y,z) { abc }
|
|
|
|
// An unnamed function expression captures the same thing, sans 'f'.
|
|
|
|
// Since asm.js modules do not contain any free variables, equality of
|
|
|
|
// [beginOffset, endOffset) is sufficient to guarantee identical code
|
|
|
|
// generation, modulo Assumptions.
|
|
|
|
//
|
|
|
|
// For functions created with 'new Function', function arguments are
|
|
|
|
// not present in the source so we must manually explicitly serialize
|
|
|
|
// and match the formals as a Vector of PropertyName.
|
|
|
|
isFunCtor_ = parser.pc->isStandaloneFunctionBody();
|
|
|
|
if (isFunCtor_) {
|
|
|
|
unsigned numArgs;
|
|
|
|
ParseNode* functionNode = parser.pc->functionBox()->functionNode;
|
|
|
|
ParseNode* arg = FunctionFormalParametersList(functionNode, &numArgs);
|
|
|
|
for (unsigned i = 0; i < numArgs; i++, arg = arg->pn_next) {
|
|
|
|
UniqueChars name = StringToNewUTF8CharsZ(nullptr, *arg->name());
|
|
|
|
if (!name || !funCtorArgs_.append(Move(name)))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t serializedSize() const {
|
|
|
|
return sizeof(uint32_t) +
|
|
|
|
sizeof(uint32_t) +
|
|
|
|
compressedSize_ +
|
|
|
|
sizeof(uint32_t) +
|
|
|
|
(isFunCtor_ ? SerializedVectorSize(funCtorArgs_) : 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t* serialize(uint8_t* cursor) const {
|
|
|
|
cursor = WriteScalar<uint32_t>(cursor, uncompressedSize_);
|
|
|
|
cursor = WriteScalar<uint32_t>(cursor, compressedSize_);
|
|
|
|
cursor = WriteBytes(cursor, compressedBuffer_.begin(), compressedSize_);
|
|
|
|
cursor = WriteScalar<uint32_t>(cursor, isFunCtor_);
|
|
|
|
if (isFunCtor_)
|
|
|
|
cursor = SerializeVector(cursor, funCtorArgs_);
|
|
|
|
return cursor;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class ModuleCharsForLookup : ModuleChars
|
|
|
|
{
|
|
|
|
Vector<char16_t, 0, SystemAllocPolicy> chars_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
const uint8_t* deserialize(const uint8_t* cursor) {
|
|
|
|
uint32_t uncompressedSize;
|
|
|
|
cursor = ReadScalar<uint32_t>(cursor, &uncompressedSize);
|
|
|
|
|
|
|
|
uint32_t compressedSize;
|
|
|
|
cursor = ReadScalar<uint32_t>(cursor, &compressedSize);
|
|
|
|
|
|
|
|
if (!chars_.resize(uncompressedSize / sizeof(char16_t)))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
const char* source = reinterpret_cast<const char*>(cursor);
|
|
|
|
char* dest = reinterpret_cast<char*>(chars_.begin());
|
|
|
|
if (!LZ4::decompress(source, dest, uncompressedSize))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
cursor += compressedSize;
|
|
|
|
|
|
|
|
cursor = ReadScalar<uint32_t>(cursor, &isFunCtor_);
|
|
|
|
if (isFunCtor_)
|
|
|
|
cursor = DeserializeVector(cursor, &funCtorArgs_);
|
|
|
|
|
|
|
|
return cursor;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool match(AsmJSParser& parser) const {
|
|
|
|
const char16_t* parseBegin = parser.tokenStream.rawCharPtrAt(beginOffset(parser));
|
|
|
|
const char16_t* parseLimit = parser.tokenStream.rawLimit();
|
|
|
|
MOZ_ASSERT(parseLimit >= parseBegin);
|
|
|
|
if (uint32_t(parseLimit - parseBegin) < chars_.length())
|
|
|
|
return false;
|
|
|
|
if (!PodEqual(chars_.begin(), parseBegin, chars_.length()))
|
|
|
|
return false;
|
|
|
|
if (isFunCtor_ != parser.pc->isStandaloneFunctionBody())
|
|
|
|
return false;
|
|
|
|
if (isFunCtor_) {
|
|
|
|
// For function statements, the closing } is included as the last
|
|
|
|
// character of the matched source. For Function constructor,
|
|
|
|
// parsing terminates with EOF which we must explicitly check. This
|
|
|
|
// prevents
|
|
|
|
// new Function('"use asm"; function f() {} return f')
|
|
|
|
// from incorrectly matching
|
|
|
|
// new Function('"use asm"; function f() {} return ff')
|
|
|
|
if (parseBegin + chars_.length() != parseLimit)
|
|
|
|
return false;
|
|
|
|
unsigned numArgs;
|
|
|
|
ParseNode* functionNode = parser.pc->functionBox()->functionNode;
|
|
|
|
ParseNode* arg = FunctionFormalParametersList(functionNode, &numArgs);
|
|
|
|
if (funCtorArgs_.length() != numArgs)
|
|
|
|
return false;
|
|
|
|
for (unsigned i = 0; i < funCtorArgs_.length(); i++, arg = arg->pn_next) {
|
|
|
|
UniqueChars name = StringToNewUTF8CharsZ(nullptr, *arg->name());
|
|
|
|
if (!name || strcmp(funCtorArgs_[i].get(), name.get()))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ScopedCacheEntryOpenedForWrite
|
|
|
|
{
|
|
|
|
ExclusiveContext* cx;
|
|
|
|
const size_t serializedSize;
|
|
|
|
uint8_t* memory;
|
|
|
|
intptr_t handle;
|
|
|
|
|
|
|
|
ScopedCacheEntryOpenedForWrite(ExclusiveContext* cx, size_t serializedSize)
|
|
|
|
: cx(cx), serializedSize(serializedSize), memory(nullptr), handle(-1)
|
|
|
|
{}
|
|
|
|
|
|
|
|
~ScopedCacheEntryOpenedForWrite() {
|
|
|
|
if (memory)
|
|
|
|
cx->asmJSCacheOps().closeEntryForWrite(serializedSize, memory, handle);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ScopedCacheEntryOpenedForRead
|
|
|
|
{
|
|
|
|
ExclusiveContext* cx;
|
|
|
|
size_t serializedSize;
|
|
|
|
const uint8_t* memory;
|
|
|
|
intptr_t handle;
|
|
|
|
|
|
|
|
explicit ScopedCacheEntryOpenedForRead(ExclusiveContext* cx)
|
|
|
|
: cx(cx), serializedSize(0), memory(nullptr), handle(0)
|
|
|
|
{}
|
|
|
|
|
|
|
|
~ScopedCacheEntryOpenedForRead() {
|
|
|
|
if (memory)
|
|
|
|
cx->asmJSCacheOps().closeEntryForRead(serializedSize, memory, handle);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // unnamed namespace
|
|
|
|
|
|
|
|
static JS::AsmJSCacheResult
|
|
|
|
StoreAsmJSModuleInCache(AsmJSParser& parser, Module& module, ExclusiveContext* cx)
|
|
|
|
{
|
|
|
|
ModuleCharsForStore moduleChars;
|
|
|
|
if (!moduleChars.init(parser))
|
|
|
|
return JS::AsmJSCache_InternalError;
|
|
|
|
|
|
|
|
size_t bytecodeSize, compiledSize;
|
|
|
|
module.serializedSize(&bytecodeSize, &compiledSize);
|
|
|
|
MOZ_RELEASE_ASSERT(bytecodeSize == 0);
|
|
|
|
MOZ_RELEASE_ASSERT(compiledSize <= UINT32_MAX);
|
|
|
|
|
|
|
|
size_t serializedSize = sizeof(uint32_t) +
|
|
|
|
compiledSize +
|
|
|
|
moduleChars.serializedSize();
|
|
|
|
|
|
|
|
JS::OpenAsmJSCacheEntryForWriteOp open = cx->asmJSCacheOps().openEntryForWrite;
|
|
|
|
if (!open)
|
|
|
|
return JS::AsmJSCache_Disabled_Internal;
|
|
|
|
|
|
|
|
const char16_t* begin = parser.tokenStream.rawCharPtrAt(ModuleChars::beginOffset(parser));
|
|
|
|
const char16_t* end = parser.tokenStream.rawCharPtrAt(ModuleChars::endOffset(parser));
|
|
|
|
bool installed = parser.options().installedFile;
|
|
|
|
|
|
|
|
ScopedCacheEntryOpenedForWrite entry(cx, serializedSize);
|
|
|
|
JS::AsmJSCacheResult openResult =
|
|
|
|
open(cx->global(), installed, begin, end, serializedSize, &entry.memory, &entry.handle);
|
|
|
|
if (openResult != JS::AsmJSCache_Success)
|
|
|
|
return openResult;
|
|
|
|
|
|
|
|
uint8_t* cursor = entry.memory;
|
|
|
|
|
|
|
|
// Everything serialized before the Module must not change incompatibly
|
|
|
|
// between any two builds (regardless of platform, architecture, ...).
|
|
|
|
// (The Module::assumptionsMatch() guard everything in the Module and
|
|
|
|
// afterwards.)
|
|
|
|
cursor = WriteScalar<uint32_t>(cursor, compiledSize);
|
|
|
|
|
|
|
|
module.serialize(/* bytecodeBegin = */ nullptr, /* bytecodeSize = */ 0, cursor, compiledSize);
|
|
|
|
cursor += compiledSize;
|
|
|
|
|
|
|
|
cursor = moduleChars.serialize(cursor);
|
|
|
|
|
|
|
|
MOZ_RELEASE_ASSERT(cursor == entry.memory + serializedSize);
|
|
|
|
|
|
|
|
return JS::AsmJSCache_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
LookupAsmJSModuleInCache(ExclusiveContext* cx, AsmJSParser& parser, bool* loadedFromCache,
|
|
|
|
SharedModule* module, UniqueChars* compilationTimeReport)
|
|
|
|
{
|
|
|
|
int64_t before = PRMJ_Now();
|
|
|
|
|
|
|
|
*loadedFromCache = false;
|
|
|
|
|
|
|
|
JS::OpenAsmJSCacheEntryForReadOp open = cx->asmJSCacheOps().openEntryForRead;
|
|
|
|
if (!open)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
const char16_t* begin = parser.tokenStream.rawCharPtrAt(ModuleChars::beginOffset(parser));
|
|
|
|
const char16_t* limit = parser.tokenStream.rawLimit();
|
|
|
|
|
|
|
|
ScopedCacheEntryOpenedForRead entry(cx);
|
|
|
|
if (!open(cx->global(), begin, limit, &entry.serializedSize, &entry.memory, &entry.handle))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
size_t remain = entry.serializedSize;
|
|
|
|
const uint8_t* cursor = entry.memory;
|
|
|
|
|
|
|
|
uint32_t compiledSize;
|
|
|
|
cursor = ReadScalarChecked<uint32_t>(cursor, &remain, &compiledSize);
|
|
|
|
if (!cursor)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
Assumptions assumptions;
|
|
|
|
if (!assumptions.initBuildIdFromContext(cx))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!Module::assumptionsMatch(assumptions, cursor, remain))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
MutableAsmJSMetadata asmJSMetadata = cx->new_<AsmJSMetadata>();
|
|
|
|
if (!asmJSMetadata)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*module = Module::deserialize(/* bytecodeBegin = */ nullptr, /* bytecodeSize = */ 0,
|
|
|
|
cursor, compiledSize, asmJSMetadata.get());
|
|
|
|
if (!*module) {
|
|
|
|
ReportOutOfMemory(cx);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
cursor += compiledSize;
|
|
|
|
|
|
|
|
// Due to the hash comparison made by openEntryForRead, this should succeed
|
|
|
|
// with high probability.
|
|
|
|
ModuleCharsForLookup moduleChars;
|
|
|
|
cursor = moduleChars.deserialize(cursor);
|
|
|
|
if (!moduleChars.match(parser))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Don't punish release users by crashing if there is a programmer error
|
|
|
|
// here, just gracefully return with a cache miss.
|
|
|
|
#ifdef NIGHTLY_BUILD
|
|
|
|
MOZ_RELEASE_ASSERT(cursor == entry.memory + entry.serializedSize);
|
|
|
|
#endif
|
|
|
|
if (cursor != entry.memory + entry.serializedSize)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// See AsmJSMetadata comment as well as ModuleValidator::init().
|
2019-09-05 10:06:35 -07:00
|
|
|
asmJSMetadata->toStringStart = parser.pc->functionBox()->toStringStart;
|
2019-03-11 03:26:37 -07:00
|
|
|
asmJSMetadata->srcStart = parser.pc->functionBox()->functionNode->pn_body->pn_pos.begin;
|
|
|
|
asmJSMetadata->srcBodyStart = parser.tokenStream.currentToken().pos.end;
|
|
|
|
asmJSMetadata->strict = parser.pc->sc()->strict() && !parser.pc->sc()->hasExplicitUseStrict();
|
|
|
|
asmJSMetadata->scriptSource.reset(parser.ss);
|
|
|
|
|
|
|
|
if (!parser.tokenStream.advance(asmJSMetadata->srcEndBeforeCurly()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
int64_t after = PRMJ_Now();
|
|
|
|
int ms = (after - before) / PRMJ_USEC_PER_MSEC;
|
|
|
|
*compilationTimeReport = UniqueChars(JS_smprintf("loaded from cache in %dms", ms));
|
|
|
|
if (!*compilationTimeReport)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
*loadedFromCache = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
// Top-level js::CompileAsmJS
|
|
|
|
|
|
|
|
static bool
|
|
|
|
NoExceptionPending(ExclusiveContext* cx)
|
|
|
|
{
|
|
|
|
return !cx->isJSContext() || !cx->asJSContext()->isExceptionPending();
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
Warn(AsmJSParser& parser, int errorNumber, const char* str)
|
|
|
|
{
|
|
|
|
ParseReportKind reportKind = parser.options().throwOnAsmJSValidationFailureOption &&
|
|
|
|
errorNumber == JSMSG_USE_ASM_TYPE_FAIL
|
|
|
|
? ParseError
|
|
|
|
: ParseWarning;
|
|
|
|
parser.reportNoOffset(reportKind, /* strict = */ false, errorNumber, str ? str : "");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
EstablishPreconditions(ExclusiveContext* cx, AsmJSParser& parser)
|
|
|
|
{
|
|
|
|
if (!HasCompilerSupport(cx))
|
|
|
|
return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by lack of compiler support");
|
|
|
|
|
|
|
|
switch (parser.options().asmJSOption) {
|
|
|
|
case AsmJSOption::Disabled:
|
|
|
|
return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by 'asmjs' runtime option");
|
|
|
|
case AsmJSOption::DisabledByDebugger:
|
|
|
|
return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by debugger");
|
|
|
|
case AsmJSOption::Enabled:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-03-12 10:39:34 -07:00
|
|
|
if (parser.pc->isStarGenerator() || parser.pc->isLegacyGenerator())
|
2019-03-11 03:26:37 -07:00
|
|
|
return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by generator context");
|
|
|
|
|
2020-03-12 10:39:34 -07:00
|
|
|
if (parser.pc->isAsync())
|
|
|
|
return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by async context");
|
|
|
|
|
2019-03-11 03:26:37 -07:00
|
|
|
if (parser.pc->isArrowFunction())
|
|
|
|
return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by arrow function context");
|
|
|
|
|
|
|
|
// Class constructors are also methods
|
|
|
|
if (parser.pc->isMethod())
|
|
|
|
return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by class constructor or method context");
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static UniqueChars
|
|
|
|
BuildConsoleMessage(ExclusiveContext* cx, unsigned time, JS::AsmJSCacheResult cacheResult)
|
|
|
|
{
|
|
|
|
#ifndef JS_MORE_DETERMINISTIC
|
|
|
|
const char* cacheString = "";
|
|
|
|
switch (cacheResult) {
|
|
|
|
case JS::AsmJSCache_Success:
|
|
|
|
cacheString = "stored in cache";
|
|
|
|
break;
|
|
|
|
case JS::AsmJSCache_ModuleTooSmall:
|
|
|
|
cacheString = "not stored in cache (too small to benefit)";
|
|
|
|
break;
|
|
|
|
case JS::AsmJSCache_SynchronousScript:
|
|
|
|
cacheString = "unable to cache asm.js in synchronous scripts; try loading "
|
|
|
|
"asm.js via <script async> or createElement('script')";
|
|
|
|
break;
|
|
|
|
case JS::AsmJSCache_QuotaExceeded:
|
|
|
|
cacheString = "not enough temporary storage quota to store in cache";
|
|
|
|
break;
|
|
|
|
case JS::AsmJSCache_StorageInitFailure:
|
|
|
|
cacheString = "storage initialization failed (consider filing a bug)";
|
|
|
|
break;
|
|
|
|
case JS::AsmJSCache_Disabled_Internal:
|
|
|
|
cacheString = "caching disabled by internal configuration (consider filing a bug)";
|
|
|
|
break;
|
|
|
|
case JS::AsmJSCache_Disabled_ShellFlags:
|
|
|
|
cacheString = "caching disabled by missing command-line arguments";
|
|
|
|
break;
|
|
|
|
case JS::AsmJSCache_Disabled_JitInspector:
|
|
|
|
cacheString = "caching disabled by active JIT inspector";
|
|
|
|
break;
|
|
|
|
case JS::AsmJSCache_InternalError:
|
|
|
|
cacheString = "unable to store in cache due to internal error (consider filing a bug)";
|
|
|
|
break;
|
|
|
|
case JS::AsmJSCache_Disabled_PrivateBrowsing:
|
|
|
|
cacheString = "caching disabled by private browsing mode";
|
|
|
|
break;
|
|
|
|
case JS::AsmJSCache_LIMIT:
|
|
|
|
MOZ_CRASH("bad AsmJSCacheResult");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return UniqueChars(JS_smprintf("total compilation time %dms; %s", time, cacheString));
|
|
|
|
#else
|
|
|
|
return DuplicateString("");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
js::CompileAsmJS(ExclusiveContext* cx, AsmJSParser& parser, ParseNode* stmtList, bool* validated)
|
|
|
|
{
|
|
|
|
*validated = false;
|
|
|
|
|
|
|
|
// Various conditions disable asm.js optimizations.
|
|
|
|
if (!EstablishPreconditions(cx, parser))
|
|
|
|
return NoExceptionPending(cx);
|
|
|
|
|
|
|
|
// Before spending any time parsing the module, try to look it up in the
|
|
|
|
// embedding's cache using the chars about to be parsed as the key.
|
|
|
|
bool loadedFromCache;
|
|
|
|
SharedModule module;
|
|
|
|
UniqueChars message;
|
|
|
|
if (!LookupAsmJSModuleInCache(cx, parser, &loadedFromCache, &module, &message))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// If not present in the cache, parse, validate and generate code in a
|
|
|
|
// single linear pass over the chars of the asm.js module.
|
|
|
|
if (!loadedFromCache) {
|
|
|
|
// "Checking" parses, validates and compiles, producing a fully compiled
|
|
|
|
// WasmModuleObject as result.
|
|
|
|
unsigned time;
|
|
|
|
module = CheckModule(cx, parser, stmtList, &time);
|
|
|
|
if (!module)
|
|
|
|
return NoExceptionPending(cx);
|
|
|
|
|
|
|
|
// Try to store the AsmJSModule in the embedding's cache. The
|
|
|
|
// AsmJSModule must be stored before static linking since static linking
|
|
|
|
// specializes the AsmJSModule to the current process's address space
|
|
|
|
// and therefore must be executed after a cache hit.
|
|
|
|
JS::AsmJSCacheResult cacheResult = StoreAsmJSModuleInCache(parser, *module, cx);
|
|
|
|
|
|
|
|
// Build the string message to display in the developer console.
|
|
|
|
message = BuildConsoleMessage(cx, time, cacheResult);
|
|
|
|
if (!message)
|
|
|
|
return NoExceptionPending(cx);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Hand over ownership to a GC object wrapper which can then be referenced
|
|
|
|
// from the module function.
|
|
|
|
Rooted<WasmModuleObject*> moduleObj(cx, WasmModuleObject::create(cx, *module));
|
|
|
|
if (!moduleObj)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// The module function dynamically links the AsmJSModule when called and
|
|
|
|
// generates a set of functions wrapping all the exports.
|
|
|
|
FunctionBox* funbox = parser.pc->functionBox();
|
|
|
|
RootedFunction moduleFun(cx, NewAsmJSModuleFunction(cx, funbox->function(), moduleObj));
|
|
|
|
if (!moduleFun)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Finished! Clobber the default function created by the parser with the new
|
|
|
|
// asm.js module function. Special cases in the bytecode emitter avoid
|
|
|
|
// generating bytecode for asm.js functions, allowing this asm.js module
|
|
|
|
// function to be the finished result.
|
|
|
|
MOZ_ASSERT(funbox->function()->isInterpreted());
|
|
|
|
funbox->object = moduleFun;
|
|
|
|
|
|
|
|
// Success! Write to the console with a "warning" message.
|
|
|
|
*validated = true;
|
|
|
|
Warn(parser, JSMSG_USE_ASM_TYPE_OK, message.get());
|
|
|
|
return NoExceptionPending(cx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
// asm.js testing functions
|
|
|
|
|
|
|
|
bool
|
|
|
|
js::IsAsmJSModuleNative(Native native)
|
|
|
|
{
|
|
|
|
return native == InstantiateAsmJS;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
js::IsAsmJSModule(JSFunction* fun)
|
|
|
|
{
|
|
|
|
return fun->maybeNative() == InstantiateAsmJS;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
js::IsAsmJSFunction(JSFunction* fun)
|
|
|
|
{
|
|
|
|
if (IsExportedFunction(fun))
|
|
|
|
return ExportedFunctionToInstance(fun).metadata().isAsmJS();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
js::IsAsmJSStrictModeModuleOrFunction(JSFunction* fun)
|
|
|
|
{
|
|
|
|
if (IsAsmJSModule(fun))
|
|
|
|
return AsmJSModuleFunctionToModule(fun).metadata().asAsmJS().strict;
|
|
|
|
|
|
|
|
if (IsAsmJSFunction(fun))
|
|
|
|
return ExportedFunctionToInstance(fun).metadata().asAsmJS().strict;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
js::IsAsmJSCompilationAvailable(JSContext* cx, unsigned argc, Value* vp)
|
|
|
|
{
|
|
|
|
CallArgs args = CallArgsFromVp(argc, vp);
|
|
|
|
|
|
|
|
// See EstablishPreconditions.
|
|
|
|
bool available = HasCompilerSupport(cx) && cx->options().asmJS();
|
|
|
|
|
|
|
|
args.rval().set(BooleanValue(available));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static JSFunction*
|
|
|
|
MaybeWrappedNativeFunction(const Value& v)
|
|
|
|
{
|
|
|
|
if (!v.isObject())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
JSObject* obj = CheckedUnwrap(&v.toObject());
|
|
|
|
if (!obj)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!obj->is<JSFunction>())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
return &obj->as<JSFunction>();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
js::IsAsmJSModule(JSContext* cx, unsigned argc, Value* vp)
|
|
|
|
{
|
|
|
|
CallArgs args = CallArgsFromVp(argc, vp);
|
|
|
|
|
|
|
|
bool rval = false;
|
|
|
|
if (JSFunction* fun = MaybeWrappedNativeFunction(args.get(0)))
|
|
|
|
rval = IsAsmJSModule(fun);
|
|
|
|
|
|
|
|
args.rval().set(BooleanValue(rval));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
js::IsAsmJSFunction(JSContext* cx, unsigned argc, Value* vp)
|
|
|
|
{
|
|
|
|
CallArgs args = CallArgsFromVp(argc, vp);
|
|
|
|
|
|
|
|
bool rval = false;
|
|
|
|
if (JSFunction* fun = MaybeWrappedNativeFunction(args.get(0)))
|
|
|
|
rval = IsAsmJSFunction(fun);
|
|
|
|
|
|
|
|
args.rval().set(BooleanValue(rval));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
js::IsAsmJSModuleLoadedFromCache(JSContext* cx, unsigned argc, Value* vp)
|
|
|
|
{
|
|
|
|
CallArgs args = CallArgsFromVp(argc, vp);
|
|
|
|
|
|
|
|
JSFunction* fun = MaybeWrappedNativeFunction(args.get(0));
|
|
|
|
if (!fun || !IsAsmJSModule(fun)) {
|
|
|
|
JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_USE_ASM_TYPE_FAIL,
|
|
|
|
"argument passed to isAsmJSModuleLoadedFromCache is not a "
|
|
|
|
"validated asm.js module");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool loadedFromCache =
|
|
|
|
AsmJSModuleFunctionToModule(fun).metadata().asAsmJS().cacheResult == CacheResult::Hit;
|
|
|
|
|
|
|
|
args.rval().set(BooleanValue(loadedFromCache));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
// asm.js toString/toSource support
|
|
|
|
|
|
|
|
JSString*
|
|
|
|
js::AsmJSModuleToString(JSContext* cx, HandleFunction fun, bool addParenToLambda)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(IsAsmJSModule(fun));
|
|
|
|
|
|
|
|
const AsmJSMetadata& metadata = AsmJSModuleFunctionToModule(fun).metadata().asAsmJS();
|
2019-09-05 10:06:35 -07:00
|
|
|
uint32_t begin = metadata.toStringStart;
|
2019-03-11 03:26:37 -07:00
|
|
|
uint32_t end = metadata.srcEndAfterCurly();
|
|
|
|
ScriptSource* source = metadata.scriptSource.get();
|
|
|
|
|
|
|
|
StringBuffer out(cx);
|
|
|
|
|
|
|
|
if (addParenToLambda && fun->isLambda() && !out.append("("))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
bool haveSource = source->hasSourceData();
|
|
|
|
if (!haveSource && !JSScript::loadSource(cx, source, &haveSource))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!haveSource) {
|
2019-05-19 23:02:17 -07:00
|
|
|
if (!out.append("function "))
|
|
|
|
return nullptr;
|
|
|
|
if (fun->explicitName() && !out.append(fun->explicitName()))
|
|
|
|
return nullptr;
|
2019-03-11 03:26:37 -07:00
|
|
|
if (!out.append("() {\n [sourceless code]\n}"))
|
|
|
|
return nullptr;
|
|
|
|
} else {
|
|
|
|
Rooted<JSFlatString*> src(cx, source->substring(cx, begin, end));
|
|
|
|
if (!src)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!out.append(src))
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (addParenToLambda && fun->isLambda() && !out.append(")"))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
return out.finishString();
|
|
|
|
}
|
|
|
|
|
|
|
|
JSString*
|
|
|
|
js::AsmJSFunctionToString(JSContext* cx, HandleFunction fun)
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(IsAsmJSFunction(fun));
|
|
|
|
|
|
|
|
const AsmJSMetadata& metadata = ExportedFunctionToInstance(fun).metadata().asAsmJS();
|
|
|
|
const AsmJSExport& f = metadata.lookupAsmJSExport(ExportedFunctionToFuncIndex(fun));
|
|
|
|
|
|
|
|
uint32_t begin = metadata.srcStart + f.startOffsetInModule();
|
|
|
|
uint32_t end = metadata.srcStart + f.endOffsetInModule();
|
|
|
|
|
|
|
|
ScriptSource* source = metadata.scriptSource.get();
|
|
|
|
StringBuffer out(cx);
|
|
|
|
|
|
|
|
if (!out.append("function "))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
bool haveSource = source->hasSourceData();
|
|
|
|
if (!haveSource && !JSScript::loadSource(cx, source, &haveSource))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!haveSource) {
|
|
|
|
// asm.js functions can't be anonymous
|
|
|
|
MOZ_ASSERT(fun->explicitName());
|
|
|
|
if (!out.append(fun->explicitName()))
|
|
|
|
return nullptr;
|
|
|
|
if (!out.append("() {\n [sourceless code]\n}"))
|
|
|
|
return nullptr;
|
|
|
|
} else {
|
|
|
|
Rooted<JSFlatString*> src(cx, source->substring(cx, begin, end));
|
|
|
|
if (!src)
|
|
|
|
return nullptr;
|
|
|
|
if (!out.append(src))
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
return out.finishString();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
js::IsValidAsmJSHeapLength(uint32_t length)
|
|
|
|
{
|
|
|
|
if (length < MinHeapLength)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return wasm::IsValidARMImmediate(length);
|
|
|
|
}
|