// Copyright 2016 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.h"
#include "src/builtins/builtins.h"
#include "src/code-stub-assembler.h"

namespace v8 {
namespace internal {

// -----------------------------------------------------------------------------
// ES6 section 22.2 TypedArray Objects

// ES6 section 22.2.3.1 get %TypedArray%.prototype.buffer
BUILTIN(TypedArrayPrototypeBuffer) {
  HandleScope scope(isolate);
  CHECK_RECEIVER(JSTypedArray, typed_array, "get TypedArray.prototype.buffer");
  return *typed_array->GetBuffer();
}

namespace {

void Generate_TypedArrayPrototypeGetter(compiler::CodeAssemblerState* state,
                                        const char* method_name,
                                        int object_offset) {
  typedef CodeStubAssembler::Label Label;
  typedef compiler::Node Node;
  CodeStubAssembler assembler(state);

  Node* receiver = assembler.Parameter(0);
  Node* context = assembler.Parameter(3);

  // Check if the {receiver} is actually a JSTypedArray.
  Label if_receiverisincompatible(&assembler, Label::kDeferred);
  assembler.GotoIf(assembler.TaggedIsSmi(receiver), &if_receiverisincompatible);
  Node* receiver_instance_type = assembler.LoadInstanceType(receiver);
  assembler.GotoUnless(
      assembler.Word32Equal(receiver_instance_type,
                            assembler.Int32Constant(JS_TYPED_ARRAY_TYPE)),
      &if_receiverisincompatible);

  // Check if the {receiver}'s JSArrayBuffer was neutered.
  Node* receiver_buffer =
      assembler.LoadObjectField(receiver, JSTypedArray::kBufferOffset);
  Label if_receiverisneutered(&assembler, Label::kDeferred);
  assembler.GotoIf(assembler.IsDetachedBuffer(receiver_buffer),
                   &if_receiverisneutered);
  assembler.Return(assembler.LoadObjectField(receiver, object_offset));

  assembler.Bind(&if_receiverisneutered);
  {
    // The {receiver}s buffer was neutered, default to zero.
    assembler.Return(assembler.SmiConstant(0));
  }

  assembler.Bind(&if_receiverisincompatible);
  {
    // The {receiver} is not a valid JSTypedArray.
    Node* result = assembler.CallRuntime(
        Runtime::kThrowIncompatibleMethodReceiver, context,
        assembler.HeapConstant(assembler.factory()->NewStringFromAsciiChecked(
            method_name, TENURED)),
        receiver);
    assembler.Return(result);  // Never reached.
  }
}

}  // namespace

// ES6 section 22.2.3.2 get %TypedArray%.prototype.byteLength
void Builtins::Generate_TypedArrayPrototypeByteLength(
    compiler::CodeAssemblerState* state) {
  Generate_TypedArrayPrototypeGetter(state,
                                     "get TypedArray.prototype.byteLength",
                                     JSTypedArray::kByteLengthOffset);
}

// ES6 section 22.2.3.3 get %TypedArray%.prototype.byteOffset
void Builtins::Generate_TypedArrayPrototypeByteOffset(
    compiler::CodeAssemblerState* state) {
  Generate_TypedArrayPrototypeGetter(state,
                                     "get TypedArray.prototype.byteOffset",
                                     JSTypedArray::kByteOffsetOffset);
}

// ES6 section 22.2.3.18 get %TypedArray%.prototype.length
void Builtins::Generate_TypedArrayPrototypeLength(
    compiler::CodeAssemblerState* state) {
  Generate_TypedArrayPrototypeGetter(state, "get TypedArray.prototype.length",
                                     JSTypedArray::kLengthOffset);
}

namespace {

template <IterationKind kIterationKind>
void Generate_TypedArrayPrototypeIterationMethod(
    compiler::CodeAssemblerState* state, const char* method_name) {
  typedef compiler::Node Node;
  typedef CodeStubAssembler::Label Label;
  typedef CodeStubAssembler::Variable Variable;
  CodeStubAssembler assembler(state);

  Node* receiver = assembler.Parameter(0);
  Node* context = assembler.Parameter(3);

  Label throw_bad_receiver(&assembler, Label::kDeferred);
  Label throw_typeerror(&assembler, Label::kDeferred);

  assembler.GotoIf(assembler.TaggedIsSmi(receiver), &throw_bad_receiver);

  Node* map = assembler.LoadMap(receiver);
  Node* instance_type = assembler.LoadMapInstanceType(map);
  assembler.GotoIf(
      assembler.Word32NotEqual(instance_type,
                               assembler.Int32Constant(JS_TYPED_ARRAY_TYPE)),
      &throw_bad_receiver);

  // Check if the {receiver}'s JSArrayBuffer was neutered.
  Node* receiver_buffer =
      assembler.LoadObjectField(receiver, JSTypedArray::kBufferOffset);
  Label if_receiverisneutered(&assembler, Label::kDeferred);
  assembler.GotoIf(assembler.IsDetachedBuffer(receiver_buffer),
                   &if_receiverisneutered);

  assembler.Return(assembler.CreateArrayIterator(receiver, map, instance_type,
                                                 context, kIterationKind));

  Variable var_message(&assembler, MachineRepresentation::kTagged);
  assembler.Bind(&throw_bad_receiver);
  var_message.Bind(
      assembler.SmiConstant(Smi::FromInt(MessageTemplate::kNotTypedArray)));
  assembler.Goto(&throw_typeerror);

  assembler.Bind(&if_receiverisneutered);
  var_message.Bind(
      assembler.SmiConstant(Smi::FromInt(MessageTemplate::kDetachedOperation)));
  assembler.Goto(&throw_typeerror);

  assembler.Bind(&throw_typeerror);
  {
    Node* arg1 = assembler.HeapConstant(
        assembler.isolate()->factory()->NewStringFromAsciiChecked(method_name,
                                                                  TENURED));
    Node* result = assembler.CallRuntime(Runtime::kThrowTypeError, context,
                                         var_message.value(), arg1);
    assembler.Return(result);
  }
}
}  // namespace

void Builtins::Generate_TypedArrayPrototypeValues(
    compiler::CodeAssemblerState* state) {
  Generate_TypedArrayPrototypeIterationMethod<IterationKind::kValues>(
      state, "%TypedArray%.prototype.values()");
}

void Builtins::Generate_TypedArrayPrototypeEntries(
    compiler::CodeAssemblerState* state) {
  Generate_TypedArrayPrototypeIterationMethod<IterationKind::kEntries>(
      state, "%TypedArray%.prototype.entries()");
}

void Builtins::Generate_TypedArrayPrototypeKeys(
    compiler::CodeAssemblerState* state) {
  Generate_TypedArrayPrototypeIterationMethod<IterationKind::kKeys>(
      state, "%TypedArray%.prototype.keys()");
}

}  // namespace internal
}  // namespace v8