interpreter-unittest.cc | Explore in Territory

// 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/interpreter.h"

#include <tuple>

#include "src/api/api-inl.h"
#include "src/base/overflowing-math.h"
#include "src/codegen/compiler.h"
#include "src/execution/execution.h"
#include "src/handles/handles.h"
#include "src/heap/heap-inl.h"
#include "src/init/v8.h"
#include "src/interpreter/bytecode-array-builder.h"
#include "src/interpreter/bytecode-array-iterator.h"
#include "src/interpreter/bytecode-flags-and-tokens.h"
#include "src/interpreter/bytecode-label.h"
#include "src/numbers/hash-seed-inl.h"
#include "src/objects/heap-number-inl.h"
#include "src/objects/objects-inl.h"
#include "src/objects/smi.h"
#include "test/unittests/interpreter/interpreter-tester.h"

namespace v8 {
namespace internal {
namespace interpreter {

class InterpreterTest : public WithContextMixin<TestWithIsolateAndZone> { … };

static int GetIndex(FeedbackSlot slot) { … }

ToBooleanMode;

TEST_F(InterpreterTest, InterpreterReturn) { … }

TEST_F(InterpreterTest, InterpreterLoadUndefined) { … }

TEST_F(InterpreterTest, InterpreterLoadNull) { … }

TEST_F(InterpreterTest, InterpreterLoadTheHole) { … }

TEST_F(InterpreterTest, InterpreterLoadTrue) { … }

TEST_F(InterpreterTest, InterpreterLoadFalse) { … }

TEST_F(InterpreterTest, InterpreterLoadLiteral) { … }

TEST_F(InterpreterTest, InterpreterLoadStoreRegisters) { … }

static const Token::Value kShiftOperators[] = …;

static const Token::Value kArithmeticOperators[] = …;

static double BinaryOpC(Token::Value op, double lhs, double rhs) { … }

TEST_F(InterpreterTest, InterpreterShiftOpsSmi) { … }

TEST_F(InterpreterTest, InterpreterBinaryOpsSmi) { … }

TEST_F(InterpreterTest, InterpreterBinaryOpsHeapNumber) { … }

TEST_F(InterpreterTest, InterpreterBinaryOpsBigInt) { … }

namespace {

struct LiteralForTest { … };

void LoadLiteralForTest(BytecodeArrayBuilder* builder,
                        const LiteralForTest& value) { … }

}  // anonymous namespace

TEST_F(InterpreterTest, InterpreterStringAdd) { … }

TEST_F(InterpreterTest, InterpreterReceiverParameter) { … }

TEST_F(InterpreterTest, InterpreterParameter0) { … }

TEST_F(InterpreterTest, InterpreterParameter8) { … }

TEST_F(InterpreterTest, InterpreterBinaryOpTypeFeedback) { … }

TEST_F(InterpreterTest, InterpreterBinaryOpSmiTypeFeedback) { … }

TEST_F(InterpreterTest, InterpreterUnaryOpFeedback) { … }

TEST_F(InterpreterTest, InterpreterBitwiseTypeFeedback) { … }

TEST_F(InterpreterTest, InterpreterParameter1Assign) { … }

TEST_F(InterpreterTest, InterpreterLoadGlobal) { … }

TEST_F(InterpreterTest, InterpreterStoreGlobal) { … }

TEST_F(InterpreterTest, InterpreterCallGlobal) { … }

TEST_F(InterpreterTest, InterpreterLoadUnallocated) { … }

TEST_F(InterpreterTest, InterpreterStoreUnallocated) { … }

TEST_F(InterpreterTest, InterpreterLoadNamedProperty) { … }

TEST_F(InterpreterTest, InterpreterLoadKeyedProperty) { … }

TEST_F(InterpreterTest, InterpreterSetNamedProperty) { … }

TEST_F(InterpreterTest, InterpreterSetKeyedProperty) { … }

TEST_F(InterpreterTest, InterpreterCall) { … }

static BytecodeArrayBuilder& SetRegister(BytecodeArrayBuilder* builder,
                                         Register reg, int value,
                                         Register scratch) { … }

static BytecodeArrayBuilder& IncrementRegister(BytecodeArrayBuilder* builder,
                                               Register reg, int value,
                                               Register scratch,
                                               int slot_index) { … }

TEST_F(InterpreterTest, InterpreterJumps) { … }

TEST_F(InterpreterTest, InterpreterConditionalJumps) { … }

TEST_F(InterpreterTest, InterpreterConditionalJumps2) { … }

TEST_F(InterpreterTest, InterpreterJumpConstantWith16BitOperand) { … }

TEST_F(InterpreterTest, InterpreterJumpWith32BitOperand) { … }

static const Token::Value kComparisonTypes[] = …;

template <typename T>
bool CompareC(Token::Value op, T lhs, T rhs, bool types_differed = false) { … }

TEST_F(InterpreterTest, InterpreterSmiComparisons) { … }

TEST_F(InterpreterTest, InterpreterHeapNumberComparisons) { … }

TEST_F(InterpreterTest, InterpreterBigIntComparisons) { … }

TEST_F(InterpreterTest, InterpreterStringComparisons) { … }

static void LoadStringAndAddSpace(BytecodeArrayBuilder* builder,
                                  AstValueFactory* ast_factory,
                                  const char* cstr,
                                  FeedbackSlot string_add_slot) { … }

TEST_F(InterpreterTest, InterpreterMixedComparisons) { … }

TEST_F(InterpreterTest, InterpreterStrictNotEqual) { … }

TEST_F(InterpreterTest, InterpreterCompareTypeOf) { … }

TEST_F(InterpreterTest, InterpreterInstanceOf) { … }

TEST_F(InterpreterTest, InterpreterTestIn) { … }

TEST_F(InterpreterTest, InterpreterUnaryNot) { … }

TEST_F(InterpreterTest, InterpreterUnaryNotNonBoolean) { … }

TEST_F(InterpreterTest, InterpreterTypeof) { … }

TEST_F(InterpreterTest, InterpreterCallRuntime) { … }

TEST_F(InterpreterTest, InterpreterFunctionLiteral) { … }

TEST_F(InterpreterTest, InterpreterRegExpLiterals) { … }

TEST_F(InterpreterTest, InterpreterArrayLiterals) { … }

TEST_F(InterpreterTest, InterpreterObjectLiterals) { … }

TEST_F(InterpreterTest, InterpreterConstruct) { … }

TEST_F(InterpreterTest, InterpreterConstructWithArgument) { … }

TEST_F(InterpreterTest, InterpreterConstructWithArguments) { … }

TEST_F(InterpreterTest, InterpreterContextVariables) { … }

TEST_F(InterpreterTest, InterpreterContextParameters) { … }

TEST_F(InterpreterTest, InterpreterOuterContextVariables) { … }

TEST_F(InterpreterTest, InterpreterComma) { … }

TEST_F(InterpreterTest, InterpreterLogicalOr) { … }

TEST_F(InterpreterTest, InterpreterLogicalAnd) { … }

TEST_F(InterpreterTest, InterpreterTryCatch) { … }

TEST_F(InterpreterTest, InterpreterTryFinally) { … }

TEST_F(InterpreterTest, InterpreterThrow) { … }

TEST_F(InterpreterTest, InterpreterCountOperators) { … }

TEST_F(InterpreterTest, InterpreterGlobalCountOperators) { … }

TEST_F(InterpreterTest, InterpreterCompoundExpressions) { … }

TEST_F(InterpreterTest, InterpreterGlobalCompoundExpressions) { … }

TEST_F(InterpreterTest, InterpreterCreateArguments) { … }

TEST_F(InterpreterTest, InterpreterConditional) { … }

TEST_F(InterpreterTest, InterpreterDelete) { … }

TEST_F(InterpreterTest, InterpreterDeleteSloppyUnqualifiedIdentifier) { … }

TEST_F(InterpreterTest, InterpreterGlobalDelete) { … }

TEST_F(InterpreterTest, InterpreterBasicLoops) { … }

TEST_F(InterpreterTest, InterpreterForIn) { … }

TEST_F(InterpreterTest, InterpreterForOf) { … }

TEST_F(InterpreterTest, InterpreterSwitch) { … }

TEST_F(InterpreterTest, InterpreterSloppyThis) { … }

TEST_F(InterpreterTest, InterpreterThisFunction) { … }

TEST_F(InterpreterTest, InterpreterNewTarget) { … }

TEST_F(InterpreterTest, InterpreterAssignmentInExpressions) { … }

TEST_F(InterpreterTest, InterpreterToName) { … }

TEST_F(InterpreterTest, TemporaryRegisterAllocation) { … }

TEST_F(InterpreterTest, InterpreterLookupSlot) { … }

TEST_F(InterpreterTest, InterpreterLookupContextSlot) { … }

TEST_F(InterpreterTest, InterpreterLookupGlobalSlot) { … }

TEST_F(InterpreterTest, InterpreterCallLookupSlot) { … }

TEST_F(InterpreterTest, InterpreterLookupSlotWide) { … }

TEST_F(InterpreterTest, InterpreterDeleteLookupSlot) { … }

TEST_F(InterpreterTest, JumpWithConstantsAndWideConstants) { … }

TEST_F(InterpreterTest, InterpreterEval) { … }

TEST_F(InterpreterTest, InterpreterEvalParams) { … }

TEST_F(InterpreterTest, InterpreterEvalGlobal) { … }

TEST_F(InterpreterTest, InterpreterEvalVariableDecl) { … }

TEST_F(InterpreterTest, InterpreterEvalFunctionDecl) { … }

TEST_F(InterpreterTest, InterpreterWideRegisterArithmetic) { … }

TEST_F(InterpreterTest, InterpreterCallWideRegisters) { … }

TEST_F(InterpreterTest, InterpreterWideParametersPickOne) { … }

TEST_F(InterpreterTest, InterpreterWideParametersSummation) { … }

TEST_F(InterpreterTest, InterpreterWithStatement) { … }

TEST_F(InterpreterTest, InterpreterClassLiterals) { … }

TEST_F(InterpreterTest, InterpreterClassAndSuperClass) { … }

TEST_F(InterpreterTest, InterpreterConstDeclaration) { … }

TEST_F(InterpreterTest, InterpreterConstDeclarationLookupSlots) { … }

TEST_F(InterpreterTest, InterpreterConstInLookupContextChain) { … }

TEST_F(InterpreterTest, InterpreterIllegalConstDeclaration) { … }

TEST_F(InterpreterTest, InterpreterGenerators) { … }

#ifndef V8_TARGET_ARCH_ARM
TEST_F(InterpreterTest, InterpreterWithNativeStack) { … }
#endif  // V8_TARGET_ARCH_ARM

TEST_F(InterpreterTest, InterpreterGetBytecodeHandler) { … }

TEST_F(InterpreterTest, InterpreterCollectSourcePositions) { … }

TEST_F(InterpreterTest, InterpreterCollectSourcePositions_StackOverflow) { … }

TEST_F(InterpreterTest, InterpreterCollectSourcePositions_ThrowFrom1stFrame) { … }

TEST_F(InterpreterTest, InterpreterCollectSourcePositions_ThrowFrom2ndFrame) { … }

namespace {

void CheckStringEqual(const char* expected_ptr, const char* actual_ptr) { … }

void CheckStringEqual(const char* expected_ptr, Handle<Object> actual_handle) { … }

}  // namespace

TEST_F(InterpreterTest, InterpreterCollectSourcePositions_GenerateStackTrace) { … }

TEST_F(InterpreterTest, InterpreterLookupNameOfBytecodeHandler) { … }

}  // namespace interpreter
}  // namespace internal
}  // namespace v8
chromium/v8/test/unittests/interpreter/interpreter-unittest.cc
