michael@0: /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
michael@0:  * vim: set ts=8 sts=4 et sw=4 tw=99:
michael@0:  * This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #include "jit/AsmJS.h"
michael@0: 
michael@0: #include "mozilla/Move.h"
michael@0: 
michael@0: #ifdef MOZ_VTUNE
michael@0: # include "vtune/VTuneWrapper.h"
michael@0: #endif
michael@0: 
michael@0: #include "jsmath.h"
michael@0: #include "jsprf.h"
michael@0: #include "jsworkers.h"
michael@0: #include "prmjtime.h"
michael@0: 
michael@0: #include "assembler/assembler/MacroAssembler.h"
michael@0: #include "frontend/Parser.h"
michael@0: #include "jit/AsmJSLink.h"
michael@0: #include "jit/AsmJSModule.h"
michael@0: #include "jit/AsmJSSignalHandlers.h"
michael@0: #include "jit/CodeGenerator.h"
michael@0: #include "jit/CompileWrappers.h"
michael@0: #include "jit/MIR.h"
michael@0: #include "jit/MIRGraph.h"
michael@0: #ifdef JS_ION_PERF
michael@0: # include "jit/PerfSpewer.h"
michael@0: #endif
michael@0: #include "vm/Interpreter.h"
michael@0: 
michael@0: #include "jsinferinlines.h"
michael@0: #include "jsobjinlines.h"
michael@0: 
michael@0: #include "frontend/ParseNode-inl.h"
michael@0: #include "frontend/Parser-inl.h"
michael@0: 
michael@0: using namespace js;
michael@0: using namespace js::frontend;
michael@0: using namespace js::jit;
michael@0: 
michael@0: using mozilla::AddToHash;
michael@0: using mozilla::ArrayLength;
michael@0: using mozilla::CountLeadingZeroes32;
michael@0: using mozilla::DebugOnly;
michael@0: using mozilla::HashGeneric;
michael@0: using mozilla::IsNaN;
michael@0: using mozilla::IsNegativeZero;
michael@0: using mozilla::Maybe;
michael@0: using mozilla::Move;
michael@0: using mozilla::PositiveInfinity;
michael@0: using JS::GenericNaN;
michael@0: 
michael@0: static const size_t LIFO_ALLOC_PRIMARY_CHUNK_SIZE = 1 << 12;
michael@0: 
michael@0: /*****************************************************************************/
michael@0: // ParseNode utilities
michael@0: 
michael@0: static inline ParseNode *
michael@0: NextNode(ParseNode *pn)
michael@0: {
michael@0:     return pn->pn_next;
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: UnaryKid(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isArity(PN_UNARY));
michael@0:     return pn->pn_kid;
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: ReturnExpr(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_RETURN));
michael@0:     return UnaryKid(pn);
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: BinaryRight(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isArity(PN_BINARY));
michael@0:     return pn->pn_right;
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: BinaryLeft(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isArity(PN_BINARY));
michael@0:     return pn->pn_left;
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: TernaryKid1(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isArity(PN_TERNARY));
michael@0:     return pn->pn_kid1;
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: TernaryKid2(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isArity(PN_TERNARY));
michael@0:     return pn->pn_kid2;
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: TernaryKid3(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isArity(PN_TERNARY));
michael@0:     return pn->pn_kid3;
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: ListHead(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isArity(PN_LIST));
michael@0:     return pn->pn_head;
michael@0: }
michael@0: 
michael@0: static inline unsigned
michael@0: ListLength(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isArity(PN_LIST));
michael@0:     return pn->pn_count;
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: CallCallee(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_CALL));
michael@0:     return ListHead(pn);
michael@0: }
michael@0: 
michael@0: static inline unsigned
michael@0: CallArgListLength(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_CALL));
michael@0:     JS_ASSERT(ListLength(pn) >= 1);
michael@0:     return ListLength(pn) - 1;
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: CallArgList(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_CALL));
michael@0:     return NextNode(ListHead(pn));
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: VarListHead(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_VAR) || pn->isKind(PNK_CONST));
michael@0:     return ListHead(pn);
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: CaseExpr(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_CASE) || pn->isKind(PNK_DEFAULT));
michael@0:     return BinaryLeft(pn);
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: CaseBody(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_CASE) || pn->isKind(PNK_DEFAULT));
michael@0:     return BinaryRight(pn);
michael@0: }
michael@0: 
michael@0: static inline bool
michael@0: IsExpressionStatement(ParseNode *pn)
michael@0: {
michael@0:     return pn->isKind(PNK_SEMI);
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: ExpressionStatementExpr(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_SEMI));
michael@0:     return UnaryKid(pn);
michael@0: }
michael@0: 
michael@0: static inline PropertyName *
michael@0: LoopControlMaybeLabel(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_BREAK) || pn->isKind(PNK_CONTINUE));
michael@0:     JS_ASSERT(pn->isArity(PN_NULLARY));
michael@0:     return pn->as<LoopControlStatement>().label();
michael@0: }
michael@0: 
michael@0: static inline PropertyName *
michael@0: LabeledStatementLabel(ParseNode *pn)
michael@0: {
michael@0:     return pn->as<LabeledStatement>().label();
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: LabeledStatementStatement(ParseNode *pn)
michael@0: {
michael@0:     return pn->as<LabeledStatement>().statement();
michael@0: }
michael@0: 
michael@0: static double
michael@0: NumberNodeValue(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_NUMBER));
michael@0:     return pn->pn_dval;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: NumberNodeHasFrac(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_NUMBER));
michael@0:     return pn->pn_u.number.decimalPoint == HasDecimal;
michael@0: }
michael@0: 
michael@0: static ParseNode *
michael@0: DotBase(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_DOT));
michael@0:     JS_ASSERT(pn->isArity(PN_NAME));
michael@0:     return pn->expr();
michael@0: }
michael@0: 
michael@0: static PropertyName *
michael@0: DotMember(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_DOT));
michael@0:     JS_ASSERT(pn->isArity(PN_NAME));
michael@0:     return pn->pn_atom->asPropertyName();
michael@0: }
michael@0: 
michael@0: static ParseNode *
michael@0: ElemBase(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_ELEM));
michael@0:     return BinaryLeft(pn);
michael@0: }
michael@0: 
michael@0: static ParseNode *
michael@0: ElemIndex(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_ELEM));
michael@0:     return BinaryRight(pn);
michael@0: }
michael@0: 
michael@0: static inline JSFunction *
michael@0: FunctionObject(ParseNode *fn)
michael@0: {
michael@0:     JS_ASSERT(fn->isKind(PNK_FUNCTION));
michael@0:     JS_ASSERT(fn->isArity(PN_CODE));
michael@0:     return fn->pn_funbox->function();
michael@0: }
michael@0: 
michael@0: static inline PropertyName *
michael@0: FunctionName(ParseNode *fn)
michael@0: {
michael@0:     if (JSAtom *atom = FunctionObject(fn)->atom())
michael@0:         return atom->asPropertyName();
michael@0:     return nullptr;
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: FunctionStatementList(ParseNode *fn)
michael@0: {
michael@0:     JS_ASSERT(fn->pn_body->isKind(PNK_ARGSBODY));
michael@0:     ParseNode *last = fn->pn_body->last();
michael@0:     JS_ASSERT(last->isKind(PNK_STATEMENTLIST));
michael@0:     return last;
michael@0: }
michael@0: 
michael@0: static inline bool
michael@0: IsNormalObjectField(ExclusiveContext *cx, ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_COLON));
michael@0:     return pn->getOp() == JSOP_INITPROP &&
michael@0:            BinaryLeft(pn)->isKind(PNK_NAME) &&
michael@0:            BinaryLeft(pn)->name() != cx->names().proto;
michael@0: }
michael@0: 
michael@0: static inline PropertyName *
michael@0: ObjectNormalFieldName(ExclusiveContext *cx, ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(IsNormalObjectField(cx, pn));
michael@0:     return BinaryLeft(pn)->name();
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: ObjectFieldInitializer(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(pn->isKind(PNK_COLON));
michael@0:     return BinaryRight(pn);
michael@0: }
michael@0: 
michael@0: static inline bool
michael@0: IsDefinition(ParseNode *pn)
michael@0: {
michael@0:     return pn->isKind(PNK_NAME) && pn->isDefn();
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: MaybeDefinitionInitializer(ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(IsDefinition(pn));
michael@0:     return pn->expr();
michael@0: }
michael@0: 
michael@0: static inline bool
michael@0: IsUseOfName(ParseNode *pn, PropertyName *name)
michael@0: {
michael@0:     return pn->isKind(PNK_NAME) && pn->name() == name;
michael@0: }
michael@0: 
michael@0: static inline bool
michael@0: IsEmptyStatement(ParseNode *pn)
michael@0: {
michael@0:     return pn->isKind(PNK_SEMI) && !UnaryKid(pn);
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: SkipEmptyStatements(ParseNode *pn)
michael@0: {
michael@0:     while (pn && IsEmptyStatement(pn))
michael@0:         pn = pn->pn_next;
michael@0:     return pn;
michael@0: }
michael@0: 
michael@0: static inline ParseNode *
michael@0: NextNonEmptyStatement(ParseNode *pn)
michael@0: {
michael@0:     return SkipEmptyStatements(pn->pn_next);
michael@0: }
michael@0: 
michael@0: static TokenKind
michael@0: PeekToken(AsmJSParser &parser)
michael@0: {
michael@0:     TokenStream &ts = parser.tokenStream;
michael@0:     while (ts.peekToken(TokenStream::Operand) == TOK_SEMI)
michael@0:         ts.consumeKnownToken(TOK_SEMI);
michael@0:     return ts.peekToken(TokenStream::Operand);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: ParseVarOrConstStatement(AsmJSParser &parser, ParseNode **var)
michael@0: {
michael@0:     TokenKind tk = PeekToken(parser);
michael@0:     if (tk != TOK_VAR && tk != TOK_CONST) {
michael@0:         *var = nullptr;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     *var = parser.statement();
michael@0:     if (!*var)
michael@0:         return false;
michael@0: 
michael@0:     JS_ASSERT((*var)->isKind(PNK_VAR) || (*var)->isKind(PNK_CONST));
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: /*****************************************************************************/
michael@0: 
michael@0: namespace {
michael@0: 
michael@0: // Respresents the type of a general asm.js expression.
michael@0: class Type
michael@0: {
michael@0:   public:
michael@0:     enum Which {
michael@0:         Double,
michael@0:         MaybeDouble,
michael@0:         Float,
michael@0:         MaybeFloat,
michael@0:         Floatish,
michael@0:         Fixnum,
michael@0:         Int,
michael@0:         Signed,
michael@0:         Unsigned,
michael@0:         Intish,
michael@0:         Void
michael@0:     };
michael@0: 
michael@0:   private:
michael@0:     Which which_;
michael@0: 
michael@0:   public:
michael@0:     Type() : which_(Which(-1)) {}
michael@0:     Type(Which w) : which_(w) {}
michael@0: 
michael@0:     bool operator==(Type rhs) const { return which_ == rhs.which_; }
michael@0:     bool operator!=(Type rhs) const { return which_ != rhs.which_; }
michael@0: 
michael@0:     bool isSigned() const {
michael@0:         return which_ == Signed || which_ == Fixnum;
michael@0:     }
michael@0: 
michael@0:     bool isUnsigned() const {
michael@0:         return which_ == Unsigned || which_ == Fixnum;
michael@0:     }
michael@0: 
michael@0:     bool isInt() const {
michael@0:         return isSigned() || isUnsigned() || which_ == Int;
michael@0:     }
michael@0: 
michael@0:     bool isIntish() const {
michael@0:         return isInt() || which_ == Intish;
michael@0:     }
michael@0: 
michael@0:     bool isDouble() const {
michael@0:         return which_ == Double;
michael@0:     }
michael@0: 
michael@0:     bool isMaybeDouble() const {
michael@0:         return isDouble() || which_ == MaybeDouble;
michael@0:     }
michael@0: 
michael@0:     bool isFloat() const {
michael@0:         return which_ == Float;
michael@0:     }
michael@0: 
michael@0:     bool isMaybeFloat() const {
michael@0:         return isFloat() || which_ == MaybeFloat;
michael@0:     }
michael@0: 
michael@0:     bool isFloatish() const {
michael@0:         return isMaybeFloat() || which_ == Floatish;
michael@0:     }
michael@0: 
michael@0:     bool isVoid() const {
michael@0:         return which_ == Void;
michael@0:     }
michael@0: 
michael@0:     bool isExtern() const {
michael@0:         return isDouble() || isSigned();
michael@0:     }
michael@0: 
michael@0:     bool isVarType() const {
michael@0:         return isInt() || isDouble() || isFloat();
michael@0:     }
michael@0: 
michael@0:     MIRType toMIRType() const {
michael@0:         switch (which_) {
michael@0:           case Double:
michael@0:           case MaybeDouble:
michael@0:             return MIRType_Double;
michael@0:           case Float:
michael@0:           case Floatish:
michael@0:           case MaybeFloat:
michael@0:             return MIRType_Float32;
michael@0:           case Fixnum:
michael@0:           case Int:
michael@0:           case Signed:
michael@0:           case Unsigned:
michael@0:           case Intish:
michael@0:             return MIRType_Int32;
michael@0:           case Void:
michael@0:             return MIRType_None;
michael@0:         }
michael@0:         MOZ_ASSUME_UNREACHABLE("Invalid Type");
michael@0:     }
michael@0: 
michael@0:     const char *toChars() const {
michael@0:         switch (which_) {
michael@0:           case Double:      return "double";
michael@0:           case MaybeDouble: return "double?";
michael@0:           case Float:       return "float";
michael@0:           case Floatish:    return "floatish";
michael@0:           case MaybeFloat:  return "float?";
michael@0:           case Fixnum:      return "fixnum";
michael@0:           case Int:         return "int";
michael@0:           case Signed:      return "signed";
michael@0:           case Unsigned:    return "unsigned";
michael@0:           case Intish:      return "intish";
michael@0:           case Void:        return "void";
michael@0:         }
michael@0:         MOZ_ASSUME_UNREACHABLE("Invalid Type");
michael@0:     }
michael@0: };
michael@0: 
michael@0: } /* anonymous namespace */
michael@0: 
michael@0: // Represents the subset of Type that can be used as the return type of a
michael@0: // function.
michael@0: class RetType
michael@0: {
michael@0:   public:
michael@0:     enum Which {
michael@0:         Void = Type::Void,
michael@0:         Signed = Type::Signed,
michael@0:         Double = Type::Double,
michael@0:         Float = Type::Float
michael@0:     };
michael@0: 
michael@0:   private:
michael@0:     Which which_;
michael@0: 
michael@0:   public:
michael@0:     RetType() : which_(Which(-1)) {}
michael@0:     RetType(Which w) : which_(w) {}
michael@0:     RetType(AsmJSCoercion coercion) {
michael@0:         switch (coercion) {
michael@0:           case AsmJS_ToInt32: which_ = Signed; break;
michael@0:           case AsmJS_ToNumber: which_ = Double; break;
michael@0:           case AsmJS_FRound: which_ = Float; break;
michael@0:         }
michael@0:     }
michael@0:     Which which() const {
michael@0:         return which_;
michael@0:     }
michael@0:     Type toType() const {
michael@0:         return Type::Which(which_);
michael@0:     }
michael@0:     AsmJSModule::ReturnType toModuleReturnType() const {
michael@0:         switch (which_) {
michael@0:           case Void: return AsmJSModule::Return_Void;
michael@0:           case Signed: return AsmJSModule::Return_Int32;
michael@0:           case Float: // will be converted to a Double
michael@0:           case Double: return AsmJSModule::Return_Double;
michael@0:         }
michael@0:         MOZ_ASSUME_UNREACHABLE("Unexpected return type");
michael@0:     }
michael@0:     MIRType toMIRType() const {
michael@0:         switch (which_) {
michael@0:           case Void: return MIRType_None;
michael@0:           case Signed: return MIRType_Int32;
michael@0:           case Double: return MIRType_Double;
michael@0:           case Float: return MIRType_Float32;
michael@0:         }
michael@0:         MOZ_ASSUME_UNREACHABLE("Unexpected return type");
michael@0:     }
michael@0:     bool operator==(RetType rhs) const { return which_ == rhs.which_; }
michael@0:     bool operator!=(RetType rhs) const { return which_ != rhs.which_; }
michael@0: };
michael@0: 
michael@0: namespace {
michael@0: 
michael@0: // Represents the subset of Type that can be used as a variable or
michael@0: // argument's type. Note: AsmJSCoercion and VarType are kept separate to
michael@0: // make very clear the signed/int distinction: a coercion may explicitly sign
michael@0: // an *expression* but, when stored as a variable, this signedness information
michael@0: // is explicitly thrown away by the asm.js type system. E.g., in
michael@0: //
michael@0: //   function f(i) {
michael@0: //     i = i | 0;             (1)
michael@0: //     if (...)
michael@0: //         i = foo() >>> 0;
michael@0: //     else
michael@0: //         i = bar() | 0;
michael@0: //     return i | 0;          (2)
michael@0: //   }
michael@0: //
michael@0: // the AsmJSCoercion of (1) is Signed (since | performs ToInt32) but, when
michael@0: // translated to an VarType, the result is a plain Int since, as shown, it
michael@0: // is legal to assign both Signed and Unsigned (or some other Int) values to
michael@0: // it. For (2), the AsmJSCoercion is also Signed but, when translated to an
michael@0: // RetType, the result is Signed since callers (asm.js and non-asm.js) can
michael@0: // rely on the return value being Signed.
michael@0: class VarType
michael@0: {
michael@0:   public:
michael@0:     enum Which {
michael@0:         Int = Type::Int,
michael@0:         Double = Type::Double,
michael@0:         Float = Type::Float
michael@0:     };
michael@0: 
michael@0:   private:
michael@0:     Which which_;
michael@0: 
michael@0:   public:
michael@0:     VarType()
michael@0:       : which_(Which(-1)) {}
michael@0:     VarType(Which w)
michael@0:       : which_(w) {}
michael@0:     VarType(AsmJSCoercion coercion) {
michael@0:         switch (coercion) {
michael@0:           case AsmJS_ToInt32: which_ = Int; break;
michael@0:           case AsmJS_ToNumber: which_ = Double; break;
michael@0:           case AsmJS_FRound: which_ = Float; break;
michael@0:         }
michael@0:     }
michael@0:     Which which() const {
michael@0:         return which_;
michael@0:     }
michael@0:     Type toType() const {
michael@0:         return Type::Which(which_);
michael@0:     }
michael@0:     MIRType toMIRType() const {
michael@0:         switch(which_) {
michael@0:           case Int:     return MIRType_Int32;
michael@0:           case Double:  return MIRType_Double;
michael@0:           case Float:   return MIRType_Float32;
michael@0:         }
michael@0:         MOZ_ASSUME_UNREACHABLE("VarType can only be Int, Double or Float");
michael@0:     }
michael@0:     AsmJSCoercion toCoercion() const {
michael@0:         switch(which_) {
michael@0:           case Int:     return AsmJS_ToInt32;
michael@0:           case Double:  return AsmJS_ToNumber;
michael@0:           case Float:   return AsmJS_FRound;
michael@0:         }
michael@0:         MOZ_ASSUME_UNREACHABLE("VarType can only be Int, Double or Float");
michael@0:     }
michael@0:     static VarType FromCheckedType(Type type) {
michael@0:         JS_ASSERT(type.isInt() || type.isMaybeDouble() || type.isFloatish());
michael@0:         if (type.isMaybeDouble())
michael@0:             return Double;
michael@0:         else if (type.isFloatish())
michael@0:             return Float;
michael@0:         else
michael@0:             return Int;
michael@0:     }
michael@0:     bool operator==(VarType rhs) const { return which_ == rhs.which_; }
michael@0:     bool operator!=(VarType rhs) const { return which_ != rhs.which_; }
michael@0: };
michael@0: 
michael@0: } /* anonymous namespace */
michael@0: 
michael@0: // Implements <: (subtype) operator when the rhs is an VarType
michael@0: static inline bool
michael@0: operator<=(Type lhs, VarType rhs)
michael@0: {
michael@0:     switch (rhs.which()) {
michael@0:       case VarType::Int:    return lhs.isInt();
michael@0:       case VarType::Double: return lhs.isDouble();
michael@0:       case VarType::Float:  return lhs.isFloat();
michael@0:     }
michael@0:     MOZ_ASSUME_UNREACHABLE("Unexpected rhs type");
michael@0: }
michael@0: 
michael@0: /*****************************************************************************/
michael@0: 
michael@0: static inline MIRType ToMIRType(MIRType t) { return t; }
michael@0: static inline MIRType ToMIRType(VarType t) { return t.toMIRType(); }
michael@0: 
michael@0: namespace {
michael@0: 
michael@0: template <class VecT>
michael@0: class ABIArgIter
michael@0: {
michael@0:     ABIArgGenerator gen_;
michael@0:     const VecT &types_;
michael@0:     unsigned i_;
michael@0: 
michael@0:     void settle() { if (!done()) gen_.next(ToMIRType(types_[i_])); }
michael@0: 
michael@0:   public:
michael@0:     ABIArgIter(const VecT &types) : types_(types), i_(0) { settle(); }
michael@0:     void operator++(int) { JS_ASSERT(!done()); i_++; settle(); }
michael@0:     bool done() const { return i_ == types_.length(); }
michael@0: 
michael@0:     ABIArg *operator->() { JS_ASSERT(!done()); return &gen_.current(); }
michael@0:     ABIArg &operator*() { JS_ASSERT(!done()); return gen_.current(); }
michael@0: 
michael@0:     unsigned index() const { JS_ASSERT(!done()); return i_; }
michael@0:     MIRType mirType() const { JS_ASSERT(!done()); return ToMIRType(types_[i_]); }
michael@0:     uint32_t stackBytesConsumedSoFar() const { return gen_.stackBytesConsumedSoFar(); }
michael@0: };
michael@0: 
michael@0: typedef js::Vector<MIRType, 8> MIRTypeVector;
michael@0: typedef ABIArgIter<MIRTypeVector> ABIArgMIRTypeIter;
michael@0: 
michael@0: typedef js::Vector<VarType, 8, LifoAllocPolicy> VarTypeVector;
michael@0: typedef ABIArgIter<VarTypeVector> ABIArgTypeIter;
michael@0: 
michael@0: class Signature
michael@0: {
michael@0:     VarTypeVector argTypes_;
michael@0:     RetType retType_;
michael@0: 
michael@0:   public:
michael@0:     Signature(LifoAlloc &alloc)
michael@0:       : argTypes_(alloc) {}
michael@0:     Signature(LifoAlloc &alloc, RetType retType)
michael@0:       : argTypes_(alloc), retType_(retType) {}
michael@0:     Signature(VarTypeVector &&argTypes, RetType retType)
michael@0:       : argTypes_(Move(argTypes)), retType_(Move(retType)) {}
michael@0:     Signature(Signature &&rhs)
michael@0:       : argTypes_(Move(rhs.argTypes_)), retType_(Move(rhs.retType_)) {}
michael@0: 
michael@0:     bool copy(const Signature &rhs) {
michael@0:         if (!argTypes_.resize(rhs.argTypes_.length()))
michael@0:             return false;
michael@0:         for (unsigned i = 0; i < argTypes_.length(); i++)
michael@0:             argTypes_[i] = rhs.argTypes_[i];
michael@0:         retType_ = rhs.retType_;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     bool appendArg(VarType type) { return argTypes_.append(type); }
michael@0:     VarType arg(unsigned i) const { return argTypes_[i]; }
michael@0:     const VarTypeVector &args() const { return argTypes_; }
michael@0:     VarTypeVector &&extractArgs() { return Move(argTypes_); }
michael@0: 
michael@0:     RetType retType() const { return retType_; }
michael@0: };
michael@0: 
michael@0: } /* namespace anonymous */
michael@0: 
michael@0: static
michael@0: bool operator==(const Signature &lhs, const Signature &rhs)
michael@0: {
michael@0:     if (lhs.retType() != rhs.retType())
michael@0:         return false;
michael@0:     if (lhs.args().length() != rhs.args().length())
michael@0:         return false;
michael@0:     for (unsigned i = 0; i < lhs.args().length(); i++) {
michael@0:         if (lhs.arg(i) != rhs.arg(i))
michael@0:             return false;
michael@0:     }
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static inline
michael@0: bool operator!=(const Signature &lhs, const Signature &rhs)
michael@0: {
michael@0:     return !(lhs == rhs);
michael@0: }
michael@0: 
michael@0: /*****************************************************************************/
michael@0: // Typed array utilities
michael@0: 
michael@0: static Type
michael@0: TypedArrayLoadType(ArrayBufferView::ViewType viewType)
michael@0: {
michael@0:     switch (viewType) {
michael@0:       case ArrayBufferView::TYPE_INT8:
michael@0:       case ArrayBufferView::TYPE_INT16:
michael@0:       case ArrayBufferView::TYPE_INT32:
michael@0:       case ArrayBufferView::TYPE_UINT8:
michael@0:       case ArrayBufferView::TYPE_UINT16:
michael@0:       case ArrayBufferView::TYPE_UINT32:
michael@0:         return Type::Intish;
michael@0:       case ArrayBufferView::TYPE_FLOAT32:
michael@0:         return Type::MaybeFloat;
michael@0:       case ArrayBufferView::TYPE_FLOAT64:
michael@0:         return Type::MaybeDouble;
michael@0:       default:;
michael@0:     }
michael@0:     MOZ_ASSUME_UNREACHABLE("Unexpected array type");
michael@0: }
michael@0: 
michael@0: enum NeedsBoundsCheck {
michael@0:     NO_BOUNDS_CHECK,
michael@0:     NEEDS_BOUNDS_CHECK
michael@0: };
michael@0: 
michael@0: namespace {
michael@0: 
michael@0: typedef js::Vector<PropertyName*,1> LabelVector;
michael@0: typedef js::Vector<MBasicBlock*,8> BlockVector;
michael@0: 
michael@0: // ModuleCompiler encapsulates the compilation of an entire asm.js module. Over
michael@0: // the course of an ModuleCompiler object's lifetime, many FunctionCompiler
michael@0: // objects will be created and destroyed in sequence, one for each function in
michael@0: // the module.
michael@0: //
michael@0: // *** asm.js FFI calls ***
michael@0: //
michael@0: // asm.js allows calling out to non-asm.js via "FFI calls". The asm.js type
michael@0: // system does not place any constraints on the FFI call. In particular:
michael@0: //  - an FFI call's target is not known or speculated at module-compile time;
michael@0: //  - a single external function can be called with different signatures.
michael@0: //
michael@0: // If performance didn't matter, all FFI calls could simply box their arguments
michael@0: // and call js::Invoke. However, we'd like to be able to specialize FFI calls
michael@0: // to be more efficient in several cases:
michael@0: //
michael@0: //  - for calls to JS functions which have been jitted, we'd like to call
michael@0: //    directly into JIT code without going through C++.
michael@0: //
michael@0: //  - for calls to certain builtins, we'd like to be call directly into the C++
michael@0: //    code for the builtin without going through the general call path.
michael@0: //
michael@0: // All of this requires dynamic specialization techniques which must happen
michael@0: // after module compilation. To support this, at module-compilation time, each
michael@0: // FFI call generates a call signature according to the system ABI, as if the
michael@0: // callee was a C++ function taking/returning the same types as the caller was
michael@0: // passing/expecting. The callee is loaded from a fixed offset in the global
michael@0: // data array which allows the callee to change at runtime. Initially, the
michael@0: // callee is stub which boxes its arguments and calls js::Invoke.
michael@0: //
michael@0: // To do this, we need to generate a callee stub for each pairing of FFI callee
michael@0: // and signature. We call this pairing an "exit". For example, this code has
michael@0: // two external functions and three exits:
michael@0: //
michael@0: //  function f(global, imports) {
michael@0: //    "use asm";
michael@0: //    var foo = imports.foo;
michael@0: //    var bar = imports.bar;
michael@0: //    function g() {
michael@0: //      foo(1);      // Exit #1: (int) -> void
michael@0: //      foo(1.5);    // Exit #2: (double) -> void
michael@0: //      bar(1)|0;    // Exit #3: (int) -> int
michael@0: //      bar(2)|0;    // Exit #3: (int) -> int
michael@0: //    }
michael@0: //  }
michael@0: //
michael@0: // The ModuleCompiler maintains a hash table (ExitMap) which allows a call site
michael@0: // to add a new exit or reuse an existing one. The key is an ExitDescriptor
michael@0: // (which holds the exit pairing) and the value is an index into the
michael@0: // Vector<Exit> stored in the AsmJSModule.
michael@0: //
michael@0: // Rooting note: ModuleCompiler is a stack class that contains unrooted
michael@0: // PropertyName (JSAtom) pointers.  This is safe because it cannot be
michael@0: // constructed without a TokenStream reference.  TokenStream is itself a stack
michael@0: // class that cannot be constructed without an AutoKeepAtoms being live on the
michael@0: // stack, which prevents collection of atoms.
michael@0: //
michael@0: // ModuleCompiler is marked as rooted in the rooting analysis.  Don't add
michael@0: // non-JSAtom pointers, or this will break!
michael@0: class MOZ_STACK_CLASS ModuleCompiler
michael@0: {
michael@0:   public:
michael@0:     class Func
michael@0:     {
michael@0:         PropertyName *name_;
michael@0:         bool defined_;
michael@0:         uint32_t srcOffset_;
michael@0:         uint32_t endOffset_;
michael@0:         Signature sig_;
michael@0:         Label *code_;
michael@0:         unsigned compileTime_;
michael@0: 
michael@0:       public:
michael@0:         Func(PropertyName *name, Signature &&sig, Label *code)
michael@0:           : name_(name), defined_(false), srcOffset_(0), endOffset_(0), sig_(Move(sig)),
michael@0:             code_(code), compileTime_(0)
michael@0:         {}
michael@0: 
michael@0:         PropertyName *name() const { return name_; }
michael@0: 
michael@0:         bool defined() const { return defined_; }
michael@0:         void finish(uint32_t start, uint32_t end) {
michael@0:             JS_ASSERT(!defined_);
michael@0:             defined_ = true;
michael@0:             srcOffset_ = start;
michael@0:             endOffset_ = end;
michael@0:         }
michael@0: 
michael@0:         uint32_t srcOffset() const { JS_ASSERT(defined_); return srcOffset_; }
michael@0:         uint32_t endOffset() const { JS_ASSERT(defined_); return endOffset_; }
michael@0:         Signature &sig() { return sig_; }
michael@0:         const Signature &sig() const { return sig_; }
michael@0:         Label *code() const { return code_; }
michael@0:         unsigned compileTime() const { return compileTime_; }
michael@0:         void accumulateCompileTime(unsigned ms) { compileTime_ += ms; }
michael@0:     };
michael@0: 
michael@0:     class Global
michael@0:     {
michael@0:       public:
michael@0:         enum Which {
michael@0:             Variable,
michael@0:             ConstantLiteral,
michael@0:             ConstantImport,
michael@0:             Function,
michael@0:             FuncPtrTable,
michael@0:             FFI,
michael@0:             ArrayView,
michael@0:             MathBuiltinFunction
michael@0:         };
michael@0: 
michael@0:       private:
michael@0:         Which which_;
michael@0:         union {
michael@0:             struct {
michael@0:                 VarType::Which type_;
michael@0:                 uint32_t index_;
michael@0:                 Value literalValue_;
michael@0:             } varOrConst;
michael@0:             uint32_t funcIndex_;
michael@0:             uint32_t funcPtrTableIndex_;
michael@0:             uint32_t ffiIndex_;
michael@0:             ArrayBufferView::ViewType viewType_;
michael@0:             AsmJSMathBuiltinFunction mathBuiltinFunc_;
michael@0:         } u;
michael@0: 
michael@0:         friend class ModuleCompiler;
michael@0:         friend class js::LifoAlloc;
michael@0: 
michael@0:         Global(Which which) : which_(which) {}
michael@0: 
michael@0:       public:
michael@0:         Which which() const {
michael@0:             return which_;
michael@0:         }
michael@0:         VarType varOrConstType() const {
michael@0:             JS_ASSERT(which_ == Variable || which_ == ConstantLiteral || which_ == ConstantImport);
michael@0:             return VarType(u.varOrConst.type_);
michael@0:         }
michael@0:         uint32_t varOrConstIndex() const {
michael@0:             JS_ASSERT(which_ == Variable || which_ == ConstantImport);
michael@0:             return u.varOrConst.index_;
michael@0:         }
michael@0:         bool isConst() const {
michael@0:             return which_ == ConstantLiteral || which_ == ConstantImport;
michael@0:         }
michael@0:         Value constLiteralValue() const {
michael@0:             JS_ASSERT(which_ == ConstantLiteral);
michael@0:             return u.varOrConst.literalValue_;
michael@0:         }
michael@0:         uint32_t funcIndex() const {
michael@0:             JS_ASSERT(which_ == Function);
michael@0:             return u.funcIndex_;
michael@0:         }
michael@0:         uint32_t funcPtrTableIndex() const {
michael@0:             JS_ASSERT(which_ == FuncPtrTable);
michael@0:             return u.funcPtrTableIndex_;
michael@0:         }
michael@0:         unsigned ffiIndex() const {
michael@0:             JS_ASSERT(which_ == FFI);
michael@0:             return u.ffiIndex_;
michael@0:         }
michael@0:         ArrayBufferView::ViewType viewType() const {
michael@0:             JS_ASSERT(which_ == ArrayView);
michael@0:             return u.viewType_;
michael@0:         }
michael@0:         AsmJSMathBuiltinFunction mathBuiltinFunction() const {
michael@0:             JS_ASSERT(which_ == MathBuiltinFunction);
michael@0:             return u.mathBuiltinFunc_;
michael@0:         }
michael@0:     };
michael@0: 
michael@0:     typedef js::Vector<const Func*> FuncPtrVector;
michael@0: 
michael@0:     class FuncPtrTable
michael@0:     {
michael@0:         Signature sig_;
michael@0:         uint32_t mask_;
michael@0:         uint32_t globalDataOffset_;
michael@0:         FuncPtrVector elems_;
michael@0: 
michael@0:       public:
michael@0:         FuncPtrTable(ExclusiveContext *cx, Signature &&sig, uint32_t mask, uint32_t gdo)
michael@0:           : sig_(Move(sig)), mask_(mask), globalDataOffset_(gdo), elems_(cx)
michael@0:         {}
michael@0: 
michael@0:         FuncPtrTable(FuncPtrTable &&rhs)
michael@0:           : sig_(Move(rhs.sig_)), mask_(rhs.mask_), globalDataOffset_(rhs.globalDataOffset_),
michael@0:             elems_(Move(rhs.elems_))
michael@0:         {}
michael@0: 
michael@0:         Signature &sig() { return sig_; }
michael@0:         const Signature &sig() const { return sig_; }
michael@0:         unsigned mask() const { return mask_; }
michael@0:         unsigned globalDataOffset() const { return globalDataOffset_; }
michael@0: 
michael@0:         bool initialized() const { return !elems_.empty(); }
michael@0:         void initElems(FuncPtrVector &&elems) { elems_ = Move(elems); JS_ASSERT(initialized()); }
michael@0:         unsigned numElems() const { JS_ASSERT(initialized()); return elems_.length(); }
michael@0:         const Func &elem(unsigned i) const { return *elems_[i]; }
michael@0:     };
michael@0: 
michael@0:     typedef js::Vector<FuncPtrTable> FuncPtrTableVector;
michael@0: 
michael@0:     class ExitDescriptor
michael@0:     {
michael@0:         PropertyName *name_;
michael@0:         Signature sig_;
michael@0: 
michael@0:       public:
michael@0:         ExitDescriptor(PropertyName *name, Signature &&sig)
michael@0:           : name_(name), sig_(Move(sig)) {}
michael@0:         ExitDescriptor(ExitDescriptor &&rhs)
michael@0:           : name_(rhs.name_), sig_(Move(rhs.sig_))
michael@0:         {}
michael@0:         const Signature &sig() const {
michael@0:             return sig_;
michael@0:         }
michael@0: 
michael@0:         // ExitDescriptor is a HashPolicy:
michael@0:         typedef ExitDescriptor Lookup;
michael@0:         static HashNumber hash(const ExitDescriptor &d) {
michael@0:             HashNumber hn = HashGeneric(d.name_, d.sig_.retType().which());
michael@0:             const VarTypeVector &args = d.sig_.args();
michael@0:             for (unsigned i = 0; i < args.length(); i++)
michael@0:                 hn = AddToHash(hn, args[i].which());
michael@0:             return hn;
michael@0:         }
michael@0:         static bool match(const ExitDescriptor &lhs, const ExitDescriptor &rhs) {
michael@0:             return lhs.name_ == rhs.name_ && lhs.sig_ == rhs.sig_;
michael@0:         }
michael@0:     };
michael@0: 
michael@0:     typedef HashMap<ExitDescriptor, unsigned, ExitDescriptor> ExitMap;
michael@0: 
michael@0:     struct MathBuiltin
michael@0:     {
michael@0:         enum Kind { Function, Constant };
michael@0:         Kind kind;
michael@0: 
michael@0:         union {
michael@0:             double cst;
michael@0:             AsmJSMathBuiltinFunction func;
michael@0:         } u;
michael@0: 
michael@0:         MathBuiltin() : kind(Kind(-1)) {}
michael@0:         MathBuiltin(double cst) : kind(Constant) {
michael@0:             u.cst = cst;
michael@0:         }
michael@0:         MathBuiltin(AsmJSMathBuiltinFunction func) : kind(Function) {
michael@0:             u.func = func;
michael@0:         }
michael@0:     };
michael@0: 
michael@0:   private:
michael@0:     struct SlowFunction
michael@0:     {
michael@0:         PropertyName *name;
michael@0:         unsigned ms;
michael@0:         unsigned line;
michael@0:         unsigned column;
michael@0:     };
michael@0: 
michael@0:     typedef HashMap<PropertyName*, MathBuiltin> MathNameMap;
michael@0:     typedef HashMap<PropertyName*, Global*> GlobalMap;
michael@0:     typedef js::Vector<Func*> FuncVector;
michael@0:     typedef js::Vector<AsmJSGlobalAccess> GlobalAccessVector;
michael@0:     typedef js::Vector<SlowFunction> SlowFunctionVector;
michael@0: 
michael@0:     ExclusiveContext *             cx_;
michael@0:     AsmJSParser &                  parser_;
michael@0: 
michael@0:     MacroAssembler                 masm_;
michael@0: 
michael@0:     ScopedJSDeletePtr<AsmJSModule> module_;
michael@0:     LifoAlloc                      moduleLifo_;
michael@0:     ParseNode *                    moduleFunctionNode_;
michael@0:     PropertyName *                 moduleFunctionName_;
michael@0: 
michael@0:     GlobalMap                      globals_;
michael@0:     FuncVector                     functions_;
michael@0:     FuncPtrTableVector             funcPtrTables_;
michael@0:     ExitMap                        exits_;
michael@0:     MathNameMap                    standardLibraryMathNames_;
michael@0:     Label                          stackOverflowLabel_;
michael@0:     Label                          interruptLabel_;
michael@0: 
michael@0:     char *                         errorString_;
michael@0:     uint32_t                       errorOffset_;
michael@0:     bool                           errorOverRecursed_;
michael@0: 
michael@0:     int64_t                        usecBefore_;
michael@0:     SlowFunctionVector             slowFunctions_;
michael@0: 
michael@0:     DebugOnly<bool>                finishedFunctionBodies_;
michael@0: 
michael@0:     bool addStandardLibraryMathName(const char *name, AsmJSMathBuiltinFunction func) {
michael@0:         JSAtom *atom = Atomize(cx_, name, strlen(name));
michael@0:         if (!atom)
michael@0:             return false;
michael@0:         MathBuiltin builtin(func);
michael@0:         return standardLibraryMathNames_.putNew(atom->asPropertyName(), builtin);
michael@0:     }
michael@0:     bool addStandardLibraryMathName(const char *name, double cst) {
michael@0:         JSAtom *atom = Atomize(cx_, name, strlen(name));
michael@0:         if (!atom)
michael@0:             return false;
michael@0:         MathBuiltin builtin(cst);
michael@0:         return standardLibraryMathNames_.putNew(atom->asPropertyName(), builtin);
michael@0:     }
michael@0: 
michael@0:   public:
michael@0:     ModuleCompiler(ExclusiveContext *cx, AsmJSParser &parser)
michael@0:       : cx_(cx),
michael@0:         parser_(parser),
michael@0:         masm_(MacroAssembler::AsmJSToken()),
michael@0:         moduleLifo_(LIFO_ALLOC_PRIMARY_CHUNK_SIZE),
michael@0:         moduleFunctionNode_(parser.pc->maybeFunction),
michael@0:         moduleFunctionName_(nullptr),
michael@0:         globals_(cx),
michael@0:         functions_(cx),
michael@0:         funcPtrTables_(cx),
michael@0:         exits_(cx),
michael@0:         standardLibraryMathNames_(cx),
michael@0:         errorString_(nullptr),
michael@0:         errorOffset_(UINT32_MAX),
michael@0:         errorOverRecursed_(false),
michael@0:         usecBefore_(PRMJ_Now()),
michael@0:         slowFunctions_(cx),
michael@0:         finishedFunctionBodies_(false)
michael@0:     {
michael@0:         JS_ASSERT(moduleFunctionNode_->pn_funbox == parser.pc->sc->asFunctionBox());
michael@0:     }
michael@0: 
michael@0:     ~ModuleCompiler() {
michael@0:         if (errorString_) {
michael@0:             JS_ASSERT(errorOffset_ != UINT32_MAX);
michael@0:             tokenStream().reportAsmJSError(errorOffset_,
michael@0:                                            JSMSG_USE_ASM_TYPE_FAIL,
michael@0:                                            errorString_);
michael@0:             js_free(errorString_);
michael@0:         }
michael@0:         if (errorOverRecursed_)
michael@0:             js_ReportOverRecursed(cx_);
michael@0: 
michael@0:         // Avoid spurious Label assertions on compilation failure.
michael@0:         if (!stackOverflowLabel_.bound())
michael@0:             stackOverflowLabel_.bind(0);
michael@0:         if (!interruptLabel_.bound())
michael@0:             interruptLabel_.bind(0);
michael@0:     }
michael@0: 
michael@0:     bool init() {
michael@0:         if (!globals_.init() || !exits_.init())
michael@0:             return false;
michael@0: 
michael@0:         if (!standardLibraryMathNames_.init() ||
michael@0:             !addStandardLibraryMathName("sin", AsmJSMathBuiltin_sin) ||
michael@0:             !addStandardLibraryMathName("cos", AsmJSMathBuiltin_cos) ||
michael@0:             !addStandardLibraryMathName("tan", AsmJSMathBuiltin_tan) ||
michael@0:             !addStandardLibraryMathName("asin", AsmJSMathBuiltin_asin) ||
michael@0:             !addStandardLibraryMathName("acos", AsmJSMathBuiltin_acos) ||
michael@0:             !addStandardLibraryMathName("atan", AsmJSMathBuiltin_atan) ||
michael@0:             !addStandardLibraryMathName("ceil", AsmJSMathBuiltin_ceil) ||
michael@0:             !addStandardLibraryMathName("floor", AsmJSMathBuiltin_floor) ||
michael@0:             !addStandardLibraryMathName("exp", AsmJSMathBuiltin_exp) ||
michael@0:             !addStandardLibraryMathName("log", AsmJSMathBuiltin_log) ||
michael@0:             !addStandardLibraryMathName("pow", AsmJSMathBuiltin_pow) ||
michael@0:             !addStandardLibraryMathName("sqrt", AsmJSMathBuiltin_sqrt) ||
michael@0:             !addStandardLibraryMathName("abs", AsmJSMathBuiltin_abs) ||
michael@0:             !addStandardLibraryMathName("atan2", AsmJSMathBuiltin_atan2) ||
michael@0:             !addStandardLibraryMathName("imul", AsmJSMathBuiltin_imul) ||
michael@0:             !addStandardLibraryMathName("fround", AsmJSMathBuiltin_fround) ||
michael@0:             !addStandardLibraryMathName("min", AsmJSMathBuiltin_min) ||
michael@0:             !addStandardLibraryMathName("max", AsmJSMathBuiltin_max) ||
michael@0:             !addStandardLibraryMathName("E", M_E) ||
michael@0:             !addStandardLibraryMathName("LN10", M_LN10) ||
michael@0:             !addStandardLibraryMathName("LN2", M_LN2) ||
michael@0:             !addStandardLibraryMathName("LOG2E", M_LOG2E) ||
michael@0:             !addStandardLibraryMathName("LOG10E", M_LOG10E) ||
michael@0:             !addStandardLibraryMathName("PI", M_PI) ||
michael@0:             !addStandardLibraryMathName("SQRT1_2", M_SQRT1_2) ||
michael@0:             !addStandardLibraryMathName("SQRT2", M_SQRT2))
michael@0:         {
michael@0:             return false;
michael@0:         }
michael@0: 
michael@0:         uint32_t funcStart = parser_.pc->maybeFunction->pn_body->pn_pos.begin;
michael@0:         uint32_t offsetToEndOfUseAsm = tokenStream().currentToken().pos.end;
michael@0: 
michael@0:         // "use strict" should be added to the source if we are in an implicit
michael@0:         // strict context, see also comment above addUseStrict in
michael@0:         // js::FunctionToString.
michael@0:         bool strict = parser_.pc->sc->strict && !parser_.pc->sc->hasExplicitUseStrict();
michael@0: 
michael@0:         module_ = cx_->new_<AsmJSModule>(parser_.ss, funcStart, offsetToEndOfUseAsm, strict);
michael@0:         if (!module_)
michael@0:             return false;
michael@0: 
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     bool failOffset(uint32_t offset, const char *str) {
michael@0:         JS_ASSERT(!errorString_);
michael@0:         JS_ASSERT(errorOffset_ == UINT32_MAX);
michael@0:         JS_ASSERT(str);
michael@0:         errorOffset_ = offset;
michael@0:         errorString_ = js_strdup(cx_, str);
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     bool fail(ParseNode *pn, const char *str) {
michael@0:         if (pn)
michael@0:             return failOffset(pn->pn_pos.begin, str);
michael@0: 
michael@0:         // The exact rooting static analysis does not perform dataflow analysis, so it believes
michael@0:         // that unrooted things on the stack during compilation may still be accessed after this.
michael@0:         // Since pn is typically only null under OOM, this suppression simply forces any GC to be
michael@0:         // delayed until the compilation is off the stack and more memory can be freed.
michael@0:         gc::AutoSuppressGC nogc(cx_);
michael@0:         return failOffset(tokenStream().peekTokenPos().begin, str);
michael@0:     }
michael@0: 
michael@0:     bool failfVA(ParseNode *pn, const char *fmt, va_list ap) {
michael@0:         JS_ASSERT(!errorString_);
michael@0:         JS_ASSERT(errorOffset_ == UINT32_MAX);
michael@0:         JS_ASSERT(fmt);
michael@0:         errorOffset_ = pn ? pn->pn_pos.begin : tokenStream().currentToken().pos.end;
michael@0:         errorString_ = JS_vsmprintf(fmt, ap);
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     bool failf(ParseNode *pn, const char *fmt, ...) {
michael@0:         va_list ap;
michael@0:         va_start(ap, fmt);
michael@0:         failfVA(pn, fmt, ap);
michael@0:         va_end(ap);
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     bool failName(ParseNode *pn, const char *fmt, PropertyName *name) {
michael@0:         // This function is invoked without the caller properly rooting its locals.
michael@0:         gc::AutoSuppressGC suppress(cx_);
michael@0:         JSAutoByteString bytes;
michael@0:         if (AtomToPrintableString(cx_, name, &bytes))
michael@0:             failf(pn, fmt, bytes.ptr());
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     bool failOverRecursed() {
michael@0:         errorOverRecursed_ = true;
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     static const unsigned SLOW_FUNCTION_THRESHOLD_MS = 250;
michael@0: 
michael@0:     bool maybeReportCompileTime(const Func &func) {
michael@0:         if (func.compileTime() < SLOW_FUNCTION_THRESHOLD_MS)
michael@0:             return true;
michael@0:         SlowFunction sf;
michael@0:         sf.name = func.name();
michael@0:         sf.ms = func.compileTime();
michael@0:         tokenStream().srcCoords.lineNumAndColumnIndex(func.srcOffset(), &sf.line, &sf.column);
michael@0:         return slowFunctions_.append(sf);
michael@0:     }
michael@0: 
michael@0:     /*************************************************** Read-only interface */
michael@0: 
michael@0:     ExclusiveContext *cx() const { return cx_; }
michael@0:     AsmJSParser &parser() const { return parser_; }
michael@0:     TokenStream &tokenStream() const { return parser_.tokenStream; }
michael@0:     MacroAssembler &masm() { return masm_; }
michael@0:     Label &stackOverflowLabel() { return stackOverflowLabel_; }
michael@0:     Label &interruptLabel() { return interruptLabel_; }
michael@0:     bool hasError() const { return errorString_ != nullptr; }
michael@0:     const AsmJSModule &module() const { return *module_.get(); }
michael@0:     uint32_t moduleStart() const { return module_->funcStart(); }
michael@0: 
michael@0:     ParseNode *moduleFunctionNode() const { return moduleFunctionNode_; }
michael@0:     PropertyName *moduleFunctionName() const { return moduleFunctionName_; }
michael@0: 
michael@0:     const Global *lookupGlobal(PropertyName *name) const {
michael@0:         if (GlobalMap::Ptr p = globals_.lookup(name))
michael@0:             return p->value();
michael@0:         return nullptr;
michael@0:     }
michael@0:     Func *lookupFunction(PropertyName *name) {
michael@0:         if (GlobalMap::Ptr p = globals_.lookup(name)) {
michael@0:             Global *value = p->value();
michael@0:             if (value->which() == Global::Function)
michael@0:                 return functions_[value->funcIndex()];
michael@0:         }
michael@0:         return nullptr;
michael@0:     }
michael@0:     unsigned numFunctions() const {
michael@0:         return functions_.length();
michael@0:     }
michael@0:     Func &function(unsigned i) {
michael@0:         return *functions_[i];
michael@0:     }
michael@0:     unsigned numFuncPtrTables() const {
michael@0:         return funcPtrTables_.length();
michael@0:     }
michael@0:     FuncPtrTable &funcPtrTable(unsigned i) {
michael@0:         return funcPtrTables_[i];
michael@0:     }
michael@0:     bool lookupStandardLibraryMathName(PropertyName *name, MathBuiltin *mathBuiltin) const {
michael@0:         if (MathNameMap::Ptr p = standardLibraryMathNames_.lookup(name)) {
michael@0:             *mathBuiltin = p->value();
michael@0:             return true;
michael@0:         }
michael@0:         return false;
michael@0:     }
michael@0:     ExitMap::Range allExits() const {
michael@0:         return exits_.all();
michael@0:     }
michael@0: 
michael@0:     /***************************************************** Mutable interface */
michael@0: 
michael@0:     void initModuleFunctionName(PropertyName *name) { moduleFunctionName_ = name; }
michael@0: 
michael@0:     void initGlobalArgumentName(PropertyName *n) { module_->initGlobalArgumentName(n); }
michael@0:     void initImportArgumentName(PropertyName *n) { module_->initImportArgumentName(n); }
michael@0:     void initBufferArgumentName(PropertyName *n) { module_->initBufferArgumentName(n); }
michael@0: 
michael@0:     bool addGlobalVarInit(PropertyName *varName, VarType type, const Value &v, bool isConst) {
michael@0:         uint32_t index;
michael@0:         if (!module_->addGlobalVarInit(v, type.toCoercion(), &index))
michael@0:             return false;
michael@0: 
michael@0:         Global::Which which = isConst ? Global::ConstantLiteral : Global::Variable;
michael@0:         Global *global = moduleLifo_.new_<Global>(which);
michael@0:         if (!global)
michael@0:             return false;
michael@0:         global->u.varOrConst.index_ = index;
michael@0:         global->u.varOrConst.type_ = type.which();
michael@0:         if (isConst)
michael@0:             global->u.varOrConst.literalValue_ = v;
michael@0: 
michael@0:         return globals_.putNew(varName, global);
michael@0:     }
michael@0:     bool addGlobalVarImport(PropertyName *varName, PropertyName *fieldName, AsmJSCoercion coercion,
michael@0:                             bool isConst) {
michael@0:         uint32_t index;
michael@0:         if (!module_->addGlobalVarImport(fieldName, coercion, &index))
michael@0:             return false;
michael@0: 
michael@0:         Global::Which which = isConst ? Global::ConstantImport : Global::Variable;
michael@0:         Global *global = moduleLifo_.new_<Global>(which);
michael@0:         if (!global)
michael@0:             return false;
michael@0:         global->u.varOrConst.index_ = index;
michael@0:         global->u.varOrConst.type_ = VarType(coercion).which();
michael@0: 
michael@0:         return globals_.putNew(varName, global);
michael@0:     }
michael@0:     bool addFunction(PropertyName *name, Signature &&sig, Func **func) {
michael@0:         JS_ASSERT(!finishedFunctionBodies_);
michael@0:         Global *global = moduleLifo_.new_<Global>(Global::Function);
michael@0:         if (!global)
michael@0:             return false;
michael@0:         global->u.funcIndex_ = functions_.length();
michael@0:         if (!globals_.putNew(name, global))
michael@0:             return false;
michael@0:         Label *code = moduleLifo_.new_<Label>();
michael@0:         if (!code)
michael@0:             return false;
michael@0:         *func = moduleLifo_.new_<Func>(name, Move(sig), code);
michael@0:         if (!*func)
michael@0:             return false;
michael@0:         return functions_.append(*func);
michael@0:     }
michael@0:     bool addFuncPtrTable(PropertyName *name, Signature &&sig, uint32_t mask, FuncPtrTable **table) {
michael@0:         Global *global = moduleLifo_.new_<Global>(Global::FuncPtrTable);
michael@0:         if (!global)
michael@0:             return false;
michael@0:         global->u.funcPtrTableIndex_ = funcPtrTables_.length();
michael@0:         if (!globals_.putNew(name, global))
michael@0:             return false;
michael@0:         uint32_t globalDataOffset;
michael@0:         if (!module_->addFuncPtrTable(/* numElems = */ mask + 1, &globalDataOffset))
michael@0:             return false;
michael@0:         FuncPtrTable tmpTable(cx_, Move(sig), mask, globalDataOffset);
michael@0:         if (!funcPtrTables_.append(Move(tmpTable)))
michael@0:             return false;
michael@0:         *table = &funcPtrTables_.back();
michael@0:         return true;
michael@0:     }
michael@0:     bool addFFI(PropertyName *varName, PropertyName *field) {
michael@0:         Global *global = moduleLifo_.new_<Global>(Global::FFI);
michael@0:         if (!global)
michael@0:             return false;
michael@0:         uint32_t index;
michael@0:         if (!module_->addFFI(field, &index))
michael@0:             return false;
michael@0:         global->u.ffiIndex_ = index;
michael@0:         return globals_.putNew(varName, global);
michael@0:     }
michael@0:     bool addArrayView(PropertyName *varName, ArrayBufferView::ViewType vt, PropertyName *fieldName) {
michael@0:         Global *global = moduleLifo_.new_<Global>(Global::ArrayView);
michael@0:         if (!global)
michael@0:             return false;
michael@0:         if (!module_->addArrayView(vt, fieldName))
michael@0:             return false;
michael@0:         global->u.viewType_ = vt;
michael@0:         return globals_.putNew(varName, global);
michael@0:     }
michael@0:     bool addMathBuiltinFunction(PropertyName *varName, AsmJSMathBuiltinFunction func, PropertyName *fieldName) {
michael@0:         if (!module_->addMathBuiltinFunction(func, fieldName))
michael@0:             return false;
michael@0:         Global *global = moduleLifo_.new_<Global>(Global::MathBuiltinFunction);
michael@0:         if (!global)
michael@0:             return false;
michael@0:         global->u.mathBuiltinFunc_ = func;
michael@0:         return globals_.putNew(varName, global);
michael@0:     }
michael@0:   private:
michael@0:     bool addGlobalDoubleConstant(PropertyName *varName, double constant) {
michael@0:         Global *global = moduleLifo_.new_<Global>(Global::ConstantLiteral);
michael@0:         if (!global)
michael@0:             return false;
michael@0:         global->u.varOrConst.literalValue_ = DoubleValue(constant);
michael@0:         global->u.varOrConst.type_ = VarType::Double;
michael@0:         return globals_.putNew(varName, global);
michael@0:     }
michael@0:   public:
michael@0:     bool addMathBuiltinConstant(PropertyName *varName, double constant, PropertyName *fieldName) {
michael@0:         if (!module_->addMathBuiltinConstant(constant, fieldName))
michael@0:             return false;
michael@0:         return addGlobalDoubleConstant(varName, constant);
michael@0:     }
michael@0:     bool addGlobalConstant(PropertyName *varName, double constant, PropertyName *fieldName) {
michael@0:         if (!module_->addGlobalConstant(constant, fieldName))
michael@0:             return false;
michael@0:         return addGlobalDoubleConstant(varName, constant);
michael@0:     }
michael@0:     bool addExportedFunction(const Func *func, PropertyName *maybeFieldName) {
michael@0:         AsmJSModule::ArgCoercionVector argCoercions;
michael@0:         const VarTypeVector &args = func->sig().args();
michael@0:         if (!argCoercions.resize(args.length()))
michael@0:             return false;
michael@0:         for (unsigned i = 0; i < args.length(); i++)
michael@0:             argCoercions[i] = args[i].toCoercion();
michael@0:         AsmJSModule::ReturnType retType = func->sig().retType().toModuleReturnType();
michael@0:         return module_->addExportedFunction(func->name(), func->srcOffset(), func->endOffset(),
michael@0:                                             maybeFieldName, Move(argCoercions), retType);
michael@0:     }
michael@0:     bool addExit(unsigned ffiIndex, PropertyName *name, Signature &&sig, unsigned *exitIndex) {
michael@0:         ExitDescriptor exitDescriptor(name, Move(sig));
michael@0:         ExitMap::AddPtr p = exits_.lookupForAdd(exitDescriptor);
michael@0:         if (p) {
michael@0:             *exitIndex = p->value();
michael@0:             return true;
michael@0:         }
michael@0:         if (!module_->addExit(ffiIndex, exitIndex))
michael@0:             return false;
michael@0:         return exits_.add(p, Move(exitDescriptor), *exitIndex);
michael@0:     }
michael@0:     bool addFunctionName(PropertyName *name, uint32_t *index) {
michael@0:         return module_->addFunctionName(name, index);
michael@0:     }
michael@0: 
michael@0:     // Note a constraint on the minimum size of the heap.  The heap size is
michael@0:     // constrained when linking to be at least the maximum of all such constraints.
michael@0:     void requireHeapLengthToBeAtLeast(uint32_t len) {
michael@0:         module_->requireHeapLengthToBeAtLeast(len);
michael@0:     }
michael@0:     uint32_t minHeapLength() const {
michael@0:         return module_->minHeapLength();
michael@0:     }
michael@0:     LifoAlloc &lifo() {
michael@0:         return moduleLifo_;
michael@0:     }
michael@0: 
michael@0: #if defined(MOZ_VTUNE) || defined(JS_ION_PERF)
michael@0:     bool trackProfiledFunction(const Func &func, unsigned endCodeOffset) {
michael@0:         unsigned lineno = 0U, columnIndex = 0U;
michael@0:         tokenStream().srcCoords.lineNumAndColumnIndex(func.srcOffset(), &lineno, &columnIndex);
michael@0:         unsigned startCodeOffset = func.code()->offset();
michael@0:         return module_->trackProfiledFunction(func.name(), startCodeOffset, endCodeOffset,
michael@0:                                               lineno, columnIndex);
michael@0:     }
michael@0: #endif
michael@0: 
michael@0: #ifdef JS_ION_PERF
michael@0:     bool trackPerfProfiledBlocks(AsmJSPerfSpewer &perfSpewer, const Func &func, unsigned endCodeOffset) {
michael@0:         unsigned startCodeOffset = func.code()->offset();
michael@0:         perfSpewer.noteBlocksOffsets();
michael@0:         unsigned endInlineCodeOffset = perfSpewer.endInlineCode.offset();
michael@0:         return module_->trackPerfProfiledBlocks(func.name(), startCodeOffset, endInlineCodeOffset,
michael@0:                                                 endCodeOffset, perfSpewer.basicBlocks());
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     void finishFunctionBodies() {
michael@0:         JS_ASSERT(!finishedFunctionBodies_);
michael@0:         masm_.align(AsmJSPageSize);
michael@0:         finishedFunctionBodies_ = true;
michael@0:         module_->initFunctionBytes(masm_.currentOffset());
michael@0:     }
michael@0: 
michael@0:     void setInterpExitOffset(unsigned exitIndex) {
michael@0:         module_->exit(exitIndex).initInterpOffset(masm_.currentOffset());
michael@0:     }
michael@0:     void setIonExitOffset(unsigned exitIndex) {
michael@0:         module_->exit(exitIndex).initIonOffset(masm_.currentOffset());
michael@0:     }
michael@0:     void setEntryOffset(unsigned exportIndex) {
michael@0:         module_->exportedFunction(exportIndex).initCodeOffset(masm_.currentOffset());
michael@0:     }
michael@0: 
michael@0:     void buildCompilationTimeReport(bool storedInCache, ScopedJSFreePtr<char> *out) {
michael@0:         ScopedJSFreePtr<char> slowFuns;
michael@0: #ifndef JS_MORE_DETERMINISTIC
michael@0:         int64_t usecAfter = PRMJ_Now();
michael@0:         int msTotal = (usecAfter - usecBefore_) / PRMJ_USEC_PER_MSEC;
michael@0:         if (!slowFunctions_.empty()) {
michael@0:             slowFuns.reset(JS_smprintf("; %d functions compiled slowly: ", slowFunctions_.length()));
michael@0:             if (!slowFuns)
michael@0:                 return;
michael@0:             for (unsigned i = 0; i < slowFunctions_.length(); i++) {
michael@0:                 SlowFunction &func = slowFunctions_[i];
michael@0:                 JSAutoByteString name;
michael@0:                 if (!AtomToPrintableString(cx_, func.name, &name))
michael@0:                     return;
michael@0:                 slowFuns.reset(JS_smprintf("%s%s:%u:%u (%ums)%s", slowFuns.get(),
michael@0:                                            name.ptr(), func.line, func.column, func.ms,
michael@0:                                            i+1 < slowFunctions_.length() ? ", " : ""));
michael@0:                 if (!slowFuns)
michael@0:                     return;
michael@0:             }
michael@0:         }
michael@0:         out->reset(JS_smprintf("total compilation time %dms; %s%s",
michael@0:                                msTotal,
michael@0:                                storedInCache ? "stored in cache" : "not stored in cache",
michael@0:                                slowFuns ? slowFuns.get() : ""));
michael@0: #endif
michael@0:     }
michael@0: 
michael@0:     bool finish(ScopedJSDeletePtr<AsmJSModule> *module)
michael@0:     {
michael@0:         module_->initFuncEnd(tokenStream().currentToken().pos.end,
michael@0:                              tokenStream().peekTokenPos().end);
michael@0:         masm_.finish();
michael@0:         if (masm_.oom())
michael@0:             return false;
michael@0: 
michael@0:         module_->assignCallSites(masm_.extractCallSites());
michael@0:         module_->assignHeapAccesses(masm_.extractAsmJSHeapAccesses());
michael@0: 
michael@0: #if defined(JS_CODEGEN_ARM)
michael@0:         // Now that compilation has finished, we need to update offsets to
michael@0:         // reflect actual offsets (an ARM distinction).
michael@0:         for (unsigned i = 0; i < module_->numHeapAccesses(); i++) {
michael@0:             AsmJSHeapAccess &a = module_->heapAccess(i);
michael@0:             a.setOffset(masm_.actualOffset(a.offset()));
michael@0:         }
michael@0:         for (unsigned i = 0; i < module_->numExportedFunctions(); i++)
michael@0:             module_->exportedFunction(i).updateCodeOffset(masm_);
michael@0:         for (unsigned i = 0; i < module_->numExits(); i++)
michael@0:             module_->exit(i).updateOffsets(masm_);
michael@0:         for (unsigned i = 0; i < module_->numCallSites(); i++) {
michael@0:             CallSite &c = module_->callSite(i);
michael@0:             c.setReturnAddressOffset(masm_.actualOffset(c.returnAddressOffset()));
michael@0:         }
michael@0: #endif
michael@0: 
michael@0:         // The returned memory is owned by module_.
michael@0:         if (!module_->allocateAndCopyCode(cx_, masm_))
michael@0:             return false;
michael@0: 
michael@0:         module_->updateFunctionBytes(masm_);
michael@0:         // c.f. JitCode::copyFrom
michael@0:         JS_ASSERT(masm_.jumpRelocationTableBytes() == 0);
michael@0:         JS_ASSERT(masm_.dataRelocationTableBytes() == 0);
michael@0:         JS_ASSERT(masm_.preBarrierTableBytes() == 0);
michael@0:         JS_ASSERT(!masm_.hasEnteredExitFrame());
michael@0: 
michael@0: #if defined(MOZ_VTUNE) || defined(JS_ION_PERF)
michael@0:         // Fix up the code offsets.
michael@0:         for (unsigned i = 0; i < module_->numProfiledFunctions(); i++) {
michael@0:             AsmJSModule::ProfiledFunction &func = module_->profiledFunction(i);
michael@0:             func.pod.startCodeOffset = masm_.actualOffset(func.pod.startCodeOffset);
michael@0:             func.pod.endCodeOffset = masm_.actualOffset(func.pod.endCodeOffset);
michael@0:         }
michael@0: #endif
michael@0: 
michael@0: #ifdef JS_ION_PERF
michael@0:         for (unsigned i = 0; i < module_->numPerfBlocksFunctions(); i++) {
michael@0:             AsmJSModule::ProfiledBlocksFunction &func = module_->perfProfiledBlocksFunction(i);
michael@0:             func.pod.startCodeOffset = masm_.actualOffset(func.pod.startCodeOffset);
michael@0:             func.endInlineCodeOffset = masm_.actualOffset(func.endInlineCodeOffset);
michael@0:             func.pod.endCodeOffset = masm_.actualOffset(func.pod.endCodeOffset);
michael@0:             BasicBlocksVector &basicBlocks = func.blocks;
michael@0:             for (uint32_t i = 0; i < basicBlocks.length(); i++) {
michael@0:                 Record &r = basicBlocks[i];
michael@0:                 r.startOffset = masm_.actualOffset(r.startOffset);
michael@0:                 r.endOffset = masm_.actualOffset(r.endOffset);
michael@0:             }
michael@0:         }
michael@0: #endif
michael@0: 
michael@0:         module_->setInterruptOffset(masm_.actualOffset(interruptLabel_.offset()));
michael@0: 
michael@0:         // CodeLabels produced during codegen
michael@0:         for (size_t i = 0; i < masm_.numCodeLabels(); i++) {
michael@0:             CodeLabel src = masm_.codeLabel(i);
michael@0:             int32_t labelOffset = src.dest()->offset();
michael@0:             int32_t targetOffset = masm_.actualOffset(src.src()->offset());
michael@0:             // The patched uses of a label embed a linked list where the
michael@0:             // to-be-patched immediate is the offset of the next to-be-patched
michael@0:             // instruction.
michael@0:             while (labelOffset != LabelBase::INVALID_OFFSET) {
michael@0:                 size_t patchAtOffset = masm_.labelOffsetToPatchOffset(labelOffset);
michael@0:                 AsmJSModule::RelativeLink link;
michael@0:                 link.patchAtOffset = patchAtOffset;
michael@0:                 link.targetOffset = targetOffset;
michael@0:                 if (!module_->addRelativeLink(link))
michael@0:                     return false;
michael@0:                 labelOffset = *(uintptr_t *)(module_->codeBase() + patchAtOffset);
michael@0:             }
michael@0:         }
michael@0: 
michael@0:         // Function-pointer-table entries
michael@0:         for (unsigned tableIndex = 0; tableIndex < funcPtrTables_.length(); tableIndex++) {
michael@0:             FuncPtrTable &table = funcPtrTables_[tableIndex];
michael@0:             unsigned tableBaseOffset = module_->offsetOfGlobalData() + table.globalDataOffset();
michael@0:             for (unsigned elemIndex = 0; elemIndex < table.numElems(); elemIndex++) {
michael@0:                 AsmJSModule::RelativeLink link;
michael@0:                 link.patchAtOffset = tableBaseOffset + elemIndex * sizeof(uint8_t*);
michael@0:                 link.targetOffset = masm_.actualOffset(table.elem(elemIndex).code()->offset());
michael@0:                 if (!module_->addRelativeLink(link))
michael@0:                     return false;
michael@0:             }
michael@0:         }
michael@0: 
michael@0: #if defined(JS_CODEGEN_X86)
michael@0:         // Global data accesses in x86 need to be patched with the absolute
michael@0:         // address of the global. Globals are allocated sequentially after the
michael@0:         // code section so we can just use an RelativeLink.
michael@0:         for (unsigned i = 0; i < masm_.numAsmJSGlobalAccesses(); i++) {
michael@0:             AsmJSGlobalAccess a = masm_.asmJSGlobalAccess(i);
michael@0:             AsmJSModule::RelativeLink link;
michael@0:             link.patchAtOffset = masm_.labelOffsetToPatchOffset(a.patchAt.offset());
michael@0:             link.targetOffset = module_->offsetOfGlobalData() + a.globalDataOffset;
michael@0:             if (!module_->addRelativeLink(link))
michael@0:                 return false;
michael@0:         }
michael@0: #endif
michael@0: 
michael@0: #if defined(JS_CODEGEN_X64)
michael@0:         // Global data accesses on x64 use rip-relative addressing and thus do
michael@0:         // not need patching after deserialization.
michael@0:         uint8_t *code = module_->codeBase();
michael@0:         for (unsigned i = 0; i < masm_.numAsmJSGlobalAccesses(); i++) {
michael@0:             AsmJSGlobalAccess a = masm_.asmJSGlobalAccess(i);
michael@0:             masm_.patchAsmJSGlobalAccess(a.patchAt, code, module_->globalData(), a.globalDataOffset);
michael@0:         }
michael@0: #endif
michael@0: 
michael@0:         // Absolute links
michael@0:         for (size_t i = 0; i < masm_.numAsmJSAbsoluteLinks(); i++) {
michael@0:             AsmJSAbsoluteLink src = masm_.asmJSAbsoluteLink(i);
michael@0:             AsmJSModule::AbsoluteLink link;
michael@0:             link.patchAt = masm_.actualOffset(src.patchAt.offset());
michael@0:             link.target = src.target;
michael@0:             if (!module_->addAbsoluteLink(link))
michael@0:                 return false;
michael@0:         }
michael@0: 
michael@0:         *module = module_.forget();
michael@0:         return true;
michael@0:     }
michael@0: };
michael@0: 
michael@0: } /* anonymous namespace */
michael@0: 
michael@0: /*****************************************************************************/
michael@0: // Numeric literal utilities
michael@0: 
michael@0: namespace {
michael@0: 
michael@0: // Represents the type and value of an asm.js numeric literal.
michael@0: //
michael@0: // A literal is a double iff the literal contains an exponent or decimal point
michael@0: // (even if the fractional part is 0). Otherwise, integers may be classified:
michael@0: //  fixnum: [0, 2^31)
michael@0: //  negative int: [-2^31, 0)
michael@0: //  big unsigned: [2^31, 2^32)
michael@0: //  out of range: otherwise
michael@0: // Lastly, a literal may be a float literal which is any double or integer
michael@0: // literal coerced with Math.fround.
michael@0: class NumLit
michael@0: {
michael@0:   public:
michael@0:     enum Which {
michael@0:         Fixnum = Type::Fixnum,
michael@0:         NegativeInt = Type::Signed,
michael@0:         BigUnsigned = Type::Unsigned,
michael@0:         Double = Type::Double,
michael@0:         Float = Type::Float,
michael@0:         OutOfRangeInt = -1
michael@0:     };
michael@0: 
michael@0:   private:
michael@0:     Which which_;
michael@0:     Value v_;
michael@0: 
michael@0:   public:
michael@0:     NumLit() {}
michael@0: 
michael@0:     NumLit(Which w, Value v)
michael@0:       : which_(w), v_(v)
michael@0:     {}
michael@0: 
michael@0:     Which which() const {
michael@0:         return which_;
michael@0:     }
michael@0: 
michael@0:     int32_t toInt32() const {
michael@0:         JS_ASSERT(which_ == Fixnum || which_ == NegativeInt || which_ == BigUnsigned);
michael@0:         return v_.toInt32();
michael@0:     }
michael@0: 
michael@0:     double toDouble() const {
michael@0:         JS_ASSERT(which_ == Double);
michael@0:         return v_.toDouble();
michael@0:     }
michael@0: 
michael@0:     float toFloat() const {
michael@0:         JS_ASSERT(which_ == Float);
michael@0:         return float(v_.toDouble());
michael@0:     }
michael@0: 
michael@0:     Value value() const {
michael@0:         JS_ASSERT(which_ != OutOfRangeInt);
michael@0:         return v_;
michael@0:     }
michael@0: 
michael@0:     bool hasType() const {
michael@0:         return which_ != OutOfRangeInt;
michael@0:     }
michael@0: 
michael@0:     Type type() const {
michael@0:         JS_ASSERT(hasType());
michael@0:         return Type::Which(which_);
michael@0:     }
michael@0: 
michael@0:     VarType varType() const {
michael@0:         JS_ASSERT(hasType());
michael@0:         switch (which_) {
michael@0:           case NumLit::Fixnum:
michael@0:           case NumLit::NegativeInt:
michael@0:           case NumLit::BigUnsigned:
michael@0:             return VarType::Int;
michael@0:           case NumLit::Double:
michael@0:             return VarType::Double;
michael@0:           case NumLit::Float:
michael@0:             return VarType::Float;
michael@0:           case NumLit::OutOfRangeInt:;
michael@0:         }
michael@0:         MOZ_ASSUME_UNREACHABLE("Unexpected NumLit type");
michael@0:     }
michael@0: };
michael@0: 
michael@0: } /* anonymous namespace */
michael@0: 
michael@0: static bool
michael@0: IsNumericNonFloatLiteral(ParseNode *pn)
michael@0: {
michael@0:     // Note: '-' is never rolled into the number; numbers are always positive
michael@0:     // and negations must be applied manually.
michael@0:     return pn->isKind(PNK_NUMBER) ||
michael@0:            (pn->isKind(PNK_NEG) && UnaryKid(pn)->isKind(PNK_NUMBER));
michael@0: }
michael@0: 
michael@0: static bool
michael@0: IsFloatCoercion(ModuleCompiler &m, ParseNode *pn, ParseNode **coercedExpr)
michael@0: {
michael@0:     if (!pn->isKind(PNK_CALL))
michael@0:         return false;
michael@0: 
michael@0:     ParseNode *callee = CallCallee(pn);
michael@0:     if (!callee->isKind(PNK_NAME))
michael@0:         return false;
michael@0: 
michael@0:     const ModuleCompiler::Global *global = m.lookupGlobal(callee->name());
michael@0:     if (!global ||
michael@0:         global->which() != ModuleCompiler::Global::MathBuiltinFunction ||
michael@0:         global->mathBuiltinFunction() != AsmJSMathBuiltin_fround)
michael@0:     {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     if (CallArgListLength(pn) != 1)
michael@0:         return false;
michael@0: 
michael@0:     if (coercedExpr)
michael@0:         *coercedExpr = CallArgList(pn);
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: IsNumericFloatLiteral(ModuleCompiler &m, ParseNode *pn)
michael@0: {
michael@0:     ParseNode *coercedExpr;
michael@0:     if (!IsFloatCoercion(m, pn, &coercedExpr))
michael@0:         return false;
michael@0: 
michael@0:     return IsNumericNonFloatLiteral(coercedExpr);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: IsNumericLiteral(ModuleCompiler &m, ParseNode *pn)
michael@0: {
michael@0:     return IsNumericNonFloatLiteral(pn) ||
michael@0:            IsNumericFloatLiteral(m, pn);
michael@0: }
michael@0: 
michael@0: // The JS grammar treats -42 as -(42) (i.e., with separate grammar
michael@0: // productions) for the unary - and literal 42). However, the asm.js spec
michael@0: // recognizes -42 (modulo parens, so -(42) and -((42))) as a single literal
michael@0: // so fold the two potential parse nodes into a single double value.
michael@0: static double
michael@0: ExtractNumericNonFloatValue(ParseNode **pn)
michael@0: {
michael@0:     JS_ASSERT(IsNumericNonFloatLiteral(*pn));
michael@0: 
michael@0:     if ((*pn)->isKind(PNK_NEG)) {
michael@0:         *pn = UnaryKid(*pn);
michael@0:         return -NumberNodeValue(*pn);
michael@0:     }
michael@0: 
michael@0:     return NumberNodeValue(*pn);
michael@0: }
michael@0: 
michael@0: static NumLit
michael@0: ExtractNumericLiteral(ModuleCompiler &m, ParseNode *pn)
michael@0: {
michael@0:     JS_ASSERT(IsNumericLiteral(m, pn));
michael@0: 
michael@0:     // Float literals are explicitly coerced and thus the coerced literal may be
michael@0:     // any valid (non-float) numeric literal.
michael@0:     if (pn->isKind(PNK_CALL)) {
michael@0:         pn = CallArgList(pn);
michael@0:         double d = ExtractNumericNonFloatValue(&pn);
michael@0:         return NumLit(NumLit::Float, DoubleValue(d));
michael@0:     }
michael@0: 
michael@0:     double d = ExtractNumericNonFloatValue(&pn);
michael@0: 
michael@0:     // The asm.js spec syntactically distinguishes any literal containing a
michael@0:     // decimal point or the literal -0 as having double type.
michael@0:     if (NumberNodeHasFrac(pn) || IsNegativeZero(d))
michael@0:         return NumLit(NumLit::Double, DoubleValue(d));
michael@0: 
michael@0:     // The syntactic checks above rule out these double values.
michael@0:     JS_ASSERT(!IsNegativeZero(d));
michael@0:     JS_ASSERT(!IsNaN(d));
michael@0: 
michael@0:     // Although doubles can only *precisely* represent 53-bit integers, they
michael@0:     // can *imprecisely* represent integers much bigger than an int64_t.
michael@0:     // Furthermore, d may be inf or -inf. In both cases, casting to an int64_t
michael@0:     // is undefined, so test against the integer bounds using doubles.
michael@0:     if (d < double(INT32_MIN) || d > double(UINT32_MAX))
michael@0:         return NumLit(NumLit::OutOfRangeInt, UndefinedValue());
michael@0: 
michael@0:     // With the above syntactic and range limitations, d is definitely an
michael@0:     // integer in the range [INT32_MIN, UINT32_MAX] range.
michael@0:     int64_t i64 = int64_t(d);
michael@0:     if (i64 >= 0) {
michael@0:         if (i64 <= INT32_MAX)
michael@0:             return NumLit(NumLit::Fixnum, Int32Value(i64));
michael@0:         JS_ASSERT(i64 <= UINT32_MAX);
michael@0:         return NumLit(NumLit::BigUnsigned, Int32Value(uint32_t(i64)));
michael@0:     }
michael@0:     JS_ASSERT(i64 >= INT32_MIN);
michael@0:     return NumLit(NumLit::NegativeInt, Int32Value(i64));
michael@0: }
michael@0: 
michael@0: static inline bool
michael@0: IsLiteralInt(ModuleCompiler &m, ParseNode *pn, uint32_t *u32)
michael@0: {
michael@0:     if (!IsNumericLiteral(m, pn))
michael@0:         return false;
michael@0: 
michael@0:     NumLit literal = ExtractNumericLiteral(m, pn);
michael@0:     switch (literal.which()) {
michael@0:       case NumLit::Fixnum:
michael@0:       case NumLit::BigUnsigned:
michael@0:       case NumLit::NegativeInt:
michael@0:         *u32 = uint32_t(literal.toInt32());
michael@0:         return true;
michael@0:       case NumLit::Double:
michael@0:       case NumLit::Float:
michael@0:       case NumLit::OutOfRangeInt:
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSUME_UNREACHABLE("Bad literal type");
michael@0: }
michael@0: 
michael@0: /*****************************************************************************/
michael@0: 
michael@0: namespace {
michael@0: 
michael@0: // Encapsulates the compilation of a single function in an asm.js module. The
michael@0: // function compiler handles the creation and final backend compilation of the
michael@0: // MIR graph. Also see ModuleCompiler comment.
michael@0: class FunctionCompiler
michael@0: {
michael@0:   public:
michael@0:     struct Local
michael@0:     {
michael@0:         VarType type;
michael@0:         unsigned slot;
michael@0:         Local(VarType t, unsigned slot) : type(t), slot(slot) {}
michael@0:     };
michael@0: 
michael@0:     struct TypedValue
michael@0:     {
michael@0:         VarType type;
michael@0:         Value value;
michael@0:         TypedValue(VarType t, const Value &v) : type(t), value(v) {}
michael@0:     };
michael@0: 
michael@0:   private:
michael@0:     typedef HashMap<PropertyName*, Local> LocalMap;
michael@0:     typedef js::Vector<TypedValue> VarInitializerVector;
michael@0:     typedef HashMap<PropertyName*, BlockVector> LabeledBlockMap;
michael@0:     typedef HashMap<ParseNode*, BlockVector> UnlabeledBlockMap;
michael@0:     typedef js::Vector<ParseNode*, 4> NodeStack;
michael@0: 
michael@0:     ModuleCompiler &       m_;
michael@0:     LifoAlloc &            lifo_;
michael@0:     ParseNode *            fn_;
michael@0:     uint32_t               functionNameIndex_;
michael@0: 
michael@0:     LocalMap               locals_;
michael@0:     VarInitializerVector   varInitializers_;
michael@0:     Maybe<RetType>         alreadyReturned_;
michael@0: 
michael@0:     TempAllocator *        alloc_;
michael@0:     MIRGraph *             graph_;
michael@0:     CompileInfo *          info_;
michael@0:     MIRGenerator *         mirGen_;
michael@0:     Maybe<IonContext>      ionContext_;
michael@0: 
michael@0:     MBasicBlock *          curBlock_;
michael@0: 
michael@0:     NodeStack              loopStack_;
michael@0:     NodeStack              breakableStack_;
michael@0:     UnlabeledBlockMap      unlabeledBreaks_;
michael@0:     UnlabeledBlockMap      unlabeledContinues_;
michael@0:     LabeledBlockMap        labeledBreaks_;
michael@0:     LabeledBlockMap        labeledContinues_;
michael@0: 
michael@0:     static const uint32_t NO_FUNCTION_NAME_INDEX = UINT32_MAX;
michael@0:     JS_STATIC_ASSERT(NO_FUNCTION_NAME_INDEX > CallSiteDesc::FUNCTION_NAME_INDEX_MAX);
michael@0: 
michael@0:   public:
michael@0:     FunctionCompiler(ModuleCompiler &m, ParseNode *fn, LifoAlloc &lifo)
michael@0:       : m_(m),
michael@0:         lifo_(lifo),
michael@0:         fn_(fn),
michael@0:         functionNameIndex_(NO_FUNCTION_NAME_INDEX),
michael@0:         locals_(m.cx()),
michael@0:         varInitializers_(m.cx()),
michael@0:         alloc_(nullptr),
michael@0:         graph_(nullptr),
michael@0:         info_(nullptr),
michael@0:         mirGen_(nullptr),
michael@0:         curBlock_(nullptr),
michael@0:         loopStack_(m.cx()),
michael@0:         breakableStack_(m.cx()),
michael@0:         unlabeledBreaks_(m.cx()),
michael@0:         unlabeledContinues_(m.cx()),
michael@0:         labeledBreaks_(m.cx()),
michael@0:         labeledContinues_(m.cx())
michael@0:     {}
michael@0: 
michael@0:     ModuleCompiler &    m() const      { return m_; }
michael@0:     TempAllocator &     alloc() const  { return *alloc_; }
michael@0:     LifoAlloc &         lifo() const   { return lifo_; }
michael@0:     ParseNode *         fn() const     { return fn_; }
michael@0:     ExclusiveContext *  cx() const     { return m_.cx(); }
michael@0:     const AsmJSModule & module() const { return m_.module(); }
michael@0: 
michael@0:     bool init()
michael@0:     {
michael@0:         return locals_.init() &&
michael@0:                unlabeledBreaks_.init() &&
michael@0:                unlabeledContinues_.init() &&
michael@0:                labeledBreaks_.init() &&
michael@0:                labeledContinues_.init();
michael@0:     }
michael@0: 
michael@0:     bool fail(ParseNode *pn, const char *str)
michael@0:     {
michael@0:         return m_.fail(pn, str);
michael@0:     }
michael@0: 
michael@0:     bool failf(ParseNode *pn, const char *fmt, ...)
michael@0:     {
michael@0:         va_list ap;
michael@0:         va_start(ap, fmt);
michael@0:         m_.failfVA(pn, fmt, ap);
michael@0:         va_end(ap);
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     bool failName(ParseNode *pn, const char *fmt, PropertyName *name)
michael@0:     {
michael@0:         return m_.failName(pn, fmt, name);
michael@0:     }
michael@0: 
michael@0:     ~FunctionCompiler()
michael@0:     {
michael@0: #ifdef DEBUG
michael@0:         if (!m().hasError() && cx()->isJSContext() && !cx()->asJSContext()->isExceptionPending()) {
michael@0:             JS_ASSERT(loopStack_.empty());
michael@0:             JS_ASSERT(unlabeledBreaks_.empty());
michael@0:             JS_ASSERT(unlabeledContinues_.empty());
michael@0:             JS_ASSERT(labeledBreaks_.empty());
michael@0:             JS_ASSERT(labeledContinues_.empty());
michael@0:             JS_ASSERT(inDeadCode());
michael@0:         }
michael@0: #endif
michael@0:     }
michael@0: 
michael@0:     /***************************************************** Local scope setup */
michael@0: 
michael@0:     bool addFormal(ParseNode *pn, PropertyName *name, VarType type)
michael@0:     {
michael@0:         LocalMap::AddPtr p = locals_.lookupForAdd(name);
michael@0:         if (p)
michael@0:             return failName(pn, "duplicate local name '%s' not allowed", name);
michael@0:         return locals_.add(p, name, Local(type, locals_.count()));
michael@0:     }
michael@0: 
michael@0:     bool addVariable(ParseNode *pn, PropertyName *name, VarType type, const Value &init)
michael@0:     {
michael@0:         LocalMap::AddPtr p = locals_.lookupForAdd(name);
michael@0:         if (p)
michael@0:             return failName(pn, "duplicate local name '%s' not allowed", name);
michael@0:         if (!locals_.add(p, name, Local(type, locals_.count())))
michael@0:             return false;
michael@0:         return varInitializers_.append(TypedValue(type, init));
michael@0:     }
michael@0: 
michael@0:     bool prepareToEmitMIR(const VarTypeVector &argTypes)
michael@0:     {
michael@0:         JS_ASSERT(locals_.count() == argTypes.length() + varInitializers_.length());
michael@0: 
michael@0:         alloc_  = lifo_.new_<TempAllocator>(&lifo_);
michael@0:         ionContext_.construct(m_.cx(), alloc_);
michael@0: 
michael@0:         graph_  = lifo_.new_<MIRGraph>(alloc_);
michael@0:         info_   = lifo_.new_<CompileInfo>(locals_.count(), SequentialExecution);
michael@0:         const OptimizationInfo *optimizationInfo = js_IonOptimizations.get(Optimization_AsmJS);
michael@0:         const JitCompileOptions options;
michael@0:         mirGen_ = lifo_.new_<MIRGenerator>(CompileCompartment::get(cx()->compartment()),
michael@0:                                            options, alloc_,
michael@0:                                            graph_, info_, optimizationInfo);
michael@0: 
michael@0:         if (!newBlock(/* pred = */ nullptr, &curBlock_, fn_))
michael@0:             return false;
michael@0: 
michael@0:         for (ABIArgTypeIter i = argTypes; !i.done(); i++) {
michael@0:             MAsmJSParameter *ins = MAsmJSParameter::New(alloc(), *i, i.mirType());
michael@0:             curBlock_->add(ins);
michael@0:             curBlock_->initSlot(info().localSlot(i.index()), ins);
michael@0:             if (!mirGen_->ensureBallast())
michael@0:                 return false;
michael@0:         }
michael@0:         unsigned firstLocalSlot = argTypes.length();
michael@0:         for (unsigned i = 0; i < varInitializers_.length(); i++) {
michael@0:             MConstant *ins = MConstant::NewAsmJS(alloc(), varInitializers_[i].value,
michael@0:                                                  varInitializers_[i].type.toMIRType());
michael@0:             curBlock_->add(ins);
michael@0:             curBlock_->initSlot(info().localSlot(firstLocalSlot + i), ins);
michael@0:             if (!mirGen_->ensureBallast())
michael@0:                 return false;
michael@0:         }
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     /******************************* For consistency of returns in a function */
michael@0: 
michael@0:     bool hasAlreadyReturned() const {
michael@0:         return !alreadyReturned_.empty();
michael@0:     }
michael@0: 
michael@0:     RetType returnedType() const {
michael@0:         return alreadyReturned_.ref();
michael@0:     }
michael@0: 
michael@0:     void setReturnedType(RetType retType) {
michael@0:         alreadyReturned_.construct(retType);
michael@0:     }
michael@0: 
michael@0:     /************************* Read-only interface (after local scope setup) */
michael@0: 
michael@0:     MIRGenerator & mirGen() const     { JS_ASSERT(mirGen_); return *mirGen_; }
michael@0:     MIRGraph &     mirGraph() const   { JS_ASSERT(graph_); return *graph_; }
michael@0:     CompileInfo &  info() const       { JS_ASSERT(info_); return *info_; }
michael@0: 
michael@0:     const Local *lookupLocal(PropertyName *name) const
michael@0:     {
michael@0:         if (LocalMap::Ptr p = locals_.lookup(name))
michael@0:             return &p->value();
michael@0:         return nullptr;
michael@0:     }
michael@0: 
michael@0:     MDefinition *getLocalDef(const Local &local)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         return curBlock_->getSlot(info().localSlot(local.slot));
michael@0:     }
michael@0: 
michael@0:     const ModuleCompiler::Global *lookupGlobal(PropertyName *name) const
michael@0:     {
michael@0:         if (locals_.has(name))
michael@0:             return nullptr;
michael@0:         return m_.lookupGlobal(name);
michael@0:     }
michael@0: 
michael@0:     /***************************** Code generation (after local scope setup) */
michael@0: 
michael@0:     MDefinition *constant(Value v, Type t)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         MConstant *constant = MConstant::NewAsmJS(alloc(), v, t.toMIRType());
michael@0:         curBlock_->add(constant);
michael@0:         return constant;
michael@0:     }
michael@0: 
michael@0:     template <class T>
michael@0:     MDefinition *unary(MDefinition *op)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         T *ins = T::NewAsmJS(alloc(), op);
michael@0:         curBlock_->add(ins);
michael@0:         return ins;
michael@0:     }
michael@0: 
michael@0:     template <class T>
michael@0:     MDefinition *unary(MDefinition *op, MIRType type)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         T *ins = T::NewAsmJS(alloc(), op, type);
michael@0:         curBlock_->add(ins);
michael@0:         return ins;
michael@0:     }
michael@0: 
michael@0:     template <class T>
michael@0:     MDefinition *binary(MDefinition *lhs, MDefinition *rhs)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         T *ins = T::New(alloc(), lhs, rhs);
michael@0:         curBlock_->add(ins);
michael@0:         return ins;
michael@0:     }
michael@0: 
michael@0:     template <class T>
michael@0:     MDefinition *binary(MDefinition *lhs, MDefinition *rhs, MIRType type)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         T *ins = T::NewAsmJS(alloc(), lhs, rhs, type);
michael@0:         curBlock_->add(ins);
michael@0:         return ins;
michael@0:     }
michael@0: 
michael@0:     MDefinition *minMax(MDefinition *lhs, MDefinition *rhs, MIRType type, bool isMax) {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         MMinMax *ins = MMinMax::New(alloc(), lhs, rhs, type, isMax);
michael@0:         curBlock_->add(ins);
michael@0:         return ins;
michael@0:     }
michael@0: 
michael@0:     MDefinition *mul(MDefinition *lhs, MDefinition *rhs, MIRType type, MMul::Mode mode)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         MMul *ins = MMul::New(alloc(), lhs, rhs, type, mode);
michael@0:         curBlock_->add(ins);
michael@0:         return ins;
michael@0:     }
michael@0: 
michael@0:     MDefinition *div(MDefinition *lhs, MDefinition *rhs, MIRType type, bool unsignd)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         MDiv *ins = MDiv::NewAsmJS(alloc(), lhs, rhs, type, unsignd);
michael@0:         curBlock_->add(ins);
michael@0:         return ins;
michael@0:     }
michael@0: 
michael@0:     MDefinition *mod(MDefinition *lhs, MDefinition *rhs, MIRType type, bool unsignd)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         MMod *ins = MMod::NewAsmJS(alloc(), lhs, rhs, type, unsignd);
michael@0:         curBlock_->add(ins);
michael@0:         return ins;
michael@0:     }
michael@0: 
michael@0:     template <class T>
michael@0:     MDefinition *bitwise(MDefinition *lhs, MDefinition *rhs)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         T *ins = T::NewAsmJS(alloc(), lhs, rhs);
michael@0:         curBlock_->add(ins);
michael@0:         return ins;
michael@0:     }
michael@0: 
michael@0:     template <class T>
michael@0:     MDefinition *bitwise(MDefinition *op)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         T *ins = T::NewAsmJS(alloc(), op);
michael@0:         curBlock_->add(ins);
michael@0:         return ins;
michael@0:     }
michael@0: 
michael@0:     MDefinition *compare(MDefinition *lhs, MDefinition *rhs, JSOp op, MCompare::CompareType type)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         MCompare *ins = MCompare::NewAsmJS(alloc(), lhs, rhs, op, type);
michael@0:         curBlock_->add(ins);
michael@0:         return ins;
michael@0:     }
michael@0: 
michael@0:     void assign(const Local &local, MDefinition *def)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return;
michael@0:         curBlock_->setSlot(info().localSlot(local.slot), def);
michael@0:     }
michael@0: 
michael@0:     MDefinition *loadHeap(ArrayBufferView::ViewType vt, MDefinition *ptr, NeedsBoundsCheck chk)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         MAsmJSLoadHeap *load = MAsmJSLoadHeap::New(alloc(), vt, ptr);
michael@0:         curBlock_->add(load);
michael@0:         if (chk == NO_BOUNDS_CHECK)
michael@0:             load->setSkipBoundsCheck(true);
michael@0:         return load;
michael@0:     }
michael@0: 
michael@0:     void storeHeap(ArrayBufferView::ViewType vt, MDefinition *ptr, MDefinition *v, NeedsBoundsCheck chk)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return;
michael@0:         MAsmJSStoreHeap *store = MAsmJSStoreHeap::New(alloc(), vt, ptr, v);
michael@0:         curBlock_->add(store);
michael@0:         if (chk == NO_BOUNDS_CHECK)
michael@0:             store->setSkipBoundsCheck(true);
michael@0:     }
michael@0: 
michael@0:     MDefinition *loadGlobalVar(const ModuleCompiler::Global &global)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0: 
michael@0:         uint32_t index = global.varOrConstIndex();
michael@0:         unsigned globalDataOffset = module().globalVarIndexToGlobalDataOffset(index);
michael@0:         MIRType type = global.varOrConstType().toMIRType();
michael@0:         MAsmJSLoadGlobalVar *load = MAsmJSLoadGlobalVar::New(alloc(), type, globalDataOffset,
michael@0:                                                              global.isConst());
michael@0:         curBlock_->add(load);
michael@0:         return load;
michael@0:     }
michael@0: 
michael@0:     void storeGlobalVar(const ModuleCompiler::Global &global, MDefinition *v)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return;
michael@0:         JS_ASSERT(!global.isConst());
michael@0:         unsigned globalDataOffset = module().globalVarIndexToGlobalDataOffset(global.varOrConstIndex());
michael@0:         curBlock_->add(MAsmJSStoreGlobalVar::New(alloc(), globalDataOffset, v));
michael@0:     }
michael@0: 
michael@0:     /***************************************************************** Calls */
michael@0: 
michael@0:     // The IonMonkey backend maintains a single stack offset (from the stack
michael@0:     // pointer to the base of the frame) by adding the total amount of spill
michael@0:     // space required plus the maximum stack required for argument passing.
michael@0:     // Since we do not use IonMonkey's MPrepareCall/MPassArg/MCall, we must
michael@0:     // manually accumulate, for the entire function, the maximum required stack
michael@0:     // space for argument passing. (This is passed to the CodeGenerator via
michael@0:     // MIRGenerator::maxAsmJSStackArgBytes.) Naively, this would just be the
michael@0:     // maximum of the stack space required for each individual call (as
michael@0:     // determined by the call ABI). However, as an optimization, arguments are
michael@0:     // stored to the stack immediately after evaluation (to decrease live
michael@0:     // ranges and reduce spilling). This introduces the complexity that,
michael@0:     // between evaluating an argument and making the call, another argument
michael@0:     // evaluation could perform a call that also needs to store to the stack.
michael@0:     // When this occurs childClobbers_ = true and the parent expression's
michael@0:     // arguments are stored above the maximum depth clobbered by a child
michael@0:     // expression.
michael@0: 
michael@0:     class Call
michael@0:     {
michael@0:         ParseNode *node_;
michael@0:         ABIArgGenerator abi_;
michael@0:         uint32_t prevMaxStackBytes_;
michael@0:         uint32_t maxChildStackBytes_;
michael@0:         uint32_t spIncrement_;
michael@0:         Signature sig_;
michael@0:         MAsmJSCall::Args regArgs_;
michael@0:         js::Vector<MAsmJSPassStackArg*> stackArgs_;
michael@0:         bool childClobbers_;
michael@0: 
michael@0:         friend class FunctionCompiler;
michael@0: 
michael@0:       public:
michael@0:         Call(FunctionCompiler &f, ParseNode *callNode, RetType retType)
michael@0:           : node_(callNode),
michael@0:             prevMaxStackBytes_(0),
michael@0:             maxChildStackBytes_(0),
michael@0:             spIncrement_(0),
michael@0:             sig_(f.m().lifo(), retType),
michael@0:             regArgs_(f.cx()),
michael@0:             stackArgs_(f.cx()),
michael@0:             childClobbers_(false)
michael@0:         { }
michael@0:         Signature &sig() { return sig_; }
michael@0:         const Signature &sig() const { return sig_; }
michael@0:     };
michael@0: 
michael@0:     void startCallArgs(Call *call)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return;
michael@0:         call->prevMaxStackBytes_ = mirGen().resetAsmJSMaxStackArgBytes();
michael@0:     }
michael@0: 
michael@0:     bool passArg(MDefinition *argDef, VarType type, Call *call)
michael@0:     {
michael@0:         if (!call->sig().appendArg(type))
michael@0:             return false;
michael@0: 
michael@0:         if (inDeadCode())
michael@0:             return true;
michael@0: 
michael@0:         uint32_t childStackBytes = mirGen().resetAsmJSMaxStackArgBytes();
michael@0:         call->maxChildStackBytes_ = Max(call->maxChildStackBytes_, childStackBytes);
michael@0:         if (childStackBytes > 0 && !call->stackArgs_.empty())
michael@0:             call->childClobbers_ = true;
michael@0: 
michael@0:         ABIArg arg = call->abi_.next(type.toMIRType());
michael@0:         if (arg.kind() == ABIArg::Stack) {
michael@0:             MAsmJSPassStackArg *mir = MAsmJSPassStackArg::New(alloc(), arg.offsetFromArgBase(),
michael@0:                                                               argDef);
michael@0:             curBlock_->add(mir);
michael@0:             if (!call->stackArgs_.append(mir))
michael@0:                 return false;
michael@0:         } else {
michael@0:             if (!call->regArgs_.append(MAsmJSCall::Arg(arg.reg(), argDef)))
michael@0:                 return false;
michael@0:         }
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     void finishCallArgs(Call *call)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return;
michael@0:         uint32_t parentStackBytes = call->abi_.stackBytesConsumedSoFar();
michael@0:         uint32_t newStackBytes;
michael@0:         if (call->childClobbers_) {
michael@0:             call->spIncrement_ = AlignBytes(call->maxChildStackBytes_, StackAlignment);
michael@0:             for (unsigned i = 0; i < call->stackArgs_.length(); i++)
michael@0:                 call->stackArgs_[i]->incrementOffset(call->spIncrement_);
michael@0:             newStackBytes = Max(call->prevMaxStackBytes_,
michael@0:                                 call->spIncrement_ + parentStackBytes);
michael@0:         } else {
michael@0:             call->spIncrement_ = 0;
michael@0:             newStackBytes = Max(call->prevMaxStackBytes_,
michael@0:                                 Max(call->maxChildStackBytes_, parentStackBytes));
michael@0:         }
michael@0:         mirGen_->setAsmJSMaxStackArgBytes(newStackBytes);
michael@0:     }
michael@0: 
michael@0:   private:
michael@0:     bool callPrivate(MAsmJSCall::Callee callee, const Call &call, MIRType returnType, MDefinition **def)
michael@0:     {
michael@0:         if (inDeadCode()) {
michael@0:             *def = nullptr;
michael@0:             return true;
michael@0:         }
michael@0: 
michael@0:         uint32_t line, column;
michael@0:         m_.tokenStream().srcCoords.lineNumAndColumnIndex(call.node_->pn_pos.begin, &line, &column);
michael@0: 
michael@0:         if (functionNameIndex_ == NO_FUNCTION_NAME_INDEX) {
michael@0:             if (!m_.addFunctionName(FunctionName(fn_), &functionNameIndex_))
michael@0:                 return false;
michael@0:         }
michael@0: 
michael@0:         CallSiteDesc desc(line, column, functionNameIndex_);
michael@0:         MAsmJSCall *ins = MAsmJSCall::New(alloc(), desc, callee, call.regArgs_, returnType,
michael@0:                                           call.spIncrement_);
michael@0:         if (!ins)
michael@0:             return false;
michael@0: 
michael@0:         curBlock_->add(ins);
michael@0:         *def = ins;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:   public:
michael@0:     bool internalCall(const ModuleCompiler::Func &func, const Call &call, MDefinition **def)
michael@0:     {
michael@0:         MIRType returnType = func.sig().retType().toMIRType();
michael@0:         return callPrivate(MAsmJSCall::Callee(func.code()), call, returnType, def);
michael@0:     }
michael@0: 
michael@0:     bool funcPtrCall(const ModuleCompiler::FuncPtrTable &table, MDefinition *index,
michael@0:                      const Call &call, MDefinition **def)
michael@0:     {
michael@0:         if (inDeadCode()) {
michael@0:             *def = nullptr;
michael@0:             return true;
michael@0:         }
michael@0: 
michael@0:         MConstant *mask = MConstant::New(alloc(), Int32Value(table.mask()));
michael@0:         curBlock_->add(mask);
michael@0:         MBitAnd *maskedIndex = MBitAnd::NewAsmJS(alloc(), index, mask);
michael@0:         curBlock_->add(maskedIndex);
michael@0:         MAsmJSLoadFuncPtr *ptrFun = MAsmJSLoadFuncPtr::New(alloc(), table.globalDataOffset(), maskedIndex);
michael@0:         curBlock_->add(ptrFun);
michael@0: 
michael@0:         MIRType returnType = table.sig().retType().toMIRType();
michael@0:         return callPrivate(MAsmJSCall::Callee(ptrFun), call, returnType, def);
michael@0:     }
michael@0: 
michael@0:     bool ffiCall(unsigned exitIndex, const Call &call, MIRType returnType, MDefinition **def)
michael@0:     {
michael@0:         if (inDeadCode()) {
michael@0:             *def = nullptr;
michael@0:             return true;
michael@0:         }
michael@0: 
michael@0:         JS_STATIC_ASSERT(offsetof(AsmJSModule::ExitDatum, exit) == 0);
michael@0:         unsigned globalDataOffset = module().exitIndexToGlobalDataOffset(exitIndex);
michael@0: 
michael@0:         MAsmJSLoadFFIFunc *ptrFun = MAsmJSLoadFFIFunc::New(alloc(), globalDataOffset);
michael@0:         curBlock_->add(ptrFun);
michael@0: 
michael@0:         return callPrivate(MAsmJSCall::Callee(ptrFun), call, returnType, def);
michael@0:     }
michael@0: 
michael@0:     bool builtinCall(AsmJSImmKind builtin, const Call &call, MIRType returnType, MDefinition **def)
michael@0:     {
michael@0:         return callPrivate(MAsmJSCall::Callee(builtin), call, returnType, def);
michael@0:     }
michael@0: 
michael@0:     /*********************************************** Control flow generation */
michael@0: 
michael@0:     inline bool inDeadCode() const {
michael@0:         return curBlock_ == nullptr;
michael@0:     }
michael@0: 
michael@0:     void returnExpr(MDefinition *expr)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return;
michael@0:         MAsmJSReturn *ins = MAsmJSReturn::New(alloc(), expr);
michael@0:         curBlock_->end(ins);
michael@0:         curBlock_ = nullptr;
michael@0:     }
michael@0: 
michael@0:     void returnVoid()
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return;
michael@0:         MAsmJSVoidReturn *ins = MAsmJSVoidReturn::New(alloc());
michael@0:         curBlock_->end(ins);
michael@0:         curBlock_ = nullptr;
michael@0:     }
michael@0: 
michael@0:     bool branchAndStartThen(MDefinition *cond, MBasicBlock **thenBlock, MBasicBlock **elseBlock,
michael@0:                             ParseNode *thenPn, ParseNode* elsePn)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return true;
michael@0: 
michael@0:         bool hasThenBlock = *thenBlock != nullptr;
michael@0:         bool hasElseBlock = *elseBlock != nullptr;
michael@0: 
michael@0:         if (!hasThenBlock && !newBlock(curBlock_, thenBlock, thenPn))
michael@0:             return false;
michael@0:         if (!hasElseBlock && !newBlock(curBlock_, elseBlock, thenPn))
michael@0:             return false;
michael@0: 
michael@0:         curBlock_->end(MTest::New(alloc(), cond, *thenBlock, *elseBlock));
michael@0: 
michael@0:         // Only add as a predecessor if newBlock hasn't been called (as it does it for us)
michael@0:         if (hasThenBlock && !(*thenBlock)->addPredecessor(alloc(), curBlock_))
michael@0:             return false;
michael@0:         if (hasElseBlock && !(*elseBlock)->addPredecessor(alloc(), curBlock_))
michael@0:             return false;
michael@0: 
michael@0:         curBlock_ = *thenBlock;
michael@0:         mirGraph().moveBlockToEnd(curBlock_);
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     void assertCurrentBlockIs(MBasicBlock *block) {
michael@0:         if (inDeadCode())
michael@0:             return;
michael@0:         JS_ASSERT(curBlock_ == block);
michael@0:     }
michael@0: 
michael@0:     bool appendThenBlock(BlockVector *thenBlocks)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return true;
michael@0:         return thenBlocks->append(curBlock_);
michael@0:     }
michael@0: 
michael@0:     bool joinIf(const BlockVector &thenBlocks, MBasicBlock *joinBlock)
michael@0:     {
michael@0:         if (!joinBlock)
michael@0:             return true;
michael@0:         JS_ASSERT_IF(curBlock_, thenBlocks.back() == curBlock_);
michael@0:         for (size_t i = 0; i < thenBlocks.length(); i++) {
michael@0:             thenBlocks[i]->end(MGoto::New(alloc(), joinBlock));
michael@0:             if (!joinBlock->addPredecessor(alloc(), thenBlocks[i]))
michael@0:                 return false;
michael@0:         }
michael@0:         curBlock_ = joinBlock;
michael@0:         mirGraph().moveBlockToEnd(curBlock_);
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     void switchToElse(MBasicBlock *elseBlock)
michael@0:     {
michael@0:         if (!elseBlock)
michael@0:             return;
michael@0:         curBlock_ = elseBlock;
michael@0:         mirGraph().moveBlockToEnd(curBlock_);
michael@0:     }
michael@0: 
michael@0:     bool joinIfElse(const BlockVector &thenBlocks, ParseNode *pn)
michael@0:     {
michael@0:         if (inDeadCode() && thenBlocks.empty())
michael@0:             return true;
michael@0:         MBasicBlock *pred = curBlock_ ? curBlock_ : thenBlocks[0];
michael@0:         MBasicBlock *join;
michael@0:         if (!newBlock(pred, &join, pn))
michael@0:             return false;
michael@0:         if (curBlock_)
michael@0:             curBlock_->end(MGoto::New(alloc(), join));
michael@0:         for (size_t i = 0; i < thenBlocks.length(); i++) {
michael@0:             thenBlocks[i]->end(MGoto::New(alloc(), join));
michael@0:             if (pred == curBlock_ || i > 0) {
michael@0:                 if (!join->addPredecessor(alloc(), thenBlocks[i]))
michael@0:                     return false;
michael@0:             }
michael@0:         }
michael@0:         curBlock_ = join;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     void pushPhiInput(MDefinition *def)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return;
michael@0:         JS_ASSERT(curBlock_->stackDepth() == info().firstStackSlot());
michael@0:         curBlock_->push(def);
michael@0:     }
michael@0: 
michael@0:     MDefinition *popPhiOutput()
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return nullptr;
michael@0:         JS_ASSERT(curBlock_->stackDepth() == info().firstStackSlot() + 1);
michael@0:         return curBlock_->pop();
michael@0:     }
michael@0: 
michael@0:     bool startPendingLoop(ParseNode *pn, MBasicBlock **loopEntry, ParseNode *bodyStmt)
michael@0:     {
michael@0:         if (!loopStack_.append(pn) || !breakableStack_.append(pn))
michael@0:             return false;
michael@0:         JS_ASSERT_IF(curBlock_, curBlock_->loopDepth() == loopStack_.length() - 1);
michael@0:         if (inDeadCode()) {
michael@0:             *loopEntry = nullptr;
michael@0:             return true;
michael@0:         }
michael@0:         *loopEntry = MBasicBlock::NewAsmJS(mirGraph(), info(), curBlock_,
michael@0:                                            MBasicBlock::PENDING_LOOP_HEADER);
michael@0:         if (!*loopEntry)
michael@0:             return false;
michael@0:         mirGraph().addBlock(*loopEntry);
michael@0:         noteBasicBlockPosition(*loopEntry, bodyStmt);
michael@0:         (*loopEntry)->setLoopDepth(loopStack_.length());
michael@0:         curBlock_->end(MGoto::New(alloc(), *loopEntry));
michael@0:         curBlock_ = *loopEntry;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     bool branchAndStartLoopBody(MDefinition *cond, MBasicBlock **afterLoop, ParseNode *bodyPn, ParseNode *afterPn)
michael@0:     {
michael@0:         if (inDeadCode()) {
michael@0:             *afterLoop = nullptr;
michael@0:             return true;
michael@0:         }
michael@0:         JS_ASSERT(curBlock_->loopDepth() > 0);
michael@0:         MBasicBlock *body;
michael@0:         if (!newBlock(curBlock_, &body, bodyPn))
michael@0:             return false;
michael@0:         if (cond->isConstant() && cond->toConstant()->valueToBoolean()) {
michael@0:             *afterLoop = nullptr;
michael@0:             curBlock_->end(MGoto::New(alloc(), body));
michael@0:         } else {
michael@0:             if (!newBlockWithDepth(curBlock_, curBlock_->loopDepth() - 1, afterLoop, afterPn))
michael@0:                 return false;
michael@0:             curBlock_->end(MTest::New(alloc(), cond, body, *afterLoop));
michael@0:         }
michael@0:         curBlock_ = body;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:   private:
michael@0:     ParseNode *popLoop()
michael@0:     {
michael@0:         ParseNode *pn = loopStack_.popCopy();
michael@0:         JS_ASSERT(!unlabeledContinues_.has(pn));
michael@0:         breakableStack_.popBack();
michael@0:         return pn;
michael@0:     }
michael@0: 
michael@0:   public:
michael@0:     bool closeLoop(MBasicBlock *loopEntry, MBasicBlock *afterLoop)
michael@0:     {
michael@0:         ParseNode *pn = popLoop();
michael@0:         if (!loopEntry) {
michael@0:             JS_ASSERT(!afterLoop);
michael@0:             JS_ASSERT(inDeadCode());
michael@0:             JS_ASSERT(!unlabeledBreaks_.has(pn));
michael@0:             return true;
michael@0:         }
michael@0:         JS_ASSERT(loopEntry->loopDepth() == loopStack_.length() + 1);
michael@0:         JS_ASSERT_IF(afterLoop, afterLoop->loopDepth() == loopStack_.length());
michael@0:         if (curBlock_) {
michael@0:             JS_ASSERT(curBlock_->loopDepth() == loopStack_.length() + 1);
michael@0:             curBlock_->end(MGoto::New(alloc(), loopEntry));
michael@0:             if (!loopEntry->setBackedgeAsmJS(curBlock_))
michael@0:                 return false;
michael@0:         }
michael@0:         curBlock_ = afterLoop;
michael@0:         if (curBlock_)
michael@0:             mirGraph().moveBlockToEnd(curBlock_);
michael@0:         return bindUnlabeledBreaks(pn);
michael@0:     }
michael@0: 
michael@0:     bool branchAndCloseDoWhileLoop(MDefinition *cond, MBasicBlock *loopEntry, ParseNode *afterLoopStmt)
michael@0:     {
michael@0:         ParseNode *pn = popLoop();
michael@0:         if (!loopEntry) {
michael@0:             JS_ASSERT(inDeadCode());
michael@0:             JS_ASSERT(!unlabeledBreaks_.has(pn));
michael@0:             return true;
michael@0:         }
michael@0:         JS_ASSERT(loopEntry->loopDepth() == loopStack_.length() + 1);
michael@0:         if (curBlock_) {
michael@0:             JS_ASSERT(curBlock_->loopDepth() == loopStack_.length() + 1);
michael@0:             if (cond->isConstant()) {
michael@0:                 if (cond->toConstant()->valueToBoolean()) {
michael@0:                     curBlock_->end(MGoto::New(alloc(), loopEntry));
michael@0:                     if (!loopEntry->setBackedgeAsmJS(curBlock_))
michael@0:                         return false;
michael@0:                     curBlock_ = nullptr;
michael@0:                 } else {
michael@0:                     MBasicBlock *afterLoop;
michael@0:                     if (!newBlock(curBlock_, &afterLoop, afterLoopStmt))
michael@0:                         return false;
michael@0:                     curBlock_->end(MGoto::New(alloc(), afterLoop));
michael@0:                     curBlock_ = afterLoop;
michael@0:                 }
michael@0:             } else {
michael@0:                 MBasicBlock *afterLoop;
michael@0:                 if (!newBlock(curBlock_, &afterLoop, afterLoopStmt))
michael@0:                     return false;
michael@0:                 curBlock_->end(MTest::New(alloc(), cond, loopEntry, afterLoop));
michael@0:                 if (!loopEntry->setBackedgeAsmJS(curBlock_))
michael@0:                     return false;
michael@0:                 curBlock_ = afterLoop;
michael@0:             }
michael@0:         }
michael@0:         return bindUnlabeledBreaks(pn);
michael@0:     }
michael@0: 
michael@0:     bool bindContinues(ParseNode *pn, const LabelVector *maybeLabels)
michael@0:     {
michael@0:         bool createdJoinBlock = false;
michael@0:         if (UnlabeledBlockMap::Ptr p = unlabeledContinues_.lookup(pn)) {
michael@0:             if (!bindBreaksOrContinues(&p->value(), &createdJoinBlock, pn))
michael@0:                 return false;
michael@0:             unlabeledContinues_.remove(p);
michael@0:         }
michael@0:         return bindLabeledBreaksOrContinues(maybeLabels, &labeledContinues_, &createdJoinBlock, pn);
michael@0:     }
michael@0: 
michael@0:     bool bindLabeledBreaks(const LabelVector *maybeLabels, ParseNode *pn)
michael@0:     {
michael@0:         bool createdJoinBlock = false;
michael@0:         return bindLabeledBreaksOrContinues(maybeLabels, &labeledBreaks_, &createdJoinBlock, pn);
michael@0:     }
michael@0: 
michael@0:     bool addBreak(PropertyName *maybeLabel) {
michael@0:         if (maybeLabel)
michael@0:             return addBreakOrContinue(maybeLabel, &labeledBreaks_);
michael@0:         return addBreakOrContinue(breakableStack_.back(), &unlabeledBreaks_);
michael@0:     }
michael@0: 
michael@0:     bool addContinue(PropertyName *maybeLabel) {
michael@0:         if (maybeLabel)
michael@0:             return addBreakOrContinue(maybeLabel, &labeledContinues_);
michael@0:         return addBreakOrContinue(loopStack_.back(), &unlabeledContinues_);
michael@0:     }
michael@0: 
michael@0:     bool startSwitch(ParseNode *pn, MDefinition *expr, int32_t low, int32_t high,
michael@0:                      MBasicBlock **switchBlock)
michael@0:     {
michael@0:         if (!breakableStack_.append(pn))
michael@0:             return false;
michael@0:         if (inDeadCode()) {
michael@0:             *switchBlock = nullptr;
michael@0:             return true;
michael@0:         }
michael@0:         curBlock_->end(MTableSwitch::New(alloc(), expr, low, high));
michael@0:         *switchBlock = curBlock_;
michael@0:         curBlock_ = nullptr;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     bool startSwitchCase(MBasicBlock *switchBlock, MBasicBlock **next, ParseNode *pn)
michael@0:     {
michael@0:         if (!switchBlock) {
michael@0:             *next = nullptr;
michael@0:             return true;
michael@0:         }
michael@0:         if (!newBlock(switchBlock, next, pn))
michael@0:             return false;
michael@0:         if (curBlock_) {
michael@0:             curBlock_->end(MGoto::New(alloc(), *next));
michael@0:             if (!(*next)->addPredecessor(alloc(), curBlock_))
michael@0:                 return false;
michael@0:         }
michael@0:         curBlock_ = *next;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     bool startSwitchDefault(MBasicBlock *switchBlock, BlockVector *cases, MBasicBlock **defaultBlock, ParseNode *pn)
michael@0:     {
michael@0:         if (!startSwitchCase(switchBlock, defaultBlock, pn))
michael@0:             return false;
michael@0:         if (!*defaultBlock)
michael@0:             return true;
michael@0:         mirGraph().moveBlockToEnd(*defaultBlock);
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     bool joinSwitch(MBasicBlock *switchBlock, const BlockVector &cases, MBasicBlock *defaultBlock)
michael@0:     {
michael@0:         ParseNode *pn = breakableStack_.popCopy();
michael@0:         if (!switchBlock)
michael@0:             return true;
michael@0:         MTableSwitch *mir = switchBlock->lastIns()->toTableSwitch();
michael@0:         size_t defaultIndex = mir->addDefault(defaultBlock);
michael@0:         for (unsigned i = 0; i < cases.length(); i++) {
michael@0:             if (!cases[i])
michael@0:                 mir->addCase(defaultIndex);
michael@0:             else
michael@0:                 mir->addCase(mir->addSuccessor(cases[i]));
michael@0:         }
michael@0:         if (curBlock_) {
michael@0:             MBasicBlock *next;
michael@0:             if (!newBlock(curBlock_, &next, pn))
michael@0:                 return false;
michael@0:             curBlock_->end(MGoto::New(alloc(), next));
michael@0:             curBlock_ = next;
michael@0:         }
michael@0:         return bindUnlabeledBreaks(pn);
michael@0:     }
michael@0: 
michael@0:     /*************************************************************************/
michael@0: 
michael@0:     MIRGenerator *extractMIR()
michael@0:     {
michael@0:         JS_ASSERT(mirGen_ != nullptr);
michael@0:         MIRGenerator *mirGen = mirGen_;
michael@0:         mirGen_ = nullptr;
michael@0:         return mirGen;
michael@0:     }
michael@0: 
michael@0:     /*************************************************************************/
michael@0:   private:
michael@0:     void noteBasicBlockPosition(MBasicBlock *blk, ParseNode *pn)
michael@0:     {
michael@0: #if defined(JS_ION_PERF)
michael@0:         if (pn) {
michael@0:             unsigned line = 0U, column = 0U;
michael@0:             m().tokenStream().srcCoords.lineNumAndColumnIndex(pn->pn_pos.begin, &line, &column);
michael@0:             blk->setLineno(line);
michael@0:             blk->setColumnIndex(column);
michael@0:         }
michael@0: #endif
michael@0:     }
michael@0: 
michael@0:     bool newBlockWithDepth(MBasicBlock *pred, unsigned loopDepth, MBasicBlock **block, ParseNode *pn)
michael@0:     {
michael@0:         *block = MBasicBlock::NewAsmJS(mirGraph(), info(), pred, MBasicBlock::NORMAL);
michael@0:         if (!*block)
michael@0:             return false;
michael@0:         noteBasicBlockPosition(*block, pn);
michael@0:         mirGraph().addBlock(*block);
michael@0:         (*block)->setLoopDepth(loopDepth);
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     bool newBlock(MBasicBlock *pred, MBasicBlock **block, ParseNode *pn)
michael@0:     {
michael@0:         return newBlockWithDepth(pred, loopStack_.length(), block, pn);
michael@0:     }
michael@0: 
michael@0:     bool bindBreaksOrContinues(BlockVector *preds, bool *createdJoinBlock, ParseNode *pn)
michael@0:     {
michael@0:         for (unsigned i = 0; i < preds->length(); i++) {
michael@0:             MBasicBlock *pred = (*preds)[i];
michael@0:             if (*createdJoinBlock) {
michael@0:                 pred->end(MGoto::New(alloc(), curBlock_));
michael@0:                 if (!curBlock_->addPredecessor(alloc(), pred))
michael@0:                     return false;
michael@0:             } else {
michael@0:                 MBasicBlock *next;
michael@0:                 if (!newBlock(pred, &next, pn))
michael@0:                     return false;
michael@0:                 pred->end(MGoto::New(alloc(), next));
michael@0:                 if (curBlock_) {
michael@0:                     curBlock_->end(MGoto::New(alloc(), next));
michael@0:                     if (!next->addPredecessor(alloc(), curBlock_))
michael@0:                         return false;
michael@0:                 }
michael@0:                 curBlock_ = next;
michael@0:                 *createdJoinBlock = true;
michael@0:             }
michael@0:             JS_ASSERT(curBlock_->begin() == curBlock_->end());
michael@0:             if (!mirGen_->ensureBallast())
michael@0:                 return false;
michael@0:         }
michael@0:         preds->clear();
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     bool bindLabeledBreaksOrContinues(const LabelVector *maybeLabels, LabeledBlockMap *map,
michael@0:                                       bool *createdJoinBlock, ParseNode *pn)
michael@0:     {
michael@0:         if (!maybeLabels)
michael@0:             return true;
michael@0:         const LabelVector &labels = *maybeLabels;
michael@0:         for (unsigned i = 0; i < labels.length(); i++) {
michael@0:             if (LabeledBlockMap::Ptr p = map->lookup(labels[i])) {
michael@0:                 if (!bindBreaksOrContinues(&p->value(), createdJoinBlock, pn))
michael@0:                     return false;
michael@0:                 map->remove(p);
michael@0:             }
michael@0:             if (!mirGen_->ensureBallast())
michael@0:                 return false;
michael@0:         }
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     template <class Key, class Map>
michael@0:     bool addBreakOrContinue(Key key, Map *map)
michael@0:     {
michael@0:         if (inDeadCode())
michael@0:             return true;
michael@0:         typename Map::AddPtr p = map->lookupForAdd(key);
michael@0:         if (!p) {
michael@0:             BlockVector empty(m().cx());
michael@0:             if (!map->add(p, key, Move(empty)))
michael@0:                 return false;
michael@0:         }
michael@0:         if (!p->value().append(curBlock_))
michael@0:             return false;
michael@0:         curBlock_ = nullptr;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     bool bindUnlabeledBreaks(ParseNode *pn)
michael@0:     {
michael@0:         bool createdJoinBlock = false;
michael@0:         if (UnlabeledBlockMap::Ptr p = unlabeledBreaks_.lookup(pn)) {
michael@0:             if (!bindBreaksOrContinues(&p->value(), &createdJoinBlock, pn))
michael@0:                 return false;
michael@0:             unlabeledBreaks_.remove(p);
michael@0:         }
michael@0:         return true;
michael@0:     }
michael@0: };
michael@0: 
michael@0: } /* anonymous namespace */
michael@0: 
michael@0: /*****************************************************************************/
michael@0: // asm.js type-checking and code-generation algorithm
michael@0: 
michael@0: static bool
michael@0: CheckIdentifier(ModuleCompiler &m, ParseNode *usepn, PropertyName *name)
michael@0: {
michael@0:     if (name == m.cx()->names().arguments || name == m.cx()->names().eval)
michael@0:         return m.failName(usepn, "'%s' is not an allowed identifier", name);
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckModuleLevelName(ModuleCompiler &m, ParseNode *usepn, PropertyName *name)
michael@0: {
michael@0:     if (!CheckIdentifier(m, usepn, name))
michael@0:         return false;
michael@0: 
michael@0:     if (name == m.moduleFunctionName() ||
michael@0:         name == m.module().globalArgumentName() ||
michael@0:         name == m.module().importArgumentName() ||
michael@0:         name == m.module().bufferArgumentName() ||
michael@0:         m.lookupGlobal(name))
michael@0:     {
michael@0:         return m.failName(usepn, "duplicate name '%s' not allowed", name);
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckFunctionHead(ModuleCompiler &m, ParseNode *fn)
michael@0: {
michael@0:     JSFunction *fun = FunctionObject(fn);
michael@0:     if (fun->hasRest())
michael@0:         return m.fail(fn, "rest args not allowed");
michael@0:     if (fun->isExprClosure())
michael@0:         return m.fail(fn, "expression closures not allowed");
michael@0:     if (fn->pn_funbox->hasDestructuringArgs)
michael@0:         return m.fail(fn, "destructuring args not allowed");
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckArgument(ModuleCompiler &m, ParseNode *arg, PropertyName **name)
michael@0: {
michael@0:     if (!IsDefinition(arg))
michael@0:         return m.fail(arg, "duplicate argument name not allowed");
michael@0: 
michael@0:     if (arg->pn_dflags & PND_DEFAULT)
michael@0:         return m.fail(arg, "default arguments not allowed");
michael@0: 
michael@0:     if (!CheckIdentifier(m, arg, arg->name()))
michael@0:         return false;
michael@0: 
michael@0:     *name = arg->name();
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckModuleArgument(ModuleCompiler &m, ParseNode *arg, PropertyName **name)
michael@0: {
michael@0:     if (!CheckArgument(m, arg, name))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckModuleLevelName(m, arg, *name))
michael@0:         return false;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckModuleArguments(ModuleCompiler &m, ParseNode *fn)
michael@0: {
michael@0:     unsigned numFormals;
michael@0:     ParseNode *arg1 = FunctionArgsList(fn, &numFormals);
michael@0:     ParseNode *arg2 = arg1 ? NextNode(arg1) : nullptr;
michael@0:     ParseNode *arg3 = arg2 ? NextNode(arg2) : nullptr;
michael@0: 
michael@0:     if (numFormals > 3)
michael@0:         return m.fail(fn, "asm.js modules takes at most 3 argument");
michael@0: 
michael@0:     PropertyName *arg1Name = nullptr;
michael@0:     if (numFormals >= 1 && !CheckModuleArgument(m, arg1, &arg1Name))
michael@0:         return false;
michael@0:     m.initGlobalArgumentName(arg1Name);
michael@0: 
michael@0:     PropertyName *arg2Name = nullptr;
michael@0:     if (numFormals >= 2 && !CheckModuleArgument(m, arg2, &arg2Name))
michael@0:         return false;
michael@0:     m.initImportArgumentName(arg2Name);
michael@0: 
michael@0:     PropertyName *arg3Name = nullptr;
michael@0:     if (numFormals >= 3 && !CheckModuleArgument(m, arg3, &arg3Name))
michael@0:         return false;
michael@0:     m.initBufferArgumentName(arg3Name);
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckPrecedingStatements(ModuleCompiler &m, ParseNode *stmtList)
michael@0: {
michael@0:     JS_ASSERT(stmtList->isKind(PNK_STATEMENTLIST));
michael@0: 
michael@0:     if (ListLength(stmtList) != 0)
michael@0:         return m.fail(ListHead(stmtList), "invalid asm.js statement");
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckGlobalVariableInitConstant(ModuleCompiler &m, PropertyName *varName, ParseNode *initNode,
michael@0:                                 bool isConst)
michael@0: {
michael@0:     NumLit literal = ExtractNumericLiteral(m, initNode);
michael@0:     if (!literal.hasType())
michael@0:         return m.fail(initNode, "global initializer is out of representable integer range");
michael@0: 
michael@0:     return m.addGlobalVarInit(varName, literal.varType(), literal.value(), isConst);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckTypeAnnotation(ModuleCompiler &m, ParseNode *coercionNode, AsmJSCoercion *coercion,
michael@0:                     ParseNode **coercedExpr = nullptr)
michael@0: {
michael@0:     switch (coercionNode->getKind()) {
michael@0:       case PNK_BITOR: {
michael@0:         ParseNode *rhs = BinaryRight(coercionNode);
michael@0:         uint32_t i;
michael@0:         if (!IsLiteralInt(m, rhs, &i) || i != 0)
michael@0:             return m.fail(rhs, "must use |0 for argument/return coercion");
michael@0:         *coercion = AsmJS_ToInt32;
michael@0:         if (coercedExpr)
michael@0:             *coercedExpr = BinaryLeft(coercionNode);
michael@0:         return true;
michael@0:       }
michael@0:       case PNK_POS: {
michael@0:         *coercion = AsmJS_ToNumber;
michael@0:         if (coercedExpr)
michael@0:             *coercedExpr = UnaryKid(coercionNode);
michael@0:         return true;
michael@0:       }
michael@0:       case PNK_CALL: {
michael@0:         *coercion = AsmJS_FRound;
michael@0:         if (!IsFloatCoercion(m, coercionNode, coercedExpr))
michael@0:             return m.fail(coercionNode, "call must be to fround coercion");
michael@0:         return true;
michael@0:       }
michael@0:       default:;
michael@0:     }
michael@0: 
michael@0:     return m.fail(coercionNode, "must be of the form +x, fround(x) or x|0");
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckGlobalVariableImportExpr(ModuleCompiler &m, PropertyName *varName, AsmJSCoercion coercion,
michael@0:                               ParseNode *coercedExpr, bool isConst)
michael@0: {
michael@0:     if (!coercedExpr->isKind(PNK_DOT))
michael@0:         return m.failName(coercedExpr, "invalid import expression for global '%s'", varName);
michael@0: 
michael@0:     ParseNode *base = DotBase(coercedExpr);
michael@0:     PropertyName *field = DotMember(coercedExpr);
michael@0: 
michael@0:     PropertyName *importName = m.module().importArgumentName();
michael@0:     if (!importName)
michael@0:         return m.fail(coercedExpr, "cannot import without an asm.js foreign parameter");
michael@0:     if (!IsUseOfName(base, importName))
michael@0:         return m.failName(coercedExpr, "base of import expression must be '%s'", importName);
michael@0: 
michael@0:     return m.addGlobalVarImport(varName, field, coercion, isConst);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckGlobalVariableInitImport(ModuleCompiler &m, PropertyName *varName, ParseNode *initNode,
michael@0:                               bool isConst)
michael@0: {
michael@0:     AsmJSCoercion coercion;
michael@0:     ParseNode *coercedExpr;
michael@0:     if (!CheckTypeAnnotation(m, initNode, &coercion, &coercedExpr))
michael@0:         return false;
michael@0:     return CheckGlobalVariableImportExpr(m, varName, coercion, coercedExpr, isConst);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckNewArrayView(ModuleCompiler &m, PropertyName *varName, ParseNode *newExpr)
michael@0: {
michael@0:     ParseNode *ctorExpr = ListHead(newExpr);
michael@0:     if (!ctorExpr->isKind(PNK_DOT))
michael@0:         return m.fail(ctorExpr, "only valid 'new' import is 'new global.*Array(buf)'");
michael@0: 
michael@0:     ParseNode *base = DotBase(ctorExpr);
michael@0:     PropertyName *field = DotMember(ctorExpr);
michael@0: 
michael@0:     PropertyName *globalName = m.module().globalArgumentName();
michael@0:     if (!globalName)
michael@0:         return m.fail(base, "cannot create array view without an asm.js global parameter");
michael@0:     if (!IsUseOfName(base, globalName))
michael@0:         return m.failName(base, "expecting '%s.*Array", globalName);
michael@0: 
michael@0:     ParseNode *bufArg = NextNode(ctorExpr);
michael@0:     if (!bufArg || NextNode(bufArg) != nullptr)
michael@0:         return m.fail(ctorExpr, "array view constructor takes exactly one argument");
michael@0: 
michael@0:     PropertyName *bufferName = m.module().bufferArgumentName();
michael@0:     if (!bufferName)
michael@0:         return m.fail(bufArg, "cannot create array view without an asm.js heap parameter");
michael@0:     if (!IsUseOfName(bufArg, bufferName))
michael@0:         return m.failName(bufArg, "argument to array view constructor must be '%s'", bufferName);
michael@0: 
michael@0:     JSAtomState &names = m.cx()->names();
michael@0:     ArrayBufferView::ViewType type;
michael@0:     if (field == names.Int8Array)
michael@0:         type = ArrayBufferView::TYPE_INT8;
michael@0:     else if (field == names.Uint8Array)
michael@0:         type = ArrayBufferView::TYPE_UINT8;
michael@0:     else if (field == names.Int16Array)
michael@0:         type = ArrayBufferView::TYPE_INT16;
michael@0:     else if (field == names.Uint16Array)
michael@0:         type = ArrayBufferView::TYPE_UINT16;
michael@0:     else if (field == names.Int32Array)
michael@0:         type = ArrayBufferView::TYPE_INT32;
michael@0:     else if (field == names.Uint32Array)
michael@0:         type = ArrayBufferView::TYPE_UINT32;
michael@0:     else if (field == names.Float32Array)
michael@0:         type = ArrayBufferView::TYPE_FLOAT32;
michael@0:     else if (field == names.Float64Array)
michael@0:         type = ArrayBufferView::TYPE_FLOAT64;
michael@0:     else
michael@0:         return m.fail(ctorExpr, "could not match typed array name");
michael@0: 
michael@0:     return m.addArrayView(varName, type, field);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckGlobalDotImport(ModuleCompiler &m, PropertyName *varName, ParseNode *initNode)
michael@0: {
michael@0:     ParseNode *base = DotBase(initNode);
michael@0:     PropertyName *field = DotMember(initNode);
michael@0: 
michael@0:     if (base->isKind(PNK_DOT)) {
michael@0:         ParseNode *global = DotBase(base);
michael@0:         PropertyName *math = DotMember(base);
michael@0:         if (!IsUseOfName(global, m.module().globalArgumentName()) || math != m.cx()->names().Math)
michael@0:             return m.fail(base, "expecting global.Math");
michael@0: 
michael@0:         ModuleCompiler::MathBuiltin mathBuiltin;
michael@0:         if (!m.lookupStandardLibraryMathName(field, &mathBuiltin))
michael@0:             return m.failName(initNode, "'%s' is not a standard Math builtin", field);
michael@0: 
michael@0:         switch (mathBuiltin.kind) {
michael@0:           case ModuleCompiler::MathBuiltin::Function:
michael@0:             return m.addMathBuiltinFunction(varName, mathBuiltin.u.func, field);
michael@0:           case ModuleCompiler::MathBuiltin::Constant:
michael@0:             return m.addMathBuiltinConstant(varName, mathBuiltin.u.cst, field);
michael@0:           default:
michael@0:             break;
michael@0:         }
michael@0:         MOZ_ASSUME_UNREACHABLE("unexpected or uninitialized math builtin type");
michael@0:     }
michael@0: 
michael@0:     if (IsUseOfName(base, m.module().globalArgumentName())) {
michael@0:         if (field == m.cx()->names().NaN)
michael@0:             return m.addGlobalConstant(varName, GenericNaN(), field);
michael@0:         if (field == m.cx()->names().Infinity)
michael@0:             return m.addGlobalConstant(varName, PositiveInfinity<double>(), field);
michael@0:         return m.failName(initNode, "'%s' is not a standard global constant", field);
michael@0:     }
michael@0: 
michael@0:     if (IsUseOfName(base, m.module().importArgumentName()))
michael@0:         return m.addFFI(varName, field);
michael@0: 
michael@0:     return m.fail(initNode, "expecting c.y where c is either the global or foreign parameter");
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckModuleGlobal(ModuleCompiler &m, ParseNode *var, bool isConst)
michael@0: {
michael@0:     if (!IsDefinition(var))
michael@0:         return m.fail(var, "import variable names must be unique");
michael@0: 
michael@0:     if (!CheckModuleLevelName(m, var, var->name()))
michael@0:         return false;
michael@0: 
michael@0:     ParseNode *initNode = MaybeDefinitionInitializer(var);
michael@0:     if (!initNode)
michael@0:         return m.fail(var, "module import needs initializer");
michael@0: 
michael@0:     if (IsNumericLiteral(m, initNode))
michael@0:         return CheckGlobalVariableInitConstant(m, var->name(), initNode, isConst);
michael@0: 
michael@0:     if (initNode->isKind(PNK_BITOR) || initNode->isKind(PNK_POS) || initNode->isKind(PNK_CALL))
michael@0:         return CheckGlobalVariableInitImport(m, var->name(), initNode, isConst);
michael@0: 
michael@0:     if (initNode->isKind(PNK_NEW))
michael@0:         return CheckNewArrayView(m, var->name(), initNode);
michael@0: 
michael@0:     if (initNode->isKind(PNK_DOT))
michael@0:         return CheckGlobalDotImport(m, var->name(), initNode);
michael@0: 
michael@0:     return m.fail(initNode, "unsupported import expression");
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckModuleGlobals(ModuleCompiler &m)
michael@0: {
michael@0:     while (true) {
michael@0:         ParseNode *varStmt;
michael@0:         if (!ParseVarOrConstStatement(m.parser(), &varStmt))
michael@0:             return false;
michael@0:         if (!varStmt)
michael@0:             break;
michael@0:         for (ParseNode *var = VarListHead(varStmt); var; var = NextNode(var)) {
michael@0:             if (!CheckModuleGlobal(m, var, varStmt->isKind(PNK_CONST)))
michael@0:                 return false;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: ArgFail(FunctionCompiler &f, PropertyName *argName, ParseNode *stmt)
michael@0: {
michael@0:     return f.failName(stmt, "expecting argument type declaration for '%s' of the "
michael@0:                       "form 'arg = arg|0' or 'arg = +arg' or 'arg = fround(arg)'", argName);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckArgumentType(FunctionCompiler &f, ParseNode *stmt, PropertyName *name, VarType *type)
michael@0: {
michael@0:     if (!stmt || !IsExpressionStatement(stmt))
michael@0:         return ArgFail(f, name, stmt ? stmt : f.fn());
michael@0: 
michael@0:     ParseNode *initNode = ExpressionStatementExpr(stmt);
michael@0:     if (!initNode || !initNode->isKind(PNK_ASSIGN))
michael@0:         return ArgFail(f, name, stmt);
michael@0: 
michael@0:     ParseNode *argNode = BinaryLeft(initNode);
michael@0:     ParseNode *coercionNode = BinaryRight(initNode);
michael@0: 
michael@0:     if (!IsUseOfName(argNode, name))
michael@0:         return ArgFail(f, name, stmt);
michael@0: 
michael@0:     ParseNode *coercedExpr;
michael@0:     AsmJSCoercion coercion;
michael@0:     if (!CheckTypeAnnotation(f.m(), coercionNode, &coercion, &coercedExpr))
michael@0:         return false;
michael@0: 
michael@0:     if (!IsUseOfName(coercedExpr, name))
michael@0:         return ArgFail(f, name, stmt);
michael@0: 
michael@0:     *type = VarType(coercion);
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckArguments(FunctionCompiler &f, ParseNode **stmtIter, VarTypeVector *argTypes)
michael@0: {
michael@0:     ParseNode *stmt = *stmtIter;
michael@0: 
michael@0:     unsigned numFormals;
michael@0:     ParseNode *argpn = FunctionArgsList(f.fn(), &numFormals);
michael@0: 
michael@0:     for (unsigned i = 0; i < numFormals; i++, argpn = NextNode(argpn), stmt = NextNode(stmt)) {
michael@0:         PropertyName *name;
michael@0:         if (!CheckArgument(f.m(), argpn, &name))
michael@0:             return false;
michael@0: 
michael@0:         VarType type;
michael@0:         if (!CheckArgumentType(f, stmt, name, &type))
michael@0:             return false;
michael@0: 
michael@0:         if (!argTypes->append(type))
michael@0:             return false;
michael@0: 
michael@0:         if (!f.addFormal(argpn, name, type))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     *stmtIter = stmt;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckFinalReturn(FunctionCompiler &f, ParseNode *stmt, RetType *retType)
michael@0: {
michael@0:     if (stmt && stmt->isKind(PNK_RETURN)) {
michael@0:         if (ParseNode *coercionNode = UnaryKid(stmt)) {
michael@0:             if (IsNumericLiteral(f.m(), coercionNode)) {
michael@0:                 switch (ExtractNumericLiteral(f.m(), coercionNode).which()) {
michael@0:                   case NumLit::BigUnsigned:
michael@0:                   case NumLit::OutOfRangeInt:
michael@0:                     return f.fail(coercionNode, "returned literal is out of integer range");
michael@0:                   case NumLit::Fixnum:
michael@0:                   case NumLit::NegativeInt:
michael@0:                     *retType = RetType::Signed;
michael@0:                     break;
michael@0:                   case NumLit::Double:
michael@0:                     *retType = RetType::Double;
michael@0:                     break;
michael@0:                   case NumLit::Float:
michael@0:                     *retType = RetType::Float;
michael@0:                     break;
michael@0:                 }
michael@0:                 return true;
michael@0:             }
michael@0: 
michael@0:             AsmJSCoercion coercion;
michael@0:             if (!CheckTypeAnnotation(f.m(), coercionNode, &coercion))
michael@0:                 return false;
michael@0: 
michael@0:             *retType = RetType(coercion);
michael@0:             return true;
michael@0:         }
michael@0: 
michael@0:         *retType = RetType::Void;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     *retType = RetType::Void;
michael@0:     f.returnVoid();
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckVariable(FunctionCompiler &f, ParseNode *var)
michael@0: {
michael@0:     if (!IsDefinition(var))
michael@0:         return f.fail(var, "local variable names must not restate argument names");
michael@0: 
michael@0:     PropertyName *name = var->name();
michael@0: 
michael@0:     if (!CheckIdentifier(f.m(), var, name))
michael@0:         return false;
michael@0: 
michael@0:     ParseNode *initNode = MaybeDefinitionInitializer(var);
michael@0:     if (!initNode)
michael@0:         return f.failName(var, "var '%s' needs explicit type declaration via an initial value", name);
michael@0: 
michael@0:     if (initNode->isKind(PNK_NAME)) {
michael@0:         PropertyName *initName = initNode->name();
michael@0:         if (const ModuleCompiler::Global *global = f.lookupGlobal(initName)) {
michael@0:             if (global->which() != ModuleCompiler::Global::ConstantLiteral)
michael@0:                 return f.failName(initNode, "'%s' isn't a possible global variable initializer, "
michael@0:                                             "needs to be a const numeric literal", initName);
michael@0:             return f.addVariable(var, name, global->varOrConstType(), global->constLiteralValue());
michael@0:         }
michael@0:         return f.failName(initNode, "'%s' needs to be a global name", initName);
michael@0:     }
michael@0: 
michael@0:     if (!IsNumericLiteral(f.m(), initNode))
michael@0:         return f.failName(initNode, "initializer for '%s' needs to be a numeric literal or a global const literal", name);
michael@0: 
michael@0:     NumLit literal = ExtractNumericLiteral(f.m(), initNode);
michael@0:     if (!literal.hasType())
michael@0:         return f.failName(initNode, "initializer for '%s' is out of range", name);
michael@0: 
michael@0:     return f.addVariable(var, name, literal.varType(), literal.value());
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckVariables(FunctionCompiler &f, ParseNode **stmtIter)
michael@0: {
michael@0:     ParseNode *stmt = *stmtIter;
michael@0: 
michael@0:     for (; stmt && stmt->isKind(PNK_VAR); stmt = NextNonEmptyStatement(stmt)) {
michael@0:         for (ParseNode *var = VarListHead(stmt); var; var = NextNode(var)) {
michael@0:             if (!CheckVariable(f, var))
michael@0:                 return false;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     *stmtIter = stmt;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckExpr(FunctionCompiler &f, ParseNode *expr, MDefinition **def, Type *type);
michael@0: 
michael@0: static bool
michael@0: CheckNumericLiteral(FunctionCompiler &f, ParseNode *num, MDefinition **def, Type *type)
michael@0: {
michael@0:     NumLit literal = ExtractNumericLiteral(f.m(), num);
michael@0:     if (!literal.hasType())
michael@0:         return f.fail(num, "numeric literal out of representable integer range");
michael@0: 
michael@0:     *type = literal.type();
michael@0:     *def = f.constant(literal.value(), literal.type());
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckVarRef(FunctionCompiler &f, ParseNode *varRef, MDefinition **def, Type *type)
michael@0: {
michael@0:     PropertyName *name = varRef->name();
michael@0: 
michael@0:     if (const FunctionCompiler::Local *local = f.lookupLocal(name)) {
michael@0:         *def = f.getLocalDef(*local);
michael@0:         *type = local->type.toType();
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (const ModuleCompiler::Global *global = f.lookupGlobal(name)) {
michael@0:         switch (global->which()) {
michael@0:           case ModuleCompiler::Global::ConstantLiteral:
michael@0:             *def = f.constant(global->constLiteralValue(), global->varOrConstType().toType());
michael@0:             *type = global->varOrConstType().toType();
michael@0:             break;
michael@0:           case ModuleCompiler::Global::ConstantImport:
michael@0:           case ModuleCompiler::Global::Variable:
michael@0:             *def = f.loadGlobalVar(*global);
michael@0:             *type = global->varOrConstType().toType();
michael@0:             break;
michael@0:           case ModuleCompiler::Global::Function:
michael@0:           case ModuleCompiler::Global::FFI:
michael@0:           case ModuleCompiler::Global::MathBuiltinFunction:
michael@0:           case ModuleCompiler::Global::FuncPtrTable:
michael@0:           case ModuleCompiler::Global::ArrayView:
michael@0:             return f.failName(varRef, "'%s' may not be accessed by ordinary expressions", name);
michael@0:         }
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     return f.failName(varRef, "'%s' not found in local or asm.js module scope", name);
michael@0: }
michael@0: 
michael@0: static inline bool
michael@0: IsLiteralOrConstInt(FunctionCompiler &f, ParseNode *pn, uint32_t *u32)
michael@0: {
michael@0:     if (IsLiteralInt(f.m(), pn, u32))
michael@0:         return true;
michael@0: 
michael@0:     if (pn->getKind() != PNK_NAME)
michael@0:         return false;
michael@0: 
michael@0:     PropertyName *name = pn->name();
michael@0:     const ModuleCompiler::Global *global = f.lookupGlobal(name);
michael@0:     if (!global || global->which() != ModuleCompiler::Global::ConstantLiteral)
michael@0:         return false;
michael@0: 
michael@0:     const Value &v = global->constLiteralValue();
michael@0:     if (!v.isInt32())
michael@0:         return false;
michael@0: 
michael@0:     *u32 = (uint32_t) v.toInt32();
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: FoldMaskedArrayIndex(FunctionCompiler &f, ParseNode **indexExpr, int32_t *mask,
michael@0:                      NeedsBoundsCheck *needsBoundsCheck)
michael@0: {
michael@0:     ParseNode *indexNode = BinaryLeft(*indexExpr);
michael@0:     ParseNode *maskNode = BinaryRight(*indexExpr);
michael@0: 
michael@0:     uint32_t mask2;
michael@0:     if (IsLiteralOrConstInt(f, maskNode, &mask2)) {
michael@0:         // Flag the access to skip the bounds check if the mask ensures that an 'out of
michael@0:         // bounds' access can not occur based on the current heap length constraint.
michael@0:         if (mask2 == 0 ||
michael@0:             CountLeadingZeroes32(f.m().minHeapLength() - 1) <= CountLeadingZeroes32(mask2)) {
michael@0:             *needsBoundsCheck = NO_BOUNDS_CHECK;
michael@0:         }
michael@0:         *mask &= mask2;
michael@0:         *indexExpr = indexNode;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     return false;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckArrayAccess(FunctionCompiler &f, ParseNode *elem, ArrayBufferView::ViewType *viewType,
michael@0:                  MDefinition **def, NeedsBoundsCheck *needsBoundsCheck)
michael@0: {
michael@0:     ParseNode *viewName = ElemBase(elem);
michael@0:     ParseNode *indexExpr = ElemIndex(elem);
michael@0:     *needsBoundsCheck = NEEDS_BOUNDS_CHECK;
michael@0: 
michael@0:     if (!viewName->isKind(PNK_NAME))
michael@0:         return f.fail(viewName, "base of array access must be a typed array view name");
michael@0: 
michael@0:     const ModuleCompiler::Global *global = f.lookupGlobal(viewName->name());
michael@0:     if (!global || global->which() != ModuleCompiler::Global::ArrayView)
michael@0:         return f.fail(viewName, "base of array access must be a typed array view name");
michael@0: 
michael@0:     *viewType = global->viewType();
michael@0: 
michael@0:     uint32_t pointer;
michael@0:     if (IsLiteralOrConstInt(f, indexExpr, &pointer)) {
michael@0:         if (pointer > (uint32_t(INT32_MAX) >> TypedArrayShift(*viewType)))
michael@0:             return f.fail(indexExpr, "constant index out of range");
michael@0:         pointer <<= TypedArrayShift(*viewType);
michael@0:         // It is adequate to note pointer+1 rather than rounding up to the next
michael@0:         // access-size boundary because access is always aligned and the constraint
michael@0:         // will be rounded up to a larger alignment later.
michael@0:         f.m().requireHeapLengthToBeAtLeast(uint32_t(pointer) + 1);
michael@0:         *needsBoundsCheck = NO_BOUNDS_CHECK;
michael@0:         *def = f.constant(Int32Value(pointer), Type::Int);
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     // Mask off the low bits to account for the clearing effect of a right shift
michael@0:     // followed by the left shift implicit in the array access. E.g., H32[i>>2]
michael@0:     // loses the low two bits.
michael@0:     int32_t mask = ~((uint32_t(1) << TypedArrayShift(*viewType)) - 1);
michael@0: 
michael@0:     MDefinition *pointerDef;
michael@0:     if (indexExpr->isKind(PNK_RSH)) {
michael@0:         ParseNode *shiftNode = BinaryRight(indexExpr);
michael@0:         ParseNode *pointerNode = BinaryLeft(indexExpr);
michael@0: 
michael@0:         uint32_t shift;
michael@0:         if (!IsLiteralInt(f.m(), shiftNode, &shift))
michael@0:             return f.failf(shiftNode, "shift amount must be constant");
michael@0: 
michael@0:         unsigned requiredShift = TypedArrayShift(*viewType);
michael@0:         if (shift != requiredShift)
michael@0:             return f.failf(shiftNode, "shift amount must be %u", requiredShift);
michael@0: 
michael@0:         if (pointerNode->isKind(PNK_BITAND))
michael@0:             FoldMaskedArrayIndex(f, &pointerNode, &mask, needsBoundsCheck);
michael@0: 
michael@0:         // Fold a 'literal constant right shifted' now, and skip the bounds check if
michael@0:         // currently possible. This handles the optimization of many of these uses without
michael@0:         // the need for range analysis, and saves the generation of a MBitAnd op.
michael@0:         if (IsLiteralOrConstInt(f, pointerNode, &pointer) && pointer <= uint32_t(INT32_MAX)) {
michael@0:             // Cases: b[c>>n], and b[(c&m)>>n]
michael@0:             pointer &= mask;
michael@0:             if (pointer < f.m().minHeapLength())
michael@0:                 *needsBoundsCheck = NO_BOUNDS_CHECK;
michael@0:             *def = f.constant(Int32Value(pointer), Type::Int);
michael@0:             return true;
michael@0:         }
michael@0: 
michael@0:         Type pointerType;
michael@0:         if (!CheckExpr(f, pointerNode, &pointerDef, &pointerType))
michael@0:             return false;
michael@0: 
michael@0:         if (!pointerType.isIntish())
michael@0:             return f.failf(indexExpr, "%s is not a subtype of int", pointerType.toChars());
michael@0:     } else {
michael@0:         if (TypedArrayShift(*viewType) != 0)
michael@0:             return f.fail(indexExpr, "index expression isn't shifted; must be an Int8/Uint8 access");
michael@0: 
michael@0:         JS_ASSERT(mask == -1);
michael@0:         bool folded = false;
michael@0: 
michael@0:         if (indexExpr->isKind(PNK_BITAND))
michael@0:             folded = FoldMaskedArrayIndex(f, &indexExpr, &mask, needsBoundsCheck);
michael@0: 
michael@0:         Type pointerType;
michael@0:         if (!CheckExpr(f, indexExpr, &pointerDef, &pointerType))
michael@0:             return false;
michael@0: 
michael@0:         if (folded) {
michael@0:             if (!pointerType.isIntish())
michael@0:                 return f.failf(indexExpr, "%s is not a subtype of intish", pointerType.toChars());
michael@0:         } else {
michael@0:             if (!pointerType.isInt())
michael@0:                 return f.failf(indexExpr, "%s is not a subtype of int", pointerType.toChars());
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Don't generate the mask op if there is no need for it which could happen for
michael@0:     // a shift of zero.
michael@0:     if (mask == -1)
michael@0:         *def = pointerDef;
michael@0:     else
michael@0:         *def = f.bitwise<MBitAnd>(pointerDef, f.constant(Int32Value(mask), Type::Int));
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckLoadArray(FunctionCompiler &f, ParseNode *elem, MDefinition **def, Type *type)
michael@0: {
michael@0:     ArrayBufferView::ViewType viewType;
michael@0:     MDefinition *pointerDef;
michael@0:     NeedsBoundsCheck needsBoundsCheck;
michael@0:     if (!CheckArrayAccess(f, elem, &viewType, &pointerDef, &needsBoundsCheck))
michael@0:         return false;
michael@0: 
michael@0:     *def = f.loadHeap(viewType, pointerDef, needsBoundsCheck);
michael@0:     *type = TypedArrayLoadType(viewType);
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckStoreArray(FunctionCompiler &f, ParseNode *lhs, ParseNode *rhs, MDefinition **def, Type *type)
michael@0: {
michael@0:     ArrayBufferView::ViewType viewType;
michael@0:     MDefinition *pointerDef;
michael@0:     NeedsBoundsCheck needsBoundsCheck;
michael@0:     if (!CheckArrayAccess(f, lhs, &viewType, &pointerDef, &needsBoundsCheck))
michael@0:         return false;
michael@0: 
michael@0:     MDefinition *rhsDef;
michael@0:     Type rhsType;
michael@0:     if (!CheckExpr(f, rhs, &rhsDef, &rhsType))
michael@0:         return false;
michael@0: 
michael@0:     switch (viewType) {
michael@0:       case ArrayBufferView::TYPE_INT8:
michael@0:       case ArrayBufferView::TYPE_INT16:
michael@0:       case ArrayBufferView::TYPE_INT32:
michael@0:       case ArrayBufferView::TYPE_UINT8:
michael@0:       case ArrayBufferView::TYPE_UINT16:
michael@0:       case ArrayBufferView::TYPE_UINT32:
michael@0:         if (!rhsType.isIntish())
michael@0:             return f.failf(lhs, "%s is not a subtype of intish", rhsType.toChars());
michael@0:         break;
michael@0:       case ArrayBufferView::TYPE_FLOAT32:
michael@0:         if (rhsType.isMaybeDouble())
michael@0:             rhsDef = f.unary<MToFloat32>(rhsDef);
michael@0:         else if (!rhsType.isFloatish())
michael@0:             return f.failf(lhs, "%s is not a subtype of double? or floatish", rhsType.toChars());
michael@0:         break;
michael@0:       case ArrayBufferView::TYPE_FLOAT64:
michael@0:         if (rhsType.isFloat())
michael@0:             rhsDef = f.unary<MToDouble>(rhsDef);
michael@0:         else if (!rhsType.isMaybeDouble())
michael@0:             return f.failf(lhs, "%s is not a subtype of float or double?", rhsType.toChars());
michael@0:         break;
michael@0:       default:
michael@0:         MOZ_ASSUME_UNREACHABLE("Unexpected view type");
michael@0:     }
michael@0: 
michael@0:     f.storeHeap(viewType, pointerDef, rhsDef, needsBoundsCheck);
michael@0: 
michael@0:     *def = rhsDef;
michael@0:     *type = rhsType;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckAssignName(FunctionCompiler &f, ParseNode *lhs, ParseNode *rhs, MDefinition **def, Type *type)
michael@0: {
michael@0:     Rooted<PropertyName *> name(f.cx(), lhs->name());
michael@0: 
michael@0:     MDefinition *rhsDef;
michael@0:     Type rhsType;
michael@0:     if (!CheckExpr(f, rhs, &rhsDef, &rhsType))
michael@0:         return false;
michael@0: 
michael@0:     if (const FunctionCompiler::Local *lhsVar = f.lookupLocal(name)) {
michael@0:         if (!(rhsType <= lhsVar->type)) {
michael@0:             return f.failf(lhs, "%s is not a subtype of %s",
michael@0:                            rhsType.toChars(), lhsVar->type.toType().toChars());
michael@0:         }
michael@0:         f.assign(*lhsVar, rhsDef);
michael@0:     } else if (const ModuleCompiler::Global *global = f.lookupGlobal(name)) {
michael@0:         if (global->which() != ModuleCompiler::Global::Variable)
michael@0:             return f.failName(lhs, "'%s' is not a mutable variable", name);
michael@0:         if (!(rhsType <= global->varOrConstType())) {
michael@0:             return f.failf(lhs, "%s is not a subtype of %s",
michael@0:                            rhsType.toChars(), global->varOrConstType().toType().toChars());
michael@0:         }
michael@0:         f.storeGlobalVar(*global, rhsDef);
michael@0:     } else {
michael@0:         return f.failName(lhs, "'%s' not found in local or asm.js module scope", name);
michael@0:     }
michael@0: 
michael@0:     *def = rhsDef;
michael@0:     *type = rhsType;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckAssign(FunctionCompiler &f, ParseNode *assign, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(assign->isKind(PNK_ASSIGN));
michael@0:     ParseNode *lhs = BinaryLeft(assign);
michael@0:     ParseNode *rhs = BinaryRight(assign);
michael@0: 
michael@0:     if (lhs->getKind() == PNK_ELEM)
michael@0:         return CheckStoreArray(f, lhs, rhs, def, type);
michael@0: 
michael@0:     if (lhs->getKind() == PNK_NAME)
michael@0:         return CheckAssignName(f, lhs, rhs, def, type);
michael@0: 
michael@0:     return f.fail(assign, "left-hand side of assignment must be a variable or array access");
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckMathIMul(FunctionCompiler &f, ParseNode *call, RetType retType, MDefinition **def, Type *type)
michael@0: {
michael@0:     if (CallArgListLength(call) != 2)
michael@0:         return f.fail(call, "Math.imul must be passed 2 arguments");
michael@0: 
michael@0:     ParseNode *lhs = CallArgList(call);
michael@0:     ParseNode *rhs = NextNode(lhs);
michael@0: 
michael@0:     MDefinition *lhsDef;
michael@0:     Type lhsType;
michael@0:     if (!CheckExpr(f, lhs, &lhsDef, &lhsType))
michael@0:         return false;
michael@0: 
michael@0:     MDefinition *rhsDef;
michael@0:     Type rhsType;
michael@0:     if (!CheckExpr(f, rhs, &rhsDef, &rhsType))
michael@0:         return false;
michael@0: 
michael@0:     if (!lhsType.isIntish())
michael@0:         return f.failf(lhs, "%s is not a subtype of intish", lhsType.toChars());
michael@0:     if (!rhsType.isIntish())
michael@0:         return f.failf(rhs, "%s is not a subtype of intish", rhsType.toChars());
michael@0:     if (retType != RetType::Signed)
michael@0:         return f.failf(call, "return type is signed, used as %s", retType.toType().toChars());
michael@0: 
michael@0:     *def = f.mul(lhsDef, rhsDef, MIRType_Int32, MMul::Integer);
michael@0:     *type = Type::Signed;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckMathAbs(FunctionCompiler &f, ParseNode *call, RetType retType, MDefinition **def, Type *type)
michael@0: {
michael@0:     if (CallArgListLength(call) != 1)
michael@0:         return f.fail(call, "Math.abs must be passed 1 argument");
michael@0: 
michael@0:     ParseNode *arg = CallArgList(call);
michael@0: 
michael@0:     MDefinition *argDef;
michael@0:     Type argType;
michael@0:     if (!CheckExpr(f, arg, &argDef, &argType))
michael@0:         return false;
michael@0: 
michael@0:     if (argType.isSigned()) {
michael@0:         if (retType != RetType::Signed)
michael@0:             return f.failf(call, "return type is signed, used as %s", retType.toType().toChars());
michael@0:         *def = f.unary<MAbs>(argDef, MIRType_Int32);
michael@0:         *type = Type::Signed;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (argType.isMaybeDouble()) {
michael@0:         if (retType != RetType::Double)
michael@0:             return f.failf(call, "return type is double, used as %s", retType.toType().toChars());
michael@0:         *def = f.unary<MAbs>(argDef, MIRType_Double);
michael@0:         *type = Type::Double;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (argType.isMaybeFloat()) {
michael@0:         if (retType != RetType::Float)
michael@0:             return f.failf(call, "return type is float, used as %s", retType.toType().toChars());
michael@0:         *def = f.unary<MAbs>(argDef, MIRType_Float32);
michael@0:         *type = Type::Float;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     return f.failf(call, "%s is not a subtype of signed, float? or double?", argType.toChars());
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckMathSqrt(FunctionCompiler &f, ParseNode *call, RetType retType, MDefinition **def, Type *type)
michael@0: {
michael@0:     if (CallArgListLength(call) != 1)
michael@0:         return f.fail(call, "Math.sqrt must be passed 1 argument");
michael@0: 
michael@0:     ParseNode *arg = CallArgList(call);
michael@0: 
michael@0:     MDefinition *argDef;
michael@0:     Type argType;
michael@0:     if (!CheckExpr(f, arg, &argDef, &argType))
michael@0:         return false;
michael@0: 
michael@0:     if (argType.isMaybeDouble()) {
michael@0:         if (retType != RetType::Double)
michael@0:             return f.failf(call, "return type is double, used as %s", retType.toType().toChars());
michael@0:         *def = f.unary<MSqrt>(argDef, MIRType_Double);
michael@0:         *type = Type::Double;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (argType.isMaybeFloat()) {
michael@0:         if (retType != RetType::Float)
michael@0:             return f.failf(call, "return type is float, used as %s", retType.toType().toChars());
michael@0:         *def = f.unary<MSqrt>(argDef, MIRType_Float32);
michael@0:         *type = Type::Float;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     return f.failf(call, "%s is neither a subtype of double? nor float?", argType.toChars());
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckMathMinMax(FunctionCompiler &f, ParseNode *callNode, RetType retType, MDefinition **def, Type *type, bool isMax)
michael@0: {
michael@0:     if (CallArgListLength(callNode) < 2)
michael@0:         return f.fail(callNode, "Math.min/max must be passed at least 2 arguments");
michael@0: 
michael@0:     ParseNode *firstArg = CallArgList(callNode);
michael@0:     MDefinition *firstDef;
michael@0:     Type firstType;
michael@0:     if (!CheckExpr(f, firstArg, &firstDef, &firstType))
michael@0:         return false;
michael@0: 
michael@0:     bool opIsDouble = firstType.isMaybeDouble();
michael@0:     bool opIsInteger = firstType.isInt();
michael@0:     MIRType opType = firstType.toMIRType();
michael@0: 
michael@0:     if (!opIsDouble && !opIsInteger)
michael@0:         return f.failf(firstArg, "%s is not a subtype of double? or int", firstType.toChars());
michael@0: 
michael@0:     MDefinition *lastDef = firstDef;
michael@0:     ParseNode *nextArg = NextNode(firstArg);
michael@0:     for (unsigned i = 1; i < CallArgListLength(callNode); i++, nextArg = NextNode(nextArg)) {
michael@0:         MDefinition *nextDef;
michael@0:         Type nextType;
michael@0:         if (!CheckExpr(f, nextArg, &nextDef, &nextType))
michael@0:             return false;
michael@0: 
michael@0:         if (opIsDouble && !nextType.isMaybeDouble())
michael@0:             return f.failf(nextArg, "%s is not a subtype of double?", nextType.toChars());
michael@0:         if (opIsInteger && !nextType.isInt())
michael@0:             return f.failf(nextArg, "%s is not a subtype of int", nextType.toChars());
michael@0: 
michael@0:         lastDef = f.minMax(lastDef, nextDef, opType, isMax);
michael@0:     }
michael@0: 
michael@0:     if (opIsDouble && retType != RetType::Double)
michael@0:         return f.failf(callNode, "return type is double, used as %s", retType.toType().toChars());
michael@0:     if (opIsInteger && retType != RetType::Signed)
michael@0:         return f.failf(callNode, "return type is int, used as %s", retType.toType().toChars());
michael@0: 
michael@0:     *type = opIsDouble ? Type::Double : Type::Signed;
michael@0:     *def = lastDef;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: typedef bool (*CheckArgType)(FunctionCompiler &f, ParseNode *argNode, Type type);
michael@0: 
michael@0: static bool
michael@0: CheckCallArgs(FunctionCompiler &f, ParseNode *callNode, CheckArgType checkArg,
michael@0:               FunctionCompiler::Call *call)
michael@0: {
michael@0:     f.startCallArgs(call);
michael@0: 
michael@0:     ParseNode *argNode = CallArgList(callNode);
michael@0:     for (unsigned i = 0; i < CallArgListLength(callNode); i++, argNode = NextNode(argNode)) {
michael@0:         MDefinition *def;
michael@0:         Type type;
michael@0:         if (!CheckExpr(f, argNode, &def, &type))
michael@0:             return false;
michael@0: 
michael@0:         if (!checkArg(f, argNode, type))
michael@0:             return false;
michael@0: 
michael@0:         if (!f.passArg(def, VarType::FromCheckedType(type), call))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     f.finishCallArgs(call);
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckSignatureAgainstExisting(ModuleCompiler &m, ParseNode *usepn, const Signature &sig,
michael@0:                               const Signature &existing)
michael@0: {
michael@0:     if (sig.args().length() != existing.args().length()) {
michael@0:         return m.failf(usepn, "incompatible number of arguments (%u here vs. %u before)",
michael@0:                        sig.args().length(), existing.args().length());
michael@0:     }
michael@0: 
michael@0:     for (unsigned i = 0; i < sig.args().length(); i++) {
michael@0:         if (sig.arg(i) != existing.arg(i)) {
michael@0:             return m.failf(usepn, "incompatible type for argument %u: (%s here vs. %s before)",
michael@0:                            i, sig.arg(i).toType().toChars(), existing.arg(i).toType().toChars());
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (sig.retType() != existing.retType()) {
michael@0:         return m.failf(usepn, "%s incompatible with previous return of type %s",
michael@0:                        sig.retType().toType().toChars(), existing.retType().toType().toChars());
michael@0:     }
michael@0: 
michael@0:     JS_ASSERT(sig == existing);
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckFunctionSignature(ModuleCompiler &m, ParseNode *usepn, Signature &&sig, PropertyName *name,
michael@0:                        ModuleCompiler::Func **func)
michael@0: {
michael@0:     ModuleCompiler::Func *existing = m.lookupFunction(name);
michael@0:     if (!existing) {
michael@0:         if (!CheckModuleLevelName(m, usepn, name))
michael@0:             return false;
michael@0:         return m.addFunction(name, Move(sig), func);
michael@0:     }
michael@0: 
michael@0:     if (!CheckSignatureAgainstExisting(m, usepn, sig, existing->sig()))
michael@0:         return false;
michael@0: 
michael@0:     *func = existing;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckIsVarType(FunctionCompiler &f, ParseNode *argNode, Type type)
michael@0: {
michael@0:     if (!type.isVarType())
michael@0:         return f.failf(argNode, "%s is not a subtype of int, float or double", type.toChars());
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckInternalCall(FunctionCompiler &f, ParseNode *callNode, PropertyName *calleeName,
michael@0:                   RetType retType, MDefinition **def, Type *type)
michael@0: {
michael@0:     FunctionCompiler::Call call(f, callNode, retType);
michael@0: 
michael@0:     if (!CheckCallArgs(f, callNode, CheckIsVarType, &call))
michael@0:         return false;
michael@0: 
michael@0:     ModuleCompiler::Func *callee;
michael@0:     if (!CheckFunctionSignature(f.m(), callNode, Move(call.sig()), calleeName, &callee))
michael@0:         return false;
michael@0: 
michael@0:     if (!f.internalCall(*callee, call, def))
michael@0:         return false;
michael@0: 
michael@0:     *type = retType.toType();
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckFuncPtrTableAgainstExisting(ModuleCompiler &m, ParseNode *usepn,
michael@0:                                  PropertyName *name, Signature &&sig, unsigned mask,
michael@0:                                  ModuleCompiler::FuncPtrTable **tableOut)
michael@0: {
michael@0:     if (const ModuleCompiler::Global *existing = m.lookupGlobal(name)) {
michael@0:         if (existing->which() != ModuleCompiler::Global::FuncPtrTable)
michael@0:             return m.failName(usepn, "'%s' is not a function-pointer table", name);
michael@0: 
michael@0:         ModuleCompiler::FuncPtrTable &table = m.funcPtrTable(existing->funcPtrTableIndex());
michael@0:         if (mask != table.mask())
michael@0:             return m.failf(usepn, "mask does not match previous value (%u)", table.mask());
michael@0: 
michael@0:         if (!CheckSignatureAgainstExisting(m, usepn, sig, table.sig()))
michael@0:             return false;
michael@0: 
michael@0:         *tableOut = &table;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (!CheckModuleLevelName(m, usepn, name))
michael@0:         return false;
michael@0: 
michael@0:     return m.addFuncPtrTable(name, Move(sig), mask, tableOut);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckFuncPtrCall(FunctionCompiler &f, ParseNode *callNode, RetType retType, MDefinition **def, Type *type)
michael@0: {
michael@0:     ParseNode *callee = CallCallee(callNode);
michael@0:     ParseNode *tableNode = ElemBase(callee);
michael@0:     ParseNode *indexExpr = ElemIndex(callee);
michael@0: 
michael@0:     if (!tableNode->isKind(PNK_NAME))
michael@0:         return f.fail(tableNode, "expecting name of function-pointer array");
michael@0: 
michael@0:     PropertyName *name = tableNode->name();
michael@0:     if (const ModuleCompiler::Global *existing = f.lookupGlobal(name)) {
michael@0:         if (existing->which() != ModuleCompiler::Global::FuncPtrTable)
michael@0:             return f.failName(tableNode, "'%s' is not the name of a function-pointer array", name);
michael@0:     }
michael@0: 
michael@0:     if (!indexExpr->isKind(PNK_BITAND))
michael@0:         return f.fail(indexExpr, "function-pointer table index expression needs & mask");
michael@0: 
michael@0:     ParseNode *indexNode = BinaryLeft(indexExpr);
michael@0:     ParseNode *maskNode = BinaryRight(indexExpr);
michael@0: 
michael@0:     uint32_t mask;
michael@0:     if (!IsLiteralInt(f.m(), maskNode, &mask) || mask == UINT32_MAX || !IsPowerOfTwo(mask + 1))
michael@0:         return f.fail(maskNode, "function-pointer table index mask value must be a power of two");
michael@0: 
michael@0:     MDefinition *indexDef;
michael@0:     Type indexType;
michael@0:     if (!CheckExpr(f, indexNode, &indexDef, &indexType))
michael@0:         return false;
michael@0: 
michael@0:     if (!indexType.isIntish())
michael@0:         return f.failf(indexNode, "%s is not a subtype of intish", indexType.toChars());
michael@0: 
michael@0:     FunctionCompiler::Call call(f, callNode, retType);
michael@0: 
michael@0:     if (!CheckCallArgs(f, callNode, CheckIsVarType, &call))
michael@0:         return false;
michael@0: 
michael@0:     ModuleCompiler::FuncPtrTable *table;
michael@0:     if (!CheckFuncPtrTableAgainstExisting(f.m(), tableNode, name, Move(call.sig()), mask, &table))
michael@0:         return false;
michael@0: 
michael@0:     if (!f.funcPtrCall(*table, indexDef, call, def))
michael@0:         return false;
michael@0: 
michael@0:     *type = retType.toType();
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckIsExternType(FunctionCompiler &f, ParseNode *argNode, Type type)
michael@0: {
michael@0:     if (!type.isExtern())
michael@0:         return f.failf(argNode, "%s is not a subtype of extern", type.toChars());
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckFFICall(FunctionCompiler &f, ParseNode *callNode, unsigned ffiIndex, RetType retType,
michael@0:              MDefinition **def, Type *type)
michael@0: {
michael@0:     PropertyName *calleeName = CallCallee(callNode)->name();
michael@0: 
michael@0:     if (retType == RetType::Float)
michael@0:         return f.fail(callNode, "FFI calls can't return float");
michael@0: 
michael@0:     FunctionCompiler::Call call(f, callNode, retType);
michael@0:     if (!CheckCallArgs(f, callNode, CheckIsExternType, &call))
michael@0:         return false;
michael@0: 
michael@0:     unsigned exitIndex;
michael@0:     if (!f.m().addExit(ffiIndex, calleeName, Move(call.sig()), &exitIndex))
michael@0:         return false;
michael@0: 
michael@0:     if (!f.ffiCall(exitIndex, call, retType.toMIRType(), def))
michael@0:         return false;
michael@0: 
michael@0:     *type = retType.toType();
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool CheckCall(FunctionCompiler &f, ParseNode *call, RetType retType, MDefinition **def, Type *type);
michael@0: 
michael@0: static bool
michael@0: CheckFRoundArg(FunctionCompiler &f, ParseNode *arg, MDefinition **def, Type *type)
michael@0: {
michael@0:     if (arg->isKind(PNK_CALL))
michael@0:         return CheckCall(f, arg, RetType::Float, def, type);
michael@0: 
michael@0:     MDefinition *inputDef;
michael@0:     Type inputType;
michael@0:     if (!CheckExpr(f, arg, &inputDef, &inputType))
michael@0:         return false;
michael@0: 
michael@0:     if (inputType.isMaybeDouble() || inputType.isSigned())
michael@0:         *def = f.unary<MToFloat32>(inputDef);
michael@0:     else if (inputType.isUnsigned())
michael@0:         *def = f.unary<MAsmJSUnsignedToFloat32>(inputDef);
michael@0:     else if (inputType.isFloatish())
michael@0:         *def = inputDef;
michael@0:     else
michael@0:         return f.failf(arg, "%s is not a subtype of signed, unsigned, double? or floatish", inputType.toChars());
michael@0: 
michael@0:     *type = Type::Float;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckMathFRound(FunctionCompiler &f, ParseNode *callNode, RetType retType, MDefinition **def, Type *type)
michael@0: {
michael@0:     ParseNode *argNode = nullptr;
michael@0:     if (!IsFloatCoercion(f.m(), callNode, &argNode))
michael@0:         return f.fail(callNode, "invalid call to fround");
michael@0: 
michael@0:     MDefinition *operand;
michael@0:     Type operandType;
michael@0:     if (!CheckFRoundArg(f, argNode, &operand, &operandType))
michael@0:         return false;
michael@0: 
michael@0:     JS_ASSERT(operandType == Type::Float);
michael@0: 
michael@0:     switch (retType.which()) {
michael@0:       case RetType::Double:
michael@0:         *def = f.unary<MToDouble>(operand);
michael@0:         *type = Type::Double;
michael@0:         return true;
michael@0:       case RetType::Signed:
michael@0:         *def = f.unary<MTruncateToInt32>(operand);
michael@0:         *type = Type::Signed;
michael@0:         return true;
michael@0:       case RetType::Float:
michael@0:         *def = operand;
michael@0:         *type = Type::Float;
michael@0:         return true;
michael@0:       case RetType::Void:
michael@0:         // definition and return types should be ignored by the caller
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSUME_UNREACHABLE("return value of fround is ignored");
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckIsMaybeDouble(FunctionCompiler &f, ParseNode *argNode, Type type)
michael@0: {
michael@0:     if (!type.isMaybeDouble())
michael@0:         return f.failf(argNode, "%s is not a subtype of double?", type.toChars());
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckIsMaybeFloat(FunctionCompiler &f, ParseNode *argNode, Type type)
michael@0: {
michael@0:     if (!type.isMaybeFloat())
michael@0:         return f.failf(argNode, "%s is not a subtype of float?", type.toChars());
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckMathBuiltinCall(FunctionCompiler &f, ParseNode *callNode, AsmJSMathBuiltinFunction func,
michael@0:                      RetType retType, MDefinition **def, Type *type)
michael@0: {
michael@0:     unsigned arity = 0;
michael@0:     AsmJSImmKind doubleCallee, floatCallee;
michael@0:     switch (func) {
michael@0:       case AsmJSMathBuiltin_imul:   return CheckMathIMul(f, callNode, retType, def, type);
michael@0:       case AsmJSMathBuiltin_abs:    return CheckMathAbs(f, callNode, retType, def, type);
michael@0:       case AsmJSMathBuiltin_sqrt:   return CheckMathSqrt(f, callNode, retType, def, type);
michael@0:       case AsmJSMathBuiltin_fround: return CheckMathFRound(f, callNode, retType, def, type);
michael@0:       case AsmJSMathBuiltin_min:    return CheckMathMinMax(f, callNode, retType, def, type, /* isMax = */ false);
michael@0:       case AsmJSMathBuiltin_max:    return CheckMathMinMax(f, callNode, retType, def, type, /* isMax = */ true);
michael@0:       case AsmJSMathBuiltin_ceil:   arity = 1; doubleCallee = AsmJSImm_CeilD;  floatCallee = AsmJSImm_CeilF;   break;
michael@0:       case AsmJSMathBuiltin_floor:  arity = 1; doubleCallee = AsmJSImm_FloorD; floatCallee = AsmJSImm_FloorF;  break;
michael@0:       case AsmJSMathBuiltin_sin:    arity = 1; doubleCallee = AsmJSImm_SinD;   floatCallee = AsmJSImm_Invalid; break;
michael@0:       case AsmJSMathBuiltin_cos:    arity = 1; doubleCallee = AsmJSImm_CosD;   floatCallee = AsmJSImm_Invalid; break;
michael@0:       case AsmJSMathBuiltin_tan:    arity = 1; doubleCallee = AsmJSImm_TanD;   floatCallee = AsmJSImm_Invalid; break;
michael@0:       case AsmJSMathBuiltin_asin:   arity = 1; doubleCallee = AsmJSImm_ASinD;  floatCallee = AsmJSImm_Invalid; break;
michael@0:       case AsmJSMathBuiltin_acos:   arity = 1; doubleCallee = AsmJSImm_ACosD;  floatCallee = AsmJSImm_Invalid; break;
michael@0:       case AsmJSMathBuiltin_atan:   arity = 1; doubleCallee = AsmJSImm_ATanD;  floatCallee = AsmJSImm_Invalid; break;
michael@0:       case AsmJSMathBuiltin_exp:    arity = 1; doubleCallee = AsmJSImm_ExpD;   floatCallee = AsmJSImm_Invalid; break;
michael@0:       case AsmJSMathBuiltin_log:    arity = 1; doubleCallee = AsmJSImm_LogD;   floatCallee = AsmJSImm_Invalid; break;
michael@0:       case AsmJSMathBuiltin_pow:    arity = 2; doubleCallee = AsmJSImm_PowD;   floatCallee = AsmJSImm_Invalid; break;
michael@0:       case AsmJSMathBuiltin_atan2:  arity = 2; doubleCallee = AsmJSImm_ATan2D; floatCallee = AsmJSImm_Invalid; break;
michael@0:       default: MOZ_ASSUME_UNREACHABLE("unexpected mathBuiltin function");
michael@0:     }
michael@0: 
michael@0:     if (retType == RetType::Float && floatCallee == AsmJSImm_Invalid)
michael@0:         return f.fail(callNode, "math builtin cannot be used as float");
michael@0:     if (retType != RetType::Double && retType != RetType::Float)
michael@0:         return f.failf(callNode, "return type of math function is double or float, used as %s", retType.toType().toChars());
michael@0: 
michael@0:     FunctionCompiler::Call call(f, callNode, retType);
michael@0:     if (retType == RetType::Float && !CheckCallArgs(f, callNode, CheckIsMaybeFloat, &call))
michael@0:         return false;
michael@0:     if (retType == RetType::Double && !CheckCallArgs(f, callNode, CheckIsMaybeDouble, &call))
michael@0:         return false;
michael@0: 
michael@0:     if (call.sig().args().length() != arity)
michael@0:         return f.failf(callNode, "call passed %u arguments, expected %u", call.sig().args().length(), arity);
michael@0: 
michael@0:     if (retType == RetType::Float && !f.builtinCall(floatCallee, call, retType.toMIRType(), def))
michael@0:         return false;
michael@0:     if (retType == RetType::Double && !f.builtinCall(doubleCallee, call, retType.toMIRType(), def))
michael@0:         return false;
michael@0: 
michael@0:     *type = retType.toType();
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckCall(FunctionCompiler &f, ParseNode *call, RetType retType, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_CHECK_RECURSION_DONT_REPORT(f.cx(), return f.m().failOverRecursed());
michael@0: 
michael@0:     ParseNode *callee = CallCallee(call);
michael@0: 
michael@0:     if (callee->isKind(PNK_ELEM))
michael@0:         return CheckFuncPtrCall(f, call, retType, def, type);
michael@0: 
michael@0:     if (!callee->isKind(PNK_NAME))
michael@0:         return f.fail(callee, "unexpected callee expression type");
michael@0: 
michael@0:     PropertyName *calleeName = callee->name();
michael@0: 
michael@0:     if (const ModuleCompiler::Global *global = f.lookupGlobal(calleeName)) {
michael@0:         switch (global->which()) {
michael@0:           case ModuleCompiler::Global::FFI:
michael@0:             return CheckFFICall(f, call, global->ffiIndex(), retType, def, type);
michael@0:           case ModuleCompiler::Global::MathBuiltinFunction:
michael@0:             return CheckMathBuiltinCall(f, call, global->mathBuiltinFunction(), retType, def, type);
michael@0:           case ModuleCompiler::Global::ConstantLiteral:
michael@0:           case ModuleCompiler::Global::ConstantImport:
michael@0:           case ModuleCompiler::Global::Variable:
michael@0:           case ModuleCompiler::Global::FuncPtrTable:
michael@0:           case ModuleCompiler::Global::ArrayView:
michael@0:             return f.failName(callee, "'%s' is not callable function", callee->name());
michael@0:           case ModuleCompiler::Global::Function:
michael@0:             break;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return CheckInternalCall(f, call, calleeName, retType, def, type);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckPos(FunctionCompiler &f, ParseNode *pos, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(pos->isKind(PNK_POS));
michael@0:     ParseNode *operand = UnaryKid(pos);
michael@0: 
michael@0:     if (operand->isKind(PNK_CALL))
michael@0:         return CheckCall(f, operand, RetType::Double, def, type);
michael@0: 
michael@0:     MDefinition *operandDef;
michael@0:     Type operandType;
michael@0:     if (!CheckExpr(f, operand, &operandDef, &operandType))
michael@0:         return false;
michael@0: 
michael@0:     if (operandType.isMaybeFloat() || operandType.isSigned())
michael@0:         *def = f.unary<MToDouble>(operandDef);
michael@0:     else if (operandType.isUnsigned())
michael@0:         *def = f.unary<MAsmJSUnsignedToDouble>(operandDef);
michael@0:     else if (operandType.isMaybeDouble())
michael@0:         *def = operandDef;
michael@0:     else
michael@0:         return f.failf(operand, "%s is not a subtype of signed, unsigned, float or double?", operandType.toChars());
michael@0: 
michael@0:     *type = Type::Double;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckNot(FunctionCompiler &f, ParseNode *expr, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(expr->isKind(PNK_NOT));
michael@0:     ParseNode *operand = UnaryKid(expr);
michael@0: 
michael@0:     MDefinition *operandDef;
michael@0:     Type operandType;
michael@0:     if (!CheckExpr(f, operand, &operandDef, &operandType))
michael@0:         return false;
michael@0: 
michael@0:     if (!operandType.isInt())
michael@0:         return f.failf(operand, "%s is not a subtype of int", operandType.toChars());
michael@0: 
michael@0:     *def = f.unary<MNot>(operandDef);
michael@0:     *type = Type::Int;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckNeg(FunctionCompiler &f, ParseNode *expr, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(expr->isKind(PNK_NEG));
michael@0:     ParseNode *operand = UnaryKid(expr);
michael@0: 
michael@0:     MDefinition *operandDef;
michael@0:     Type operandType;
michael@0:     if (!CheckExpr(f, operand, &operandDef, &operandType))
michael@0:         return false;
michael@0: 
michael@0:     if (operandType.isInt()) {
michael@0:         *def = f.unary<MAsmJSNeg>(operandDef, MIRType_Int32);
michael@0:         *type = Type::Intish;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (operandType.isMaybeDouble()) {
michael@0:         *def = f.unary<MAsmJSNeg>(operandDef, MIRType_Double);
michael@0:         *type = Type::Double;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (operandType.isMaybeFloat()) {
michael@0:         *def = f.unary<MAsmJSNeg>(operandDef, MIRType_Float32);
michael@0:         *type = Type::Floatish;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     return f.failf(operand, "%s is not a subtype of int, float? or double?", operandType.toChars());
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckCoerceToInt(FunctionCompiler &f, ParseNode *expr, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(expr->isKind(PNK_BITNOT));
michael@0:     ParseNode *operand = UnaryKid(expr);
michael@0: 
michael@0:     MDefinition *operandDef;
michael@0:     Type operandType;
michael@0:     if (!CheckExpr(f, operand, &operandDef, &operandType))
michael@0:         return false;
michael@0: 
michael@0:     if (operandType.isMaybeDouble() || operandType.isMaybeFloat()) {
michael@0:         *def = f.unary<MTruncateToInt32>(operandDef);
michael@0:         *type = Type::Signed;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (!operandType.isIntish())
michael@0:         return f.failf(operand, "%s is not a subtype of double?, float? or intish", operandType.toChars());
michael@0: 
michael@0:     *def = operandDef;
michael@0:     *type = Type::Signed;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckBitNot(FunctionCompiler &f, ParseNode *neg, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(neg->isKind(PNK_BITNOT));
michael@0:     ParseNode *operand = UnaryKid(neg);
michael@0: 
michael@0:     if (operand->isKind(PNK_BITNOT))
michael@0:         return CheckCoerceToInt(f, operand, def, type);
michael@0: 
michael@0:     MDefinition *operandDef;
michael@0:     Type operandType;
michael@0:     if (!CheckExpr(f, operand, &operandDef, &operandType))
michael@0:         return false;
michael@0: 
michael@0:     if (!operandType.isIntish())
michael@0:         return f.failf(operand, "%s is not a subtype of intish", operandType.toChars());
michael@0: 
michael@0:     *def = f.bitwise<MBitNot>(operandDef);
michael@0:     *type = Type::Signed;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckComma(FunctionCompiler &f, ParseNode *comma, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(comma->isKind(PNK_COMMA));
michael@0:     ParseNode *operands = ListHead(comma);
michael@0: 
michael@0:     ParseNode *pn = operands;
michael@0:     for (; NextNode(pn); pn = NextNode(pn)) {
michael@0:         MDefinition *_1;
michael@0:         Type _2;
michael@0:         if (pn->isKind(PNK_CALL)) {
michael@0:             if (!CheckCall(f, pn, RetType::Void, &_1, &_2))
michael@0:                 return false;
michael@0:         } else {
michael@0:             if (!CheckExpr(f, pn, &_1, &_2))
michael@0:                 return false;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (!CheckExpr(f, pn, def, type))
michael@0:         return false;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckConditional(FunctionCompiler &f, ParseNode *ternary, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(ternary->isKind(PNK_CONDITIONAL));
michael@0:     ParseNode *cond = TernaryKid1(ternary);
michael@0:     ParseNode *thenExpr = TernaryKid2(ternary);
michael@0:     ParseNode *elseExpr = TernaryKid3(ternary);
michael@0: 
michael@0:     MDefinition *condDef;
michael@0:     Type condType;
michael@0:     if (!CheckExpr(f, cond, &condDef, &condType))
michael@0:         return false;
michael@0: 
michael@0:     if (!condType.isInt())
michael@0:         return f.failf(cond, "%s is not a subtype of int", condType.toChars());
michael@0: 
michael@0:     MBasicBlock *thenBlock = nullptr, *elseBlock = nullptr;
michael@0:     if (!f.branchAndStartThen(condDef, &thenBlock, &elseBlock, thenExpr, elseExpr))
michael@0:         return false;
michael@0: 
michael@0:     MDefinition *thenDef;
michael@0:     Type thenType;
michael@0:     if (!CheckExpr(f, thenExpr, &thenDef, &thenType))
michael@0:         return false;
michael@0: 
michael@0:     BlockVector thenBlocks(f.cx());
michael@0:     if (!f.appendThenBlock(&thenBlocks))
michael@0:         return false;
michael@0: 
michael@0:     f.pushPhiInput(thenDef);
michael@0:     f.switchToElse(elseBlock);
michael@0: 
michael@0:     MDefinition *elseDef;
michael@0:     Type elseType;
michael@0:     if (!CheckExpr(f, elseExpr, &elseDef, &elseType))
michael@0:         return false;
michael@0: 
michael@0:     f.pushPhiInput(elseDef);
michael@0: 
michael@0:     if (thenType.isInt() && elseType.isInt()) {
michael@0:         *type = Type::Int;
michael@0:     } else if (thenType.isDouble() && elseType.isDouble()) {
michael@0:         *type = Type::Double;
michael@0:     } else if (thenType.isFloat() && elseType.isFloat()) {
michael@0:         *type = Type::Float;
michael@0:     } else {
michael@0:         return f.failf(ternary, "then/else branches of conditional must both produce int or double, "
michael@0:                        "current types are %s and %s", thenType.toChars(), elseType.toChars());
michael@0:     }
michael@0: 
michael@0:     if (!f.joinIfElse(thenBlocks, elseExpr))
michael@0:         return false;
michael@0: 
michael@0:     *def = f.popPhiOutput();
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: IsValidIntMultiplyConstant(ModuleCompiler &m, ParseNode *expr)
michael@0: {
michael@0:     if (!IsNumericLiteral(m, expr))
michael@0:         return false;
michael@0: 
michael@0:     NumLit literal = ExtractNumericLiteral(m, expr);
michael@0:     switch (literal.which()) {
michael@0:       case NumLit::Fixnum:
michael@0:       case NumLit::NegativeInt:
michael@0:         if (abs(literal.toInt32()) < (1<<20))
michael@0:             return true;
michael@0:         return false;
michael@0:       case NumLit::BigUnsigned:
michael@0:       case NumLit::Double:
michael@0:       case NumLit::Float:
michael@0:       case NumLit::OutOfRangeInt:
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSUME_UNREACHABLE("Bad literal");
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckMultiply(FunctionCompiler &f, ParseNode *star, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(star->isKind(PNK_STAR));
michael@0:     ParseNode *lhs = BinaryLeft(star);
michael@0:     ParseNode *rhs = BinaryRight(star);
michael@0: 
michael@0:     MDefinition *lhsDef;
michael@0:     Type lhsType;
michael@0:     if (!CheckExpr(f, lhs, &lhsDef, &lhsType))
michael@0:         return false;
michael@0: 
michael@0:     MDefinition *rhsDef;
michael@0:     Type rhsType;
michael@0:     if (!CheckExpr(f, rhs, &rhsDef, &rhsType))
michael@0:         return false;
michael@0: 
michael@0:     if (lhsType.isInt() && rhsType.isInt()) {
michael@0:         if (!IsValidIntMultiplyConstant(f.m(), lhs) && !IsValidIntMultiplyConstant(f.m(), rhs))
michael@0:             return f.fail(star, "one arg to int multiply must be a small (-2^20, 2^20) int literal");
michael@0:         *def = f.mul(lhsDef, rhsDef, MIRType_Int32, MMul::Integer);
michael@0:         *type = Type::Intish;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (lhsType.isMaybeDouble() && rhsType.isMaybeDouble()) {
michael@0:         *def = f.mul(lhsDef, rhsDef, MIRType_Double, MMul::Normal);
michael@0:         *type = Type::Double;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (lhsType.isMaybeFloat() && rhsType.isMaybeFloat()) {
michael@0:         *def = f.mul(lhsDef, rhsDef, MIRType_Float32, MMul::Normal);
michael@0:         *type = Type::Floatish;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     return f.fail(star, "multiply operands must be both int, both double? or both float?");
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckAddOrSub(FunctionCompiler &f, ParseNode *expr, MDefinition **def, Type *type,
michael@0:               unsigned *numAddOrSubOut = nullptr)
michael@0: {
michael@0:     JS_CHECK_RECURSION_DONT_REPORT(f.cx(), return f.m().failOverRecursed());
michael@0: 
michael@0:     JS_ASSERT(expr->isKind(PNK_ADD) || expr->isKind(PNK_SUB));
michael@0:     ParseNode *lhs = BinaryLeft(expr);
michael@0:     ParseNode *rhs = BinaryRight(expr);
michael@0: 
michael@0:     MDefinition *lhsDef, *rhsDef;
michael@0:     Type lhsType, rhsType;
michael@0:     unsigned lhsNumAddOrSub, rhsNumAddOrSub;
michael@0: 
michael@0:     if (lhs->isKind(PNK_ADD) || lhs->isKind(PNK_SUB)) {
michael@0:         if (!CheckAddOrSub(f, lhs, &lhsDef, &lhsType, &lhsNumAddOrSub))
michael@0:             return false;
michael@0:         if (lhsType == Type::Intish)
michael@0:             lhsType = Type::Int;
michael@0:     } else {
michael@0:         if (!CheckExpr(f, lhs, &lhsDef, &lhsType))
michael@0:             return false;
michael@0:         lhsNumAddOrSub = 0;
michael@0:     }
michael@0: 
michael@0:     if (rhs->isKind(PNK_ADD) || rhs->isKind(PNK_SUB)) {
michael@0:         if (!CheckAddOrSub(f, rhs, &rhsDef, &rhsType, &rhsNumAddOrSub))
michael@0:             return false;
michael@0:         if (rhsType == Type::Intish)
michael@0:             rhsType = Type::Int;
michael@0:     } else {
michael@0:         if (!CheckExpr(f, rhs, &rhsDef, &rhsType))
michael@0:             return false;
michael@0:         rhsNumAddOrSub = 0;
michael@0:     }
michael@0: 
michael@0:     unsigned numAddOrSub = lhsNumAddOrSub + rhsNumAddOrSub + 1;
michael@0:     if (numAddOrSub > (1<<20))
michael@0:         return f.fail(expr, "too many + or - without intervening coercion");
michael@0: 
michael@0:     if (lhsType.isInt() && rhsType.isInt()) {
michael@0:         *def = expr->isKind(PNK_ADD)
michael@0:                ? f.binary<MAdd>(lhsDef, rhsDef, MIRType_Int32)
michael@0:                : f.binary<MSub>(lhsDef, rhsDef, MIRType_Int32);
michael@0:         *type = Type::Intish;
michael@0:     } else if (lhsType.isMaybeDouble() && rhsType.isMaybeDouble()) {
michael@0:         *def = expr->isKind(PNK_ADD)
michael@0:                ? f.binary<MAdd>(lhsDef, rhsDef, MIRType_Double)
michael@0:                : f.binary<MSub>(lhsDef, rhsDef, MIRType_Double);
michael@0:         *type = Type::Double;
michael@0:     } else if (lhsType.isMaybeFloat() && rhsType.isMaybeFloat()) {
michael@0:         *def = expr->isKind(PNK_ADD)
michael@0:                ? f.binary<MAdd>(lhsDef, rhsDef, MIRType_Float32)
michael@0:                : f.binary<MSub>(lhsDef, rhsDef, MIRType_Float32);
michael@0:         *type = Type::Floatish;
michael@0:     } else {
michael@0:         return f.failf(expr, "operands to + or - must both be int, float? or double?, got %s and %s",
michael@0:                        lhsType.toChars(), rhsType.toChars());
michael@0:     }
michael@0: 
michael@0:     if (numAddOrSubOut)
michael@0:         *numAddOrSubOut = numAddOrSub;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckDivOrMod(FunctionCompiler &f, ParseNode *expr, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(expr->isKind(PNK_DIV) || expr->isKind(PNK_MOD));
michael@0:     ParseNode *lhs = BinaryLeft(expr);
michael@0:     ParseNode *rhs = BinaryRight(expr);
michael@0: 
michael@0:     MDefinition *lhsDef, *rhsDef;
michael@0:     Type lhsType, rhsType;
michael@0:     if (!CheckExpr(f, lhs, &lhsDef, &lhsType))
michael@0:         return false;
michael@0:     if (!CheckExpr(f, rhs, &rhsDef, &rhsType))
michael@0:         return false;
michael@0: 
michael@0:     if (lhsType.isMaybeDouble() && rhsType.isMaybeDouble()) {
michael@0:         *def = expr->isKind(PNK_DIV)
michael@0:                ? f.div(lhsDef, rhsDef, MIRType_Double, /* unsignd = */ false)
michael@0:                : f.mod(lhsDef, rhsDef, MIRType_Double, /* unsignd = */ false);
michael@0:         *type = Type::Double;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (lhsType.isMaybeFloat() && rhsType.isMaybeFloat()) {
michael@0:         if (expr->isKind(PNK_DIV))
michael@0:             *def = f.div(lhsDef, rhsDef, MIRType_Float32, /* unsignd = */ false);
michael@0:         else
michael@0:             return f.fail(expr, "modulo cannot receive float arguments");
michael@0:         *type = Type::Floatish;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (lhsType.isSigned() && rhsType.isSigned()) {
michael@0:         if (expr->isKind(PNK_DIV))
michael@0:             *def = f.div(lhsDef, rhsDef, MIRType_Int32, /* unsignd = */ false);
michael@0:         else
michael@0:             *def = f.mod(lhsDef, rhsDef, MIRType_Int32, /* unsignd = */ false);
michael@0:         *type = Type::Intish;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (lhsType.isUnsigned() && rhsType.isUnsigned()) {
michael@0:         if (expr->isKind(PNK_DIV))
michael@0:             *def = f.div(lhsDef, rhsDef, MIRType_Int32, /* unsignd = */ true);
michael@0:         else
michael@0:             *def = f.mod(lhsDef, rhsDef, MIRType_Int32, /* unsignd = */ true);
michael@0:         *type = Type::Intish;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     return f.failf(expr, "arguments to / or %% must both be double?, float?, signed, or unsigned; "
michael@0:                    "%s and %s are given", lhsType.toChars(), rhsType.toChars());
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckComparison(FunctionCompiler &f, ParseNode *comp, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(comp->isKind(PNK_LT) || comp->isKind(PNK_LE) || comp->isKind(PNK_GT) ||
michael@0:               comp->isKind(PNK_GE) || comp->isKind(PNK_EQ) || comp->isKind(PNK_NE));
michael@0:     ParseNode *lhs = BinaryLeft(comp);
michael@0:     ParseNode *rhs = BinaryRight(comp);
michael@0: 
michael@0:     MDefinition *lhsDef, *rhsDef;
michael@0:     Type lhsType, rhsType;
michael@0:     if (!CheckExpr(f, lhs, &lhsDef, &lhsType))
michael@0:         return false;
michael@0:     if (!CheckExpr(f, rhs, &rhsDef, &rhsType))
michael@0:         return false;
michael@0: 
michael@0:     if ((lhsType.isSigned() && rhsType.isSigned()) || (lhsType.isUnsigned() && rhsType.isUnsigned())) {
michael@0:         MCompare::CompareType compareType = (lhsType.isUnsigned() && rhsType.isUnsigned())
michael@0:                                             ? MCompare::Compare_UInt32
michael@0:                                             : MCompare::Compare_Int32;
michael@0:         *def = f.compare(lhsDef, rhsDef, comp->getOp(), compareType);
michael@0:         *type = Type::Int;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (lhsType.isDouble() && rhsType.isDouble()) {
michael@0:         *def = f.compare(lhsDef, rhsDef, comp->getOp(), MCompare::Compare_Double);
michael@0:         *type = Type::Int;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (lhsType.isFloat() && rhsType.isFloat()) {
michael@0:         *def = f.compare(lhsDef, rhsDef, comp->getOp(), MCompare::Compare_Float32);
michael@0:         *type = Type::Int;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     return f.failf(comp, "arguments to a comparison must both be signed, unsigned, floats or doubles; "
michael@0:                    "%s and %s are given", lhsType.toChars(), rhsType.toChars());
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckBitwise(FunctionCompiler &f, ParseNode *bitwise, MDefinition **def, Type *type)
michael@0: {
michael@0:     ParseNode *lhs = BinaryLeft(bitwise);
michael@0:     ParseNode *rhs = BinaryRight(bitwise);
michael@0: 
michael@0:     int32_t identityElement;
michael@0:     bool onlyOnRight;
michael@0:     switch (bitwise->getKind()) {
michael@0:       case PNK_BITOR:  identityElement = 0;  onlyOnRight = false; *type = Type::Signed;   break;
michael@0:       case PNK_BITAND: identityElement = -1; onlyOnRight = false; *type = Type::Signed;   break;
michael@0:       case PNK_BITXOR: identityElement = 0;  onlyOnRight = false; *type = Type::Signed;   break;
michael@0:       case PNK_LSH:    identityElement = 0;  onlyOnRight = true;  *type = Type::Signed;   break;
michael@0:       case PNK_RSH:    identityElement = 0;  onlyOnRight = true;  *type = Type::Signed;   break;
michael@0:       case PNK_URSH:   identityElement = 0;  onlyOnRight = true;  *type = Type::Unsigned; break;
michael@0:       default: MOZ_ASSUME_UNREACHABLE("not a bitwise op");
michael@0:     }
michael@0: 
michael@0:     uint32_t i;
michael@0:     if (!onlyOnRight && IsLiteralInt(f.m(), lhs, &i) && i == uint32_t(identityElement)) {
michael@0:         Type rhsType;
michael@0:         if (!CheckExpr(f, rhs, def, &rhsType))
michael@0:             return false;
michael@0:         if (!rhsType.isIntish())
michael@0:             return f.failf(bitwise, "%s is not a subtype of intish", rhsType.toChars());
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (IsLiteralInt(f.m(), rhs, &i) && i == uint32_t(identityElement)) {
michael@0:         if (bitwise->isKind(PNK_BITOR) && lhs->isKind(PNK_CALL))
michael@0:             return CheckCall(f, lhs, RetType::Signed, def, type);
michael@0: 
michael@0:         Type lhsType;
michael@0:         if (!CheckExpr(f, lhs, def, &lhsType))
michael@0:             return false;
michael@0:         if (!lhsType.isIntish())
michael@0:             return f.failf(bitwise, "%s is not a subtype of intish", lhsType.toChars());
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     MDefinition *lhsDef;
michael@0:     Type lhsType;
michael@0:     if (!CheckExpr(f, lhs, &lhsDef, &lhsType))
michael@0:         return false;
michael@0: 
michael@0:     MDefinition *rhsDef;
michael@0:     Type rhsType;
michael@0:     if (!CheckExpr(f, rhs, &rhsDef, &rhsType))
michael@0:         return false;
michael@0: 
michael@0:     if (!lhsType.isIntish())
michael@0:         return f.failf(lhs, "%s is not a subtype of intish", lhsType.toChars());
michael@0:     if (!rhsType.isIntish())
michael@0:         return f.failf(rhs, "%s is not a subtype of intish", rhsType.toChars());
michael@0: 
michael@0:     switch (bitwise->getKind()) {
michael@0:       case PNK_BITOR:  *def = f.bitwise<MBitOr>(lhsDef, rhsDef); break;
michael@0:       case PNK_BITAND: *def = f.bitwise<MBitAnd>(lhsDef, rhsDef); break;
michael@0:       case PNK_BITXOR: *def = f.bitwise<MBitXor>(lhsDef, rhsDef); break;
michael@0:       case PNK_LSH:    *def = f.bitwise<MLsh>(lhsDef, rhsDef); break;
michael@0:       case PNK_RSH:    *def = f.bitwise<MRsh>(lhsDef, rhsDef); break;
michael@0:       case PNK_URSH:   *def = f.bitwise<MUrsh>(lhsDef, rhsDef); break;
michael@0:       default: MOZ_ASSUME_UNREACHABLE("not a bitwise op");
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckUncoercedCall(FunctionCompiler &f, ParseNode *expr, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_ASSERT(expr->isKind(PNK_CALL));
michael@0: 
michael@0:     ParseNode *arg;
michael@0:     if (!IsFloatCoercion(f.m(), expr, &arg)) {
michael@0:         return f.fail(expr, "all function calls must either be ignored (via f(); or "
michael@0:                             "comma-expression), coerced to signed (via f()|0), coerced to float "
michael@0:                             "(via fround(f())) or coerced to double (via +f())");
michael@0:     }
michael@0: 
michael@0:     return CheckFRoundArg(f, arg, def, type);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckExpr(FunctionCompiler &f, ParseNode *expr, MDefinition **def, Type *type)
michael@0: {
michael@0:     JS_CHECK_RECURSION_DONT_REPORT(f.cx(), return f.m().failOverRecursed());
michael@0: 
michael@0:     if (!f.mirGen().ensureBallast())
michael@0:         return false;
michael@0: 
michael@0:     if (IsNumericLiteral(f.m(), expr))
michael@0:         return CheckNumericLiteral(f, expr, def, type);
michael@0: 
michael@0:     switch (expr->getKind()) {
michael@0:       case PNK_NAME:        return CheckVarRef(f, expr, def, type);
michael@0:       case PNK_ELEM:        return CheckLoadArray(f, expr, def, type);
michael@0:       case PNK_ASSIGN:      return CheckAssign(f, expr, def, type);
michael@0:       case PNK_POS:         return CheckPos(f, expr, def, type);
michael@0:       case PNK_NOT:         return CheckNot(f, expr, def, type);
michael@0:       case PNK_NEG:         return CheckNeg(f, expr, def, type);
michael@0:       case PNK_BITNOT:      return CheckBitNot(f, expr, def, type);
michael@0:       case PNK_COMMA:       return CheckComma(f, expr, def, type);
michael@0:       case PNK_CONDITIONAL: return CheckConditional(f, expr, def, type);
michael@0:       case PNK_STAR:        return CheckMultiply(f, expr, def, type);
michael@0:       case PNK_CALL:        return CheckUncoercedCall(f, expr, def, type);
michael@0: 
michael@0:       case PNK_ADD:
michael@0:       case PNK_SUB:         return CheckAddOrSub(f, expr, def, type);
michael@0: 
michael@0:       case PNK_DIV:
michael@0:       case PNK_MOD:         return CheckDivOrMod(f, expr, def, type);
michael@0: 
michael@0:       case PNK_LT:
michael@0:       case PNK_LE:
michael@0:       case PNK_GT:
michael@0:       case PNK_GE:
michael@0:       case PNK_EQ:
michael@0:       case PNK_NE:          return CheckComparison(f, expr, def, type);
michael@0: 
michael@0:       case PNK_BITOR:
michael@0:       case PNK_BITAND:
michael@0:       case PNK_BITXOR:
michael@0:       case PNK_LSH:
michael@0:       case PNK_RSH:
michael@0:       case PNK_URSH:        return CheckBitwise(f, expr, def, type);
michael@0: 
michael@0:       default:;
michael@0:     }
michael@0: 
michael@0:     return f.fail(expr, "unsupported expression");
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckStatement(FunctionCompiler &f, ParseNode *stmt, LabelVector *maybeLabels = nullptr);
michael@0: 
michael@0: static bool
michael@0: CheckExprStatement(FunctionCompiler &f, ParseNode *exprStmt)
michael@0: {
michael@0:     JS_ASSERT(exprStmt->isKind(PNK_SEMI));
michael@0:     ParseNode *expr = UnaryKid(exprStmt);
michael@0: 
michael@0:     if (!expr)
michael@0:         return true;
michael@0: 
michael@0:     MDefinition *_1;
michael@0:     Type _2;
michael@0: 
michael@0:     if (expr->isKind(PNK_CALL))
michael@0:         return CheckCall(f, expr, RetType::Void, &_1, &_2);
michael@0: 
michael@0:     return CheckExpr(f, UnaryKid(exprStmt), &_1, &_2);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckWhile(FunctionCompiler &f, ParseNode *whileStmt, const LabelVector *maybeLabels)
michael@0: {
michael@0:     JS_ASSERT(whileStmt->isKind(PNK_WHILE));
michael@0:     ParseNode *cond = BinaryLeft(whileStmt);
michael@0:     ParseNode *body = BinaryRight(whileStmt);
michael@0: 
michael@0:     MBasicBlock *loopEntry;
michael@0:     if (!f.startPendingLoop(whileStmt, &loopEntry, body))
michael@0:         return false;
michael@0: 
michael@0:     MDefinition *condDef;
michael@0:     Type condType;
michael@0:     if (!CheckExpr(f, cond, &condDef, &condType))
michael@0:         return false;
michael@0: 
michael@0:     if (!condType.isInt())
michael@0:         return f.failf(cond, "%s is not a subtype of int", condType.toChars());
michael@0: 
michael@0:     MBasicBlock *afterLoop;
michael@0:     if (!f.branchAndStartLoopBody(condDef, &afterLoop, body, NextNode(whileStmt)))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckStatement(f, body))
michael@0:         return false;
michael@0: 
michael@0:     if (!f.bindContinues(whileStmt, maybeLabels))
michael@0:         return false;
michael@0: 
michael@0:     return f.closeLoop(loopEntry, afterLoop);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckFor(FunctionCompiler &f, ParseNode *forStmt, const LabelVector *maybeLabels)
michael@0: {
michael@0:     JS_ASSERT(forStmt->isKind(PNK_FOR));
michael@0:     ParseNode *forHead = BinaryLeft(forStmt);
michael@0:     ParseNode *body = BinaryRight(forStmt);
michael@0: 
michael@0:     if (!forHead->isKind(PNK_FORHEAD))
michael@0:         return f.fail(forHead, "unsupported for-loop statement");
michael@0: 
michael@0:     ParseNode *maybeInit = TernaryKid1(forHead);
michael@0:     ParseNode *maybeCond = TernaryKid2(forHead);
michael@0:     ParseNode *maybeInc = TernaryKid3(forHead);
michael@0: 
michael@0:     if (maybeInit) {
michael@0:         MDefinition *_1;
michael@0:         Type _2;
michael@0:         if (!CheckExpr(f, maybeInit, &_1, &_2))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     MBasicBlock *loopEntry;
michael@0:     if (!f.startPendingLoop(forStmt, &loopEntry, body))
michael@0:         return false;
michael@0: 
michael@0:     MDefinition *condDef;
michael@0:     if (maybeCond) {
michael@0:         Type condType;
michael@0:         if (!CheckExpr(f, maybeCond, &condDef, &condType))
michael@0:             return false;
michael@0: 
michael@0:         if (!condType.isInt())
michael@0:             return f.failf(maybeCond, "%s is not a subtype of int", condType.toChars());
michael@0:     } else {
michael@0:         condDef = f.constant(Int32Value(1), Type::Int);
michael@0:     }
michael@0: 
michael@0:     MBasicBlock *afterLoop;
michael@0:     if (!f.branchAndStartLoopBody(condDef, &afterLoop, body, NextNode(forStmt)))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckStatement(f, body))
michael@0:         return false;
michael@0: 
michael@0:     if (!f.bindContinues(forStmt, maybeLabels))
michael@0:         return false;
michael@0: 
michael@0:     if (maybeInc) {
michael@0:         MDefinition *_1;
michael@0:         Type _2;
michael@0:         if (!CheckExpr(f, maybeInc, &_1, &_2))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     return f.closeLoop(loopEntry, afterLoop);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckDoWhile(FunctionCompiler &f, ParseNode *whileStmt, const LabelVector *maybeLabels)
michael@0: {
michael@0:     JS_ASSERT(whileStmt->isKind(PNK_DOWHILE));
michael@0:     ParseNode *body = BinaryLeft(whileStmt);
michael@0:     ParseNode *cond = BinaryRight(whileStmt);
michael@0: 
michael@0:     MBasicBlock *loopEntry;
michael@0:     if (!f.startPendingLoop(whileStmt, &loopEntry, body))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckStatement(f, body))
michael@0:         return false;
michael@0: 
michael@0:     if (!f.bindContinues(whileStmt, maybeLabels))
michael@0:         return false;
michael@0: 
michael@0:     MDefinition *condDef;
michael@0:     Type condType;
michael@0:     if (!CheckExpr(f, cond, &condDef, &condType))
michael@0:         return false;
michael@0: 
michael@0:     if (!condType.isInt())
michael@0:         return f.failf(cond, "%s is not a subtype of int", condType.toChars());
michael@0: 
michael@0:     return f.branchAndCloseDoWhileLoop(condDef, loopEntry, NextNode(whileStmt));
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckLabel(FunctionCompiler &f, ParseNode *labeledStmt, LabelVector *maybeLabels)
michael@0: {
michael@0:     JS_ASSERT(labeledStmt->isKind(PNK_LABEL));
michael@0:     PropertyName *label = LabeledStatementLabel(labeledStmt);
michael@0:     ParseNode *stmt = LabeledStatementStatement(labeledStmt);
michael@0: 
michael@0:     if (maybeLabels) {
michael@0:         if (!maybeLabels->append(label))
michael@0:             return false;
michael@0:         if (!CheckStatement(f, stmt, maybeLabels))
michael@0:             return false;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     LabelVector labels(f.cx());
michael@0:     if (!labels.append(label))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckStatement(f, stmt, &labels))
michael@0:         return false;
michael@0: 
michael@0:     return f.bindLabeledBreaks(&labels, labeledStmt);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckLeafCondition(FunctionCompiler &f, ParseNode *cond, ParseNode *thenStmt, ParseNode *elseOrJoinStmt,
michael@0:                    MBasicBlock **thenBlock, MBasicBlock **elseOrJoinBlock)
michael@0: {
michael@0:     MDefinition *condDef;
michael@0:     Type condType;
michael@0:     if (!CheckExpr(f, cond, &condDef, &condType))
michael@0:         return false;
michael@0:     if (!condType.isInt())
michael@0:         return f.failf(cond, "%s is not a subtype of int", condType.toChars());
michael@0: 
michael@0:     if (!f.branchAndStartThen(condDef, thenBlock, elseOrJoinBlock, thenStmt, elseOrJoinStmt))
michael@0:         return false;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckIfCondition(FunctionCompiler &f, ParseNode *cond, ParseNode *thenStmt, ParseNode *elseOrJoinStmt,
michael@0:                  MBasicBlock **thenBlock, MBasicBlock **elseOrJoinBlock);
michael@0: 
michael@0: static bool
michael@0: CheckIfConditional(FunctionCompiler &f, ParseNode *conditional, ParseNode *thenStmt, ParseNode *elseOrJoinStmt,
michael@0:                    MBasicBlock **thenBlock, MBasicBlock **elseOrJoinBlock)
michael@0: {
michael@0:     JS_ASSERT(conditional->isKind(PNK_CONDITIONAL));
michael@0: 
michael@0:     // a ? b : c <=> (a && b) || (!a && c)
michael@0:     // b is always referred to the AND condition, as we need A and B to reach this test,
michael@0:     // c is always referred as the OR condition, as we reach it if we don't have A.
michael@0:     ParseNode *cond = TernaryKid1(conditional);
michael@0:     ParseNode *lhs = TernaryKid2(conditional);
michael@0:     ParseNode *rhs = TernaryKid3(conditional);
michael@0: 
michael@0:     MBasicBlock *maybeAndTest = nullptr, *maybeOrTest = nullptr;
michael@0:     MBasicBlock **ifTrueBlock = &maybeAndTest, **ifFalseBlock = &maybeOrTest;
michael@0:     ParseNode *ifTrueBlockNode = lhs, *ifFalseBlockNode = rhs;
michael@0: 
michael@0:     // Try to spot opportunities for short-circuiting in the AND subpart
michael@0:     uint32_t andTestLiteral = 0;
michael@0:     bool skipAndTest = false;
michael@0: 
michael@0:     if (IsLiteralInt(f.m(), lhs, &andTestLiteral)) {
michael@0:         skipAndTest = true;
michael@0:         if (andTestLiteral == 0) {
michael@0:             // (a ? 0 : b) is equivalent to !a && b
michael@0:             // If a is true, jump to the elseBlock directly
michael@0:             ifTrueBlock = elseOrJoinBlock;
michael@0:             ifTrueBlockNode = elseOrJoinStmt;
michael@0:         } else {
michael@0:             // (a ? 1 : b) is equivalent to a || b
michael@0:             // If a is true, jump to the thenBlock directly
michael@0:             ifTrueBlock = thenBlock;
michael@0:             ifTrueBlockNode = thenStmt;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Try to spot opportunities for short-circuiting in the OR subpart
michael@0:     uint32_t orTestLiteral = 0;
michael@0:     bool skipOrTest = false;
michael@0: 
michael@0:     if (IsLiteralInt(f.m(), rhs, &orTestLiteral)) {
michael@0:         skipOrTest = true;
michael@0:         if (orTestLiteral == 0) {
michael@0:             // (a ? b : 0) is equivalent to a && b
michael@0:             // If a is false, jump to the elseBlock directly
michael@0:             ifFalseBlock = elseOrJoinBlock;
michael@0:             ifFalseBlockNode = elseOrJoinStmt;
michael@0:         } else {
michael@0:             // (a ? b : 1) is equivalent to !a || b
michael@0:             // If a is false, jump to the thenBlock directly
michael@0:             ifFalseBlock = thenBlock;
michael@0:             ifFalseBlockNode = thenStmt;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Pathological cases: a ? 0 : 0 (i.e. false) or a ? 1 : 1 (i.e. true)
michael@0:     // These cases can't be optimized properly at this point: one of the blocks might be
michael@0:     // created and won't ever be executed. Furthermore, it introduces inconsistencies in the
michael@0:     // MIR graph (even if we try to create a block by hand, it will have no predecessor, which
michael@0:     // breaks graph assumptions). The only way we could optimize it is to do it directly in
michael@0:     // CheckIf by removing the control flow entirely.
michael@0:     if (skipOrTest && skipAndTest && (!!orTestLiteral == !!andTestLiteral))
michael@0:         return CheckLeafCondition(f, conditional, thenStmt, elseOrJoinStmt, thenBlock, elseOrJoinBlock);
michael@0: 
michael@0:     if (!CheckIfCondition(f, cond, ifTrueBlockNode, ifFalseBlockNode, ifTrueBlock, ifFalseBlock))
michael@0:         return false;
michael@0:     f.assertCurrentBlockIs(*ifTrueBlock);
michael@0: 
michael@0:     // Add supplementary tests, if needed
michael@0:     if (!skipAndTest) {
michael@0:         if (!CheckIfCondition(f, lhs, thenStmt, elseOrJoinStmt, thenBlock, elseOrJoinBlock))
michael@0:             return false;
michael@0:         f.assertCurrentBlockIs(*thenBlock);
michael@0:     }
michael@0: 
michael@0:     if (!skipOrTest) {
michael@0:         f.switchToElse(*ifFalseBlock);
michael@0:         if (!CheckIfCondition(f, rhs, thenStmt, elseOrJoinStmt, thenBlock, elseOrJoinBlock))
michael@0:             return false;
michael@0:         f.assertCurrentBlockIs(*thenBlock);
michael@0:     }
michael@0: 
michael@0:     // We might not be on the thenBlock in one case
michael@0:     if (ifTrueBlock == elseOrJoinBlock) {
michael@0:         JS_ASSERT(skipAndTest && andTestLiteral == 0);
michael@0:         f.switchToElse(*thenBlock);
michael@0:     }
michael@0: 
michael@0:     // Check post-conditions
michael@0:     f.assertCurrentBlockIs(*thenBlock);
michael@0:     JS_ASSERT_IF(!f.inDeadCode(), *thenBlock && *elseOrJoinBlock);
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: /*
michael@0:  * Recursive function that checks for a complex condition (formed with ternary
michael@0:  * conditionals) and creates the associated short-circuiting control flow graph.
michael@0:  *
michael@0:  * After a call to CheckCondition, the followings are true:
michael@0:  * - if *thenBlock and *elseOrJoinBlock were non-null on entry, their value is
michael@0:  *   not changed by this function.
michael@0:  * - *thenBlock and *elseOrJoinBlock are non-null on exit.
michael@0:  * - the current block on exit is the *thenBlock.
michael@0:  */
michael@0: static bool
michael@0: CheckIfCondition(FunctionCompiler &f, ParseNode *cond, ParseNode *thenStmt,
michael@0:                  ParseNode *elseOrJoinStmt, MBasicBlock **thenBlock, MBasicBlock **elseOrJoinBlock)
michael@0: {
michael@0:     JS_CHECK_RECURSION_DONT_REPORT(f.cx(), return f.m().failOverRecursed());
michael@0: 
michael@0:     if (cond->isKind(PNK_CONDITIONAL))
michael@0:         return CheckIfConditional(f, cond, thenStmt, elseOrJoinStmt, thenBlock, elseOrJoinBlock);
michael@0: 
michael@0:     // We've reached a leaf, i.e. an atomic condition
michael@0:     JS_ASSERT(!cond->isKind(PNK_CONDITIONAL));
michael@0:     if (!CheckLeafCondition(f, cond, thenStmt, elseOrJoinStmt, thenBlock, elseOrJoinBlock))
michael@0:         return false;
michael@0: 
michael@0:     // Check post-conditions
michael@0:     f.assertCurrentBlockIs(*thenBlock);
michael@0:     JS_ASSERT_IF(!f.inDeadCode(), *thenBlock && *elseOrJoinBlock);
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckIf(FunctionCompiler &f, ParseNode *ifStmt)
michael@0: {
michael@0:     // Handle if/else-if chains using iteration instead of recursion. This
michael@0:     // avoids blowing the C stack quota for long if/else-if chains and also
michael@0:     // creates fewer MBasicBlocks at join points (by creating one join block
michael@0:     // for the entire if/else-if chain).
michael@0:     BlockVector thenBlocks(f.cx());
michael@0: 
michael@0:     ParseNode *nextStmt = NextNode(ifStmt);
michael@0:   recurse:
michael@0:     JS_ASSERT(ifStmt->isKind(PNK_IF));
michael@0:     ParseNode *cond = TernaryKid1(ifStmt);
michael@0:     ParseNode *thenStmt = TernaryKid2(ifStmt);
michael@0:     ParseNode *elseStmt = TernaryKid3(ifStmt);
michael@0: 
michael@0:     MBasicBlock *thenBlock = nullptr, *elseBlock = nullptr;
michael@0:     ParseNode *elseOrJoinStmt = elseStmt ? elseStmt : nextStmt;
michael@0: 
michael@0:     if (!CheckIfCondition(f, cond, thenStmt, elseOrJoinStmt, &thenBlock, &elseBlock))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckStatement(f, thenStmt))
michael@0:         return false;
michael@0: 
michael@0:     if (!f.appendThenBlock(&thenBlocks))
michael@0:         return false;
michael@0: 
michael@0:     if (!elseStmt) {
michael@0:         if (!f.joinIf(thenBlocks, elseBlock))
michael@0:             return false;
michael@0:     } else {
michael@0:         f.switchToElse(elseBlock);
michael@0: 
michael@0:         if (elseStmt->isKind(PNK_IF)) {
michael@0:             ifStmt = elseStmt;
michael@0:             goto recurse;
michael@0:         }
michael@0: 
michael@0:         if (!CheckStatement(f, elseStmt))
michael@0:             return false;
michael@0: 
michael@0:         if (!f.joinIfElse(thenBlocks, nextStmt))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckCaseExpr(FunctionCompiler &f, ParseNode *caseExpr, int32_t *value)
michael@0: {
michael@0:     if (!IsNumericLiteral(f.m(), caseExpr))
michael@0:         return f.fail(caseExpr, "switch case expression must be an integer literal");
michael@0: 
michael@0:     NumLit literal = ExtractNumericLiteral(f.m(), caseExpr);
michael@0:     switch (literal.which()) {
michael@0:       case NumLit::Fixnum:
michael@0:       case NumLit::NegativeInt:
michael@0:         *value = literal.toInt32();
michael@0:         break;
michael@0:       case NumLit::OutOfRangeInt:
michael@0:       case NumLit::BigUnsigned:
michael@0:         return f.fail(caseExpr, "switch case expression out of integer range");
michael@0:       case NumLit::Double:
michael@0:       case NumLit::Float:
michael@0:         return f.fail(caseExpr, "switch case expression must be an integer literal");
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckDefaultAtEnd(FunctionCompiler &f, ParseNode *stmt)
michael@0: {
michael@0:     for (; stmt; stmt = NextNode(stmt)) {
michael@0:         JS_ASSERT(stmt->isKind(PNK_CASE) || stmt->isKind(PNK_DEFAULT));
michael@0:         if (stmt->isKind(PNK_DEFAULT) && NextNode(stmt) != nullptr)
michael@0:             return f.fail(stmt, "default label must be at the end");
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckSwitchRange(FunctionCompiler &f, ParseNode *stmt, int32_t *low, int32_t *high,
michael@0:                  int32_t *tableLength)
michael@0: {
michael@0:     if (stmt->isKind(PNK_DEFAULT)) {
michael@0:         *low = 0;
michael@0:         *high = -1;
michael@0:         *tableLength = 0;
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     int32_t i = 0;
michael@0:     if (!CheckCaseExpr(f, CaseExpr(stmt), &i))
michael@0:         return false;
michael@0: 
michael@0:     *low = *high = i;
michael@0: 
michael@0:     ParseNode *initialStmt = stmt;
michael@0:     for (stmt = NextNode(stmt); stmt && stmt->isKind(PNK_CASE); stmt = NextNode(stmt)) {
michael@0:         int32_t i = 0;
michael@0:         if (!CheckCaseExpr(f, CaseExpr(stmt), &i))
michael@0:             return false;
michael@0: 
michael@0:         *low = Min(*low, i);
michael@0:         *high = Max(*high, i);
michael@0:     }
michael@0: 
michael@0:     int64_t i64 = (int64_t(*high) - int64_t(*low)) + 1;
michael@0:     if (i64 > 4*1024*1024)
michael@0:         return f.fail(initialStmt, "all switch statements generate tables; this table would be too big");
michael@0: 
michael@0:     *tableLength = int32_t(i64);
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckSwitch(FunctionCompiler &f, ParseNode *switchStmt)
michael@0: {
michael@0:     JS_ASSERT(switchStmt->isKind(PNK_SWITCH));
michael@0:     ParseNode *switchExpr = BinaryLeft(switchStmt);
michael@0:     ParseNode *switchBody = BinaryRight(switchStmt);
michael@0: 
michael@0:     if (!switchBody->isKind(PNK_STATEMENTLIST))
michael@0:         return f.fail(switchBody, "switch body may not contain 'let' declarations");
michael@0: 
michael@0:     MDefinition *exprDef;
michael@0:     Type exprType;
michael@0:     if (!CheckExpr(f, switchExpr, &exprDef, &exprType))
michael@0:         return false;
michael@0: 
michael@0:     if (!exprType.isSigned())
michael@0:         return f.failf(switchExpr, "%s is not a subtype of signed", exprType.toChars());
michael@0: 
michael@0:     ParseNode *stmt = ListHead(switchBody);
michael@0: 
michael@0:     if (!CheckDefaultAtEnd(f, stmt))
michael@0:         return false;
michael@0: 
michael@0:     if (!stmt)
michael@0:         return true;
michael@0: 
michael@0:     int32_t low = 0, high = 0, tableLength = 0;
michael@0:     if (!CheckSwitchRange(f, stmt, &low, &high, &tableLength))
michael@0:         return false;
michael@0: 
michael@0:     BlockVector cases(f.cx());
michael@0:     if (!cases.resize(tableLength))
michael@0:         return false;
michael@0: 
michael@0:     MBasicBlock *switchBlock;
michael@0:     if (!f.startSwitch(switchStmt, exprDef, low, high, &switchBlock))
michael@0:         return false;
michael@0: 
michael@0:     for (; stmt && stmt->isKind(PNK_CASE); stmt = NextNode(stmt)) {
michael@0:         int32_t caseValue = ExtractNumericLiteral(f.m(), CaseExpr(stmt)).toInt32();
michael@0:         unsigned caseIndex = caseValue - low;
michael@0: 
michael@0:         if (cases[caseIndex])
michael@0:             return f.fail(stmt, "no duplicate case labels");
michael@0: 
michael@0:         if (!f.startSwitchCase(switchBlock, &cases[caseIndex], stmt))
michael@0:             return false;
michael@0: 
michael@0:         if (!CheckStatement(f, CaseBody(stmt)))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     MBasicBlock *defaultBlock;
michael@0:     if (!f.startSwitchDefault(switchBlock, &cases, &defaultBlock, stmt))
michael@0:         return false;
michael@0: 
michael@0:     if (stmt && stmt->isKind(PNK_DEFAULT)) {
michael@0:         if (!CheckStatement(f, CaseBody(stmt)))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     return f.joinSwitch(switchBlock, cases, defaultBlock);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckReturnType(FunctionCompiler &f, ParseNode *usepn, RetType retType)
michael@0: {
michael@0:     if (!f.hasAlreadyReturned()) {
michael@0:         f.setReturnedType(retType);
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (f.returnedType() != retType) {
michael@0:         return f.failf(usepn, "%s incompatible with previous return of type %s",
michael@0:                        retType.toType().toChars(), f.returnedType().toType().toChars());
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckReturn(FunctionCompiler &f, ParseNode *returnStmt)
michael@0: {
michael@0:     ParseNode *expr = ReturnExpr(returnStmt);
michael@0: 
michael@0:     if (!expr) {
michael@0:         if (!CheckReturnType(f, returnStmt, RetType::Void))
michael@0:             return false;
michael@0: 
michael@0:         f.returnVoid();
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     MDefinition *def;
michael@0:     Type type;
michael@0:     if (!CheckExpr(f, expr, &def, &type))
michael@0:         return false;
michael@0: 
michael@0:     RetType retType;
michael@0:     if (type.isSigned())
michael@0:         retType = RetType::Signed;
michael@0:     else if (type.isDouble())
michael@0:         retType = RetType::Double;
michael@0:     else if (type.isFloat())
michael@0:         retType = RetType::Float;
michael@0:     else if (type.isVoid())
michael@0:         retType = RetType::Void;
michael@0:     else
michael@0:         return f.failf(expr, "%s is not a valid return type", type.toChars());
michael@0: 
michael@0:     if (!CheckReturnType(f, expr, retType))
michael@0:         return false;
michael@0: 
michael@0:     if (retType == RetType::Void)
michael@0:         f.returnVoid();
michael@0:     else
michael@0:         f.returnExpr(def);
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckStatementList(FunctionCompiler &f, ParseNode *stmtList)
michael@0: {
michael@0:     JS_ASSERT(stmtList->isKind(PNK_STATEMENTLIST));
michael@0: 
michael@0:     for (ParseNode *stmt = ListHead(stmtList); stmt; stmt = NextNode(stmt)) {
michael@0:         if (!CheckStatement(f, stmt))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckStatement(FunctionCompiler &f, ParseNode *stmt, LabelVector *maybeLabels)
michael@0: {
michael@0:     JS_CHECK_RECURSION_DONT_REPORT(f.cx(), return f.m().failOverRecursed());
michael@0: 
michael@0:     if (!f.mirGen().ensureBallast())
michael@0:         return false;
michael@0: 
michael@0:     switch (stmt->getKind()) {
michael@0:       case PNK_SEMI:          return CheckExprStatement(f, stmt);
michael@0:       case PNK_WHILE:         return CheckWhile(f, stmt, maybeLabels);
michael@0:       case PNK_FOR:           return CheckFor(f, stmt, maybeLabels);
michael@0:       case PNK_DOWHILE:       return CheckDoWhile(f, stmt, maybeLabels);
michael@0:       case PNK_LABEL:         return CheckLabel(f, stmt, maybeLabels);
michael@0:       case PNK_IF:            return CheckIf(f, stmt);
michael@0:       case PNK_SWITCH:        return CheckSwitch(f, stmt);
michael@0:       case PNK_RETURN:        return CheckReturn(f, stmt);
michael@0:       case PNK_STATEMENTLIST: return CheckStatementList(f, stmt);
michael@0:       case PNK_BREAK:         return f.addBreak(LoopControlMaybeLabel(stmt));
michael@0:       case PNK_CONTINUE:      return f.addContinue(LoopControlMaybeLabel(stmt));
michael@0:       default:;
michael@0:     }
michael@0: 
michael@0:     return f.fail(stmt, "unexpected statement kind");
michael@0: }
michael@0: 
michael@0: static bool
michael@0: ParseFunction(ModuleCompiler &m, ParseNode **fnOut)
michael@0: {
michael@0:     TokenStream &tokenStream = m.tokenStream();
michael@0: 
michael@0:     DebugOnly<TokenKind> tk = tokenStream.getToken();
michael@0:     JS_ASSERT(tk == TOK_FUNCTION);
michael@0: 
michael@0:     RootedPropertyName name(m.cx());
michael@0: 
michael@0:     TokenKind tt = tokenStream.getToken();
michael@0:     if (tt == TOK_NAME) {
michael@0:         name = tokenStream.currentName();
michael@0:     } else if (tt == TOK_YIELD) {
michael@0:         if (!m.parser().checkYieldNameValidity())
michael@0:             return false;
michael@0:         name = m.cx()->names().yield;
michael@0:     } else {
michael@0:         return false;  // The regular parser will throw a SyntaxError, no need to m.fail.
michael@0:     }
michael@0: 
michael@0:     ParseNode *fn = m.parser().handler.newFunctionDefinition();
michael@0:     if (!fn)
michael@0:         return false;
michael@0: 
michael@0:     // This flows into FunctionBox, so must be tenured.
michael@0:     RootedFunction fun(m.cx(), NewFunction(m.cx(), NullPtr(), nullptr, 0, JSFunction::INTERPRETED,
michael@0:                                            m.cx()->global(), name, JSFunction::FinalizeKind,
michael@0:                                            TenuredObject));
michael@0:     if (!fun)
michael@0:         return false;
michael@0: 
michael@0:     AsmJSParseContext *outerpc = m.parser().pc;
michael@0: 
michael@0:     Directives directives(outerpc);
michael@0:     FunctionBox *funbox = m.parser().newFunctionBox(fn, fun, outerpc, directives, NotGenerator);
michael@0:     if (!funbox)
michael@0:         return false;
michael@0: 
michael@0:     Directives newDirectives = directives;
michael@0:     AsmJSParseContext funpc(&m.parser(), outerpc, fn, funbox, &newDirectives,
michael@0:                             outerpc->staticLevel + 1, outerpc->blockidGen,
michael@0:                             /* blockScopeDepth = */ 0);
michael@0:     if (!funpc.init(tokenStream))
michael@0:         return false;
michael@0: 
michael@0:     if (!m.parser().functionArgsAndBodyGeneric(fn, fun, Normal, Statement, &newDirectives))
michael@0:         return false;
michael@0: 
michael@0:     if (tokenStream.hadError() || directives != newDirectives)
michael@0:         return false;
michael@0: 
michael@0:     outerpc->blockidGen = funpc.blockidGen;
michael@0:     fn->pn_blockid = outerpc->blockid();
michael@0: 
michael@0:     *fnOut = fn;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckFunction(ModuleCompiler &m, LifoAlloc &lifo, MIRGenerator **mir, ModuleCompiler::Func **funcOut)
michael@0: {
michael@0:     int64_t before = PRMJ_Now();
michael@0: 
michael@0:     // asm.js modules can be quite large when represented as parse trees so pop
michael@0:     // the backing LifoAlloc after parsing/compiling each function.
michael@0:     AsmJSParser::Mark mark = m.parser().mark();
michael@0: 
michael@0:     ParseNode *fn;
michael@0:     if (!ParseFunction(m, &fn))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckFunctionHead(m, fn))
michael@0:         return false;
michael@0: 
michael@0:     FunctionCompiler f(m, fn, lifo);
michael@0:     if (!f.init())
michael@0:         return false;
michael@0: 
michael@0:     ParseNode *stmtIter = ListHead(FunctionStatementList(fn));
michael@0: 
michael@0:     VarTypeVector argTypes(m.lifo());
michael@0:     if (!CheckArguments(f, &stmtIter, &argTypes))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckVariables(f, &stmtIter))
michael@0:         return false;
michael@0: 
michael@0:     if (!f.prepareToEmitMIR(argTypes))
michael@0:         return false;
michael@0: 
michael@0:     ParseNode *lastNonEmptyStmt = nullptr;
michael@0:     for (; stmtIter; stmtIter = NextNode(stmtIter)) {
michael@0:         if (!CheckStatement(f, stmtIter))
michael@0:             return false;
michael@0:         if (!IsEmptyStatement(stmtIter))
michael@0:             lastNonEmptyStmt = stmtIter;
michael@0:     }
michael@0: 
michael@0:     RetType retType;
michael@0:     if (!CheckFinalReturn(f, lastNonEmptyStmt, &retType))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckReturnType(f, lastNonEmptyStmt, retType))
michael@0:         return false;
michael@0: 
michael@0:     Signature sig(Move(argTypes), retType);
michael@0:     ModuleCompiler::Func *func = nullptr;
michael@0:     if (!CheckFunctionSignature(m, fn, Move(sig), FunctionName(fn), &func))
michael@0:         return false;
michael@0: 
michael@0:     if (func->defined())
michael@0:         return m.failName(fn, "function '%s' already defined", FunctionName(fn));
michael@0: 
michael@0:     uint32_t funcBegin = fn->pn_pos.begin;
michael@0:     uint32_t funcEnd = fn->pn_pos.end;
michael@0:     // The begin/end char range is relative to the beginning of the module,
michael@0:     // hence the assertions.
michael@0:     JS_ASSERT(funcBegin > m.moduleStart());
michael@0:     JS_ASSERT(funcEnd > m.moduleStart());
michael@0:     funcBegin -= m.moduleStart();
michael@0:     funcEnd -= m.moduleStart();
michael@0:     func->finish(funcBegin, funcEnd);
michael@0: 
michael@0:     func->accumulateCompileTime((PRMJ_Now() - before) / PRMJ_USEC_PER_MSEC);
michael@0: 
michael@0:     m.parser().release(mark);
michael@0: 
michael@0:     // Copy the cumulative minimum heap size constraint to the MIR for use in analysis.  The length
michael@0:     // is also constrained to particular lengths, so firstly round up - a larger 'heap required
michael@0:     // length' can help range analysis to prove that bounds checks are not needed.
michael@0:     uint32_t len = js::RoundUpToNextValidAsmJSHeapLength(m.minHeapLength());
michael@0:     m.requireHeapLengthToBeAtLeast(len);
michael@0: 
michael@0:     *mir = f.extractMIR();
michael@0:     (*mir)->noteMinAsmJSHeapLength(len);
michael@0:     *funcOut = func;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: GenerateCode(ModuleCompiler &m, ModuleCompiler::Func &func, MIRGenerator &mir, LIRGraph &lir)
michael@0: {
michael@0:     int64_t before = PRMJ_Now();
michael@0: 
michael@0:     // A single MacroAssembler is reused for all function compilations so
michael@0:     // that there is a single linear code segment for each module. To avoid
michael@0:     // spiking memory, a LifoAllocScope in the caller frees all MIR/LIR
michael@0:     // after each function is compiled. This method is responsible for cleaning
michael@0:     // out any dangling pointers that the MacroAssembler may have kept.
michael@0:     m.masm().resetForNewCodeGenerator(mir.alloc());
michael@0: 
michael@0:     m.masm().bind(func.code());
michael@0: 
michael@0:     ScopedJSDeletePtr<CodeGenerator> codegen(js_new<CodeGenerator>(&mir, &lir, &m.masm()));
michael@0:     if (!codegen || !codegen->generateAsmJS(&m.stackOverflowLabel()))
michael@0:         return m.fail(nullptr, "internal codegen failure (probably out of memory)");
michael@0: 
michael@0: #if defined(MOZ_VTUNE) || defined(JS_ION_PERF)
michael@0:     // Profiling might not be active now, but it may be activated later (perhaps
michael@0:     // after the module has been cached and reloaded from the cache). Function
michael@0:     // profiling info isn't huge, so store it always (in --enable-profiling
michael@0:     // builds, which is only Nightly builds, but default).
michael@0:     if (!m.trackProfiledFunction(func, m.masm().currentOffset()))
michael@0:         return false;
michael@0: #endif
michael@0: 
michael@0: #ifdef JS_ION_PERF
michael@0:     // Per-block profiling info uses significantly more memory so only store
michael@0:     // this information if it is actively requested.
michael@0:     if (PerfBlockEnabled()) {
michael@0:         if (!m.trackPerfProfiledBlocks(mir.perfSpewer(), func, m.masm().currentOffset()))
michael@0:             return false;
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     // Align internal function headers.
michael@0:     m.masm().align(CodeAlignment);
michael@0: 
michael@0:     func.accumulateCompileTime((PRMJ_Now() - before) / PRMJ_USEC_PER_MSEC);
michael@0:     if (!m.maybeReportCompileTime(func))
michael@0:         return false;
michael@0: 
michael@0:     // Unlike regular IonMonkey which links and generates a new JitCode for
michael@0:     // every function, we accumulate all the functions in the module in a
michael@0:     // single MacroAssembler and link at end. Linking asm.js doesn't require a
michael@0:     // CodeGenerator so we can destroy it now.
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckAllFunctionsDefined(ModuleCompiler &m)
michael@0: {
michael@0:     for (unsigned i = 0; i < m.numFunctions(); i++) {
michael@0:         if (!m.function(i).code()->bound())
michael@0:             return m.failName(nullptr, "missing definition of function %s", m.function(i).name());
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckFunctionsSequential(ModuleCompiler &m)
michael@0: {
michael@0:     // Use a single LifoAlloc to allocate all the temporary compiler IR.
michael@0:     // All allocated LifoAlloc'd memory is released after compiling each
michael@0:     // function by the LifoAllocScope inside the loop.
michael@0:     LifoAlloc lifo(LIFO_ALLOC_PRIMARY_CHUNK_SIZE);
michael@0: 
michael@0:     while (PeekToken(m.parser()) == TOK_FUNCTION) {
michael@0:         LifoAllocScope scope(&lifo);
michael@0: 
michael@0:         MIRGenerator *mir;
michael@0:         ModuleCompiler::Func *func;
michael@0:         if (!CheckFunction(m, lifo, &mir, &func))
michael@0:             return false;
michael@0: 
michael@0:         int64_t before = PRMJ_Now();
michael@0: 
michael@0:         IonContext icx(m.cx(), &mir->alloc());
michael@0: 
michael@0:         IonSpewNewFunction(&mir->graph(), NullPtr());
michael@0: 
michael@0:         if (!OptimizeMIR(mir))
michael@0:             return m.failOffset(func->srcOffset(), "internal compiler failure (probably out of memory)");
michael@0: 
michael@0:         LIRGraph *lir = GenerateLIR(mir);
michael@0:         if (!lir)
michael@0:             return m.failOffset(func->srcOffset(), "internal compiler failure (probably out of memory)");
michael@0: 
michael@0:         func->accumulateCompileTime((PRMJ_Now() - before) / PRMJ_USEC_PER_MSEC);
michael@0: 
michael@0:         if (!GenerateCode(m, *func, *mir, *lir))
michael@0:             return false;
michael@0: 
michael@0:         IonSpewEndFunction();
michael@0:     }
michael@0: 
michael@0:     if (!CheckAllFunctionsDefined(m))
michael@0:         return false;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: #ifdef JS_THREADSAFE
michael@0: 
michael@0: // Currently, only one asm.js parallel compilation is allowed at a time.
michael@0: // This RAII class attempts to claim this parallel compilation using atomic ops
michael@0: // on rt->workerThreadState->asmJSCompilationInProgress.
michael@0: class ParallelCompilationGuard
michael@0: {
michael@0:     bool parallelState_;
michael@0:   public:
michael@0:     ParallelCompilationGuard() : parallelState_(false) {}
michael@0:     ~ParallelCompilationGuard() {
michael@0:         if (parallelState_) {
michael@0:             JS_ASSERT(WorkerThreadState().asmJSCompilationInProgress == true);
michael@0:             WorkerThreadState().asmJSCompilationInProgress = false;
michael@0:         }
michael@0:     }
michael@0:     bool claim() {
michael@0:         JS_ASSERT(!parallelState_);
michael@0:         if (!WorkerThreadState().asmJSCompilationInProgress.compareExchange(false, true))
michael@0:             return false;
michael@0:         parallelState_ = true;
michael@0:         return true;
michael@0:     }
michael@0: };
michael@0: 
michael@0: static bool
michael@0: ParallelCompilationEnabled(ExclusiveContext *cx)
michael@0: {
michael@0:     // If 'cx' isn't a JSContext, then we are already off the main thread so
michael@0:     // off-thread compilation must be enabled. However, since there are a fixed
michael@0:     // number of worker threads and one is already being consumed by this
michael@0:     // parsing task, ensure that there another free thread to avoid deadlock.
michael@0:     // (Note: there is at most one thread used for parsing so we don't have to
michael@0:     // worry about general dining philosophers.)
michael@0:     if (WorkerThreadState().threadCount <= 1)
michael@0:         return false;
michael@0: 
michael@0:     if (!cx->isJSContext())
michael@0:         return true;
michael@0:     return cx->asJSContext()->runtime()->canUseParallelIonCompilation();
michael@0: }
michael@0: 
michael@0: // State of compilation as tracked and updated by the main thread.
michael@0: struct ParallelGroupState
michael@0: {
michael@0:     js::Vector<AsmJSParallelTask> &tasks;
michael@0:     int32_t outstandingJobs; // Good work, jobs!
michael@0:     uint32_t compiledJobs;
michael@0: 
michael@0:     ParallelGroupState(js::Vector<AsmJSParallelTask> &tasks)
michael@0:       : tasks(tasks), outstandingJobs(0), compiledJobs(0)
michael@0:     { }
michael@0: };
michael@0: 
michael@0: // Block until a worker-assigned LifoAlloc becomes finished.
michael@0: static AsmJSParallelTask *
michael@0: GetFinishedCompilation(ModuleCompiler &m, ParallelGroupState &group)
michael@0: {
michael@0:     AutoLockWorkerThreadState lock;
michael@0: 
michael@0:     while (!WorkerThreadState().asmJSWorkerFailed()) {
michael@0:         if (!WorkerThreadState().asmJSFinishedList().empty()) {
michael@0:             group.outstandingJobs--;
michael@0:             return WorkerThreadState().asmJSFinishedList().popCopy();
michael@0:         }
michael@0:         WorkerThreadState().wait(GlobalWorkerThreadState::CONSUMER);
michael@0:     }
michael@0: 
michael@0:     return nullptr;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: GenerateCodeForFinishedJob(ModuleCompiler &m, ParallelGroupState &group, AsmJSParallelTask **outTask)
michael@0: {
michael@0:     // Block until a used LifoAlloc becomes available.
michael@0:     AsmJSParallelTask *task = GetFinishedCompilation(m, group);
michael@0:     if (!task)
michael@0:         return false;
michael@0: 
michael@0:     ModuleCompiler::Func &func = *reinterpret_cast<ModuleCompiler::Func *>(task->func);
michael@0:     func.accumulateCompileTime(task->compileTime);
michael@0: 
michael@0:     {
michael@0:         // Perform code generation on the main thread.
michael@0:         IonContext ionContext(m.cx(), &task->mir->alloc());
michael@0:         if (!GenerateCode(m, func, *task->mir, *task->lir))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     group.compiledJobs++;
michael@0: 
michael@0:     // Clear the LifoAlloc for use by another worker.
michael@0:     TempAllocator &tempAlloc = task->mir->alloc();
michael@0:     tempAlloc.TempAllocator::~TempAllocator();
michael@0:     task->lifo.releaseAll();
michael@0: 
michael@0:     *outTask = task;
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static inline bool
michael@0: GetUnusedTask(ParallelGroupState &group, uint32_t i, AsmJSParallelTask **outTask)
michael@0: {
michael@0:     // Since functions are dispatched in order, if fewer than |numLifos| functions
michael@0:     // have been generated, then the |i'th| LifoAlloc must never have been
michael@0:     // assigned to a worker thread.
michael@0:     if (i >= group.tasks.length())
michael@0:         return false;
michael@0:     *outTask = &group.tasks[i];
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckFunctionsParallelImpl(ModuleCompiler &m, ParallelGroupState &group)
michael@0: {
michael@0: #ifdef DEBUG
michael@0:     {
michael@0:         AutoLockWorkerThreadState lock;
michael@0:         JS_ASSERT(WorkerThreadState().asmJSWorklist().empty());
michael@0:         JS_ASSERT(WorkerThreadState().asmJSFinishedList().empty());
michael@0:     }
michael@0: #endif
michael@0:     WorkerThreadState().resetAsmJSFailureState();
michael@0: 
michael@0:     for (unsigned i = 0; PeekToken(m.parser()) == TOK_FUNCTION; i++) {
michael@0:         // Get exclusive access to an empty LifoAlloc from the thread group's pool.
michael@0:         AsmJSParallelTask *task = nullptr;
michael@0:         if (!GetUnusedTask(group, i, &task) && !GenerateCodeForFinishedJob(m, group, &task))
michael@0:             return false;
michael@0: 
michael@0:         // Generate MIR into the LifoAlloc on the main thread.
michael@0:         MIRGenerator *mir;
michael@0:         ModuleCompiler::Func *func;
michael@0:         if (!CheckFunction(m, task->lifo, &mir, &func))
michael@0:             return false;
michael@0: 
michael@0:         // Perform optimizations and LIR generation on a worker thread.
michael@0:         task->init(m.cx()->compartment()->runtimeFromAnyThread(), func, mir);
michael@0:         if (!StartOffThreadAsmJSCompile(m.cx(), task))
michael@0:             return false;
michael@0: 
michael@0:         group.outstandingJobs++;
michael@0:     }
michael@0: 
michael@0:     // Block for all outstanding workers to complete.
michael@0:     while (group.outstandingJobs > 0) {
michael@0:         AsmJSParallelTask *ignored = nullptr;
michael@0:         if (!GenerateCodeForFinishedJob(m, group, &ignored))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     if (!CheckAllFunctionsDefined(m))
michael@0:         return false;
michael@0: 
michael@0:     JS_ASSERT(group.outstandingJobs == 0);
michael@0:     JS_ASSERT(group.compiledJobs == m.numFunctions());
michael@0: #ifdef DEBUG
michael@0:     {
michael@0:         AutoLockWorkerThreadState lock;
michael@0:         JS_ASSERT(WorkerThreadState().asmJSWorklist().empty());
michael@0:         JS_ASSERT(WorkerThreadState().asmJSFinishedList().empty());
michael@0:     }
michael@0: #endif
michael@0:     JS_ASSERT(!WorkerThreadState().asmJSWorkerFailed());
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static void
michael@0: CancelOutstandingJobs(ModuleCompiler &m, ParallelGroupState &group)
michael@0: {
michael@0:     // This is failure-handling code, so it's not allowed to fail.
michael@0:     // The problem is that all memory for compilation is stored in LifoAllocs
michael@0:     // maintained in the scope of CheckFunctionsParallel() -- so in order
michael@0:     // for that function to safely return, and thereby remove the LifoAllocs,
michael@0:     // none of that memory can be in use or reachable by workers.
michael@0: 
michael@0:     JS_ASSERT(group.outstandingJobs >= 0);
michael@0:     if (!group.outstandingJobs)
michael@0:         return;
michael@0: 
michael@0:     AutoLockWorkerThreadState lock;
michael@0: 
michael@0:     // From the compiling tasks, eliminate those waiting for worker assignation.
michael@0:     group.outstandingJobs -= WorkerThreadState().asmJSWorklist().length();
michael@0:     WorkerThreadState().asmJSWorklist().clear();
michael@0: 
michael@0:     // From the compiling tasks, eliminate those waiting for codegen.
michael@0:     group.outstandingJobs -= WorkerThreadState().asmJSFinishedList().length();
michael@0:     WorkerThreadState().asmJSFinishedList().clear();
michael@0: 
michael@0:     // Eliminate tasks that failed without adding to the finished list.
michael@0:     group.outstandingJobs -= WorkerThreadState().harvestFailedAsmJSJobs();
michael@0: 
michael@0:     // Any remaining tasks are therefore undergoing active compilation.
michael@0:     JS_ASSERT(group.outstandingJobs >= 0);
michael@0:     while (group.outstandingJobs > 0) {
michael@0:         WorkerThreadState().wait(GlobalWorkerThreadState::CONSUMER);
michael@0: 
michael@0:         group.outstandingJobs -= WorkerThreadState().harvestFailedAsmJSJobs();
michael@0:         group.outstandingJobs -= WorkerThreadState().asmJSFinishedList().length();
michael@0:         WorkerThreadState().asmJSFinishedList().clear();
michael@0:     }
michael@0: 
michael@0:     JS_ASSERT(group.outstandingJobs == 0);
michael@0:     JS_ASSERT(WorkerThreadState().asmJSWorklist().empty());
michael@0:     JS_ASSERT(WorkerThreadState().asmJSFinishedList().empty());
michael@0: }
michael@0: 
michael@0: static const size_t LIFO_ALLOC_PARALLEL_CHUNK_SIZE = 1 << 12;
michael@0: 
michael@0: static bool
michael@0: CheckFunctionsParallel(ModuleCompiler &m)
michael@0: {
michael@0:     // If parallel compilation isn't enabled (not enough cores, disabled by
michael@0:     // pref, etc) or another thread is currently compiling asm.js in parallel,
michael@0:     // fall back to sequential compilation. (We could lift the latter
michael@0:     // constraint by hoisting asmJS* state out of WorkerThreadState so multiple
michael@0:     // concurrent asm.js parallel compilations don't race.)
michael@0:     ParallelCompilationGuard g;
michael@0:     if (!ParallelCompilationEnabled(m.cx()) || !g.claim())
michael@0:         return CheckFunctionsSequential(m);
michael@0: 
michael@0:     IonSpew(IonSpew_Logs, "Can't log asm.js script. (Compiled on background thread.)");
michael@0: 
michael@0:     // Saturate all worker threads plus the main thread.
michael@0:     size_t numParallelJobs = WorkerThreadState().threadCount + 1;
michael@0: 
michael@0:     // Allocate scoped AsmJSParallelTask objects. Each contains a unique
michael@0:     // LifoAlloc that provides all necessary memory for compilation.
michael@0:     js::Vector<AsmJSParallelTask, 0> tasks(m.cx());
michael@0:     if (!tasks.initCapacity(numParallelJobs))
michael@0:         return false;
michael@0: 
michael@0:     for (size_t i = 0; i < numParallelJobs; i++)
michael@0:         tasks.infallibleAppend(LIFO_ALLOC_PARALLEL_CHUNK_SIZE);
michael@0: 
michael@0:     // With compilation memory in-scope, dispatch worker threads.
michael@0:     ParallelGroupState group(tasks);
michael@0:     if (!CheckFunctionsParallelImpl(m, group)) {
michael@0:         CancelOutstandingJobs(m, group);
michael@0: 
michael@0:         // If failure was triggered by a worker thread, report error.
michael@0:         if (void *maybeFunc = WorkerThreadState().maybeAsmJSFailedFunction()) {
michael@0:             ModuleCompiler::Func *func = reinterpret_cast<ModuleCompiler::Func *>(maybeFunc);
michael@0:             return m.failOffset(func->srcOffset(), "allocation failure during compilation");
michael@0:         }
michael@0: 
michael@0:         // Otherwise, the error occurred on the main thread and was already reported.
michael@0:         return false;
michael@0:     }
michael@0:     return true;
michael@0: }
michael@0: #endif // JS_THREADSAFE
michael@0: 
michael@0: static bool
michael@0: CheckFuncPtrTable(ModuleCompiler &m, ParseNode *var)
michael@0: {
michael@0:     if (!IsDefinition(var))
michael@0:         return m.fail(var, "function-pointer table name must be unique");
michael@0: 
michael@0:     ParseNode *arrayLiteral = MaybeDefinitionInitializer(var);
michael@0:     if (!arrayLiteral || !arrayLiteral->isKind(PNK_ARRAY))
michael@0:         return m.fail(var, "function-pointer table's initializer must be an array literal");
michael@0: 
michael@0:     unsigned length = ListLength(arrayLiteral);
michael@0: 
michael@0:     if (!IsPowerOfTwo(length))
michael@0:         return m.failf(arrayLiteral, "function-pointer table length must be a power of 2 (is %u)", length);
michael@0: 
michael@0:     unsigned mask = length - 1;
michael@0: 
michael@0:     ModuleCompiler::FuncPtrVector elems(m.cx());
michael@0:     const Signature *firstSig = nullptr;
michael@0: 
michael@0:     for (ParseNode *elem = ListHead(arrayLiteral); elem; elem = NextNode(elem)) {
michael@0:         if (!elem->isKind(PNK_NAME))
michael@0:             return m.fail(elem, "function-pointer table's elements must be names of functions");
michael@0: 
michael@0:         PropertyName *funcName = elem->name();
michael@0:         const ModuleCompiler::Func *func = m.lookupFunction(funcName);
michael@0:         if (!func)
michael@0:             return m.fail(elem, "function-pointer table's elements must be names of functions");
michael@0: 
michael@0:         if (firstSig) {
michael@0:             if (*firstSig != func->sig())
michael@0:                 return m.fail(elem, "all functions in table must have same signature");
michael@0:         } else {
michael@0:             firstSig = &func->sig();
michael@0:         }
michael@0: 
michael@0:         if (!elems.append(func))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     Signature sig(m.lifo());
michael@0:     if (!sig.copy(*firstSig))
michael@0:         return false;
michael@0: 
michael@0:     ModuleCompiler::FuncPtrTable *table;
michael@0:     if (!CheckFuncPtrTableAgainstExisting(m, var, var->name(), Move(sig), mask, &table))
michael@0:         return false;
michael@0: 
michael@0:     table->initElems(Move(elems));
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckFuncPtrTables(ModuleCompiler &m)
michael@0: {
michael@0:     while (true) {
michael@0:         ParseNode *varStmt;
michael@0:         if (!ParseVarOrConstStatement(m.parser(), &varStmt))
michael@0:             return false;
michael@0:         if (!varStmt)
michael@0:             break;
michael@0:         for (ParseNode *var = VarListHead(varStmt); var; var = NextNode(var)) {
michael@0:             if (!CheckFuncPtrTable(m, var))
michael@0:                 return false;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     for (unsigned i = 0; i < m.numFuncPtrTables(); i++) {
michael@0:         if (!m.funcPtrTable(i).initialized())
michael@0:             return m.fail(nullptr, "expecting function-pointer table");
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckModuleExportFunction(ModuleCompiler &m, ParseNode *returnExpr)
michael@0: {
michael@0:     if (!returnExpr->isKind(PNK_NAME))
michael@0:         return m.fail(returnExpr, "export statement must be of the form 'return name'");
michael@0: 
michael@0:     PropertyName *funcName = returnExpr->name();
michael@0: 
michael@0:     const ModuleCompiler::Func *func = m.lookupFunction(funcName);
michael@0:     if (!func)
michael@0:         return m.failName(returnExpr, "exported function name '%s' not found", funcName);
michael@0: 
michael@0:     return m.addExportedFunction(func, /* maybeFieldName = */ nullptr);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckModuleExportObject(ModuleCompiler &m, ParseNode *object)
michael@0: {
michael@0:     JS_ASSERT(object->isKind(PNK_OBJECT));
michael@0: 
michael@0:     for (ParseNode *pn = ListHead(object); pn; pn = NextNode(pn)) {
michael@0:         if (!IsNormalObjectField(m.cx(), pn))
michael@0:             return m.fail(pn, "only normal object properties may be used in the export object literal");
michael@0: 
michael@0:         PropertyName *fieldName = ObjectNormalFieldName(m.cx(), pn);
michael@0: 
michael@0:         ParseNode *initNode = ObjectFieldInitializer(pn);
michael@0:         if (!initNode->isKind(PNK_NAME))
michael@0:             return m.fail(initNode, "initializer of exported object literal must be name of function");
michael@0: 
michael@0:         PropertyName *funcName = initNode->name();
michael@0: 
michael@0:         const ModuleCompiler::Func *func = m.lookupFunction(funcName);
michael@0:         if (!func)
michael@0:             return m.failName(initNode, "exported function name '%s' not found", funcName);
michael@0: 
michael@0:         if (!m.addExportedFunction(func, fieldName))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckModuleReturn(ModuleCompiler &m)
michael@0: {
michael@0:     if (PeekToken(m.parser()) != TOK_RETURN) {
michael@0:         TokenKind tk = PeekToken(m.parser());
michael@0:         if (tk == TOK_RC || tk == TOK_EOF)
michael@0:             return m.fail(nullptr, "expecting return statement");
michael@0:         return m.fail(nullptr, "invalid asm.js statement");
michael@0:     }
michael@0: 
michael@0:     ParseNode *returnStmt = m.parser().statement();
michael@0:     if (!returnStmt)
michael@0:         return false;
michael@0: 
michael@0:     ParseNode *returnExpr = ReturnExpr(returnStmt);
michael@0:     if (!returnExpr)
michael@0:         return m.fail(returnStmt, "export statement must return something");
michael@0: 
michael@0:     if (returnExpr->isKind(PNK_OBJECT)) {
michael@0:         if (!CheckModuleExportObject(m, returnExpr))
michael@0:             return false;
michael@0:     } else {
michael@0:         if (!CheckModuleExportFunction(m, returnExpr))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     // Function statements are not added to the lexical scope in ParseContext
michael@0:     // (since cx->tempLifoAlloc is marked/released after each function
michael@0:     // statement) and thus all the identifiers in the return statement will be
michael@0:     // mistaken as free variables and added to lexdeps. Clear these now.
michael@0:     m.parser().pc->lexdeps->clear();
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: // All registers except the stack pointer.
michael@0: static const RegisterSet AllRegsExceptSP =
michael@0:     RegisterSet(GeneralRegisterSet(Registers::AllMask &
michael@0:                                    ~(uint32_t(1) << Registers::StackPointer)),
michael@0:                 FloatRegisterSet(FloatRegisters::AllMask));
michael@0: #if defined(JS_CODEGEN_ARM)
michael@0: // The ARM system ABI also includes d15 in the non volatile float registers.
michael@0: static const RegisterSet NonVolatileRegs =
michael@0:     RegisterSet(GeneralRegisterSet(Registers::NonVolatileMask),
michael@0:                     FloatRegisterSet(FloatRegisters::NonVolatileMask | (1 << FloatRegisters::d15)));
michael@0: #else
michael@0: static const RegisterSet NonVolatileRegs =
michael@0:     RegisterSet(GeneralRegisterSet(Registers::NonVolatileMask),
michael@0:                 FloatRegisterSet(FloatRegisters::NonVolatileMask));
michael@0: #endif
michael@0: 
michael@0: static void
michael@0: LoadAsmJSActivationIntoRegister(MacroAssembler &masm, Register reg)
michael@0: {
michael@0:     masm.movePtr(AsmJSImm_Runtime, reg);
michael@0:     size_t offset = offsetof(JSRuntime, mainThread) +
michael@0:                     PerThreadData::offsetOfAsmJSActivationStackReadOnly();
michael@0:     masm.loadPtr(Address(reg, offset), reg);
michael@0: }
michael@0: 
michael@0: static void
michael@0: LoadJSContextFromActivation(MacroAssembler &masm, Register activation, Register dest)
michael@0: {
michael@0:     masm.loadPtr(Address(activation, AsmJSActivation::offsetOfContext()), dest);
michael@0: }
michael@0: 
michael@0: static void
michael@0: AssertStackAlignment(MacroAssembler &masm)
michael@0: {
michael@0:     JS_ASSERT((AlignmentAtPrologue + masm.framePushed()) % StackAlignment == 0);
michael@0: #ifdef DEBUG
michael@0:     Label ok;
michael@0:     JS_ASSERT(IsPowerOfTwo(StackAlignment));
michael@0:     masm.branchTestPtr(Assembler::Zero, StackPointer, Imm32(StackAlignment - 1), &ok);
michael@0:     masm.assumeUnreachable("Stack should be aligned.");
michael@0:     masm.bind(&ok);
michael@0: #endif
michael@0: }
michael@0: 
michael@0: template <class VectorT>
michael@0: static unsigned
michael@0: StackArgBytes(const VectorT &argTypes)
michael@0: {
michael@0:     ABIArgIter<VectorT> iter(argTypes);
michael@0:     while (!iter.done())
michael@0:         iter++;
michael@0:     return iter.stackBytesConsumedSoFar();
michael@0: }
michael@0: 
michael@0: static unsigned
michael@0: StackDecrementForCall(MacroAssembler &masm, unsigned bytesToPush)
michael@0: {
michael@0:     // Include extra padding so that, after pushing the bytesToPush,
michael@0:     // the stack is aligned for a call instruction.
michael@0:     unsigned alreadyPushed = AlignmentAtPrologue + masm.framePushed();
michael@0:     return AlignBytes(alreadyPushed + bytesToPush, StackAlignment) - alreadyPushed;
michael@0: }
michael@0: 
michael@0: template <class VectorT>
michael@0: static unsigned
michael@0: StackDecrementForCall(MacroAssembler &masm, const VectorT &argTypes, unsigned extraBytes = 0)
michael@0: {
michael@0:     return StackDecrementForCall(masm, StackArgBytes(argTypes) + extraBytes);
michael@0: }
michael@0: 
michael@0: static const unsigned FramePushedAfterSave = NonVolatileRegs.gprs().size() * sizeof(intptr_t) +
michael@0:                                              NonVolatileRegs.fpus().size() * sizeof(double);
michael@0: 
michael@0: // On arm, we need to include an extra word of space at the top of the stack so
michael@0: // we can explicitly store the return address before making the call to C++ or
michael@0: // Ion. On x86/x64, this isn't necessary since the call instruction pushes the
michael@0: // return address.
michael@0: #ifdef JS_CODEGEN_ARM
michael@0: static const unsigned MaybeRetAddr = sizeof(void*);
michael@0: #else
michael@0: static const unsigned MaybeRetAddr = 0;
michael@0: #endif
michael@0: 
michael@0: static bool
michael@0: GenerateEntry(ModuleCompiler &m, const AsmJSModule::ExportedFunction &exportedFunc)
michael@0: {
michael@0:     MacroAssembler &masm = m.masm();
michael@0: 
michael@0:     // In constrast to the system ABI, the Ion convention is that all registers
michael@0:     // are clobbered by calls. Thus, we must save the caller's non-volatile
michael@0:     // registers.
michael@0:     //
michael@0:     // NB: GenerateExits assumes that masm.framePushed() == 0 before
michael@0:     // PushRegsInMask(NonVolatileRegs).
michael@0:     masm.setFramePushed(0);
michael@0:     masm.PushRegsInMask(NonVolatileRegs);
michael@0:     JS_ASSERT(masm.framePushed() == FramePushedAfterSave);
michael@0: 
michael@0:     // Remember the stack pointer in the current AsmJSActivation. This will be
michael@0:     // used by error exit paths to set the stack pointer back to what it was
michael@0:     // right after the (C++) caller's non-volatile registers were saved so that
michael@0:     // they can be restored.
michael@0:     Register activation = ABIArgGenerator::NonArgReturnVolatileReg0;
michael@0:     LoadAsmJSActivationIntoRegister(masm, activation);
michael@0:     masm.storePtr(StackPointer, Address(activation, AsmJSActivation::offsetOfErrorRejoinSP()));
michael@0: 
michael@0:     // ARM has a globally-pinned GlobalReg (x64 uses RIP-relative addressing,
michael@0:     // x86 uses immediates in effective addresses) and NaN register (used as
michael@0:     // part of the out-of-bounds handling in heap loads/stores).
michael@0: #if defined(JS_CODEGEN_ARM)
michael@0:     masm.movePtr(IntArgReg1, GlobalReg);
michael@0:     masm.ma_vimm(GenericNaN(), NANReg);
michael@0: #endif
michael@0: 
michael@0:     // ARM and x64 have a globally-pinned HeapReg (x86 uses immediates in
michael@0:     // effective addresses).
michael@0: #if defined(JS_CODEGEN_X64) || defined(JS_CODEGEN_ARM)
michael@0:     masm.loadPtr(Address(IntArgReg1, m.module().heapOffset()), HeapReg);
michael@0: #endif
michael@0: 
michael@0:     // Get 'argv' into a non-arg register and save it on the stack.
michael@0:     Register argv = ABIArgGenerator::NonArgReturnVolatileReg0;
michael@0:     Register scratch = ABIArgGenerator::NonArgReturnVolatileReg1;
michael@0: #if defined(JS_CODEGEN_X86)
michael@0:     masm.loadPtr(Address(StackPointer, NativeFrameSize + masm.framePushed()), argv);
michael@0: #else
michael@0:     masm.movePtr(IntArgReg0, argv);
michael@0: #endif
michael@0:     masm.Push(argv);
michael@0: 
michael@0:     // Bump the stack for the call.
michael@0:     const ModuleCompiler::Func &func = *m.lookupFunction(exportedFunc.name());
michael@0:     unsigned stackDec = StackDecrementForCall(masm, func.sig().args());
michael@0:     masm.reserveStack(stackDec);
michael@0: 
michael@0:     // Copy parameters out of argv and into the registers/stack-slots specified by
michael@0:     // the system ABI.
michael@0:     for (ABIArgTypeIter iter(func.sig().args()); !iter.done(); iter++) {
michael@0:         unsigned argOffset = iter.index() * sizeof(uint64_t);
michael@0:         Address src(argv, argOffset);
michael@0:         switch (iter->kind()) {
michael@0:           case ABIArg::GPR:
michael@0:             masm.load32(src, iter->gpr());
michael@0:             break;
michael@0:           case ABIArg::FPU:
michael@0:             masm.loadDouble(src, iter->fpu());
michael@0:             break;
michael@0:           case ABIArg::Stack:
michael@0:             if (iter.mirType() == MIRType_Int32) {
michael@0:                 masm.load32(src, scratch);
michael@0:                 masm.storePtr(scratch, Address(StackPointer, iter->offsetFromArgBase()));
michael@0:             } else {
michael@0:                 JS_ASSERT(iter.mirType() == MIRType_Double || iter.mirType() == MIRType_Float32);
michael@0:                 masm.loadDouble(src, ScratchFloatReg);
michael@0:                 masm.storeDouble(ScratchFloatReg, Address(StackPointer, iter->offsetFromArgBase()));
michael@0:             }
michael@0:             break;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Call into the real function.
michael@0:     AssertStackAlignment(masm);
michael@0:     masm.call(CallSiteDesc::Entry(), func.code());
michael@0: 
michael@0:     // Pop the stack and recover the original 'argv' argument passed to the
michael@0:     // trampoline (which was pushed on the stack).
michael@0:     masm.freeStack(stackDec);
michael@0:     masm.Pop(argv);
michael@0: 
michael@0:     // Store the return value in argv[0]
michael@0:     switch (func.sig().retType().which()) {
michael@0:       case RetType::Void:
michael@0:         break;
michael@0:       case RetType::Signed:
michael@0:         masm.storeValue(JSVAL_TYPE_INT32, ReturnReg, Address(argv, 0));
michael@0:         break;
michael@0:       case RetType::Float:
michael@0:         masm.convertFloat32ToDouble(ReturnFloatReg, ReturnFloatReg);
michael@0:         // Fall through as ReturnFloatReg now contains a Double
michael@0:       case RetType::Double:
michael@0:         masm.canonicalizeDouble(ReturnFloatReg);
michael@0:         masm.storeDouble(ReturnFloatReg, Address(argv, 0));
michael@0:         break;
michael@0:     }
michael@0: 
michael@0:     // Restore clobbered non-volatile registers of the caller.
michael@0:     masm.PopRegsInMask(NonVolatileRegs);
michael@0: 
michael@0:     JS_ASSERT(masm.framePushed() == 0);
michael@0: 
michael@0:     masm.move32(Imm32(true), ReturnReg);
michael@0:     masm.abiret();
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static inline bool
michael@0: TryEnablingIon(JSContext *cx, AsmJSModule &module, HandleFunction fun, uint32_t exitIndex,
michael@0:                int32_t argc, Value *argv)
michael@0: {
michael@0:     if (!fun->hasScript())
michael@0:         return true;
michael@0: 
michael@0:     // Test if the function is Ion compiled
michael@0:     JSScript *script = fun->nonLazyScript();
michael@0:     if (!script->hasIonScript())
michael@0:         return true;
michael@0: 
michael@0:     // Currently we can't rectify arguments. Therefore disabling if argc is too low.
michael@0:     if (fun->nargs() > size_t(argc))
michael@0:         return true;
michael@0: 
michael@0:     // Normally the types should corresond, since we just ran with those types,
michael@0:     // but there are reports this is asserting. Therefore doing it as a check, instead of DEBUG only.
michael@0:     if (!types::TypeScript::ThisTypes(script)->hasType(types::Type::UndefinedType()))
michael@0:         return true;
michael@0:     for(uint32_t i = 0; i < fun->nargs(); i++) {
michael@0:         types::StackTypeSet *typeset = types::TypeScript::ArgTypes(script, i);
michael@0:         types::Type type = types::Type::DoubleType();
michael@0:         if (!argv[i].isDouble())
michael@0:             type = types::Type::PrimitiveType(argv[i].extractNonDoubleType());
michael@0:         if (!typeset->hasType(type))
michael@0:             return true;
michael@0:     }
michael@0: 
michael@0:     // Enable
michael@0:     IonScript *ionScript = script->ionScript();
michael@0:     if (!ionScript->addDependentAsmJSModule(cx, DependentAsmJSModuleExit(&module, exitIndex)))
michael@0:         return false;
michael@0: 
michael@0:     module.exitIndexToGlobalDatum(exitIndex).exit = module.ionExitTrampoline(module.exit(exitIndex));
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: namespace js {
michael@0: 
michael@0: int32_t
michael@0: InvokeFromAsmJS_Ignore(JSContext *cx, int32_t exitIndex, int32_t argc, Value *argv)
michael@0: {
michael@0:     AsmJSModule &module = cx->mainThread().asmJSActivationStackFromOwnerThread()->module();
michael@0: 
michael@0:     RootedFunction fun(cx, module.exitIndexToGlobalDatum(exitIndex).fun);
michael@0:     RootedValue fval(cx, ObjectValue(*fun));
michael@0:     RootedValue rval(cx);
michael@0:     if (!Invoke(cx, UndefinedValue(), fval, argc, argv, &rval))
michael@0:         return false;
michael@0: 
michael@0:     if (!TryEnablingIon(cx, module, fun, exitIndex, argc, argv))
michael@0:         return false;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: int32_t
michael@0: InvokeFromAsmJS_ToInt32(JSContext *cx, int32_t exitIndex, int32_t argc, Value *argv)
michael@0: {
michael@0:     AsmJSModule &module = cx->mainThread().asmJSActivationStackFromOwnerThread()->module();
michael@0: 
michael@0:     RootedFunction fun(cx, module.exitIndexToGlobalDatum(exitIndex).fun);
michael@0:     RootedValue fval(cx, ObjectValue(*fun));
michael@0:     RootedValue rval(cx);
michael@0:     if (!Invoke(cx, UndefinedValue(), fval, argc, argv, &rval))
michael@0:         return false;
michael@0: 
michael@0:     if (!TryEnablingIon(cx, module, fun, exitIndex, argc, argv))
michael@0:         return false;
michael@0: 
michael@0:     int32_t i32;
michael@0:     if (!ToInt32(cx, rval, &i32))
michael@0:         return false;
michael@0:     argv[0] = Int32Value(i32);
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: int32_t
michael@0: InvokeFromAsmJS_ToNumber(JSContext *cx, int32_t exitIndex, int32_t argc, Value *argv)
michael@0: {
michael@0:     AsmJSModule &module = cx->mainThread().asmJSActivationStackFromOwnerThread()->module();
michael@0: 
michael@0:     RootedFunction fun(cx, module.exitIndexToGlobalDatum(exitIndex).fun);
michael@0:     RootedValue fval(cx, ObjectValue(*fun));
michael@0:     RootedValue rval(cx);
michael@0:     if (!Invoke(cx, UndefinedValue(), fval, argc, argv, &rval))
michael@0:         return false;
michael@0: 
michael@0:     if (!TryEnablingIon(cx, module, fun, exitIndex, argc, argv))
michael@0:         return false;
michael@0: 
michael@0:     double dbl;
michael@0:     if (!ToNumber(cx, rval, &dbl))
michael@0:         return false;
michael@0:     argv[0] = DoubleValue(dbl);
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: }  // namespace js
michael@0: 
michael@0: static void
michael@0: FillArgumentArray(ModuleCompiler &m, const VarTypeVector &argTypes,
michael@0:                   unsigned offsetToArgs, unsigned offsetToCallerStackArgs,
michael@0:                   Register scratch)
michael@0: {
michael@0:     MacroAssembler &masm = m.masm();
michael@0: 
michael@0:     for (ABIArgTypeIter i(argTypes); !i.done(); i++) {
michael@0:         Address dstAddr = Address(StackPointer, offsetToArgs + i.index() * sizeof(Value));
michael@0:         switch (i->kind()) {
michael@0:           case ABIArg::GPR:
michael@0:             masm.storeValue(JSVAL_TYPE_INT32, i->gpr(), dstAddr);
michael@0:             break;
michael@0:           case ABIArg::FPU: {
michael@0:               masm.canonicalizeDouble(i->fpu());
michael@0:               masm.storeDouble(i->fpu(), dstAddr);
michael@0:               break;
michael@0:           }
michael@0:           case ABIArg::Stack:
michael@0:             if (i.mirType() == MIRType_Int32) {
michael@0:                 Address src(StackPointer, offsetToCallerStackArgs + i->offsetFromArgBase());
michael@0: #if defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64)
michael@0:                 masm.load32(src, scratch);
michael@0:                 masm.storeValue(JSVAL_TYPE_INT32, scratch, dstAddr);
michael@0: #else
michael@0:                 masm.memIntToValue(src, dstAddr);
michael@0: #endif
michael@0:             } else {
michael@0:                 JS_ASSERT(i.mirType() == MIRType_Double);
michael@0:                 Address src(StackPointer, offsetToCallerStackArgs + i->offsetFromArgBase());
michael@0:                 masm.loadDouble(src, ScratchFloatReg);
michael@0:                 masm.canonicalizeDouble(ScratchFloatReg);
michael@0:                 masm.storeDouble(ScratchFloatReg, dstAddr);
michael@0:             }
michael@0:             break;
michael@0:         }
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void
michael@0: GenerateFFIInterpreterExit(ModuleCompiler &m, const ModuleCompiler::ExitDescriptor &exit,
michael@0:                            unsigned exitIndex, Label *throwLabel)
michael@0: {
michael@0:     MacroAssembler &masm = m.masm();
michael@0:     masm.align(CodeAlignment);
michael@0:     m.setInterpExitOffset(exitIndex);
michael@0:     masm.setFramePushed(0);
michael@0: #if defined(JS_CODEGEN_ARM)
michael@0:     masm.Push(lr);
michael@0: #endif
michael@0: 
michael@0:     MIRType typeArray[] = { MIRType_Pointer,   // cx
michael@0:                             MIRType_Pointer,   // exitDatum
michael@0:                             MIRType_Int32,     // argc
michael@0:                             MIRType_Pointer }; // argv
michael@0:     MIRTypeVector invokeArgTypes(m.cx());
michael@0:     invokeArgTypes.infallibleAppend(typeArray, ArrayLength(typeArray));
michael@0: 
michael@0:     // The stack layout looks like:
michael@0:     // | return address | stack arguments | array of values |
michael@0:     unsigned arraySize = Max<size_t>(1, exit.sig().args().length()) * sizeof(Value);
michael@0:     unsigned stackDec = StackDecrementForCall(masm, invokeArgTypes, arraySize + MaybeRetAddr);
michael@0:     masm.reserveStack(stackDec);
michael@0: 
michael@0:     // Fill the argument array.
michael@0:     unsigned offsetToCallerStackArgs = AlignmentAtPrologue + masm.framePushed();
michael@0:     unsigned offsetToArgv = StackArgBytes(invokeArgTypes) + MaybeRetAddr;
michael@0:     Register scratch = ABIArgGenerator::NonArgReturnVolatileReg0;
michael@0:     FillArgumentArray(m, exit.sig().args(), offsetToArgv, offsetToCallerStackArgs, scratch);
michael@0: 
michael@0:     // Prepare the arguments for the call to InvokeFromAsmJS_*.
michael@0:     ABIArgMIRTypeIter i(invokeArgTypes);
michael@0:     Register activation = ABIArgGenerator::NonArgReturnVolatileReg1;
michael@0:     LoadAsmJSActivationIntoRegister(masm, activation);
michael@0: 
michael@0:     // Record sp in the AsmJSActivation for stack-walking.
michael@0:     masm.storePtr(StackPointer, Address(activation, AsmJSActivation::offsetOfExitSP()));
michael@0: 
michael@0:     // argument 0: cx
michael@0:     if (i->kind() == ABIArg::GPR) {
michael@0:         LoadJSContextFromActivation(masm, activation, i->gpr());
michael@0:     } else {
michael@0:         LoadJSContextFromActivation(masm, activation, scratch);
michael@0:         masm.storePtr(scratch, Address(StackPointer, i->offsetFromArgBase()));
michael@0:     }
michael@0:     i++;
michael@0: 
michael@0:     // argument 1: exitIndex
michael@0:     if (i->kind() == ABIArg::GPR)
michael@0:         masm.mov(ImmWord(exitIndex), i->gpr());
michael@0:     else
michael@0:         masm.store32(Imm32(exitIndex), Address(StackPointer, i->offsetFromArgBase()));
michael@0:     i++;
michael@0: 
michael@0:     // argument 2: argc
michael@0:     unsigned argc = exit.sig().args().length();
michael@0:     if (i->kind() == ABIArg::GPR)
michael@0:         masm.mov(ImmWord(argc), i->gpr());
michael@0:     else
michael@0:         masm.store32(Imm32(argc), Address(StackPointer, i->offsetFromArgBase()));
michael@0:     i++;
michael@0: 
michael@0:     // argument 3: argv
michael@0:     Address argv(StackPointer, offsetToArgv);
michael@0:     if (i->kind() == ABIArg::GPR) {
michael@0:         masm.computeEffectiveAddress(argv, i->gpr());
michael@0:     } else {
michael@0:         masm.computeEffectiveAddress(argv, scratch);
michael@0:         masm.storePtr(scratch, Address(StackPointer, i->offsetFromArgBase()));
michael@0:     }
michael@0:     i++;
michael@0:     JS_ASSERT(i.done());
michael@0: 
michael@0:     // Make the call, test whether it succeeded, and extract the return value.
michael@0:     AssertStackAlignment(masm);
michael@0:     switch (exit.sig().retType().which()) {
michael@0:       case RetType::Void:
michael@0:         masm.callExit(AsmJSImm_InvokeFromAsmJS_Ignore, i.stackBytesConsumedSoFar());
michael@0:         masm.branchTest32(Assembler::Zero, ReturnReg, ReturnReg, throwLabel);
michael@0:         break;
michael@0:       case RetType::Signed:
michael@0:         masm.callExit(AsmJSImm_InvokeFromAsmJS_ToInt32, i.stackBytesConsumedSoFar());
michael@0:         masm.branchTest32(Assembler::Zero, ReturnReg, ReturnReg, throwLabel);
michael@0:         masm.unboxInt32(argv, ReturnReg);
michael@0:         break;
michael@0:       case RetType::Double:
michael@0:         masm.callExit(AsmJSImm_InvokeFromAsmJS_ToNumber, i.stackBytesConsumedSoFar());
michael@0:         masm.branchTest32(Assembler::Zero, ReturnReg, ReturnReg, throwLabel);
michael@0:         masm.loadDouble(argv, ReturnFloatReg);
michael@0:         break;
michael@0:       case RetType::Float:
michael@0:         MOZ_ASSUME_UNREACHABLE("Float32 shouldn't be returned from a FFI");
michael@0:         break;
michael@0:     }
michael@0: 
michael@0:     // Note: the caller is IonMonkey code which means there are no non-volatile
michael@0:     // registers to restore.
michael@0:     masm.freeStack(stackDec);
michael@0:     masm.ret();
michael@0: }
michael@0: 
michael@0: static void
michael@0: GenerateOOLConvert(ModuleCompiler &m, RetType retType, Label *throwLabel)
michael@0: {
michael@0:     MacroAssembler &masm = m.masm();
michael@0: 
michael@0:     MIRType typeArray[] = { MIRType_Pointer,   // cx
michael@0:                             MIRType_Pointer }; // argv
michael@0:     MIRTypeVector callArgTypes(m.cx());
michael@0:     callArgTypes.infallibleAppend(typeArray, ArrayLength(typeArray));
michael@0: 
michael@0:     // The stack is assumed to be aligned.  The frame is allocated by GenerateFFIIonExit and
michael@0:     // the stack usage here needs to kept in sync with GenerateFFIIonExit.
michael@0: 
michael@0:     // Store value
michael@0:     unsigned offsetToArgv = StackArgBytes(callArgTypes) + MaybeRetAddr;
michael@0:     masm.storeValue(JSReturnOperand, Address(StackPointer, offsetToArgv));
michael@0: 
michael@0:     Register scratch = ABIArgGenerator::NonArgReturnVolatileReg0;
michael@0:     Register activation = ABIArgGenerator::NonArgReturnVolatileReg1;
michael@0:     LoadAsmJSActivationIntoRegister(masm, activation);
michael@0: 
michael@0:     // Record sp in the AsmJSActivation for stack-walking.
michael@0:     masm.storePtr(StackPointer, Address(activation, AsmJSActivation::offsetOfExitSP()));
michael@0: 
michael@0:     // Store real arguments
michael@0:     ABIArgMIRTypeIter i(callArgTypes);
michael@0: 
michael@0:     // argument 0: cx
michael@0:     if (i->kind() == ABIArg::GPR) {
michael@0:         LoadJSContextFromActivation(masm, activation, i->gpr());
michael@0:     } else {
michael@0:         LoadJSContextFromActivation(masm, activation, scratch);
michael@0:         masm.storePtr(scratch, Address(StackPointer, i->offsetFromArgBase()));
michael@0:     }
michael@0:     i++;
michael@0: 
michael@0:     // argument 1: argv
michael@0:     Address argv(StackPointer, offsetToArgv);
michael@0:     if (i->kind() == ABIArg::GPR) {
michael@0:         masm.computeEffectiveAddress(argv, i->gpr());
michael@0:     } else {
michael@0:         masm.computeEffectiveAddress(argv, scratch);
michael@0:         masm.storePtr(scratch, Address(StackPointer, i->offsetFromArgBase()));
michael@0:     }
michael@0:     i++;
michael@0:     JS_ASSERT(i.done());
michael@0: 
michael@0:     // Call
michael@0:     AssertStackAlignment(masm);
michael@0:     switch (retType.which()) {
michael@0:       case RetType::Signed:
michael@0:         masm.callExit(AsmJSImm_CoerceInPlace_ToInt32, i.stackBytesConsumedSoFar());
michael@0:         masm.branchTest32(Assembler::Zero, ReturnReg, ReturnReg, throwLabel);
michael@0:         masm.unboxInt32(Address(StackPointer, offsetToArgv), ReturnReg);
michael@0:         break;
michael@0:       case RetType::Double:
michael@0:         masm.callExit(AsmJSImm_CoerceInPlace_ToNumber, i.stackBytesConsumedSoFar());
michael@0:         masm.branchTest32(Assembler::Zero, ReturnReg, ReturnReg, throwLabel);
michael@0:         masm.loadDouble(Address(StackPointer, offsetToArgv), ReturnFloatReg);
michael@0:         break;
michael@0:       default:
michael@0:         MOZ_ASSUME_UNREACHABLE("Unsupported convert type");
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void
michael@0: GenerateFFIIonExit(ModuleCompiler &m, const ModuleCompiler::ExitDescriptor &exit,
michael@0:                          unsigned exitIndex, Label *throwLabel)
michael@0: {
michael@0:     MacroAssembler &masm = m.masm();
michael@0:     masm.align(CodeAlignment);
michael@0:     m.setIonExitOffset(exitIndex);
michael@0:     masm.setFramePushed(0);
michael@0: 
michael@0: #if defined(JS_CODEGEN_X64)
michael@0:     masm.Push(HeapReg);
michael@0: #elif defined(JS_CODEGEN_ARM)
michael@0:     // The lr register holds the return address and needs to be saved.  The GlobalReg
michael@0:     // (r10) and HeapReg (r11) also need to be restored before returning to asm.js code.
michael@0:     // The NANReg also needs to be restored, but is a constant and is reloaded before
michael@0:     // returning to asm.js code.
michael@0:     masm.PushRegsInMask(RegisterSet(GeneralRegisterSet((1<<GlobalReg.code()) |
michael@0:                                                        (1<<HeapReg.code()) |
michael@0:                                                        (1<<lr.code())),
michael@0:                                     FloatRegisterSet(uint32_t(0))));
michael@0: #endif
michael@0: 
michael@0:     // The stack frame is used for the call into Ion and also for calls into C for OOL
michael@0:     // conversion of the result.  A frame large enough for both is allocated.
michael@0:     //
michael@0:     // Arguments to the Ion function are in the following order on the stack:
michael@0:     // | return address | descriptor | callee | argc | this | arg1 | arg2 | ...
michael@0:     unsigned argBytes = 3 * sizeof(size_t) + (1 + exit.sig().args().length()) * sizeof(Value);
michael@0:     unsigned offsetToArgs = MaybeRetAddr;
michael@0:     unsigned stackDecForIonCall = StackDecrementForCall(masm, argBytes + offsetToArgs);
michael@0: 
michael@0:     // Reserve space for a call to AsmJSImm_CoerceInPlace_* and an array of values used by
michael@0:     // OOLConvert which reuses the same frame. This code needs to be kept in sync with the
michael@0:     // stack usage in GenerateOOLConvert.
michael@0:     MIRType typeArray[] = { MIRType_Pointer, MIRType_Pointer }; // cx, argv
michael@0:     MIRTypeVector callArgTypes(m.cx());
michael@0:     callArgTypes.infallibleAppend(typeArray, ArrayLength(typeArray));
michael@0:     unsigned oolExtraBytes = sizeof(Value) + MaybeRetAddr;
michael@0:     unsigned stackDecForOOLCall = StackDecrementForCall(masm, callArgTypes, oolExtraBytes);
michael@0: 
michael@0:     // Allocate a frame large enough for both of the above calls.
michael@0:     unsigned stackDec = Max(stackDecForIonCall, stackDecForOOLCall);
michael@0: 
michael@0:     masm.reserveStack(stackDec);
michael@0:     AssertStackAlignment(masm);
michael@0: 
michael@0:     // 1. Descriptor
michael@0:     size_t argOffset = offsetToArgs;
michael@0:     uint32_t descriptor = MakeFrameDescriptor(masm.framePushed(), JitFrame_Entry);
michael@0:     masm.storePtr(ImmWord(uintptr_t(descriptor)), Address(StackPointer, argOffset));
michael@0:     argOffset += sizeof(size_t);
michael@0: 
michael@0:     // 2. Callee
michael@0:     Register callee = ABIArgGenerator::NonArgReturnVolatileReg0;
michael@0:     Register scratch = ABIArgGenerator::NonArgReturnVolatileReg1;
michael@0: 
michael@0:     // 2.1. Get ExitDatum
michael@0:     unsigned globalDataOffset = m.module().exitIndexToGlobalDataOffset(exitIndex);
michael@0: #if defined(JS_CODEGEN_X64)
michael@0:     CodeOffsetLabel label2 = masm.leaRipRelative(callee);
michael@0:     m.masm().append(AsmJSGlobalAccess(label2.offset(), globalDataOffset));
michael@0: #elif defined(JS_CODEGEN_X86)
michael@0:     CodeOffsetLabel label2 = masm.movlWithPatch(Imm32(0), callee);
michael@0:     m.masm().append(AsmJSGlobalAccess(label2.offset(), globalDataOffset));
michael@0: #else
michael@0:     masm.lea(Operand(GlobalReg, globalDataOffset), callee);
michael@0: #endif
michael@0: 
michael@0:     // 2.2. Get callee
michael@0:     masm.loadPtr(Address(callee, offsetof(AsmJSModule::ExitDatum, fun)), callee);
michael@0: 
michael@0:     // 2.3. Save callee
michael@0:     masm.storePtr(callee, Address(StackPointer, argOffset));
michael@0:     argOffset += sizeof(size_t);
michael@0: 
michael@0:     // 3. Argc
michael@0:     unsigned argc = exit.sig().args().length();
michael@0:     masm.storePtr(ImmWord(uintptr_t(argc)), Address(StackPointer, argOffset));
michael@0:     argOffset += sizeof(size_t);
michael@0: 
michael@0:     // 4. |this| value
michael@0:     masm.storeValue(UndefinedValue(), Address(StackPointer, argOffset));
michael@0:     argOffset += sizeof(Value);
michael@0: 
michael@0:     // 5. Fill the arguments
michael@0:     unsigned offsetToCallerStackArgs = masm.framePushed();
michael@0: #if defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64)
michael@0:     offsetToCallerStackArgs += NativeFrameSize;
michael@0: #endif
michael@0:     FillArgumentArray(m, exit.sig().args(), argOffset, offsetToCallerStackArgs, scratch);
michael@0:     argOffset += exit.sig().args().length() * sizeof(Value);
michael@0:     JS_ASSERT(argOffset == offsetToArgs + argBytes);
michael@0: 
michael@0:     // Get the pointer to the ion code
michael@0:     Label done, oolConvert;
michael@0:     Label *maybeDebugBreakpoint = nullptr;
michael@0: 
michael@0: #ifdef DEBUG
michael@0:     Label ionFailed;
michael@0:     maybeDebugBreakpoint = &ionFailed;
michael@0:     masm.branchIfFunctionHasNoScript(callee, &ionFailed);
michael@0: #endif
michael@0: 
michael@0:     masm.loadPtr(Address(callee, JSFunction::offsetOfNativeOrScript()), callee);
michael@0:     masm.loadBaselineOrIonNoArgCheck(callee, callee, SequentialExecution, maybeDebugBreakpoint);
michael@0: 
michael@0:     AssertStackAlignment(masm);
michael@0: 
michael@0:     {
michael@0:         // Enable Activation.
michael@0:         //
michael@0:         // This sequence requires four registers, and needs to preserve the 'callee'
michael@0:         // register, so there are five live registers.
michael@0:         JS_ASSERT(callee == AsmJSIonExitRegCallee);
michael@0:         Register reg0 = AsmJSIonExitRegE0;
michael@0:         Register reg1 = AsmJSIonExitRegE1;
michael@0:         Register reg2 = AsmJSIonExitRegE2;
michael@0:         Register reg3 = AsmJSIonExitRegE3;
michael@0: 
michael@0:         LoadAsmJSActivationIntoRegister(masm, reg0);
michael@0: 
michael@0:         // Record sp in the AsmJSActivation for stack-walking.
michael@0:         masm.storePtr(StackPointer, Address(reg0, AsmJSActivation::offsetOfExitSP()));
michael@0: 
michael@0:         // The following is inlined:
michael@0:         //   JSContext *cx = activation->cx();
michael@0:         //   Activation *act = cx->mainThread().activation();
michael@0:         //   act.active_ = true;
michael@0:         //   act.prevIonTop_ = cx->mainThread().ionTop;
michael@0:         //   act.prevJitJSContext_ = cx->mainThread().jitJSContext;
michael@0:         //   cx->mainThread().jitJSContext = cx;
michael@0:         // On the ARM store8() uses the secondScratchReg (lr) as a temp.
michael@0:         size_t offsetOfActivation = offsetof(JSRuntime, mainThread) +
michael@0:                                     PerThreadData::offsetOfActivation();
michael@0:         size_t offsetOfIonTop = offsetof(JSRuntime, mainThread) + offsetof(PerThreadData, ionTop);
michael@0:         size_t offsetOfJitJSContext = offsetof(JSRuntime, mainThread) +
michael@0:                                       offsetof(PerThreadData, jitJSContext);
michael@0:         masm.loadPtr(Address(reg0, AsmJSActivation::offsetOfContext()), reg3);
michael@0:         masm.loadPtr(Address(reg3, JSContext::offsetOfRuntime()), reg0);
michael@0:         masm.loadPtr(Address(reg0, offsetOfActivation), reg1);
michael@0:         masm.store8(Imm32(1), Address(reg1, JitActivation::offsetOfActiveUint8()));
michael@0:         masm.loadPtr(Address(reg0, offsetOfIonTop), reg2);
michael@0:         masm.storePtr(reg2, Address(reg1, JitActivation::offsetOfPrevIonTop()));
michael@0:         masm.loadPtr(Address(reg0, offsetOfJitJSContext), reg2);
michael@0:         masm.storePtr(reg2, Address(reg1, JitActivation::offsetOfPrevJitJSContext()));
michael@0:         masm.storePtr(reg3, Address(reg0, offsetOfJitJSContext));
michael@0:     }
michael@0: 
michael@0:     // 2. Call
michael@0:     AssertStackAlignment(masm);
michael@0:     masm.callIonFromAsmJS(callee);
michael@0:     AssertStackAlignment(masm);
michael@0: 
michael@0:     {
michael@0:         // Disable Activation.
michael@0:         //
michael@0:         // This sequence needs three registers, and must preserve the JSReturnReg_Data and
michael@0:         // JSReturnReg_Type, so there are five live registers.
michael@0:         JS_ASSERT(JSReturnReg_Data == AsmJSIonExitRegReturnData);
michael@0:         JS_ASSERT(JSReturnReg_Type == AsmJSIonExitRegReturnType);
michael@0:         Register reg0 = AsmJSIonExitRegD0;
michael@0:         Register reg1 = AsmJSIonExitRegD1;
michael@0:         Register reg2 = AsmJSIonExitRegD2;
michael@0: 
michael@0:         LoadAsmJSActivationIntoRegister(masm, reg0);
michael@0: 
michael@0:         // The following is inlined:
michael@0:         //   JSContext *cx = activation->cx();
michael@0:         //   Activation *act = cx->mainThread().activation();
michael@0:         //   act.active_ = false;
michael@0:         //   cx->mainThread().ionTop = prevIonTop_;
michael@0:         //   cx->mainThread().jitJSContext = prevJitJSContext_;
michael@0:         // On the ARM store8() uses the secondScratchReg (lr) as a temp.
michael@0:         size_t offsetOfActivation = offsetof(JSRuntime, mainThread) +
michael@0:                                     PerThreadData::offsetOfActivation();
michael@0:         size_t offsetOfIonTop = offsetof(JSRuntime, mainThread) + offsetof(PerThreadData, ionTop);
michael@0:         size_t offsetOfJitJSContext = offsetof(JSRuntime, mainThread) +
michael@0:                                       offsetof(PerThreadData, jitJSContext);
michael@0:         masm.loadPtr(Address(reg0, AsmJSActivation::offsetOfContext()), reg0);
michael@0:         masm.loadPtr(Address(reg0, JSContext::offsetOfRuntime()), reg0);
michael@0:         masm.loadPtr(Address(reg0, offsetOfActivation), reg1);
michael@0:         masm.store8(Imm32(0), Address(reg1, JitActivation::offsetOfActiveUint8()));
michael@0:         masm.loadPtr(Address(reg1, JitActivation::offsetOfPrevIonTop()), reg2);
michael@0:         masm.storePtr(reg2, Address(reg0, offsetOfIonTop));
michael@0:         masm.loadPtr(Address(reg1, JitActivation::offsetOfPrevJitJSContext()), reg2);
michael@0:         masm.storePtr(reg2, Address(reg0, offsetOfJitJSContext));
michael@0:     }
michael@0: 
michael@0: #ifdef DEBUG
michael@0:     masm.branchTestMagicValue(Assembler::Equal, JSReturnOperand, JS_ION_ERROR, throwLabel);
michael@0:     masm.branchTestMagic(Assembler::Equal, JSReturnOperand, &ionFailed);
michael@0: #else
michael@0:     masm.branchTestMagic(Assembler::Equal, JSReturnOperand, throwLabel);
michael@0: #endif
michael@0: 
michael@0:     uint32_t oolConvertFramePushed = masm.framePushed();
michael@0:     switch (exit.sig().retType().which()) {
michael@0:       case RetType::Void:
michael@0:         break;
michael@0:       case RetType::Signed:
michael@0:         masm.convertValueToInt32(JSReturnOperand, ReturnFloatReg, ReturnReg, &oolConvert,
michael@0:                                  /* -0 check */ false);
michael@0:         break;
michael@0:       case RetType::Double:
michael@0:         masm.convertValueToDouble(JSReturnOperand, ReturnFloatReg, &oolConvert);
michael@0:         break;
michael@0:       case RetType::Float:
michael@0:         MOZ_ASSUME_UNREACHABLE("Float shouldn't be returned from a FFI");
michael@0:         break;
michael@0:     }
michael@0: 
michael@0:     masm.bind(&done);
michael@0:     masm.freeStack(stackDec);
michael@0: #if defined(JS_CODEGEN_ARM)
michael@0:     masm.ma_vimm(GenericNaN(), NANReg);
michael@0:     masm.PopRegsInMask(RegisterSet(GeneralRegisterSet((1<<GlobalReg.code()) |
michael@0:                                                       (1<<HeapReg.code()) |
michael@0:                                                       (1<<pc.code())),
michael@0:                                    FloatRegisterSet(uint32_t(0))));
michael@0: #else
michael@0: # if defined(JS_CODEGEN_X64)
michael@0:     masm.Pop(HeapReg);
michael@0: # endif
michael@0:     masm.ret();
michael@0: #endif
michael@0:     JS_ASSERT(masm.framePushed() == 0);
michael@0: 
michael@0:     // oolConvert
michael@0:     if (oolConvert.used()) {
michael@0:         masm.bind(&oolConvert);
michael@0:         masm.setFramePushed(oolConvertFramePushed);
michael@0:         GenerateOOLConvert(m, exit.sig().retType(), throwLabel);
michael@0:         masm.setFramePushed(0);
michael@0:         masm.jump(&done);
michael@0:     }
michael@0: 
michael@0: #ifdef DEBUG
michael@0:     masm.bind(&ionFailed);
michael@0:     masm.assumeUnreachable("AsmJS to IonMonkey call failed.");
michael@0: #endif
michael@0: }
michael@0: 
michael@0: // See "asm.js FFI calls" comment above.
michael@0: static void
michael@0: GenerateFFIExit(ModuleCompiler &m, const ModuleCompiler::ExitDescriptor &exit, unsigned exitIndex,
michael@0:                 Label *throwLabel)
michael@0: {
michael@0:     // Generate the slow path through the interpreter
michael@0:     GenerateFFIInterpreterExit(m, exit, exitIndex, throwLabel);
michael@0: 
michael@0:     // Generate the fast path
michael@0:     GenerateFFIIonExit(m, exit, exitIndex, throwLabel);
michael@0: }
michael@0: 
michael@0: // The stack-overflow exit is called when the stack limit has definitely been
michael@0: // exceeded. In this case, we can clobber everything since we are about to pop
michael@0: // all the frames.
michael@0: static bool
michael@0: GenerateStackOverflowExit(ModuleCompiler &m, Label *throwLabel)
michael@0: {
michael@0:     MacroAssembler &masm = m.masm();
michael@0:     masm.align(CodeAlignment);
michael@0:     masm.bind(&m.stackOverflowLabel());
michael@0: 
michael@0:     // The overflow check always occurs before the initial function-specific
michael@0:     // stack-size adjustment. See CodeGenerator::generateAsmJSPrologue.
michael@0:     masm.setFramePushed(AlignmentMidPrologue - AlignmentAtPrologue);
michael@0: 
michael@0:     MIRTypeVector argTypes(m.cx());
michael@0:     argTypes.infallibleAppend(MIRType_Pointer); // cx
michael@0: 
michael@0:     unsigned stackDec = StackDecrementForCall(masm, argTypes, MaybeRetAddr);
michael@0:     masm.reserveStack(stackDec);
michael@0: 
michael@0:     Register activation = ABIArgGenerator::NonArgReturnVolatileReg0;
michael@0:     LoadAsmJSActivationIntoRegister(masm, activation);
michael@0: 
michael@0:     // Record sp in the AsmJSActivation for stack-walking.
michael@0:     masm.storePtr(StackPointer, Address(activation, AsmJSActivation::offsetOfExitSP()));
michael@0: 
michael@0:     ABIArgMIRTypeIter i(argTypes);
michael@0: 
michael@0:     // argument 0: cx
michael@0:     if (i->kind() == ABIArg::GPR) {
michael@0:         LoadJSContextFromActivation(masm, activation, i->gpr());
michael@0:     } else {
michael@0:         LoadJSContextFromActivation(masm, activation, activation);
michael@0:         masm.storePtr(activation, Address(StackPointer, i->offsetFromArgBase()));
michael@0:     }
michael@0:     i++;
michael@0: 
michael@0:     JS_ASSERT(i.done());
michael@0: 
michael@0:     AssertStackAlignment(masm);
michael@0:     masm.callExit(AsmJSImm_ReportOverRecursed, i.stackBytesConsumedSoFar());
michael@0: 
michael@0:     // Don't worry about restoring the stack; throwLabel will pop everything.
michael@0:     masm.jump(throwLabel);
michael@0:     return !masm.oom();
michael@0: }
michael@0: 
michael@0: // The operation-callback exit is called from arbitrarily-interrupted asm.js
michael@0: // code. That means we must first save *all* registers and restore *all*
michael@0: // registers (except the stack pointer) when we resume. The address to resume to
michael@0: // (assuming that js::HandleExecutionInterrupt doesn't indicate that the
michael@0: // execution should be aborted) is stored in AsmJSActivation::resumePC_.
michael@0: // Unfortunately, loading this requires a scratch register which we don't have
michael@0: // after restoring all registers. To hack around this, push the resumePC on the
michael@0: // stack so that it can be popped directly into PC.
michael@0: static bool
michael@0: GenerateInterruptExit(ModuleCompiler &m, Label *throwLabel)
michael@0: {
michael@0:     MacroAssembler &masm = m.masm();
michael@0:     masm.align(CodeAlignment);
michael@0:     masm.bind(&m.interruptLabel());
michael@0: 
michael@0: #ifndef JS_CODEGEN_ARM
michael@0:     // Be very careful here not to perturb the machine state before saving it
michael@0:     // to the stack. In particular, add/sub instructions may set conditions in
michael@0:     // the flags register.
michael@0:     masm.push(Imm32(0));            // space for resumePC
michael@0:     masm.pushFlags();               // after this we are safe to use sub
michael@0:     masm.setFramePushed(0);         // set to zero so we can use masm.framePushed() below
michael@0:     masm.PushRegsInMask(AllRegsExceptSP); // save all GP/FP registers (except SP)
michael@0: 
michael@0:     Register activation = ABIArgGenerator::NonArgReturnVolatileReg0;
michael@0:     Register scratch = ABIArgGenerator::NonArgReturnVolatileReg1;
michael@0: 
michael@0:     // Store resumePC into the reserved space.
michael@0:     LoadAsmJSActivationIntoRegister(masm, activation);
michael@0:     masm.loadPtr(Address(activation, AsmJSActivation::offsetOfResumePC()), scratch);
michael@0:     masm.storePtr(scratch, Address(StackPointer, masm.framePushed() + sizeof(void*)));
michael@0: 
michael@0:     // We know that StackPointer is word-aligned, but not necessarily
michael@0:     // stack-aligned, so we need to align it dynamically.
michael@0:     masm.mov(StackPointer, ABIArgGenerator::NonVolatileReg);
michael@0: #if defined(JS_CODEGEN_X86)
michael@0:     // Ensure that at least one slot is pushed for passing 'cx' below.
michael@0:     masm.push(Imm32(0));
michael@0: #endif
michael@0:     masm.andPtr(Imm32(~(StackAlignment - 1)), StackPointer);
michael@0:     if (ShadowStackSpace)
michael@0:         masm.subPtr(Imm32(ShadowStackSpace), StackPointer);
michael@0: 
michael@0:     // argument 0: cx
michael@0: #if defined(JS_CODEGEN_X86)
michael@0:     LoadJSContextFromActivation(masm, activation, scratch);
michael@0:     masm.storePtr(scratch, Address(StackPointer, 0));
michael@0: #elif defined(JS_CODEGEN_X64)
michael@0:     LoadJSContextFromActivation(masm, activation, IntArgReg0);
michael@0: #endif
michael@0: 
michael@0:     masm.call(AsmJSImm_HandleExecutionInterrupt);
michael@0:     masm.branchIfFalseBool(ReturnReg, throwLabel);
michael@0: 
michael@0:     // Restore the StackPointer to it's position before the call.
michael@0:     masm.mov(ABIArgGenerator::NonVolatileReg, StackPointer);
michael@0: 
michael@0:     // Restore the machine state to before the interrupt.
michael@0:     masm.PopRegsInMask(AllRegsExceptSP); // restore all GP/FP registers (except SP)
michael@0:     masm.popFlags();              // after this, nothing that sets conditions
michael@0:     masm.ret();                   // pop resumePC into PC
michael@0: #else
michael@0:     masm.setFramePushed(0);         // set to zero so we can use masm.framePushed() below
michael@0:     masm.PushRegsInMask(RegisterSet(GeneralRegisterSet(Registers::AllMask & ~(1<<Registers::sp)), FloatRegisterSet(uint32_t(0))));   // save all GP registers,excep sp
michael@0: 
michael@0:     // Save both the APSR and FPSCR in non-volatile registers.
michael@0:     masm.as_mrs(r4);
michael@0:     masm.as_vmrs(r5);
michael@0:     // Save the stack pointer in a non-volatile register.
michael@0:     masm.mov(sp,r6);
michael@0:     // Align the stack.
michael@0:     masm.ma_and(Imm32(~7), sp, sp);
michael@0: 
michael@0:     // Store resumePC into the return PC stack slot.
michael@0:     LoadAsmJSActivationIntoRegister(masm, IntArgReg0);
michael@0:     masm.loadPtr(Address(IntArgReg0, AsmJSActivation::offsetOfResumePC()), IntArgReg1);
michael@0:     masm.storePtr(IntArgReg1, Address(r6, 14 * sizeof(uint32_t*)));
michael@0: 
michael@0:     // argument 0: cx
michael@0:     masm.loadPtr(Address(IntArgReg0, AsmJSActivation::offsetOfContext()), IntArgReg0);
michael@0: 
michael@0:     masm.PushRegsInMask(RegisterSet(GeneralRegisterSet(0), FloatRegisterSet(FloatRegisters::AllMask)));   // save all FP registers
michael@0:     masm.call(AsmJSImm_HandleExecutionInterrupt);
michael@0:     masm.branchIfFalseBool(ReturnReg, throwLabel);
michael@0: 
michael@0:     // Restore the machine state to before the interrupt. this will set the pc!
michael@0:     masm.PopRegsInMask(RegisterSet(GeneralRegisterSet(0), FloatRegisterSet(FloatRegisters::AllMask)));   // restore all FP registers
michael@0:     masm.mov(r6,sp);
michael@0:     masm.as_vmsr(r5);
michael@0:     masm.as_msr(r4);
michael@0:     // Restore all GP registers
michael@0:     masm.startDataTransferM(IsLoad, sp, IA, WriteBack);
michael@0:     masm.transferReg(r0);
michael@0:     masm.transferReg(r1);
michael@0:     masm.transferReg(r2);
michael@0:     masm.transferReg(r3);
michael@0:     masm.transferReg(r4);
michael@0:     masm.transferReg(r5);
michael@0:     masm.transferReg(r6);
michael@0:     masm.transferReg(r7);
michael@0:     masm.transferReg(r8);
michael@0:     masm.transferReg(r9);
michael@0:     masm.transferReg(r10);
michael@0:     masm.transferReg(r11);
michael@0:     masm.transferReg(r12);
michael@0:     masm.transferReg(lr);
michael@0:     masm.finishDataTransfer();
michael@0:     masm.ret();
michael@0: 
michael@0: #endif
michael@0: 
michael@0:     return !masm.oom();
michael@0: }
michael@0: 
michael@0: // If an exception is thrown, simply pop all frames (since asm.js does not
michael@0: // contain try/catch). To do this:
michael@0: //  1. Restore 'sp' to it's value right after the PushRegsInMask in GenerateEntry.
michael@0: //  2. PopRegsInMask to restore the caller's non-volatile registers.
michael@0: //  3. Return (to CallAsmJS).
michael@0: static bool
michael@0: GenerateThrowExit(ModuleCompiler &m, Label *throwLabel)
michael@0: {
michael@0:     MacroAssembler &masm = m.masm();
michael@0:     masm.align(CodeAlignment);
michael@0:     masm.bind(throwLabel);
michael@0: 
michael@0:     Register activation = ABIArgGenerator::NonArgReturnVolatileReg0;
michael@0:     LoadAsmJSActivationIntoRegister(masm, activation);
michael@0: 
michael@0:     masm.setFramePushed(FramePushedAfterSave);
michael@0:     masm.loadPtr(Address(activation, AsmJSActivation::offsetOfErrorRejoinSP()), StackPointer);
michael@0: 
michael@0:     masm.PopRegsInMask(NonVolatileRegs);
michael@0:     JS_ASSERT(masm.framePushed() == 0);
michael@0: 
michael@0:     masm.mov(ImmWord(0), ReturnReg);
michael@0:     masm.abiret();
michael@0: 
michael@0:     return !masm.oom();
michael@0: }
michael@0: 
michael@0: static bool
michael@0: GenerateStubs(ModuleCompiler &m)
michael@0: {
michael@0:     for (unsigned i = 0; i < m.module().numExportedFunctions(); i++) {
michael@0:         m.setEntryOffset(i);
michael@0:         if (!GenerateEntry(m, m.module().exportedFunction(i)))
michael@0:             return false;
michael@0:         if (m.masm().oom())
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     Label throwLabel;
michael@0: 
michael@0:     // The order of the iterations here is non-deterministic, since
michael@0:     // m.allExits() is a hash keyed by pointer values!
michael@0:     for (ModuleCompiler::ExitMap::Range r = m.allExits(); !r.empty(); r.popFront()) {
michael@0:         GenerateFFIExit(m, r.front().key(), r.front().value(), &throwLabel);
michael@0:         if (m.masm().oom())
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     if (m.stackOverflowLabel().used()) {
michael@0:         if (!GenerateStackOverflowExit(m, &throwLabel))
michael@0:             return false;
michael@0:     }
michael@0: 
michael@0:     if (!GenerateInterruptExit(m, &throwLabel))
michael@0:         return false;
michael@0: 
michael@0:     if (!GenerateThrowExit(m, &throwLabel))
michael@0:         return false;
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: FinishModule(ModuleCompiler &m,
michael@0:              ScopedJSDeletePtr<AsmJSModule> *module)
michael@0: {
michael@0:     LifoAlloc lifo(LIFO_ALLOC_PRIMARY_CHUNK_SIZE);
michael@0:     TempAllocator alloc(&lifo);
michael@0:     IonContext ionContext(m.cx(), &alloc);
michael@0: 
michael@0:     m.masm().resetForNewCodeGenerator(alloc);
michael@0: 
michael@0:     if (!GenerateStubs(m))
michael@0:         return false;
michael@0: 
michael@0:     return m.finish(module);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckModule(ExclusiveContext *cx, AsmJSParser &parser, ParseNode *stmtList,
michael@0:             ScopedJSDeletePtr<AsmJSModule> *moduleOut,
michael@0:             ScopedJSFreePtr<char> *compilationTimeReport)
michael@0: {
michael@0:     if (!LookupAsmJSModuleInCache(cx, parser, moduleOut, compilationTimeReport))
michael@0:         return false;
michael@0:     if (*moduleOut)
michael@0:         return true;
michael@0: 
michael@0:     ModuleCompiler m(cx, parser);
michael@0:     if (!m.init())
michael@0:         return false;
michael@0: 
michael@0:     if (PropertyName *moduleFunctionName = FunctionName(m.moduleFunctionNode())) {
michael@0:         if (!CheckModuleLevelName(m, m.moduleFunctionNode(), moduleFunctionName))
michael@0:             return false;
michael@0:         m.initModuleFunctionName(moduleFunctionName);
michael@0:     }
michael@0: 
michael@0:     if (!CheckFunctionHead(m, m.moduleFunctionNode()))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckModuleArguments(m, m.moduleFunctionNode()))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckPrecedingStatements(m, stmtList))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckModuleGlobals(m))
michael@0:         return false;
michael@0: 
michael@0: #ifdef JS_THREADSAFE
michael@0:     if (!CheckFunctionsParallel(m))
michael@0:         return false;
michael@0: #else
michael@0:     if (!CheckFunctionsSequential(m))
michael@0:         return false;
michael@0: #endif
michael@0: 
michael@0:     m.finishFunctionBodies();
michael@0: 
michael@0:     if (!CheckFuncPtrTables(m))
michael@0:         return false;
michael@0: 
michael@0:     if (!CheckModuleReturn(m))
michael@0:         return false;
michael@0: 
michael@0:     TokenKind tk = PeekToken(m.parser());
michael@0:     if (tk != TOK_EOF && tk != TOK_RC)
michael@0:         return m.fail(nullptr, "top-level export (return) must be the last statement");
michael@0: 
michael@0:     // The instruction cache is flushed when dynamically linking, so can inhibit now.
michael@0:     AutoFlushICache afc("CheckModule", /* inhibit= */ true);
michael@0: 
michael@0:     ScopedJSDeletePtr<AsmJSModule> module;
michael@0:     if (!FinishModule(m, &module))
michael@0:         return false;
michael@0: 
michael@0:     bool storedInCache = StoreAsmJSModuleInCache(parser, *module, cx);
michael@0:     module->staticallyLink(cx);
michael@0: 
michael@0:     m.buildCompilationTimeReport(storedInCache, compilationTimeReport);
michael@0:     *moduleOut = module.forget();
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: Warn(AsmJSParser &parser, int errorNumber, const char *str)
michael@0: {
michael@0:     parser.reportNoOffset(ParseWarning, /* strict = */ false, errorNumber, str ? str : "");
michael@0:     return false;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: EstablishPreconditions(ExclusiveContext *cx, AsmJSParser &parser)
michael@0: {
michael@0:     if (!cx->jitSupportsFloatingPoint())
michael@0:         return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by lack of floating point support");
michael@0: 
michael@0:     if (!cx->signalHandlersInstalled())
michael@0:         return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Platform missing signal handler support");
michael@0: 
michael@0:     if (cx->gcSystemPageSize() != AsmJSPageSize)
michael@0:         return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by non 4KiB system page size");
michael@0: 
michael@0:     if (!parser.options().asmJSOption)
michael@0:         return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by javascript.options.asmjs in about:config");
michael@0: 
michael@0:     if (!parser.options().compileAndGo)
michael@0:         return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Temporarily disabled for event-handler and other cloneable scripts");
michael@0: 
michael@0:     if (cx->compartment()->debugMode())
michael@0:         return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by debugger");
michael@0: 
michael@0:     if (parser.pc->isGenerator())
michael@0:         return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by generator context");
michael@0: 
michael@0:     if (parser.pc->isArrowFunction())
michael@0:         return Warn(parser, JSMSG_USE_ASM_TYPE_FAIL, "Disabled by arrow function context");
michael@0: 
michael@0: #ifdef JS_THREADSAFE
michael@0:     if (ParallelCompilationEnabled(cx))
michael@0:         EnsureWorkerThreadsInitialized(cx);
michael@0: #endif
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: NoExceptionPending(ExclusiveContext *cx)
michael@0: {
michael@0:     return !cx->isJSContext() || !cx->asJSContext()->isExceptionPending();
michael@0: }
michael@0: 
michael@0: bool
michael@0: js::CompileAsmJS(ExclusiveContext *cx, AsmJSParser &parser, ParseNode *stmtList, bool *validated)
michael@0: {
michael@0:     *validated = false;
michael@0: 
michael@0:     if (!EstablishPreconditions(cx, parser))
michael@0:         return NoExceptionPending(cx);
michael@0: 
michael@0:     ScopedJSFreePtr<char> compilationTimeReport;
michael@0:     ScopedJSDeletePtr<AsmJSModule> module;
michael@0:     if (!CheckModule(cx, parser, stmtList, &module, &compilationTimeReport))
michael@0:         return NoExceptionPending(cx);
michael@0: 
michael@0:     RootedObject moduleObj(cx, AsmJSModuleObject::create(cx, &module));
michael@0:     if (!moduleObj)
michael@0:         return false;
michael@0: 
michael@0:     FunctionBox *funbox = parser.pc->maybeFunction->pn_funbox;
michael@0:     RootedFunction moduleFun(cx, NewAsmJSModuleFunction(cx, funbox->function(), moduleObj));
michael@0:     if (!moduleFun)
michael@0:         return false;
michael@0: 
michael@0:     JS_ASSERT(funbox->function()->isInterpreted());
michael@0:     funbox->object = moduleFun;
michael@0: 
michael@0:     *validated = true;
michael@0:     Warn(parser, JSMSG_USE_ASM_TYPE_OK, compilationTimeReport.get());
michael@0:     return NoExceptionPending(cx);
michael@0: }
michael@0: 
michael@0: bool
michael@0: js::IsAsmJSCompilationAvailable(JSContext *cx, unsigned argc, Value *vp)
michael@0: {
michael@0:     CallArgs args = CallArgsFromVp(argc, vp);
michael@0: 
michael@0:     // See EstablishPreconditions.
michael@0:     bool available = cx->jitSupportsFloatingPoint() &&
michael@0:                      cx->signalHandlersInstalled() &&
michael@0:                      cx->gcSystemPageSize() == AsmJSPageSize &&
michael@0:                      !cx->compartment()->debugMode() &&
michael@0:                      cx->runtime()->options().asmJS();
michael@0: 
michael@0:     args.rval().set(BooleanValue(available));
michael@0:     return true;
michael@0: }