// 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/bytecode-array-builder.h"

#include "src/common/assert-scope.h"

#include "src/common/globals.h"

#include "src/interpreter/bytecode-array-writer.h"

#include "src/interpreter/bytecode-jump-table.h"

#include "src/interpreter/bytecode-label.h"

#include "src/interpreter/bytecode-node.h"

#include "src/interpreter/bytecode-register-optimizer.h"

#include "src/interpreter/bytecode-source-info.h"

#include "src/interpreter/interpreter-intrinsics.h"

#include "src/objects/objects-inl.h"

#include "src/objects/smi.h"

namespace v8 {

namespace internal {

namespace interpreter {

class RegisterTransferWriter final

: public NON_EXPORTED_BASE(BytecodeRegisterOptimizer::BytecodeWriter),

public NON_EXPORTED_BASE(ZoneObject) {

public:

explicit RegisterTransferWriter(BytecodeArrayBuilder* builder)

: builder_(builder) {}

~RegisterTransferWriter() override = default;

void EmitLdar(Register input) override { builder_->OutputLdarRaw(input); }

void EmitStar(Register output) override { builder_->OutputStarRaw(output); }

void EmitMov(Register input, Register output) override {

builder_->OutputMovRaw(input, output);

}

private:

BytecodeArrayBuilder* builder_;

};

BytecodeArrayBuilder::BytecodeArrayBuilder(

Zone* zone, int parameter_count, int locals_count,

FeedbackVectorSpec* feedback_vector_spec,

SourcePositionTableBuilder::RecordingMode source_position_mode)

: zone_(zone),

feedback_vector_spec_(feedback_vector_spec),

bytecode_generated_(false),

constant_array_builder_(zone),

handler_table_builder_(zone),

parameter_count_(parameter_count),

local_register_count_(locals_count),

register_allocator_(fixed_register_count()),

bytecode_array_writer_(zone, &constant_array_builder_,

source_position_mode),

register_optimizer_(nullptr) {

DCHECK_GE(parameter_count_, 0);

DCHECK_GE(local_register_count_, 0);

if (FLAG_ignition_reo) {

register_optimizer_ = zone->New<BytecodeRegisterOptimizer>(

zone, &register_allocator_, fixed_register_count(), parameter_count,

zone->New<RegisterTransferWriter>(this));

}

}

Register BytecodeArrayBuilder::Parameter(int parameter_index) const {

DCHECK_GE(parameter_index, 0);

// The parameter indices are shifted by 1 (receiver is the

// first entry).

return Register::FromParameterIndex(parameter_index + 1, parameter_count());

}

Register BytecodeArrayBuilder::Receiver() const {

return Register::FromParameterIndex(0, parameter_count());

}

Register BytecodeArrayBuilder::Local(int index) const {

// TODO(marja): Make a DCHECK once crbug.com/706234 is fixed.

CHECK_LT(index, locals_count());

return Register(index);

}

template <typename LocalIsolate>

Handle<BytecodeArray> BytecodeArrayBuilder::ToBytecodeArray(

LocalIsolate* isolate) {

DCHECK(RemainderOfBlockIsDead());

DCHECK(!bytecode_generated_);

bytecode_generated_ = true;

int register_count = total_register_count();

if (register_optimizer_) {

register_optimizer_->Flush();

register_count = register_optimizer_->maxiumum_register_index() + 1;

}

Handle<ByteArray> handler_table =

handler_table_builder()->ToHandlerTable(isolate);

return bytecode_array_writer_.ToBytecodeArray(

isolate, register_count, parameter_count(), handler_table);

}

template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)

Handle<BytecodeArray> BytecodeArrayBuilder::ToBytecodeArray(

Isolate* isolate);

template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)

Handle<BytecodeArray> BytecodeArrayBuilder::ToBytecodeArray(

OffThreadIsolate* isolate);

#ifdef DEBUG

int BytecodeArrayBuilder::CheckBytecodeMatches(BytecodeArray bytecode) {

DisallowHeapAllocation no_gc;

return bytecode_array_writer_.CheckBytecodeMatches(bytecode);

}

#endif

template <typename LocalIsolate>

Handle<ByteArray> BytecodeArrayBuilder::ToSourcePositionTable(

LocalIsolate* isolate) {

DCHECK(RemainderOfBlockIsDead());

return bytecode_array_writer_.ToSourcePositionTable(isolate);

}

template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)

Handle<ByteArray> BytecodeArrayBuilder::ToSourcePositionTable(

Isolate* isolate);

template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)

Handle<ByteArray> BytecodeArrayBuilder::ToSourcePositionTable(

OffThreadIsolate* isolate);

BytecodeSourceInfo BytecodeArrayBuilder::CurrentSourcePosition(

Bytecode bytecode) {

BytecodeSourceInfo source_position;

if (latest_source_info_.is_valid()) {

// Statement positions need to be emitted immediately. Expression

// positions can be pushed back until a bytecode is found that can

// throw (if expression position filtering is turned on). We only

// invalidate the existing source position information if it is used.

if (latest_source_info_.is_statement() ||

!FLAG_ignition_filter_expression_positions ||

!Bytecodes::IsWithoutExternalSideEffects(bytecode)) {

source_position = latest_source_info_;

latest_source_info_.set_invalid();

}

}

return source_position;

}

void BytecodeArrayBuilder::SetDeferredSourceInfo(

BytecodeSourceInfo source_info) {

if (!source_info.is_valid()) return;

deferred_source_info_ = source_info;

}

void BytecodeArrayBuilder::AttachOrEmitDeferredSourceInfo(BytecodeNode* node) {

if (!deferred_source_info_.is_valid()) return;

if (!node->source_info().is_valid()) {

node->set_source_info(deferred_source_info_);

} else if (deferred_source_info_.is_statement() &&

node->source_info().is_expression()) {

BytecodeSourceInfo source_position = node->source_info();

source_position.MakeStatementPosition(source_position.source_position());

node->set_source_info(source_position);

}

deferred_source_info_.set_invalid();

}

void BytecodeArrayBuilder::Write(BytecodeNode* node) {

AttachOrEmitDeferredSourceInfo(node);

bytecode_array_writer_.Write(node);

}

void BytecodeArrayBuilder::WriteJump(BytecodeNode* node, BytecodeLabel* label) {

AttachOrEmitDeferredSourceInfo(node);

bytecode_array_writer_.WriteJump(node, label);

}

void BytecodeArrayBuilder::WriteJumpLoop(BytecodeNode* node,

BytecodeLoopHeader* loop_header) {

AttachOrEmitDeferredSourceInfo(node);

bytecode_array_writer_.WriteJumpLoop(node, loop_header);

}

void BytecodeArrayBuilder::WriteSwitch(BytecodeNode* node,

BytecodeJumpTable* jump_table) {

AttachOrEmitDeferredSourceInfo(node);

bytecode_array_writer_.WriteSwitch(node, jump_table);

}

void BytecodeArrayBuilder::OutputLdarRaw(Register reg) {

uint32_t operand = static_cast<uint32_t>(reg.ToOperand());

BytecodeNode node(BytecodeNode::Ldar(BytecodeSourceInfo(), operand));

Write(&node);

}

void BytecodeArrayBuilder::OutputStarRaw(Register reg) {

uint32_t operand = static_cast<uint32_t>(reg.ToOperand());

BytecodeNode node(BytecodeNode::Star(BytecodeSourceInfo(), operand));

Write(&node);

}

void BytecodeArrayBuilder::OutputMovRaw(Register src, Register dest) {

uint32_t operand0 = static_cast<uint32_t>(src.ToOperand());

uint32_t operand1 = static_cast<uint32_t>(dest.ToOperand());

BytecodeNode node(

BytecodeNode::Mov(BytecodeSourceInfo(), operand0, operand1));

Write(&node);

}

namespace {

template <OperandTypeInfo type_info>

class UnsignedOperandHelper {

public:

V8_INLINE static uint32_t Convert(BytecodeArrayBuilder* builder,

size_t value) {

DCHECK(IsValid(value));

return static_cast<uint32_t>(value);

}

V8_INLINE static uint32_t Convert(BytecodeArrayBuilder* builder, int value) {

DCHECK_GE(value, 0);

return Convert(builder, static_cast<size_t>(value));

}

private:

static bool IsValid(size_t value) {

switch (type_info) {

case OperandTypeInfo::kFixedUnsignedByte:

return value <= kMaxUInt8;

case OperandTypeInfo::kFixedUnsignedShort:

return value <= kMaxUInt16;

case OperandTypeInfo::kScalableUnsignedByte:

return value <= kMaxUInt32;

default:

UNREACHABLE();

}

}

};

template <OperandType>

class OperandHelper {};

#define DEFINE_UNSIGNED_OPERAND_HELPER(Name, Type) \

template <> \

class OperandHelper<OperandType::k##Name> \

: public UnsignedOperandHelper<Type> {};

UNSIGNED_FIXED_SCALAR_OPERAND_TYPE_LIST(DEFINE_UNSIGNED_OPERAND_HELPER)

UNSIGNED_SCALABLE_SCALAR_OPERAND_TYPE_LIST(DEFINE_UNSIGNED_OPERAND_HELPER)

#undef DEFINE_UNSIGNED_OPERAND_HELPER

template <>

class OperandHelper<OperandType::kImm> {

public:

V8_INLINE static uint32_t Convert(BytecodeArrayBuilder* builder, int value) {

return static_cast<uint32_t>(value);

}

};

template <>

class OperandHelper<OperandType::kReg> {

public:

V8_INLINE static uint32_t Convert(BytecodeArrayBuilder* builder,

Register reg) {

return builder->GetInputRegisterOperand(reg);

}

};

template <>

class OperandHelper<OperandType::kRegList> {

public:

V8_INLINE static uint32_t Convert(BytecodeArrayBuilder* builder,

RegisterList reg_list) {

return builder->GetInputRegisterListOperand(reg_list);

}

};

template <>

class OperandHelper<OperandType::kRegPair> {

public:

V8_INLINE static uint32_t Convert(BytecodeArrayBuilder* builder,

RegisterList reg_list) {

DCHECK_EQ(reg_list.register_count(), 2);

return builder->GetInputRegisterListOperand(reg_list);

}

};

template <>

class OperandHelper<OperandType::kRegOut> {

public:

V8_INLINE static uint32_t Convert(BytecodeArrayBuilder* builder,

Register reg) {

return builder->GetOutputRegisterOperand(reg);

}

};

template <>

class OperandHelper<OperandType::kRegOutList> {

public:

V8_INLINE static uint32_t Convert(BytecodeArrayBuilder* builder,

RegisterList reg_list) {

return builder->GetOutputRegisterListOperand(reg_list);

}

};

template <>

class OperandHelper<OperandType::kRegOutPair> {

public:

V8_INLINE static uint32_t Convert(BytecodeArrayBuilder* builder,

RegisterList reg_list) {

DCHECK_EQ(2, reg_list.register_count());

return builder->GetOutputRegisterListOperand(reg_list);

}

};

template <>

class OperandHelper<OperandType::kRegOutTriple> {

public:

V8_INLINE static uint32_t Convert(BytecodeArrayBuilder* builder,

RegisterList reg_list) {

DCHECK_EQ(3, reg_list.register_count());

return builder->GetOutputRegisterListOperand(reg_list);

}

};

} // namespace

template <Bytecode bytecode, AccumulatorUse accumulator_use,

OperandType... operand_types>

class BytecodeNodeBuilder {

public:

template <typename... Operands>

V8_INLINE static BytecodeNode Make(BytecodeArrayBuilder* builder,

Operands... operands) {

static_assert(sizeof...(Operands) <= Bytecodes::kMaxOperands,

"too many operands for bytecode");

builder->PrepareToOutputBytecode<bytecode, accumulator_use>();

// The "OperandHelper<operand_types>::Convert(builder, operands)..." will

// expand both the OperandType... and Operands... parameter packs e.g. for:

// BytecodeNodeBuilder<OperandType::kReg, OperandType::kImm>::Make<

// Register, int>(..., Register reg, int immediate)

// the code will expand into:

// OperandHelper<OperandType::kReg>::Convert(builder, reg),

// OperandHelper<OperandType::kImm>::Convert(builder, immediate),

return BytecodeNode::Create<bytecode, accumulator_use, operand_types...>(

builder->CurrentSourcePosition(bytecode),

OperandHelper<operand_types>::Convert(builder, operands)...);

}

};

#define DEFINE_BYTECODE_OUTPUT(name, ...) \

template <typename... Operands> \

BytecodeNode BytecodeArrayBuilder::Create##name##Node( \

Operands... operands) { \

return BytecodeNodeBuilder<Bytecode::k##name, __VA_ARGS__>::Make( \

this, operands...); \

} \

\

template <typename... Operands> \

void BytecodeArrayBuilder::Output##name(Operands... operands) { \

BytecodeNode node(Create##name##Node(operands...)); \

Write(&node); \

} \

\

template <typename... Operands> \

void BytecodeArrayBuilder::Output##name(BytecodeLabel* label, \

Operands... operands) { \

DCHECK(Bytecodes::IsForwardJump(Bytecode::k##name)); \

BytecodeNode node(Create##name##Node(operands...)); \

WriteJump(&node, label); \

}

BYTECODE_LIST(DEFINE_BYTECODE_OUTPUT)

#undef DEFINE_BYTECODE_OUTPUT

void BytecodeArrayBuilder::OutputJumpLoop(BytecodeLoopHeader* loop_header,

int loop_depth) {

BytecodeNode node(CreateJumpLoopNode(0, loop_depth));

WriteJumpLoop(&node, loop_header);

}

void BytecodeArrayBuilder::OutputSwitchOnSmiNoFeedback(

BytecodeJumpTable* jump_table) {

BytecodeNode node(CreateSwitchOnSmiNoFeedbackNode(

jump_table->constant_pool_index(), jump_table->size(),

jump_table->case_value_base()));

WriteSwitch(&node, jump_table);

}

BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperation(Token::Value op,

Register reg,

int feedback_slot) {

switch (op) {

case Token::Value::ADD:

OutputAdd(reg, feedback_slot);

break;

case Token::Value::SUB:

OutputSub(reg, feedback_slot);

break;

case Token::Value::MUL:

OutputMul(reg, feedback_slot);

break;

case Token::Value::DIV:

OutputDiv(reg, feedback_slot);

break;

case Token::Value::MOD:

OutputMod(reg, feedback_slot);

break;

case Token::Value::EXP:

OutputExp(reg, feedback_slot);

break;

case Token::Value::BIT_OR:

OutputBitwiseOr(reg, feedback_slot);

break;

case Token::Value::BIT_XOR:

OutputBitwiseXor(reg, feedback_slot);

break;

case Token::Value::BIT_AND:

OutputBitwiseAnd(reg, feedback_slot);

break;

case Token::Value::SHL:

OutputShiftLeft(reg, feedback_slot);

break;

case Token::Value::SAR:

OutputShiftRight(reg, feedback_slot);

break;

case Token::Value::SHR:

OutputShiftRightLogical(reg, feedback_slot);

break;

default:

UNREACHABLE();

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperationSmiLiteral(

Token::Value op, Smi literal, int feedback_slot) {

switch (op) {

case Token::Value::ADD:

OutputAddSmi(literal.value(), feedback_slot);

break;

case Token::Value::SUB:

OutputSubSmi(literal.value(), feedback_slot);

break;

case Token::Value::MUL:

OutputMulSmi(literal.value(), feedback_slot);

break;

case Token::Value::DIV:

OutputDivSmi(literal.value(), feedback_slot);

break;

case Token::Value::MOD:

OutputModSmi(literal.value(), feedback_slot);

break;

case Token::Value::EXP:

OutputExpSmi(literal.value(), feedback_slot);

break;

case Token::Value::BIT_OR:

OutputBitwiseOrSmi(literal.value(), feedback_slot);

break;

case Token::Value::BIT_XOR:

OutputBitwiseXorSmi(literal.value(), feedback_slot);

break;

case Token::Value::BIT_AND:

OutputBitwiseAndSmi(literal.value(), feedback_slot);

break;

case Token::Value::SHL:

OutputShiftLeftSmi(literal.value(), feedback_slot);

break;

case Token::Value::SAR:

OutputShiftRightSmi(literal.value(), feedback_slot);

break;

case Token::Value::SHR:

OutputShiftRightLogicalSmi(literal.value(), feedback_slot);

break;

default:

UNREACHABLE();

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::UnaryOperation(Token::Value op,

int feedback_slot) {

switch (op) {

case Token::Value::INC:

OutputInc(feedback_slot);

break;

case Token::Value::DEC:

OutputDec(feedback_slot);

break;

case Token::Value::ADD:

OutputToNumber(feedback_slot);

break;

case Token::Value::SUB:

OutputNegate(feedback_slot);

break;

case Token::Value::BIT_NOT:

OutputBitwiseNot(feedback_slot);

break;

default:

UNREACHABLE();

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LogicalNot(ToBooleanMode mode) {

if (mode == ToBooleanMode::kAlreadyBoolean) {

OutputLogicalNot();

} else {

DCHECK_EQ(mode, ToBooleanMode::kConvertToBoolean);

OutputToBooleanLogicalNot();

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::TypeOf() {

OutputTypeOf();

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::GetSuperConstructor(Register out) {

OutputGetSuperConstructor(out);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CompareOperation(

Token::Value op, Register reg, int feedback_slot) {

switch (op) {

case Token::Value::EQ:

OutputTestEqual(reg, feedback_slot);

break;

case Token::Value::EQ_STRICT:

OutputTestEqualStrict(reg, feedback_slot);

break;

case Token::Value::LT:

OutputTestLessThan(reg, feedback_slot);

break;

case Token::Value::GT:

OutputTestGreaterThan(reg, feedback_slot);

break;

case Token::Value::LTE:

OutputTestLessThanOrEqual(reg, feedback_slot);

break;

case Token::Value::GTE:

OutputTestGreaterThanOrEqual(reg, feedback_slot);

break;

case Token::Value::INSTANCEOF:

OutputTestInstanceOf(reg, feedback_slot);

break;

case Token::Value::IN:

OutputTestIn(reg, feedback_slot);

break;

default:

UNREACHABLE();

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CompareReference(Register reg) {

OutputTestReferenceEqual(reg);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CompareUndetectable() {

OutputTestUndetectable();

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CompareUndefined() {

OutputTestUndefined();

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CompareNull() {

OutputTestNull();

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CompareNil(Token::Value op,

NilValue nil) {

if (op == Token::EQ) {

return CompareUndetectable();

} else {

DCHECK_EQ(Token::EQ_STRICT, op);

if (nil == kUndefinedValue) {

return CompareUndefined();

} else {

DCHECK_EQ(kNullValue, nil);

return CompareNull();

}

}

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CompareTypeOf(

TestTypeOfFlags::LiteralFlag literal_flag) {

DCHECK_NE(literal_flag, TestTypeOfFlags::LiteralFlag::kOther);

OutputTestTypeOf(TestTypeOfFlags::Encode(literal_flag));

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadConstantPoolEntry(

size_t entry) {

OutputLdaConstant(entry);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(Smi smi) {

int32_t raw_smi = smi.value();

if (raw_smi == 0) {

OutputLdaZero();

} else {

OutputLdaSmi(raw_smi);

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(double value) {

size_t entry = GetConstantPoolEntry(value);

OutputLdaConstant(entry);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(

const AstRawString* raw_string) {

size_t entry = GetConstantPoolEntry(raw_string);

OutputLdaConstant(entry);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(const Scope* scope) {

size_t entry = GetConstantPoolEntry(scope);

OutputLdaConstant(entry);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(AstBigInt bigint) {

size_t entry = GetConstantPoolEntry(bigint);

OutputLdaConstant(entry);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral(AstSymbol symbol) {

size_t entry;

switch (symbol) {

case AstSymbol::kHomeObjectSymbol:

entry = HomeObjectSymbolConstantPoolEntry();

break;

// No default case so that we get a warning if AstSymbol changes

}

OutputLdaConstant(entry);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadUndefined() {

OutputLdaUndefined();

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadNull() {

OutputLdaNull();

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadTheHole() {

OutputLdaTheHole();

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadTrue() {

OutputLdaTrue();

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadFalse() {

OutputLdaFalse();

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadBoolean(bool value) {

return value ? LoadTrue() : LoadFalse();

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadAccumulatorWithRegister(

Register reg) {

if (register_optimizer_) {

// Defer source info so that if we elide the bytecode transfer, we attach

// the source info to a subsequent bytecode if it exists.

SetDeferredSourceInfo(CurrentSourcePosition(Bytecode::kLdar));

register_optimizer_->DoLdar(reg);

} else {

OutputLdar(reg);

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreAccumulatorInRegister(

Register reg) {

if (register_optimizer_) {

// Defer source info so that if we elide the bytecode transfer, we attach

// the source info to a subsequent bytecode if it exists.

SetDeferredSourceInfo(CurrentSourcePosition(Bytecode::kStar));

register_optimizer_->DoStar(reg);

} else {

OutputStar(reg);

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::MoveRegister(Register from,

Register to) {

DCHECK(from != to);

if (register_optimizer_) {

// Defer source info so that if we elide the bytecode transfer, we attach

// the source info to a subsequent bytecode if it exists.

SetDeferredSourceInfo(CurrentSourcePosition(Bytecode::kMov));

register_optimizer_->DoMov(from, to);

} else {

OutputMov(from, to);

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadGlobal(const AstRawString* name,

int feedback_slot,

TypeofMode typeof_mode) {

size_t name_index = GetConstantPoolEntry(name);

// Ensure that typeof mode is in sync with the IC slot kind.

DCHECK_EQ(GetTypeofModeFromSlotKind(feedback_vector_spec()->GetKind(

FeedbackVector::ToSlot(feedback_slot))),

typeof_mode);

if (typeof_mode == INSIDE_TYPEOF) {

OutputLdaGlobalInsideTypeof(name_index, feedback_slot);

} else {

DCHECK_EQ(typeof_mode, NOT_INSIDE_TYPEOF);

OutputLdaGlobal(name_index, feedback_slot);

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreGlobal(

const AstRawString* name, int feedback_slot) {

size_t name_index = GetConstantPoolEntry(name);

OutputStaGlobal(name_index, feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadContextSlot(

Register context, int slot_index, int depth,

ContextSlotMutability mutability) {

if (context.is_current_context() && depth == 0) {

if (mutability == kImmutableSlot) {

OutputLdaImmutableCurrentContextSlot(slot_index);

} else {

DCHECK_EQ(kMutableSlot, mutability);

OutputLdaCurrentContextSlot(slot_index);

}

} else if (mutability == kImmutableSlot) {

OutputLdaImmutableContextSlot(context, slot_index, depth);

} else {

DCHECK_EQ(mutability, kMutableSlot);

OutputLdaContextSlot(context, slot_index, depth);

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreContextSlot(Register context,

int slot_index,

int depth) {

if (context.is_current_context() && depth == 0) {

OutputStaCurrentContextSlot(slot_index);

} else {

OutputStaContextSlot(context, slot_index, depth);

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLookupSlot(

const AstRawString* name, TypeofMode typeof_mode) {

size_t name_index = GetConstantPoolEntry(name);

if (typeof_mode == INSIDE_TYPEOF) {

OutputLdaLookupSlotInsideTypeof(name_index);

} else {

DCHECK_EQ(typeof_mode, NOT_INSIDE_TYPEOF);

OutputLdaLookupSlot(name_index);

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLookupContextSlot(

const AstRawString* name, TypeofMode typeof_mode, int slot_index,

int depth) {

size_t name_index = GetConstantPoolEntry(name);

if (typeof_mode == INSIDE_TYPEOF) {

OutputLdaLookupContextSlotInsideTypeof(name_index, slot_index, depth);

} else {

DCHECK(typeof_mode == NOT_INSIDE_TYPEOF);

OutputLdaLookupContextSlot(name_index, slot_index, depth);

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLookupGlobalSlot(

const AstRawString* name, TypeofMode typeof_mode, int feedback_slot,

int depth) {

size_t name_index = GetConstantPoolEntry(name);

if (typeof_mode == INSIDE_TYPEOF) {

OutputLdaLookupGlobalSlotInsideTypeof(name_index, feedback_slot, depth);

} else {

DCHECK(typeof_mode == NOT_INSIDE_TYPEOF);

OutputLdaLookupGlobalSlot(name_index, feedback_slot, depth);

}

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreLookupSlot(

const AstRawString* name, LanguageMode language_mode,

LookupHoistingMode lookup_hoisting_mode) {

size_t name_index = GetConstantPoolEntry(name);

uint8_t flags =

StoreLookupSlotFlags::Encode(language_mode, lookup_hoisting_mode);

OutputStaLookupSlot(name_index, flags);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadNamedProperty(

Register object, const AstRawString* name, int feedback_slot) {

size_t name_index = GetConstantPoolEntry(name);

OutputLdaNamedProperty(object, name_index, feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadNamedPropertyNoFeedback(

Register object, const AstRawString* name) {

size_t name_index = GetConstantPoolEntry(name);

OutputLdaNamedPropertyNoFeedback(object, name_index);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadKeyedProperty(

Register object, int feedback_slot) {

OutputLdaKeyedProperty(object, feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadIteratorProperty(

Register object, int feedback_slot) {

size_t name_index = IteratorSymbolConstantPoolEntry();

OutputLdaNamedProperty(object, name_index, feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::GetIterator(

Register object, int load_feedback_slot, int call_feedback_slot) {

OutputGetIterator(object, load_feedback_slot, call_feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadAsyncIteratorProperty(

Register object, int feedback_slot) {

size_t name_index = AsyncIteratorSymbolConstantPoolEntry();

OutputLdaNamedProperty(object, name_index, feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreDataPropertyInLiteral(

Register object, Register name, DataPropertyInLiteralFlags flags,

int feedback_slot) {

OutputStaDataPropertyInLiteral(object, name, flags, feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CollectTypeProfile(int position) {

OutputCollectTypeProfile(position);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedProperty(

Register object, size_t name_index, int feedback_slot,

LanguageMode language_mode) {

// Ensure that language mode is in sync with the IC slot kind.

DCHECK_EQ(GetLanguageModeFromSlotKind(feedback_vector_spec()->GetKind(

FeedbackVector::ToSlot(feedback_slot))),

language_mode);

OutputStaNamedProperty(object, name_index, feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedProperty(

Register object, const AstRawString* name, int feedback_slot,

LanguageMode language_mode) {

size_t name_index = GetConstantPoolEntry(name);

return StoreNamedProperty(object, name_index, feedback_slot, language_mode);

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedPropertyNoFeedback(

Register object, const AstRawString* name, LanguageMode language_mode) {

size_t name_index = GetConstantPoolEntry(name);

OutputStaNamedPropertyNoFeedback(object, name_index,

static_cast<uint8_t>(language_mode));

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedOwnProperty(

Register object, const AstRawString* name, int feedback_slot) {

size_t name_index = GetConstantPoolEntry(name);

// Ensure that the store operation is in sync with the IC slot kind.

DCHECK_EQ(

FeedbackSlotKind::kStoreOwnNamed,

feedback_vector_spec()->GetKind(FeedbackVector::ToSlot(feedback_slot)));

OutputStaNamedOwnProperty(object, name_index, feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreKeyedProperty(

Register object, Register key, int feedback_slot,

LanguageMode language_mode) {

// Ensure that language mode is in sync with the IC slot kind.

DCHECK_EQ(GetLanguageModeFromSlotKind(feedback_vector_spec()->GetKind(

FeedbackVector::ToSlot(feedback_slot))),

language_mode);

OutputStaKeyedProperty(object, key, feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreInArrayLiteral(

Register array, Register index, int feedback_slot) {

OutputStaInArrayLiteral(array, index, feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreHomeObjectProperty(

Register object, int feedback_slot, LanguageMode language_mode) {

size_t name_index = HomeObjectSymbolConstantPoolEntry();

return StoreNamedProperty(object, name_index, feedback_slot, language_mode);

}

BytecodeArrayBuilder& BytecodeArrayBuilder::StoreClassFieldsInitializer(

Register constructor, int feedback_slot) {

size_t name_index = ClassFieldsSymbolConstantPoolEntry();

return StoreNamedProperty(constructor, name_index, feedback_slot,

LanguageMode::kStrict);

}

BytecodeArrayBuilder& BytecodeArrayBuilder::LoadClassFieldsInitializer(

Register constructor, int feedback_slot) {

size_t name_index = ClassFieldsSymbolConstantPoolEntry();

OutputLdaNamedProperty(constructor, name_index, feedback_slot);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CreateClosure(

size_t shared_function_info_entry, int slot, int flags) {

OutputCreateClosure(shared_function_info_entry, slot, flags);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CreateBlockContext(

const Scope* scope) {

size_t entry = GetConstantPoolEntry(scope);

OutputCreateBlockContext(entry);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CreateCatchContext(

Register exception, const Scope* scope) {

size_t scope_index = GetConstantPoolEntry(scope);

OutputCreateCatchContext(exception, scope_index);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CreateFunctionContext(

const Scope* scope, int slots) {

size_t scope_index = GetConstantPoolEntry(scope);

OutputCreateFunctionContext(scope_index, slots);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CreateEvalContext(

const Scope* scope, int slots) {

size_t scope_index = GetConstantPoolEntry(scope);

OutputCreateEvalContext(scope_index, slots);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CreateWithContext(

Register object, const Scope* scope) {

size_t scope_index = GetConstantPoolEntry(scope);

OutputCreateWithContext(object, scope_index);

return *this;

}

BytecodeArrayBuilder& BytecodeArrayBuilder::CreateArguments(

CreateArgumentsType type) {

switch (type) {

case CreateArgumentsType::kMappedArguments:

OutputCreateMappedArguments();

break;

case CreateArgumentsType::kUnmappedArguments:

OutputCreateUnmappedArguments();