maglev-ir-arm64.cc File Reference

#include "src/base/logging.h"
#include "src/codegen/arm64/assembler-arm64-inl.h"
#include "src/codegen/arm64/register-arm64.h"
#include "src/codegen/interface-descriptors-inl.h"
#include "src/maglev/arm64/maglev-assembler-arm64-inl.h"
#include "src/maglev/maglev-assembler-inl.h"
#include "src/maglev/maglev-graph-processor.h"
#include "src/maglev/maglev-graph.h"
#include "src/maglev/maglev-ir-inl.h"
#include "src/maglev/maglev-ir.h"
#include "src/objects/feedback-cell.h"
#include "src/objects/js-function.h"

Include dependency graph for maglev-ir-arm64.cc:

Go to the source code of this file.

Namespaces
namespace	v8
namespace	v8::internal
namespace	v8::internal::maglev

Macros
#define	__   masm->
#define	DEF_BITWISE_BINOP(Instruction, opcode)
#define	DEF_SHIFT_BINOP(Instruction, opcode)

Macro Definition Documentation

__

#define __   masm->

Definition at line 22 of file maglev-ir-arm64.cc.

DEF_BITWISE_BINOP

#define DEF_BITWISE_BINOP	(		Instruction,
			opcode )

Value:

  void Instruction::SetValueLocationConstraints() {                    \
    UseRegister(left_input());                                         \
    if (TryGetLogicalImmediateInt32ConstantInput(this, kRightIndex)) { \
      UseAny(right_input());                                           \
    } else {                                                           \
      UseRegister(right_input());                                      \
    }                                                                  \
    DefineAsRegister(this);                                            \
  }                                                                    \
                                                                       \
  void Instruction::GenerateCode(MaglevAssembler* masm,                \
                                 const ProcessingState& state) {       \
    Register left = ToRegister(left_input()).W();                      \
    Register out = ToRegister(result()).W();                           \
    if (!right_input().operand().IsRegister()) {                       \
      auto right_const = TryGetInt32ConstantInput(kRightIndex);        \
      DCHECK(right_const);                                             \
      __ opcode(out, left, *right_const);                              \
    } else {                                                           \
      Register right = ToRegister(right_input()).W();                  \
      __ opcode(out, left, right);                                     \
    }                                                                  \
  }

Definition at line 520 of file maglev-ir-arm64.cc.

DEF_SHIFT_BINOP

#define DEF_SHIFT_BINOP	(		Instruction,
			opcode )

Value:

  void Instruction::SetValueLocationConstraints() {                 \
    UseRegister(left_input());                                      \
    if (TryGetInt32ConstantInput(kRightIndex)) {                    \
      UseAny(right_input());                                        \
    } else {                                                        \
      UseRegister(right_input());                                   \
    }                                                               \
    DefineAsRegister(this);                                         \
  }                                                                 \
                                                                    \
  void Instruction::GenerateCode(MaglevAssembler* masm,             \
                                 const ProcessingState& state) {    \
    Register out = ToRegister(result()).W();                        \
    Register left = ToRegister(left_input()).W();                   \
    if (auto right_const = TryGetInt32ConstantInput(kRightIndex)) { \
      int right = *right_const & 31;                                \
      if (right == 0) {                                             \
        __ Move(out, left);                                         \
      } else {                                                      \
        __ opcode(out, left, right);                                \
      }                                                             \
    } else {                                                        \
      Register right = ToRegister(right_input()).W();               \
      __ opcode##v(out, left, right);                               \
    }                                                               \
  }

Definition at line 549 of file maglev-ir-arm64.cc.