src/kjs/nodes2bytecode.cpp

/*
 *  This file is part of the KDE libraries
 *  Copyright (C) 1999-2002 Harri Porten (porten@kde.org)
 *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
 *  Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
 *  Copyright (C) 2007, 2008 Maksim Orlovich (maksim@kde.org)
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public License
 *  along with this library; see the file COPYING.LIB.  If not, write to
 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA 02110-1301, USA.
 *
 */
#include "nodes2bytecode.h"
#include <wtf/Assertions.h>

#include <typeinfo>
#include <iostream>

namespace KJS
{

// A few helpers..
static void emitError(CompileState *comp, Node *node, ErrorType type, const char *msgStr)
{
    OpValue me = OpValue::immNode(node);
    OpValue se = OpValue::immInt32(type);
    OpValue msg = OpValue::immCStr(msgStr);
    CodeGen::emitOp(comp, Op_RaiseError, nullptr, &me, &se, &msg);
}

static void emitSyntaxError(CompileState *comp, Node *node, const char *msgStr)
{
    emitError(comp, node, SyntaxError, msgStr);
}

static void emitReferenceError(CompileState *comp, Node *node, const char *msgStr)
{
    emitError(comp, node, ReferenceError, msgStr);
}

OpValue Node::generateEvalCode(CompileState *)
{
    std::cerr << "WARNING: no generateEvalCode for:" << typeid(*this).name() << "\n";
    ASSERT(0);

    return OpValue::immInt32(42);
}

void StatementNode::generateExecCode(CompileState *)
{
    std::cerr << "WARNING: no generateExecCode for:" << typeid(*this).name() << "\n";
    ASSERT(0);
}

void StatementNode::generateDebugInfo(CompileState *comp)
{
    OpValue me = OpValue::immNode(this);
    CodeGen::emitOp(comp, Op_AtStatement, nullptr, &me);
}

static inline bool exitContextNeeded(CompileState *comp)
{
    return comp->compileType() == Debug &&
           comp->codeType()    == FunctionCode;
}

static void generateExitContextIfNeeded(CompileState *comp)
{
    if (exitContextNeeded(comp)) {
        OpValue ourNode = OpValue::immNode(comp->functionBody());
        CodeGen::emitOp(comp, Op_ExitDebugContext, nullptr, &ourNode);
    }
}

// ------------------------------ Basic literals -----------------------------------------

OpValue NullNode::generateEvalCode(CompileState *)
{
    return OpValue::immValue(jsNull());
}

OpValue BooleanNode::generateEvalCode(CompileState *)
{
    return OpValue::immBool(value());
}

OpValue NumberNode::generateEvalCode(CompileState *)
{
    using namespace std;
#if 0
    if (typeHint == OpType_Value) {
        // Try to fit into a JSValue if at all possible..
        JSValue *im = JSImmediate::from(value());
        if (im) {
            OpValue res = mkImmediateVal(OpType_value);
            return res;
        }
    }
#endif

    // Numeric-like..
    double d = value();
    int32_t i32 = JSValue::toInt32(d);
    if (double(i32) == d && !(i32 == 0 && signbit(d))) { // be careful with -0.0 here
        return OpValue::immInt32(i32);
    } else {
        return OpValue::immNumber(d);
    }
}

OpValue StringNode::generateEvalCode(CompileState *comp)
{
    // For now, just generate a JSValue
    // We may want to permit string pointers as well, to help overload resolution,
    // but it's not clear whether that's useful, since we can't MM them. Perhaps
    // a special StringInstance type may be of use eventually.

    if (interned) { // we're re-compiling.. just reuse it
        return OpValue::immValue(interned);
    }

    // Intern shorter strings
    if (val.size() < 16) {
        interned = Interpreter::internString(val);
        return OpValue::immValue(interned);
    } else {
        OpValue inStr = OpValue::immString(&val);

        OpValue out;
        CodeGen::emitOp(comp, Op_OwnedString, &out, &inStr);
        return out;
    }
}

StringNode::~StringNode()
{
    if (interned) {
        Interpreter::releaseInternedString(val);
    }
}

OpValue RegExpNode::generateEvalCode(CompileState *comp)
{
    // ### TODO: cache the engine object?
    OpValue out;
    OpValue patternV = OpValue::immString(&pattern);
    OpValue flagsV   = OpValue::immString(&flags);
    CodeGen::emitOp(comp, Op_NewRegExp, &out, &patternV, &flagsV);
    return out;
}

OpValue ThisNode::generateEvalCode(CompileState *comp)
{
    return *comp->thisValue();
}

// ------------------------------ VarAccessNode ----------------------------------------

size_t VarAccessNode::classifyVariable(CompileState *comp, Classification &classify)
{
    // Are we inside a with or catch? In that case, it's all dynamic. Boo.
    // Ditto for eval.
    // ### actually that may be improvable if we can
    // distinguish eval-from-global and eval-from-local, since
    // we'd have an activation or global object available for access.
    if (comp->inNestedScope() || comp->codeType() == EvalCode) {
        classify = Dynamic;
        return missingSymbolMarker();
    }

    // If we're inside global scope (and as per above, not inside any nested scope!)
    // we can always used the global object
    if (comp->codeType() == GlobalCode) {
        classify = Global;
        return missingSymbolMarker();
    }

    // We're inside a function...
    if (ident == CommonIdentifiers::shared()->arguments) {
        // arguments is too much of a pain to handle in general path..
        classify = Dynamic;
        return missingSymbolMarker();
    }

    // Do we know this?
    size_t index = comp->functionBody()->lookupSymbolID(ident);
    if (index == missingSymbolMarker()) {
        classify = NonLocal;
    } else {
        classify = Local;
    }

    return index;
}

OpValue VarAccessNode::generateEvalCode(CompileState *comp)
{
    Classification classify;
    size_t index = classifyVariable(comp, classify);

    OpValue out;
    OpValue varName = OpValue::immIdent(&ident);
    switch (classify) {
    case Local: {
        // Register read.
        out = comp->localReadVal(index);
        break;
    }
    case NonLocal:
        CodeGen::emitOp(comp, Op_NonLocalVarGet, &out, &varName);
        break;
    case Global:
        CodeGen::emitOp(comp, Op_GlobalObjectGet, &out, &varName);
        break;
    case Dynamic:
        CodeGen::emitOp(comp, Op_VarGet, &out, &varName);
        break;
    }

    return out;
}

OpValue VarAccessNode::valueForTypeOf(CompileState *comp)
{
    // ### some code dupe here.
    Classification classify;
    size_t index = classifyVariable(comp, classify);

    OpValue scopeTemp;
    OpValue out, outReg;
    OpValue varName = OpValue::immIdent(&ident);
    switch (classify) {
    case Local:
        // Register read. Easy.
        out = comp->localReadVal(index);
        break;
    case Global:
        CodeGen::emitOp(comp, Op_SymGetKnownObject, &out, comp->globalScope(), &varName);
        break;
    case NonLocal:
        comp->requestTemporary(OpType_value, &out, &outReg);
        CodeGen::emitOp(comp, Op_NonLocalScopeLookupAndGet, &scopeTemp, &outReg, &varName);
        break;
    case Dynamic:
        comp->requestTemporary(OpType_value, &out, &outReg);
        CodeGen::emitOp(comp, Op_ScopeLookupAndGet, &scopeTemp, &outReg, &varName);
        break;
    }

    return out;
}

CompileReference *VarAccessNode::generateRefBind(CompileState *comp)
{
    Classification classify;
    classifyVariable(comp, classify);

    if (classify == Local || classify == Global) {
        return nullptr;    // nothing to do, we know where it is
    }

    // Otherwise, we need to find the scope for writing
    CompileReference *ref = new CompileReference;

    OpValue quiet = OpValue::immNode(nullptr);
    OpValue varName = OpValue::immIdent(&ident);
    CodeGen::emitOp(comp, classify == Dynamic ? Op_ScopeLookup : Op_NonLocalScopeLookup,
                    &ref->baseObj, &varName, &quiet);
    return ref;
}

CompileReference *VarAccessNode::generateRefRead(CompileState *comp, OpValue *out)
{
    Classification classify;
    classifyVariable(comp, classify);

    // We want to bind and read, also issuing an error.

    // If we don't need any binding, just use normal read code..
    if (classify == Local || classify == Global) {
        *out = generateEvalCode(comp);
        return nullptr;
    }

    // For others, use the lookup-and-fetch ops
    CompileReference *ref = new CompileReference;

    OpValue readReg;
    OpValue varName = OpValue::immIdent(&ident);
    comp->requestTemporary(OpType_value, out, &readReg);

    OpName op;
    if (classify == Dynamic) {
        op = Op_ScopeLookupAndGetChecked;
    } else {
        op = Op_NonLocalScopeLookupAndGetChecked;
    }
    CodeGen::emitOp(comp, op, &ref->baseObj, &readReg, &varName);

    return ref;
}

void VarAccessNode::generateRefWrite(CompileState *comp,
                                     CompileReference *ref, OpValue &valToStore)
{
    Classification classify;
    size_t index = classifyVariable(comp, classify);

    if (classify == Local) {
        // Straight register put..
        OpValue destReg = comp->localWriteRef(comp->codeBlock(), index);
        CodeGen::emitOp(comp, Op_RegPutValue, nullptr, &destReg, &valToStore);
    } else {
        // Symbolic write to the appropriate scope..
        OpValue varName = OpValue::immIdent(&ident);
        CodeGen::emitOp(comp, Op_SymPutKnownObject, nullptr,
                        (classify == Global ? comp->globalScope() : &ref->baseObj), &varName, &valToStore);
    }
}

OpValue VarAccessNode::generateRefDelete(CompileState *comp)
{
    Classification classify;
    classifyVariable(comp, classify);

    if (classify == Local) {
        // Normal locals are DontDelete, so this always fails.
        return OpValue::immBool(false);
    }

    // Otherwise, fetch the appropriate scope
    OpValue base;
    if (classify == Global) {
        base = *comp->globalScope();
    } else {
        OpValue varName = OpValue::immIdent(&ident);
        OpValue silent  = OpValue::immNode(nullptr);
        CodeGen::emitOp(comp, classify == Dynamic ? Op_ScopeLookup : Op_NonLocalScopeLookup,
                        &base, &varName, &silent);
    }

    // Remove the property..
    OpValue out;
    OpValue varName = OpValue::immIdent(&ident);
    CodeGen::emitOp(comp, Op_SymDeleteKnownObject, &out, &base, &varName);
    return out;
}

void VarAccessNode::generateRefFunc(CompileState *comp, OpValue *funOut, OpValue *thisOut)
{
    Classification classify;
    classifyVariable(comp, classify);

    OpValue varName = OpValue::immIdent(&ident);

    OpValue thisReg;
    switch (classify) {
    case Local:
    case Global:
        // Both of these use global object for this, and use straightforward lookup for value
        *funOut  = generateEvalCode(comp);
        *thisOut = *comp->globalScope();
        break;
    case NonLocal:
        comp->requestTemporary(OpType_value, thisOut, &thisReg);
        CodeGen::emitOp(comp, Op_NonLocalFunctionLookupAndGet, funOut, &thisReg, &varName);
        break;
    case Dynamic:
        comp->requestTemporary(OpType_value, thisOut, &thisReg);
        CodeGen::emitOp(comp, Op_FunctionLookupAndGet, funOut, &thisReg, &varName);
        break;
    }
}

// ------------------------------ GroupNode----------------------------------------

OpValue GroupNode::generateEvalCode(CompileState *comp)
{
    return group->generateEvalCode(comp);
}

// ------------------------------ Object + Array literals --------------------------

OpValue ArrayNode::generateEvalCode(CompileState *comp)
{
    OpValue arr;
    CodeGen::emitOp(comp, Op_NewEmptyArray, &arr);

    OpValue und = OpValue::immValue(jsUndefined());

    int pos = 0;
    for (ElementNode *el = element.get(); el; el = el->next.get()) {
        if (!el->node) {
            // Fill elision w/undefined, unless we can just skip over to a value
            for (int i = 0; i < el->elision; i++) {
                OpValue ind = OpValue::immInt32(pos);
                CodeGen::emitOp(comp, Op_BracketPutKnownObject, nullptr, &arr, &ind, &und);
                ++pos;
            }
        } else {
            pos += el->elision;
        }

        if (el->node) {
            OpValue val = el->node->generateEvalCode(comp);
            OpValue ind = OpValue::immInt32(pos);
            CodeGen::emitOp(comp, Op_BracketPutKnownObject, nullptr, &arr, &ind, &val);
            ++pos;
        }
    }

    for (int i = 0; i < elision; i++) {
        OpValue ind = OpValue::immInt32(pos);
        CodeGen::emitOp(comp, Op_BracketPutKnownObject, nullptr, &arr, &ind, &und);
        ++pos;
    }

    return arr;
}

OpValue ObjectLiteralNode::generateEvalCode(CompileState *comp)
{
    OpValue obj;
    CodeGen::emitOp(comp, Op_NewObject, &obj);

    for (PropertyListNode *entry = list.get(); entry; entry = entry->next.get()) {
        PropertyNode *prop = entry->node.get();
        OpValue name = OpValue::immIdent(&prop->name->str);
        OpValue val  = prop->assign->generateEvalCode(comp);

        switch (prop->type) {
        case PropertyNode::Getter:
            CodeGen::emitOp(comp, Op_DefineGetter, nullptr, &obj, &name, &val);
            break;
        case PropertyNode::Setter:
            CodeGen::emitOp(comp, Op_DefineSetter, nullptr, &obj, &name, &val);
            break;
        case PropertyNode::Constant:
            CodeGen::emitOp(comp, Op_SymPutKnownObject, nullptr, &obj, &name, &val);
            break;
        }
    }

    return obj;
}

// ------------------------------ BracketAccessorNode --------------------------------
OpValue BracketAccessorNode::generateEvalCode(CompileState *comp)
{
    OpValue ret;
    OpValue base  = expr1->generateEvalCode(comp);
    OpValue index = expr2->generateEvalCode(comp);

    // ### optimize foo["bar"] ?
    CodeGen::emitOp(comp, Op_BracketGet, &ret, &base, &index);
    return ret;
}

CompileReference *BracketAccessorNode::generateRefBind(CompileState *comp)
{
    // Per 11.2.1, the following steps must happen when evaluating foo[bar]
    // 1) eval foo
    // 2) eval bar
    // 3) call toObject on [[foo]]
    // 4) call toString on [[bar]]
    // ... all of which are part of reference evaluation. Fun.
    // ### FIXME FIXME FIXME: we don't do step 4 in right spot yet!
    CompileReference *ref = new CompileReference;
    OpValue baseV = expr1->generateEvalCode(comp);
    ref->indexVal = expr2->generateEvalCode(comp);
    CodeGen::emitOp(comp, Op_ToObject, &ref->baseObj, &baseV);
    return ref;
}

CompileReference *BracketAccessorNode::generateRefRead(CompileState *comp, OpValue *out)
{
    CompileReference *ref = new CompileReference;

    // ### As above, this sequence should store the toString on reference, if there will be a follow up
    // write --- need a hint for that..
    OpValue baseV = expr1->generateEvalCode(comp);
    ref->indexVal = expr2->generateEvalCode(comp);

    // Store the object for future use.
    OpValue baseReg;
    comp->requestTemporary(OpType_value, &ref->baseObj, &baseReg);

    CodeGen::emitOp(comp, Op_BracketGetAndBind, out, &baseReg, &baseV, &ref->indexVal);
    return ref;
}

void BracketAccessorNode::generateRefWrite(CompileState *comp,
        CompileReference *ref, OpValue &valToStore)
{
    CodeGen::emitOp(comp, Op_BracketPutKnownObject, nullptr, &ref->baseObj, &ref->indexVal, &valToStore);
}

OpValue BracketAccessorNode::generateRefDelete(CompileState *comp)
{
    OpValue base  = expr1->generateEvalCode(comp);
    OpValue index = expr2->generateEvalCode(comp);

    OpValue out;
    CodeGen::emitOp(comp, Op_BracketDelete, &out, &base, &index);
    return out;
}

void BracketAccessorNode::generateRefFunc(CompileState *comp, OpValue *funOut, OpValue *thisOut)
{
    OpValue baseV  = expr1->generateEvalCode(comp);
    OpValue indexV = expr2->generateEvalCode(comp);

    // We need to memorize the toObject for 'this'
    OpValue baseReg;
    comp->requestTemporary(OpType_value, thisOut, &baseReg);

    CodeGen::emitOp(comp, Op_BracketGetAndBind, funOut, &baseReg, &baseV, &indexV);
}

// ------------------------------ DotAccessorNode --------------------------------

// ECMA 11.2.1b
OpValue DotAccessorNode::generateEvalCode(CompileState *comp)
{
    OpValue ret;
    OpValue base    = expr->generateEvalCode(comp);
    OpValue varName = OpValue::immIdent(&ident);
    CodeGen::emitOp(comp, Op_SymGet, &ret, &base, &varName);
    return ret;
}

CompileReference *DotAccessorNode::generateRefBind(CompileState *comp)
{
    CompileReference *ref = new CompileReference;
    OpValue baseV = expr->generateEvalCode(comp);
    CodeGen::emitOp(comp, Op_ToObject, &ref->baseObj, &baseV);
    return ref;
}

CompileReference *DotAccessorNode::generateRefRead(CompileState *comp, OpValue *out)
{
    CompileReference *ref = new CompileReference;
    OpValue baseV = expr->generateEvalCode(comp);
    OpValue baseReg;
    OpValue varName = OpValue::immIdent(&ident);
    comp->requestTemporary(OpType_value, &ref->baseObj, &baseReg);
    CodeGen::emitOp(comp, Op_SymGetAndBind, out, &baseReg, &baseV, &varName);
    return ref;
}

void DotAccessorNode::generateRefWrite(CompileState *comp,
                                       CompileReference *ref, OpValue &valToStore)
{
    OpValue varName = OpValue::immIdent(&ident);
    CodeGen::emitOp(comp, Op_SymPutKnownObject, nullptr, &ref->baseObj, &varName, &valToStore);
}

OpValue DotAccessorNode::generateRefDelete(CompileState *comp)
{
    OpValue base = expr->generateEvalCode(comp);
    OpValue varName = OpValue::immIdent(&ident);
    OpValue out;
    CodeGen::emitOp(comp, Op_SymDelete, &out, &base, &varName);
    return out;
}

void DotAccessorNode::generateRefFunc(CompileState *comp, OpValue *funOut, OpValue *thisOut)
{
    OpValue baseV = expr->generateEvalCode(comp);
    OpValue varName = OpValue::immIdent(&ident);

    OpValue baseReg;
    comp->requestTemporary(OpType_value, thisOut, &baseReg);
    CodeGen::emitOp(comp, Op_SymGetAndBind, funOut, &baseReg, &baseV, &varName);
}

// ------------------ ........

void ArgumentsNode::generateEvalArguments(CompileState *comp)
{
    WTF::Vector<OpValue> args;

    // We need evaluate arguments and push them in separate steps as there may be
    // function/ctor calls inside.
    for (ArgumentListNode *arg = list.get(); arg; arg = arg->next.get()) {
        args.append(arg->expr->generateEvalCode(comp));
    }

    CodeGen::emitOp(comp, Op_ClearArgs, nullptr);

    size_t c = 0;
    while (c < args.size()) {
        if (c + 3 <= args.size()) {
            CodeGen::emitOp(comp, Op_Add3Arg, nullptr, &args[c], &args[c + 1], &args[c + 2]);
            c += 3;
        } else if (c + 2 <= args.size()) {
            CodeGen::emitOp(comp, Op_Add2Arg, nullptr, &args[c], &args[c + 1]);
            c += 2;
        } else {
            CodeGen::emitOp(comp, Op_AddArg, nullptr, &args[c]);
            c += 1;
        }
    }
}

OpValue NewExprNode::generateEvalCode(CompileState *comp)
{
    OpValue v = expr->generateEvalCode(comp);

    if (args) {
        args->generateEvalArguments(comp);
    } else {
        CodeGen::emitOp(comp, Op_ClearArgs, nullptr);
    }

    OpValue out;
    CodeGen::emitOp(comp, Op_CtorCall, &out, &v);
    return out;
}

OpValue FunctionCallValueNode::generateEvalCode(CompileState *comp)
{
    OpValue v = expr->generateEvalCode(comp);
    args->generateEvalArguments(comp);

    OpValue out;
    CodeGen::emitOp(comp, Op_FunctionCall, &out, &v, comp->globalScope());
    return out;
}

OpValue FunctionCallReferenceNode::generateEvalCode(CompileState *comp)
{
    Node *cand = expr->nodeInsideAllParens();
    ASSERT(cand->isLocation());
    LocationNode *loc = static_cast<LocationNode *>(cand);

    OpValue funVal, thisVal;
    loc->generateRefFunc(comp, &funVal, &thisVal);
    args->generateEvalArguments(comp);

    OpValue out;
    CodeGen::emitOp(comp, Op_FunctionCall, &out, &funVal, &thisVal);
    return out;
}

OpValue PostfixNode::generateEvalCode(CompileState *comp)
{
    Node *cand = m_loc->nodeInsideAllParens();
    if (!cand->isLocation()) {
        emitReferenceError(comp, this,
                           m_oper == OpPlusPlus ?
                           "Postfix ++ operator applied to value that is not a reference." :
                           "Postfix -- operator applied to value that is not a reference.");
        return OpValue::immValue(jsUndefined());
    }

    LocationNode *loc = static_cast<LocationNode *>(cand);

    // ### we want to fold this in if the kid is a local -- any elegant way?

    //read current value
    OpValue curV;
    CompileReference *ref = loc->generateRefRead(comp, &curV);

    // We need it to be a number..
    if (curV.type != OpType_number) {
        OpValue numVal;
        CodeGen::emitConvertTo(comp, &curV, OpType_number, &numVal);
        curV = numVal;
    }

    // Compute new one
    OpValue newV;
    CodeGen::emitOp(comp, (m_oper == OpPlusPlus) ? Op_Add1 : Op_Sub1,
                    &newV, &curV);

    loc->generateRefWrite(comp, ref, newV);
    delete ref;
    return curV;
}

OpValue DeleteReferenceNode::generateEvalCode(CompileState *comp)
{
    return loc->generateRefDelete(comp);
}

OpValue DeleteValueNode::generateEvalCode(CompileState *)
{
    return OpValue::immBool(true);
}

OpValue VoidNode::generateEvalCode(CompileState *comp)
{
    (void)expr->generateEvalCode(comp);
    return OpValue::immValue(jsUndefined());
}

OpValue TypeOfVarNode::generateEvalCode(CompileState *comp)
{
    OpValue v = loc->valueForTypeOf(comp);

    OpValue out;
    CodeGen::emitOp(comp, Op_TypeOf, &out, &v);
    return out;
}

OpValue TypeOfValueNode::generateEvalCode(CompileState *comp)
{
    OpValue v = m_expr->generateEvalCode(comp);
    OpValue typeOfV;
    CodeGen::emitOp(comp, Op_TypeOf, &typeOfV, &v);
    return typeOfV;
}

OpValue PrefixNode::generateEvalCode(CompileState *comp)
{
    Node *cand = m_loc->nodeInsideAllParens();
    if (!cand->isLocation()) {
        emitReferenceError(comp, this,
                           m_oper == OpPlusPlus ?
                           "Prefix ++ operator applied to value that is not a reference." :
                           "Prefix -- operator applied to value that is not a reference.");
        return OpValue::immValue(jsUndefined());
    }

    LocationNode *loc = static_cast<LocationNode *>(cand);

    // ### we want to fold this in if the kid is a local -- any elegant way?

    //read current value
    OpValue curV;
    CompileReference *ref = loc->generateRefRead(comp, &curV);

    OpValue newV;
    CodeGen::emitOp(comp, (m_oper == OpPlusPlus) ? Op_Add1 : Op_Sub1,
                    &newV, &curV);

    // Write out + return new value.
    loc->generateRefWrite(comp, ref, newV);
    delete ref;
    return newV;
}

OpValue UnaryPlusNode::generateEvalCode(CompileState *comp)
{
    // This is basically just a number cast
    OpValue curV = expr->generateEvalCode(comp);

    if (curV.type != OpType_number) {
        OpValue numVal;
        CodeGen::emitConvertTo(comp, &curV, OpType_number, &numVal);
        curV = numVal;
    }

    return curV;
}

OpValue NegateNode::generateEvalCode(CompileState *comp)
{
    OpValue v = expr->generateEvalCode(comp);
    OpValue negV;
    CodeGen::emitOp(comp, Op_Neg, &negV, &v);
    return negV;
}

OpValue BitwiseNotNode::generateEvalCode(CompileState *comp)
{
    OpValue v = expr->generateEvalCode(comp);
    OpValue out;
    CodeGen::emitOp(comp, Op_BitNot, &out, &v);
    return out;
}

OpValue LogicalNotNode::generateEvalCode(CompileState *comp)
{
    OpValue v = expr->generateEvalCode(comp);
    OpValue out;
    CodeGen::emitOp(comp, Op_LogicalNot, &out, &v);
    return out;
}

OpValue BinaryOperatorNode::generateEvalCode(CompileState *comp)
{
    OpValue v1 = expr1->generateEvalCode(comp);
    OpValue v2 = expr2->generateEvalCode(comp);

    OpName codeOp; // ### could perhaps skip conversion entirely,
    // and set these in the parser?
    switch (oper) {
    case OpMult:
        // operator *
        codeOp = Op_Mult;
        break;
    case OpDiv:
        // operator /
        codeOp = Op_Div;
        break;
    case OpMod:
        // operator %
        codeOp = Op_Mod;
        break;
    case OpExp:
        // operator **
        codeOp = Op_Exp;
        break;
    case OpPlus:
        // operator +
        codeOp = Op_Add;
        break;
    case OpMinus:
        // operator -
        codeOp = Op_Sub;
        break;
    case OpLShift:
        // operator <<
        codeOp = Op_LShift;
        break;
    case OpRShift:
        // operator >>
        codeOp = Op_RShift;
        break;
    case OpURShift:
        // operator >>>
        codeOp = Op_URShift;
        break;
    case OpLess:
        // operator <
        codeOp = Op_Less;
        break;
    case OpGreaterEq:
        // operator >=
        codeOp = Op_GreaterEq;
        break;
    case OpGreater:
        // operator >
        codeOp = Op_Greater;
        break;
    case OpLessEq:
        // operator <=
        codeOp = Op_LessEq;
        break;
    case OpEqEq:
        // operator ==
        codeOp = Op_EqEq;
        break;
    case OpNotEq:
        // operator !=
        codeOp = Op_NotEq;
        break;
    case OpStrEq:
        // operator ===
        codeOp = Op_StrEq;
        break;
    case OpStrNEq:
        // operator !==
        codeOp = Op_StrNEq;
        break;
    case OpBitAnd:
        // operator &
        codeOp = Op_BitAnd;
        break;
    case OpBitXOr:
        // operator ^
        codeOp = Op_BitXOr;
        break;
    case OpBitOr:
        // operator |
        codeOp = Op_BitOr;
        break;
    case OpIn:
        codeOp = Op_In;
        break;
    case OpInstanceOf:
        codeOp = Op_InstanceOf;
        break;

    default:
        codeOp = Op_InstanceOf; // Initialize it to something just to silence -Wsometimes-uninitialized
        assert(!"BinaryOperatorNode: unhandled switch case");
    }

    OpValue out;
    CodeGen::emitOp(comp, codeOp, &out, &v1, &v2);
    return out;
}

OpValue BinaryLogicalNode::generateEvalCode(CompileState *comp)
{
    // This is somewhat ugly since we can't patchup labels in already generated
    // code, and don't know the types in advance. It could also benefit from
    // a type hint, since it's easier if we only want a bool, which is quite common

    OpValue a = expr1->generateEvalCode(comp);

    // Make a register for storing the result, and put 'a' there, as out first guess.
    OpValue aVal, aReg;
    comp->requestTemporary(a.type, &aVal, &aReg);
    CodeGen::emitRegStore(comp, &aReg, &a);

    // Is this enough to shortcircuit?
    // if op is && and a is false, we jump out, ditto
    // for || and true.
    Addr jumpToShortCircuit = CodeGen::emitOp(comp, oper == OpAnd ? Op_IfNotJump : Op_IfJump,
                              nullptr, &a, OpValue::dummyAddr());

    // Now, generate the code for b...
    OpValue b = expr2->generateEvalCode(comp);

    // Hopefully, either the types match, or the result slot is already a value,
    // so we can just promote b (which will happen automatically to produce param for Op_RegPutVal)
    if (a.type == b.type || a.type == OpType_value) {
        if (a.type == OpType_value) {
            CodeGen::emitOp(comp, Op_RegPutValue, nullptr, &aReg, &b);
        } else {
            CodeGen::emitRegStore(comp, &aReg, &b);
        }
        CodeGen::patchJumpToNext(comp, jumpToShortCircuit, 1);
        return aVal;
    } else {
        // We need to promote 'a' as well, which means we need to skip over the code jumpToShortCircuit
        // went to after handling store of 'b'.

        // Get a new register for the result, put b there..
        OpValue resVal, resReg;
        comp->requestTemporary(OpType_value, &resVal, &resReg);
        CodeGen::emitOp(comp, Op_RegPutValue, nullptr, &resReg, &b);

        // skip to after a promotion..
        Addr jumpToAfter = CodeGen::emitOp(comp, Op_Jump, nullptr, OpValue::dummyAddr());

        // a's promotion goes here..
        CodeGen::patchJumpToNext(comp, jumpToShortCircuit, 1);
        CodeGen::emitOp(comp, Op_RegPutValue, nullptr, &resReg, &a);

        // now we're after it..
        CodeGen::patchJumpToNext(comp, jumpToAfter, 0);

        return resVal;
    }
}

OpValue ConditionalNode::generateEvalCode(CompileState *comp)
{
    // As above, we have some difficulty here, since we do not have a way of knowing
    // the types in advance, but since we can't reasonably speculate on them both being bool,
    // we just always produce a value.
    OpValue resVal, resReg;

    // Evaluate conditional, and jump..
    OpValue v = logical->generateEvalCode(comp);
    Addr jumpToElse = CodeGen::emitOp(comp, Op_IfNotJump, nullptr, &v, OpValue::dummyAddr());

    // True branch
    OpValue v1out = expr1->generateEvalCode(comp);

    // Request a temporary for the result. (We can't reuse any, since it may be a variable!)
    // ### perhaps do an isTemporary check here?
    comp->requestTemporary(OpType_value, &resVal, &resReg);
    CodeGen::emitOp(comp, Op_RegPutValue, nullptr, &resReg, &v1out);

    Addr jumpToAfter = CodeGen::emitOp(comp, Op_Jump, nullptr, OpValue::dummyAddr());

    // Jump to else goes here.
    CodeGen::patchJumpToNext(comp, jumpToElse, 1);

    // : part..
    OpValue v2out = expr2->generateEvalCode(comp);
    CodeGen::emitOp(comp, Op_RegPutValue, nullptr, &resReg, &v2out);

    // After everything
    CodeGen::patchJumpToNext(comp, jumpToAfter, 0);

    return resVal;
}

OpValue FuncExprNode::generateEvalCode(CompileState *comp)
{
    comp->setNeedsClosures();

    OpValue out;
    OpValue nameV = OpValue::immIdent(&ident);
    OpValue bodyV = OpValue::immNode(body.get());
    CodeGen::emitOp(comp, Op_EvalFuncExpr, &out, &nameV, &bodyV);
    return out;
}

void FuncDeclNode::generateExecCode(CompileState *comp)
{
    comp->setNeedsClosures();

    // No executable content...
}

void SourceElementsNode::generateExecCode(CompileState *comp)
{
    node->generateExecCode(comp);

    // ### FIXME: how do we do proper completion?
    for (SourceElementsNode *n = next.get(); n; n = n->next.get()) {
        n->node->generateExecCode(comp);
    }
}

OpValue AssignNode::generateEvalCode(CompileState *comp)
{
    Node *cand = m_loc->nodeInsideAllParens();
    if (!cand->isLocation()) {
        emitReferenceError(comp, this, "Left side of assignment is not a reference.");
        return OpValue::immValue(jsUndefined());
    }

    LocationNode *loc = static_cast<LocationNode *>(cand);

    CompileReference *ref;

    OpValue v;
    if (m_oper == OpEqual) {
        ref = loc->generateRefBind(comp);
        v = m_right->generateEvalCode(comp);
    } else {
        OpValue v1;
        ref = loc->generateRefRead(comp, &v1);
        OpValue v2 = m_right->generateEvalCode(comp);

        OpName codeOp;
        switch (m_oper) {
        case OpMultEq:
            codeOp = Op_Mult;
            break;
        case OpDivEq:
            codeOp = Op_Div;
            break;
        case OpModEq:
            codeOp = Op_Mod;
            break;
        case OpExpEq:
            codeOp = Op_Exp;
            break;
        case OpPlusEq:
            codeOp = Op_Add;
            break;
        case OpMinusEq:
            codeOp = Op_Sub;
            break;
        case OpLShift:
            codeOp = Op_LShift;
            break;
        case OpRShift:
            codeOp = Op_RShift;
            break;
        case OpURShift:
            codeOp = Op_URShift;
            break;
        case OpAndEq:
            codeOp = Op_BitAnd;
            break;
        case OpXOrEq:
            codeOp = Op_BitXOr;
            break;
        case OpOrEq:
            codeOp = Op_BitOr;
            break;
        default:
            codeOp = Op_BitOr; // Initialize it to something just to silence -Wsometimes-uninitialized
            ASSERT(0);
        }

        CodeGen::emitOp(comp, codeOp, &v, &v1, &v2);
    }

    loc->generateRefWrite(comp, ref, v);

    delete ref;
    return v;
}

OpValue CommaNode::generateEvalCode(CompileState *comp)
{
    expr1->generateEvalCode(comp);
    return expr2->generateEvalCode(comp);
}

OpValue AssignExprNode::generateEvalCode(CompileState *comp)
{
    return expr->generateEvalCode(comp);
}

void VarDeclNode::generateCode(CompileState *comp)
{
    // We only care about things which have an initializer ---
    // everything else is a no-op at execution time,
    // and only makes a difference at processVarDecl time
    if (init) {
        if (comp->inNestedScope()) {
            // We need to do the full lookup mess, which includes doing split binding and store
            OpValue quiet   = OpValue::immNode(nullptr);
            OpValue varName = OpValue::immIdent(&ident);
            OpValue base;
            CodeGen::emitOp(comp, Op_ScopeLookup, &base, &varName, &quiet);

            OpValue val = init->generateEvalCode(comp);
            CodeGen::emitOp(comp, Op_SymPutKnownObject, nullptr, &base, &varName, &val);
            return;
        }

        OpValue val = init->generateEvalCode(comp);
        size_t localID = comp->functionBody()->lookupSymbolID(ident);
        if (localID == missingSymbolMarker()) {
            // Generate a symbolic assignment, always to local scope
            OpValue identV = OpValue::immIdent(&ident);
            CodeGen::emitOp(comp, Op_SymPutKnownObject, nullptr, comp->localScope(), &identV, &val);
        } else {
            // Store to the local..
            OpValue dest = comp->localWriteRef(comp->codeBlock(), localID);
            CodeGen::emitOp(comp, Op_RegPutValue, nullptr, &dest, &val);
        }
    } // if initializer..
}

OpValue VarDeclListNode::generateEvalCode(CompileState *comp)
{
    for (VarDeclListNode *n = this; n; n = n->next.get()) {
        n->var->generateCode(comp);
    }

    return OpValue::immInt32(0); // unused..
}

void VarStatementNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    next->generateEvalCode(comp);
}

void BlockNode::generateExecCode(CompileState *comp)
{
    if (source) {
        generateDebugInfoIfNeeded(comp);
        source->generateExecCode(comp);
    }
}

void EmptyStatementNode::generateExecCode(CompileState *)
{}

void ExprStatementNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    OpValue val = expr->generateEvalCode(comp);

    // Update the result for eval or global code
    if (comp->codeType() != FunctionCode) {
        CodeGen::emitOp(comp, Op_RegPutValue, nullptr, comp->evalResultReg(), &val);
    }
}

void IfNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);

    // eval the condition
    OpValue cond = expr->generateEvalCode(comp);

    // If condition is not true, jump to after or else..
    Addr afterTrueJmp = CodeGen::emitOp(comp, Op_IfNotJump, nullptr, &cond, OpValue::dummyAddr());

    // Emit the body of true...
    statement1->generateExecCode(comp);

    // If we have an else, add in a jump to skip over it.
    Addr afterAllJmp = 0;
    if (statement2) {
        afterAllJmp = CodeGen::emitOp(comp, Op_Jump, nullptr, OpValue::dummyAddr());
    }

    // This is where we go if true fails --- else, or afterwards.
    CodeGen::patchJumpToNext(comp, afterTrueJmp, 1);

    if (statement2) {
        // Body of else
        statement2->generateExecCode(comp);

        // Fix up the jump-over code
        CodeGen::patchJumpToNext(comp, afterAllJmp, 0);
    }
}

void DoWhileNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    comp->enterLoop(this);

    // Body
    OpValue beforeBody = OpValue::immAddr(CodeGen::nextPC(comp));
    statement->generateExecCode(comp);

    // continues go to just before the test..
    comp->resolvePendingContinues(this, CodeGen::nextPC(comp));

    // test
    OpValue cond = expr->generateEvalCode(comp);
    CodeGen::emitOp(comp, Op_IfJump, nullptr, &cond, &beforeBody);

    comp->exitLoop(this);
}

void WhileNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    comp->enterLoop(this);

    // Jump to test.
    Addr  jumpToTest = CodeGen::emitOp(comp, Op_Jump, nullptr, OpValue::dummyAddr());

    // Body
    OpValue beforeBody = OpValue::immAddr(CodeGen::nextPC(comp));
    statement->generateExecCode(comp);

    // continues go to just before the test..
    comp->resolvePendingContinues(this, CodeGen::nextPC(comp));

    // patch up the destination of the initial jump to test
    CodeGen::patchJumpToNext(comp, jumpToTest, 0);

    // test
    OpValue cond = expr->generateEvalCode(comp);
    CodeGen::emitOp(comp, Op_IfJump, nullptr, &cond, &beforeBody);

    comp->exitLoop(this);
}

void ForNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    comp->enterLoop(this);

    // Initializer, if any..
    if (expr1) {
        expr1->generateEvalCode(comp);
    }

    // Insert a jump to the loop test (address not yet known)
    Addr jumpToTest = CodeGen::emitOp(comp, Op_Jump, nullptr, OpValue::dummyAddr());

    // Generate loop body..
    OpValue bodyAddr = OpValue::immAddr(CodeGen::nextPC(comp));
    statement->generateExecCode(comp);

    // We're about to generate the increment... The continues should go here..
    comp->resolvePendingContinues(this, CodeGen::nextPC(comp));

    // Generate increment...
    if (expr3) {
        expr3->generateEvalCode(comp);
    }

    // The test goes here, so patch up the previous jump..
    CodeGen::patchJumpToNext(comp, jumpToTest, 0);

    // Make the test itself --- if it exists..
    if (expr2) {
        OpValue cond = expr2->generateEvalCode(comp);
        CodeGen::emitOp(comp, Op_IfJump, nullptr, &cond, &bodyAddr);
    } else {
        // Just jump back to the body.
        CodeGen::emitOp(comp, Op_Jump, nullptr, &bodyAddr);
    }

    comp->exitLoop(this);
}

void ForInNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    if (varDecl) {
        varDecl->generateCode(comp);
    }

    OpValue val = expr->generateEvalCode(comp);
    OpValue obj; // version of val after toObject, returned by BeginForIn.

    OpValue stateVal, stateReg;
    comp->requestTemporary(OpType_value, &stateVal, &stateReg);

    // Fetch the property name array..
    CodeGen::emitOp(comp, Op_BeginForIn, &obj, &val, &stateReg);

    comp->enterLoop(this);

    // We put the test first here, since the test and the fetch are combined.
    OpValue sym;
    Addr fetchNext = CodeGen::emitOp(comp, Op_NextForInEntry, &sym, &obj,
                                     &stateVal, OpValue::dummyAddr());

    // Write to the variable
    assert(lexpr->isLocation());
    LocationNode *loc = static_cast<LocationNode *>(lexpr.get());

    CompileReference *ref = loc->generateRefBind(comp);
    loc->generateRefWrite(comp, ref, sym);
    delete ref;

    // Run the body.
    statement->generateExecCode(comp);

    // Can fix the continues to go back to the test...
    comp->resolvePendingContinues(this, fetchNext);

    // Jump back..
    OpValue backVal = OpValue::immAddr(fetchNext);
    CodeGen::emitOp(comp, Op_Jump, nullptr, &backVal);

    // The end address is here (3 argument + return val)
    CodeGen::patchJumpToNext(comp, fetchNext, 3);

    comp->exitLoop(this);
}

// Helper for continue/break -- emits stack cleanup call if needed,
// and a jump either to the or an ??? exception.
static void handleJumpOut(CompileState *comp, Node *dest, ComplType breakOrCont)
{
    // We scan up the nest stack until we get to the target or
    // a try-finally.
    int toUnwind = 0;

    const WTF::Vector<CompileState::NestInfo> &nests = comp->nestStack();

    for (int pos = nests.size() - 1; pos >= 0; --pos) {
        switch (nests[pos].type) {
        case CompileState::Scope:
        case CompileState::OtherCleanup:
            ++toUnwind;
            break;
        case CompileState::TryFinally: {
            // Uh-oh. We have to handle this via exception machinery, giving it the
            // original address
            Addr    pc    = CodeGen::nextPC(comp);
            CodeGen::emitOp(comp, Op_ContBreakInTryFinally, nullptr, OpValue::dummyAddr());

            // Queue destination for resolution
            if (breakOrCont == Continue) {
                comp->addPendingContinue(dest, pc);
            } else {
                comp->addPendingBreak(dest, pc);
            }

            return;
        }

        case CompileState::ContBreakTarget:
            if (nests[pos].node == dest) {
                // Great. We found where we're going! Emit the unwind instr (if needed),
                // and the jump.
                if (toUnwind) {
                    OpValue unwind = OpValue::immInt32(toUnwind);
                    CodeGen::emitOp(comp, Op_UnwindStacks, nullptr, &unwind);
                }

                // Emit a jump...
                Addr    pc    = CodeGen::nextPC(comp);
                CodeGen::emitOp(comp, Op_Jump, nullptr, OpValue::dummyAddr());

                // Queue destination for resolution
                if (breakOrCont == Continue) {
                    comp->addPendingContinue(dest, pc);
                } else {
                    comp->addPendingBreak(dest, pc);
                }

                return;
            } // if matching destination..
        }
    }

    assert(!"Huh? Unable to find continue/break target in the nest stack");
}

void ContinueNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    Node *dest = comp->resolveContinueLabel(ident);
    if (!dest) {
        if (ident.isEmpty()) {
            emitSyntaxError(comp, this, "Illegal continue without target outside a loop.");
        } else {
            emitSyntaxError(comp, this, "Invalid label in continue.");
        }
    } else {
        // Continue can only be used for a loop
        if (dest->isIterationStatement()) {
            handleJumpOut(comp, dest, Continue);
        } else {
            emitSyntaxError(comp, this, "Invalid continue target; must be a loop.");
        }
    }
}

void BreakNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    Node *dest = comp->resolveBreakLabel(ident);
    if (!dest) {
        if (ident.isEmpty()) {
            emitSyntaxError(comp, this, "Illegal break without target outside a loop or switch.");
        } else {
            emitSyntaxError(comp, this, "Invalid label in break.");
        }
    } else {
        handleJumpOut(comp, dest, Break);
    }
}

void ReturnNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    OpValue arg;

    // Return is invalid in non-function..
    if (comp->codeType() != FunctionCode) {
        emitSyntaxError(comp, this, "Invalid return.");
        return;
    }

    if (!value) {
        arg = OpValue::immValue(jsUndefined());
    } else {
        arg = value->generateEvalCode(comp);
    }

    if (!comp->inTryFinally()) {
        generateExitContextIfNeeded(comp);
    }

    CodeGen::emitOp(comp, comp->inTryFinally() ? Op_ReturnInTryFinally : Op_Return, nullptr, &arg);
}

void WithNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    // ### this may be too conservative --- it only applies if there is
    // a function call within
    comp->setNeedsClosures();

    OpValue scopeObj = expr->generateEvalCode(comp);

    comp->pushNest(CompileState::Scope, this);
    CodeGen::emitOp(comp, Op_PushScope, nullptr, &scopeObj);

    statement->generateExecCode(comp);

    CodeGen::emitOp(comp, Op_PopScope, nullptr);
    comp->popNest();
}

void LabelNode::generateExecCode(CompileState *comp)
{
    if (!comp->pushLabel(label)) {
        emitSyntaxError(comp, this, "Duplicated label found.");
        return;
    }

    if (!statement->isLabelNode()) { // we're the last label..
        comp->pushNest(CompileState::ContBreakTarget, statement.get());
        comp->bindLabels(statement.get());
    }

    // Generate code for stuff inside the label...
    statement->generateExecCode(comp);

    // Fix up any breaks..
    if (!statement->isLabelNode()) {
        comp->popNest();
        comp->resolvePendingBreaks(statement.get(), CodeGen::nextPC(comp));
    }

    comp->popLabel();
}

void ThrowNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    OpValue projectile = expr->generateEvalCode(comp);
    CodeGen::emitOp(comp, Op_Throw, nullptr, &projectile);
}

void TryNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    // ### this may be too conservative --- it only applies if there is
    // a function call within the catch
    comp->setNeedsClosures();

    // Set the catch handler, run the try clause, pop the try handler..
    Addr setCatchHandler = CodeGen::emitOp(comp, Op_PushExceptionHandler, nullptr, OpValue::dummyAddr());
    comp->pushNest(finallyBlock ? CompileState::TryFinally : CompileState::OtherCleanup);

    tryBlock->generateExecCode(comp);

    CodeGen::emitOp(comp, Op_PopExceptionHandler);
    comp->popNest();

    // Jump over the catch if try is OK
    Addr jumpOverCatch = 0;
    if (catchBlock) {
        jumpOverCatch = CodeGen::emitOp(comp, Op_Jump, nullptr, OpValue::dummyAddr());
    }

    // Exceptions would go here --- either in a catch or a finally.
    CodeGen::patchJumpToNext(comp, setCatchHandler, 0);

    Addr catchToFinallyEH = 0;
    if (catchBlock) {
        // If there is a finally block, that acts as an exception handler for the catch;
        // we need to set it before entering the catch scope, so the cleanup entries for that
        // are on top. Also, that's needed because if the inside raised a non-exception
        // continuation, EnterCatch will re-raise it.
        if (finallyBlock) {
            catchToFinallyEH = CodeGen::emitOp(comp, Op_PushExceptionHandler, nullptr, OpValue::dummyAddr());
            comp->pushNest(CompileState::TryFinally);
        }

        // Emit the catch.. Note: the unwinder has already popped the catch handler entry,
        // but the exception object is still set, since we need to make a scope for it.
        // EnterCatch would do that for us, given the name
        OpValue catchVar = OpValue::immIdent(&exceptionIdent);
        CodeGen::emitOp(comp, Op_EnterCatch, nullptr, &catchVar);
        comp->pushNest(CompileState::Scope);

        catchBlock->generateExecCode(comp);

        // If needed, cleanup the binding to finally, and always cleans the catch scope
        CodeGen::emitOp(comp, Op_ExitCatch);
        comp->popNest();

        if (finallyBlock) {
            CodeGen::emitOp(comp, Op_PopExceptionHandler);
            comp->popNest();
        }

        // after an OK 'try', we always go to finally, if any, which needs an op if there is a catch block
        CodeGen::patchJumpToNext(comp, jumpOverCatch, 0);
    }

    if (finallyBlock) {
        if (catchBlock) { // if a catch was using us an EH, patch that instruction to here
            CodeGen::patchJumpToNext(comp, catchToFinallyEH, 0);
        }

        CodeGen::emitOp(comp, Op_DeferCompletion);
        comp->pushNest(CompileState::OtherCleanup);

        finallyBlock->generateExecCode(comp);

        OpValue otherTryFinally = OpValue::immBool(comp->inTryFinally());

        if (exitContextNeeded(comp)) {
            OpValue ourNode = OpValue::immNode(comp->functionBody());
            CodeGen::emitOp(comp, Op_ReactivateCompletionDebug, nullptr, &otherTryFinally, &ourNode);
        } else {
            CodeGen::emitOp(comp, Op_ReactivateCompletion, nullptr, &otherTryFinally);
        }
        comp->popNest();
    }
}

void FunctionBodyNode::generateExecCode(CompileState *comp)
{
    // Load scope, global and 'this' pointers.
    OpValue scopeVal,  scopeReg,
            globalVal, globalReg,
            thisVal,   thisReg;

    comp->requestTemporary(OpType_value, &scopeVal,  &scopeReg);
    comp->requestTemporary(OpType_value, &globalVal, &globalReg);
    comp->requestTemporary(OpType_value, &thisVal,   &thisReg);

    CodeGen::emitOp(comp, Op_Preamble, nullptr, &scopeReg, &globalReg, &thisReg);

    comp->setPreloadRegs(&scopeVal, &globalVal, &thisVal);

    OpValue evalResReg, evalResVal;
    if (comp->codeType() != FunctionCode) {
        comp->requestTemporary(OpType_value, &evalResVal, &evalResReg);
        comp->setEvalResultRegister(&evalResReg);

        // There is no need to initialize this as everything will be set to undefined anyway
    } else {
        if (comp->compileType() == Debug) {
            OpValue ourNode = OpValue::immNode(this);
            CodeGen::emitOp(comp, Op_EnterDebugContext, nullptr, &ourNode);
        }
    }

    // Set unwind..
    Addr unwind = CodeGen::emitOp(comp, Op_PushExceptionHandler, nullptr, OpValue::dummyAddr());

    // Generate body...
    BlockNode::generateExecCode(comp);

    // Make sure we exit!
    if (comp->codeType() != FunctionCode) {
        CodeGen::emitOp(comp, Op_Return, nullptr, &evalResVal);
    } else {
        generateExitContextIfNeeded(comp);
        CodeGen::emitOp(comp, Op_Exit);
    }

    // Unwind stuff..
    CodeGen::patchJumpToNext(comp, unwind, 0);
    generateExitContextIfNeeded(comp);
    CodeGen::emitOp(comp, Op_PropagateException);
}

void SwitchNode::generateExecCode(CompileState *comp)
{
    generateDebugInfoIfNeeded(comp);
    CaseBlockNode *caseBlock = this->block.get();

    // The code we produce has 2 stages: first, we emit all the conditionals, and pick
    // the label to jump to (with the jump to the default being last),
    // then we just emit all the clauses in the row. The breaks will be
    // resolved at the end --- for that, we bind ourselves for label'less break.
    comp->pushNest(CompileState::ContBreakTarget, this);
    comp->pushDefaultBreak(this);

    // What we compare with
    OpValue switchOn = expr->generateEvalCode(comp);

    WTF::Vector<Addr> list1jumps;
    WTF::Vector<Addr> list2jumps;
    Addr defJump;

    // Jumps for list 1..
    for (ClauseListNode *iter = caseBlock->list1.get(); iter; iter = iter->next.get()) {
        OpValue ref = iter->clause->expr->generateEvalCode(comp);
        OpValue match;
        CodeGen::emitOp(comp, Op_StrEq, &match, &switchOn, &ref);

        Addr jumpToClause = CodeGen::emitOp(comp, Op_IfJump, nullptr, &match, OpValue::dummyAddr());
        list1jumps.append(jumpToClause);
    }

    // Jumps for list 2..
    for (ClauseListNode *iter = caseBlock->list2.get(); iter; iter = iter->next.get()) {
        OpValue ref = iter->clause->expr->generateEvalCode(comp);
        OpValue match;
        CodeGen::emitOp(comp, Op_StrEq, &match, &switchOn, &ref);

        Addr jumpToClause = CodeGen::emitOp(comp, Op_IfJump, nullptr, &match, OpValue::dummyAddr());
        list2jumps.append(jumpToClause);
    }

    // Jump to default (or after, if there is no default)
    defJump = CodeGen::emitOp(comp, Op_Jump, nullptr, OpValue::dummyAddr());

    // Now, we can actually emit the bodies, fixing the addresses as we go
    int p = 0;
    for (ClauseListNode *iter = caseBlock->list1.get(); iter; iter = iter->next.get()) {
        CodeGen::patchJumpToNext(comp, list1jumps[p], 1);
        if (iter->clause->source) {
            iter->clause->source->generateExecCode(comp);
        }
        ++p;
    }

    if (caseBlock->def) {
        CodeGen::patchJumpToNext(comp, defJump, 0);
        if (caseBlock->def->source) {
            caseBlock->def->source->generateExecCode(comp);
        }
    }

    p = 0;
    for (ClauseListNode *iter = caseBlock->list2.get(); iter; iter = iter->next.get()) {
        CodeGen::patchJumpToNext(comp, list2jumps[p], 1);
        if (iter->clause->source) {
            iter->clause->source->generateExecCode(comp);
        }
        ++p;
    }

    // If we didn't have a default, that jump is to here..
    if (!caseBlock->def) {
        CodeGen::patchJumpToNext(comp, defJump, 0);
    }

    // Breaks should go after us..
    comp->popDefaultBreak();
    comp->popNest();
    comp->resolvePendingBreaks(this, CodeGen::nextPC(comp));
}

void ImportStatement::generateExecCode(CompileState *)
{} // handled as a declaration..

}