Attachment #8767828 for bug #1016936

Attachment #8767828: (Plan A) Part 1: Throw if the value returned by iterator.next() is not an object. for bug #1016936

View | Details | Raw Unified | Return to bug 1016936
Collapse All | Expand All





    if (!emitN(JSOP_DUPAT, 3, &off))
        return false;

    jsbytecode* pc = code(off);
    SET_UINT24(pc, slotFromTop);
    return true;
}

bool
BytecodeEmitter::emitCheckIsObj(CheckIsObjectKind kind)
{
    return emit2(JSOP_CHECKISOBJ, uint8_t(kind));
}

static const char*
StatementName(StmtInfoBCE* stmt)
{
    if (!stmt)
        return js_script_str;

    /* XXX too many "... statement" L10N gaffes -- fix via js.msg! */
    static const char* const statementName[] = {

    if (!emit1(JSOP_DUP))                                 // ... ITER ITER
        return false;
    if (!emitAtomOp(cx->names().next, JSOP_CALLPROP))     // ... ITER NEXT
        return false;
    if (!emit1(JSOP_SWAP))                                // ... NEXT ITER
        return false;
    if (!emitCall(JSOP_CALL, 0, pn))                      // ... RESULT
        return false;
    if (!emitCheckIsObj(CheckIsObjectKind::IteratorNext)) // ... RESULT
        return false;
    checkTypeSet(JSOP_CALL);
    return true;
}

bool
BytecodeEmitter::emitDefault(ParseNode* defaultExpr)
{
    if (!emit1(JSOP_DUP))                                 // VALUE VALUE

    if (!emitAtomOp(cx->names().next, JSOP_CALLPROP))            // RECEIVED ITER ITER NEXT
        return false;
    if (!emit1(JSOP_SWAP))                                       // RECEIVED ITER NEXT ITER
        return false;
    if (!emit2(JSOP_PICK, 3))                                    // ITER NEXT ITER RECEIVED
        return false;
    if (!emitCall(JSOP_CALL, 1, iter))                           // ITER RESULT
        return false;
    if (!emitCheckIsObj(CheckIsObjectKind::IteratorNext))        // ITER RESULT
        return false;
    checkTypeSet(JSOP_CALL);
    MOZ_ASSERT(this->stackDepth == depth);

    if (!emitJumpTargetAndPatch(checkResult))                    // checkResult:
        return false;

    // if (!result.done) goto tryStart;                          // ITER RESULT
    if (!emit1(JSOP_DUP))                                        // ITER RESULT RESULT





#include "jscntxt.h"
#include "jsopcode.h"
#include "jsscript.h"

#include "frontend/ParseMaps.h"
#include "frontend/Parser.h"
#include "frontend/SharedContext.h"
#include "frontend/SourceNotes.h"
#include "vm/Interpreter.h"

namespace js {

class ScopeObject;

namespace frontend {

class FullParseHandler;


    // Emit three bytecodes, an opcode with two bytes of immediate operands.
    MOZ_MUST_USE bool emit3(JSOp op, jsbytecode op1, jsbytecode op2);

    // Helper to emit JSOP_DUPAT. The argument is the value's depth on the
    // JS stack, as measured from the top.
    MOZ_MUST_USE bool emitDupAt(unsigned slotFromTop);

    // Helper to emit JSOP_CHECKISOBJ.
    MOZ_MUST_USE bool emitCheckIsObj(CheckIsObjectKind kind);

    // Emit a bytecode followed by an uint16 immediate operand stored in
    // big-endian order.
    MOZ_MUST_USE bool emitUint16Operand(JSOp op, uint32_t operand);

    // Emit a bytecode followed by an uint32 immediate operand.
    MOZ_MUST_USE bool emitUint32Operand(JSOp op, uint32_t operand);

    // Emit (1 + extra) bytecodes, for N bytes of op and its immediate operand.





      case JSOP_NEWARRAY_COPYONWRITE: {
        JSObject* obj = script->getObject(GET_UINT32_INDEX(pc));
        RootedValue objv(cx, ObjectValue(*obj));
        JSString* str = ValueToSource(cx, objv);
        if (!str)
            return false;
        return write(str);
      }
      case JSOP_CHECKISOBJ:
        return decompilePCForStackOperand(pc, -1);
      case JSOP_VOID:
        return write("void ") && decompilePCForStackOperand(pc, -1);
      default:
        break;
    }
    return write("(intermediate value)");
}







    RootedValue v(cx_);
    if (!GetProperty(cx_, iterator, iterator, cx_->names().next, &v))
        return false;

    if (!js::Call(cx_, v, iterator, &v))
        return false;

    if (!v.isObject())
        return ThrowCheckIsObject(cx_, CheckIsObjectKind::IteratorNext);
        return false;

    RootedObject resultObj(cx_, &v.toObject());
    if (!GetProperty(cx_, resultObj, resultObj, cx_->names().done, &v))
        return false;

    *done = ToBoolean(v);
    if (*done) {
        vp.setUndefined();
        return true;
    }





    /* Commence executing the actual opcode. */
    SANITY_CHECKS();
    DISPATCH_TO(op);
}

/* Various 1-byte no-ops. */
CASE(JSOP_NOP)
CASE(JSOP_NOP_DESTRUCTURING)
CASE(JSOP_UNUSED14)
CASE(JSOP_UNUSED149)
CASE(JSOP_UNUSED179)
CASE(JSOP_UNUSED180)
CASE(JSOP_UNUSED181)
CASE(JSOP_UNUSED182)
CASE(JSOP_UNUSED183)
CASE(JSOP_UNUSED187)
CASE(JSOP_UNUSED192)

            goto error;
    } else {
        ClonedBlockObject* lexicalScope = &cx->global()->lexicalScope();
        PUSH_COPY(lexicalScope->thisValue());
    }
}
END_CASE(JSOP_GLOBALTHIS)

CASE(JSOP_CHECKISOBJ)
{
    if (!REGS.sp[-1].isObject()) {
        MOZ_ALWAYS_FALSE(ThrowCheckIsObject(cx, CheckIsObjectKind(GET_UINT8(REGS.pc))));
        goto error;
    }
}
END_CASE(JSOP_CHECKISOBJ)

CASE(JSOP_CHECKTHIS)
{
    if (REGS.sp[-1].isMagic(JS_UNINITIALIZED_LEXICAL)) {
        MOZ_ALWAYS_FALSE(ThrowUninitializedThis(cx, REGS.fp()));
        goto error;
    }
}
END_CASE(JSOP_CHECKTHIS)

        else
            kindStr = frontend::Definition::kindString(declKind);
        JS_ReportErrorNumber(cx, GetErrorMessage, nullptr, JSMSG_REDECLARED_VAR,
                             kindStr, printable.ptr());
    }
}

bool
js::ThrowCheckIsObject(JSContext* cx, CheckIsObjectKind kind)
{
    switch (kind) {
      case CheckIsObjectKind::IteratorNext:
        JS_ReportErrorNumber(cx, GetErrorMessage, nullptr, JSMSG_NEXT_RETURNED_PRIMITIVE);
        break;
      default:
        MOZ_CRASH("Unknown kind");
    }
    return false;
}

bool
js::ThrowUninitializedThis(JSContext* cx, AbstractFramePtr frame)
{
    RootedFunction fun(cx);
    if (frame.isFunctionFrame()) {
        fun = frame.callee();
    } else {
        MOZ_ASSERT(frame.isEvalFrame());
        MOZ_ASSERT(frame.script()->isDirectEvalInFunction());






// The parser only reports redeclarations that occurs within a single
// script. Due to the extensibility of the global lexical scope, we also check
// for redeclarations during runtime in JSOP_DEF{VAR,LET,CONST}.
void
ReportRuntimeRedeclaration(JSContext* cx, HandlePropertyName name,
                           frontend::Definition::Kind declKind);

enum class CheckIsObjectKind : uint8_t {
    IteratorNext
};

bool
ThrowCheckIsObject(JSContext* cx, CheckIsObjectKind kind);

bool
ThrowUninitializedThis(JSContext* cx, AbstractFramePtr frame);

bool
DefaultClassConstructor(JSContext* cx, unsigned argc, Value* vp);

bool
Debug_CheckSelfHosted(JSContext* cx, HandleValue v);





     * Duplicates the top two values on the stack.
     *   Category: Operators
     *   Type: Stack Operations
     *   Operands:
     *   Stack: v1, v2 => v1, v2, v1, v2
     */ \
    macro(JSOP_DUP2,      13, "dup2",       NULL,         1,  2,  4, JOF_BYTE) \
    \
    /*
     * Check if the top value of the stack is an object, and throws if not.
     *   Category: Statements
     *   Type: Generator
     *   Operands: int8_t kind
     *   Stack: result => result
     */ \
    macro(JSOP_CHECKISOBJ,14, "checkisobj", NULL,         2,  1,  1, JOF_UINT8) \
    \
    /*
     * Pops the top two values 'lval' and 'rval' from the stack, then pushes
     * the result of the operation applied to the two operands, converting
     * both to 32-bit signed integers if necessary.
     *   Category: Operators
     *   Type: Bitwise Logical Operators
     *   Operands:

Return to bug 1016936