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

namespace v8 {
namespace internal {
namespace interpreter {

using compiler::Node;

#define __ assembler_->

IntrinsicsHelper::IntrinsicsHelper(InterpreterAssembler* assembler)
    : assembler_(assembler) {}

bool IntrinsicsHelper::IsSupported(Runtime::FunctionId function_id) {
  switch (function_id) {
#define SUPPORTED(name, lower_case, count) case Runtime::kInline##name:
    INTRINSICS_LIST(SUPPORTED)
    return true;
#undef SUPPORTED
    default:
      return false;
  }
}

Node* IntrinsicsHelper::InvokeIntrinsic(Node* function_id, Node* context,
                                        Node* first_arg_reg, Node* arg_count) {
  InterpreterAssembler::Label abort(assembler_), end(assembler_);
  InterpreterAssembler::Variable result(assembler_,
                                        MachineRepresentation::kTagged);

#define MAKE_LABEL(name, lower_case, count) \
  InterpreterAssembler::Label lower_case(assembler_);
  INTRINSICS_LIST(MAKE_LABEL)
#undef MAKE_LABEL

#define LABEL_POINTER(name, lower_case, count) &lower_case,
  InterpreterAssembler::Label* labels[] = {INTRINSICS_LIST(LABEL_POINTER)};
#undef LABEL_POINTER

#define CASE(name, lower_case, count) \
  static_cast<int32_t>(Runtime::kInline##name),
  int32_t cases[] = {INTRINSICS_LIST(CASE)};
#undef CASE

  __ Switch(function_id, &abort, cases, labels, arraysize(cases));
#define HANDLE_CASE(name, lower_case, expected_arg_count)   \
  __ Bind(&lower_case);                                     \
  if (FLAG_debug_code) {                                    \
    AbortIfArgCountMismatch(expected_arg_count, arg_count); \
  }                                                         \
  result.Bind(name(first_arg_reg));                         \
  __ Goto(&end);
  INTRINSICS_LIST(HANDLE_CASE)
#undef HANDLE_CASE

  __ Bind(&abort);
  __ Abort(BailoutReason::kUnexpectedFunctionIDForInvokeIntrinsic);
  result.Bind(__ UndefinedConstant());
  __ Goto(&end);

  __ Bind(&end);
  return result.value();
}

Node* IntrinsicsHelper::CompareInstanceType(Node* map, int type,
                                            InstanceTypeCompareMode mode) {
  InterpreterAssembler::Variable return_value(assembler_,
                                              MachineRepresentation::kTagged);
  Node* instance_type = __ LoadInstanceType(map);

  InterpreterAssembler::Label if_true(assembler_), if_false(assembler_),
      end(assembler_);
  Node* condition;
  if (mode == kInstanceTypeEqual) {
    condition = __ Word32Equal(instance_type, __ Int32Constant(type));
  } else {
    DCHECK(mode == kInstanceTypeGreaterThanOrEqual);
    condition =
        __ Int32GreaterThanOrEqual(instance_type, __ Int32Constant(type));
  }
  __ Branch(condition, &if_true, &if_false);

  __ Bind(&if_true);
  return_value.Bind(__ BooleanConstant(true));
  __ Goto(&end);

  __ Bind(&if_false);
  return_value.Bind(__ BooleanConstant(false));
  __ Goto(&end);

  __ Bind(&end);
  return return_value.value();
}

Node* IntrinsicsHelper::IsJSReceiver(Node* input) {
  InterpreterAssembler::Variable return_value(assembler_,
                                              MachineRepresentation::kTagged);

  InterpreterAssembler::Label if_smi(assembler_), if_not_smi(assembler_),
      end(assembler_);
  Node* arg = __ LoadRegister(input);

  __ Branch(__ WordIsSmi(arg), &if_smi, &if_not_smi);
  __ Bind(&if_smi);
  return_value.Bind(__ BooleanConstant(false));
  __ Goto(&end);

  __ Bind(&if_not_smi);
  STATIC_ASSERT(LAST_TYPE == LAST_JS_RECEIVER_TYPE);
  return_value.Bind(CompareInstanceType(arg, FIRST_JS_RECEIVER_TYPE,
                                        kInstanceTypeGreaterThanOrEqual));
  __ Goto(&end);

  __ Bind(&end);
  return return_value.value();
}

Node* IntrinsicsHelper::IsArray(Node* input) {
  InterpreterAssembler::Variable return_value(assembler_,
                                              MachineRepresentation::kTagged);

  InterpreterAssembler::Label if_smi(assembler_), if_not_smi(assembler_),
      end(assembler_);
  Node* arg = __ LoadRegister(input);

  __ Branch(__ WordIsSmi(arg), &if_smi, &if_not_smi);
  __ Bind(&if_smi);
  return_value.Bind(__ BooleanConstant(false));
  __ Goto(&end);

  __ Bind(&if_not_smi);
  return_value.Bind(
      CompareInstanceType(arg, JS_ARRAY_TYPE, kInstanceTypeEqual));
  __ Goto(&end);

  __ Bind(&end);
  return return_value.value();
}

void IntrinsicsHelper::AbortIfArgCountMismatch(int expected, Node* actual) {
  InterpreterAssembler::Label match(assembler_), mismatch(assembler_),
      end(assembler_);
  Node* comparison = __ Word32Equal(actual, __ Int32Constant(expected));
  __ Branch(comparison, &match, &mismatch);
  __ Bind(&mismatch);
  __ Abort(kWrongArgumentCountForInvokeIntrinsic);
  __ Goto(&end);
  __ Bind(&match);
  __ Goto(&end);
  __ Bind(&end);
}

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