/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "frontend/TryEmitter.h"

#include "mozilla/Assertions.h"  // MOZ_ASSERT

#include "frontend/BytecodeEmitter.h"  // BytecodeEmitter
#include "frontend/IfEmitter.h"        // BytecodeEmitter
#include "frontend/SharedContext.h"    // StatementKind
#include "vm/Opcodes.h"                // JSOp

using namespace js;
using namespace js::frontend;

using mozilla::Maybe;

TryEmitter::TryEmitter(BytecodeEmitter* bce, Kind kind, ControlKind controlKind)
    : bce_(bce),
      kind_(kind),
      controlKind_(controlKind),
      depth_(0),
      tryOpOffset_(0)
#ifdef DEBUG
      ,
      state_(State::Start)
#endif
{
  if (controlKind_ == ControlKind::Syntactic) {
    controlInfo_.emplace(
        bce_, hasFinally() ? StatementKind::Finally : StatementKind::Try);
  }
}

bool TryEmitter::emitTry() {
  MOZ_ASSERT(state_ == State::Start);

  // Since an exception can be thrown at any place inside the try block,
  // we need to restore the stack and the scope chain before we transfer
  // the control to the exception handler.
  //
  // For that we store in a try note associated with the catch or
  // finally block the stack depth upon the try entry. The interpreter
  // uses this depth to properly unwind the stack and the scope chain.
  depth_ = bce_->bytecodeSection().stackDepth();

  tryOpOffset_ = bce_->bytecodeSection().offset();
  if (!bce_->emit1(JSOp::Try)) {
    return false;
  }

#ifdef DEBUG
  state_ = State::Try;
#endif
  return true;
}

bool TryEmitter::emitJumpToFinallyWithFallthrough() {
  uint32_t stackDepthForNextBlock = bce_->bytecodeSection().stackDepth();

  // The fallthrough continuation is special-cased with index 0.
  uint32_t idx = TryFinallyControl::SpecialContinuations::Fallthrough;
  if (!bce_->emitJumpToFinally(&controlInfo_->finallyJumps_, idx)) {
    return false;
  }

  // Reset the stack depth for the following catch or finally block.
  bce_->bytecodeSection().setStackDepth(stackDepthForNextBlock);
  return true;
}

bool TryEmitter::emitTryEnd() {
  MOZ_ASSERT(state_ == State::Try);
  MOZ_ASSERT(depth_ == bce_->bytecodeSection().stackDepth());

  if (hasFinally() && controlInfo_) {
    if (!emitJumpToFinallyWithFallthrough()) {
      return false;
    }
  } else {
    // Emit jump over catch
    if (!bce_->emitJump(JSOp::Goto, &catchAndFinallyJump_)) {
      return false;
    }
  }

  if (!bce_->emitJumpTarget(&tryEnd_)) {
    return false;
  }

  return true;
}

bool TryEmitter::emitCatch(ExceptionStack stack) {
  MOZ_ASSERT(state_ == State::Try);
  if (!emitTryEnd()) {
    return false;
  }

  MOZ_ASSERT(bce_->bytecodeSection().stackDepth() == depth_);

  if (shouldUpdateRval()) {
    // Clear the frame's return value that might have been set by the
    // try block:
    //
    //   eval("try { 1; throw 2 } catch(e) {}"); // undefined, not 1
    if (!bce_->emit1(JSOp::Undefined)) {
      return false;
    }
    if (!bce_->emit1(JSOp::SetRval)) {
      return false;
    }
  }

  if (stack == ExceptionStack::No) {
    if (!bce_->emit1(JSOp::Exception)) {
      return false;
    }
  } else {
    if (!bce_->emit1(JSOp::ExceptionAndStack)) {
      return false;
    }
  }

#ifdef DEBUG
  state_ = State::Catch;
#endif
  return true;
}

bool TryEmitter::emitCatchEnd() {
  MOZ_ASSERT(state_ == State::Catch);

  if (!controlInfo_) {
    return true;
  }

  // Jump to <finally>, if required.
  if (hasFinally()) {
    if (!emitJumpToFinallyWithFallthrough()) {
      return false;
    }
  }

  return true;
}

bool TryEmitter::emitFinally(
    const Maybe<uint32_t>& finallyPos /* = Nothing() */) {
  // If we are using controlInfo_ (i.e., emitting a syntactic try
  // blocks), we must have specified up front if there will be a finally
  // close. For internal non-syntactic try blocks, like those emitted for
  // yield* and IteratorClose inside for-of loops, we can emitFinally even
  // without specifying up front, since the internal non-syntactic try
  // blocks emit no JSOp::Goto.
  if (!controlInfo_) {
    if (kind_ == Kind::TryCatch) {
      kind_ = Kind::TryCatchFinally;
    }
  } else {
    MOZ_ASSERT(hasFinally());
  }

  if (!hasCatch()) {
    MOZ_ASSERT(state_ == State::Try);
    if (!emitTryEnd()) {
      return false;
    }
  } else {
    MOZ_ASSERT(state_ == State::Catch);
    if (!emitCatchEnd()) {
      return false;
    }
  }

  MOZ_ASSERT(bce_->bytecodeSection().stackDepth() == depth_);

  // Upon entry to the finally, there are three additional values on the stack:
  // a boolean value to indicate whether we're throwing an exception, the
  // exception stack (if we're throwing) or null, and either that exception (if
  // we're throwing) or a resume index to which we will return (if we're not
  // throwing).
  bce_->bytecodeSection().setStackDepth(depth_ + 3);

  if (!bce_->emitJumpTarget(&finallyStart_)) {
    return false;
  }

  if (controlInfo_) {
    // Fix up the jumps to the finally code.
    bce_->patchJumpsToTarget(controlInfo_->finallyJumps_, finallyStart_);

    // Indicate that we're emitting a subroutine body.
    controlInfo_->setEmittingSubroutine();
  }
  if (finallyPos) {
    if (!bce_->updateSourceCoordNotes(finallyPos.value())) {
      return false;
    }
  }
  if (!bce_->emit1(JSOp::Finally)) {
    return false;
  }

  if (shouldUpdateRval()) {
    if (!bce_->emit1(JSOp::GetRval)) {
      return false;
    }

    // Clear the frame's return value to make break/continue return
    // correct value even if there's no other statement before them:
    //
    //   eval("x: try { 1 } finally { break x; }"); // undefined, not 1
    if (!bce_->emit1(JSOp::Undefined)) {
      return false;
    }
    if (!bce_->emit1(JSOp::SetRval)) {
      return false;
    }
  }

#ifdef DEBUG
  state_ = State::Finally;
#endif
  return true;
}

bool TryEmitter::emitFinallyEnd() {
  MOZ_ASSERT(state_ == State::Finally);

  if (shouldUpdateRval()) {
    if (!bce_->emit1(JSOp::SetRval)) {
      return false;
    }
  }

  //                [stack] RESUME_INDEX_OR_EXCEPTION, EXCEPTION_STACK, THROWING

  InternalIfEmitter ifThrowing(bce_);
  if (!ifThrowing.emitThenElse()) {
    //              [stack] RESUME_INDEX_OR_EXCEPTION, EXCEPTION_STACK
    return false;
  }

  if (!bce_->emit1(JSOp::ThrowWithStack)) {
    //              [stack]
    return false;
  }

  if (!ifThrowing.emitElse()) {
    //              [stack] RESUME_INDEX_OR_EXCEPTION, EXCEPTION_STACK
    return false;
  }

  if (!bce_->emit1(JSOp::Pop)) {
    //              [stack] RESUME_INDEX_OR_EXCEPTION
    return false;
  }

  if (controlInfo_ && !controlInfo_->continuations_.empty()) {
    if (!controlInfo_->emitContinuations(bce_)) {
      //              [stack]
      return false;
    }
  } else {
    // If there are no non-local jumps, then the only possible jump target
    // is the code immediately following this finally block. Instead of
    // emitting a tableswitch, we can simply pop the continuation index
    // and fall through.
    if (!bce_->emit1(JSOp::Pop)) {
      //              [stack]
      return false;
    }
  }

  if (!ifThrowing.emitEnd()) {
    return false;
  }

  bce_->hasTryFinally = true;
  return true;
}

bool TryEmitter::emitEnd() {
  if (!hasFinally()) {
    MOZ_ASSERT(state_ == State::Catch);
    if (!emitCatchEnd()) {
      return false;
    }
  } else {
    MOZ_ASSERT(state_ == State::Finally);
    if (!emitFinallyEnd()) {
      return false;
    }
  }

  MOZ_ASSERT(bce_->bytecodeSection().stackDepth() == depth_);

  if (catchAndFinallyJump_.offset.valid()) {
    // Fix up the end-of-try/catch jumps to come here.
    if (!bce_->emitJumpTargetAndPatch(catchAndFinallyJump_)) {
      return false;
    }
  }

  // Add the try note last, to let post-order give us the right ordering
  // (first to last for a given nesting level, inner to outer by level).
  if (hasCatch()) {
    if (!bce_->addTryNote(TryNoteKind::Catch, depth_, offsetAfterTryOp(),
                          tryEnd_.offset)) {
      return false;
    }
  }

  // If we've got a finally, mark try+catch region with additional
  // trynote to catch exceptions (re)thrown from a catch block or
  // for the try{}finally{} case.
  if (hasFinally()) {
    if (!bce_->addTryNote(TryNoteKind::Finally, depth_, offsetAfterTryOp(),
                          finallyStart_.offset)) {
      return false;
    }
  }

#ifdef DEBUG
  state_ = State::End;
#endif
  return true;
}

bool TryEmitter::shouldUpdateRval() const {
  return controlKind_ == ControlKind::Syntactic && !bce_->sc->noScriptRval();
}