chromium/v8/src/interpreter/control-flow-builders.cc

// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/interpreter/control-flow-builders.h"
#include "src/objects/objects-inl.h"

namespace v8 {
namespace internal {
namespace interpreter {


BreakableControlFlowBuilder::~BreakableControlFlowBuilder() { … }

void BreakableControlFlowBuilder::BindBreakTarget() { … }

void BreakableControlFlowBuilder::EmitJump(BytecodeLabels* sites) { … }

void BreakableControlFlowBuilder::EmitJumpIfTrue(
    BytecodeArrayBuilder::ToBooleanMode mode, BytecodeLabels* sites) { … }

void BreakableControlFlowBuilder::EmitJumpIfFalse(
    BytecodeArrayBuilder::ToBooleanMode mode, BytecodeLabels* sites) { … }

void BreakableControlFlowBuilder::EmitJumpIfUndefined(BytecodeLabels* sites) { … }

void BreakableControlFlowBuilder::EmitJumpIfForInDone(BytecodeLabels* sites,
                                                      Register index,
                                                      Register cache_length) { … }

LoopBuilder::~LoopBuilder() { … }

void LoopBuilder::LoopHeader() { … }

void LoopBuilder::LoopBody() { … }

void LoopBuilder::JumpToHeader(int loop_depth, LoopBuilder* const parent_loop) { … }

void LoopBuilder::BindContinueTarget() { … }

void LoopBuilder::BindLoopEnd() { … }

SwitchBuilder::~SwitchBuilder() { … }

void SwitchBuilder::BindCaseTargetForJumpTable(int case_value,
                                               CaseClause* clause) { … }

void SwitchBuilder::BindCaseTargetForCompareJump(int index,
                                                 CaseClause* clause) { … }

void SwitchBuilder::JumpToCaseIfTrue(BytecodeArrayBuilder::ToBooleanMode mode,
                                     int index) { … }

// Precondition: tag is in the accumulator
void SwitchBuilder::EmitJumpTableIfExists(
    int min_case, int max_case, std::map<int, CaseClause*>& covered_cases) { … }

void SwitchBuilder::BindDefault(CaseClause* clause) { … }

void SwitchBuilder::JumpToDefault() { … }

void SwitchBuilder::JumpToFallThroughIfFalse() { … }

TryCatchBuilder::~TryCatchBuilder() { … }

void TryCatchBuilder::BeginTry(Register context) { … }


void TryCatchBuilder::EndTry() { … }

void TryCatchBuilder::EndCatch() { … }

TryFinallyBuilder::~TryFinallyBuilder() { … }

void TryFinallyBuilder::BeginTry(Register context) { … }


void TryFinallyBuilder::LeaveTry() { … }


void TryFinallyBuilder::EndTry() { … }


void TryFinallyBuilder::BeginHandler() { … }

void TryFinallyBuilder::BeginFinally() { … }

void TryFinallyBuilder::EndFinally() { … }

ConditionalChainControlFlowBuilder::~ConditionalChainControlFlowBuilder() { … }

void ConditionalChainControlFlowBuilder::JumpToEnd() { … }

void ConditionalChainControlFlowBuilder::ThenAt(size_t index) { … }

void ConditionalChainControlFlowBuilder::ElseAt(size_t index) { … }

ConditionalControlFlowBuilder::~ConditionalControlFlowBuilder() { … }

void ConditionalControlFlowBuilder::JumpToEnd() { … }

void ConditionalControlFlowBuilder::Then() { … }

void ConditionalControlFlowBuilder::Else() { … }

}  // namespace interpreter
}  // namespace internal
}  // namespace v8