src/third_party/v8/src/builtins/builtins-number-gen.cc

// Copyright 2017 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/builtins/builtins-utils-gen.h"
#include "src/builtins/builtins.h"
#include "src/codegen/code-stub-assembler.h"
#include "src/ic/binary-op-assembler.h"
#include "src/ic/unary-op-assembler.h"

namespace v8 {
namespace internal {

// -----------------------------------------------------------------------------
// ES6 section 20.1 Number Objects

#define DEF_BINOP(Name, Generator)                                            \
  TF_BUILTIN(Name, CodeStubAssembler) {                                       \
    auto lhs = Parameter<Object>(Descriptor::kLeft);                          \
    auto rhs = Parameter<Object>(Descriptor::kRight);                         \
    auto context = Parameter<Context>(Descriptor::kContext);                  \
    auto maybe_feedback_vector =                                              \
        Parameter<HeapObject>(Descriptor::kMaybeFeedbackVector);              \
    auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot);              \
                                                                              \
    BinaryOpAssembler binop_asm(state());                                     \
    TNode<Object> result = binop_asm.Generator(context, lhs, rhs, slot,       \
                                               maybe_feedback_vector, false); \
                                                                              \
    Return(result);                                                           \
  }
DEF_BINOP(Add_WithFeedback, Generate_AddWithFeedback)
DEF_BINOP(Subtract_WithFeedback, Generate_SubtractWithFeedback)
DEF_BINOP(Multiply_WithFeedback, Generate_MultiplyWithFeedback)
DEF_BINOP(Divide_WithFeedback, Generate_DivideWithFeedback)
DEF_BINOP(Modulus_WithFeedback, Generate_ModulusWithFeedback)
DEF_BINOP(Exponentiate_WithFeedback, Generate_ExponentiateWithFeedback)
DEF_BINOP(BitwiseOr_WithFeedback, Generate_BitwiseOrWithFeedback)
DEF_BINOP(BitwiseXor_WithFeedback, Generate_BitwiseXorWithFeedback)
DEF_BINOP(BitwiseAnd_WithFeedback, Generate_BitwiseAndWithFeedback)
DEF_BINOP(ShiftLeft_WithFeedback, Generate_ShiftLeftWithFeedback)
DEF_BINOP(ShiftRight_WithFeedback, Generate_ShiftRightWithFeedback)
DEF_BINOP(ShiftRightLogical_WithFeedback,
          Generate_ShiftRightLogicalWithFeedback)
#undef DEF_BINOP

#define DEF_UNOP(Name, Generator)                                 \
  TF_BUILTIN(Name, CodeStubAssembler) {                           \
    auto value = Parameter<Object>(Descriptor::kValue);           \
    auto context = Parameter<Context>(Descriptor::kContext);      \
    auto maybe_feedback_vector =                                  \
        Parameter<HeapObject>(Descriptor::kMaybeFeedbackVector);  \
    auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot);  \
                                                                  \
    UnaryOpAssembler a(state());                                  \
    TNode<Object> result =                                        \
        a.Generator(context, value, slot, maybe_feedback_vector); \
                                                                  \
    Return(result);                                               \
  }
DEF_UNOP(BitwiseNot_WithFeedback, Generate_BitwiseNotWithFeedback)
DEF_UNOP(Decrement_WithFeedback, Generate_DecrementWithFeedback)
DEF_UNOP(Increment_WithFeedback, Generate_IncrementWithFeedback)
DEF_UNOP(Negate_WithFeedback, Generate_NegateWithFeedback)
#undef DEF_UNOP

#define DEF_COMPARE(Name)                                                      \
  TF_BUILTIN(Name##_WithFeedback, CodeStubAssembler) {                         \
    auto lhs = Parameter<Object>(Descriptor::kLeft);                           \
    auto rhs = Parameter<Object>(Descriptor::kRight);                          \
    auto context = Parameter<Context>(Descriptor::kContext);                   \
    auto maybe_feedback_vector =                                               \
        Parameter<HeapObject>(Descriptor::kMaybeFeedbackVector);               \
    auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot);               \
                                                                               \
    TVARIABLE(Smi, var_type_feedback);                                         \
    TNode<Oddball> result = RelationalComparison(Operation::k##Name, lhs, rhs, \
                                                 context, &var_type_feedback); \
    UpdateFeedback(var_type_feedback.value(), maybe_feedback_vector, slot);    \
                                                                               \
    Return(result);                                                            \
  }
DEF_COMPARE(LessThan)
DEF_COMPARE(LessThanOrEqual)
DEF_COMPARE(GreaterThan)
DEF_COMPARE(GreaterThanOrEqual)
#undef DEF_COMPARE

TF_BUILTIN(Equal_WithFeedback, CodeStubAssembler) {
  auto lhs = Parameter<Object>(Descriptor::kLeft);
  auto rhs = Parameter<Object>(Descriptor::kRight);
  auto context = Parameter<Context>(Descriptor::kContext);
  auto maybe_feedback_vector =
      Parameter<HeapObject>(Descriptor::kMaybeFeedbackVector);
  auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot);

  TVARIABLE(Smi, var_type_feedback);
  TNode<Oddball> result = Equal(lhs, rhs, context, &var_type_feedback);
  UpdateFeedback(var_type_feedback.value(), maybe_feedback_vector, slot);

  Return(result);
}

TF_BUILTIN(StrictEqual_WithFeedback, CodeStubAssembler) {
  auto lhs = Parameter<Object>(Descriptor::kLeft);
  auto rhs = Parameter<Object>(Descriptor::kRight);
  auto maybe_feedback_vector =
      Parameter<HeapObject>(Descriptor::kMaybeFeedbackVector);
  auto slot = UncheckedParameter<UintPtrT>(Descriptor::kSlot);

  TVARIABLE(Smi, var_type_feedback);
  TNode<Oddball> result = StrictEqual(lhs, rhs, &var_type_feedback);
  UpdateFeedback(var_type_feedback.value(), maybe_feedback_vector, slot);

  Return(result);
}

}  // namespace internal
}  // namespace v8