// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

#include <vector>

#include "vm/compiler/backend/il_printer.h"
#include "vm/compiler/backend/il_test_helper.h"
#include "vm/compiler/call_specializer.h"
#include "vm/compiler/compiler_pass.h"
#include "vm/object.h"
#include "vm/unit_test.h"

namespace dart {

#if defined(DART_PRECOMPILER) && !defined(TARGET_ARCH_DBC)

// This test asserts that we are inlining accesses to typed data interfaces
// (e.g. Uint8List) if there are no instantiated 3rd party classes.
ISOLATE_UNIT_TEST_CASE(IRTest_TypedDataAOT_Inlining) {
  const char* kScript =
      R"(
      import 'dart:typed_data';

      void foo(Uint8List list, int from) {
        if (from >= list.length) {
          list[from];
        }
      }
      )";

  const auto& root_library = Library::Handle(LoadTestScript(kScript));
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));

  TestPipeline pipeline(function, CompilerPass::kAOT);
  FlowGraph* flow_graph = pipeline.RunPasses({});

  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);

  CheckNullInstr* check_null = nullptr;
  LoadFieldInstr* load_field = nullptr;
  GenericCheckBoundInstr* bounds_check = nullptr;
  Instruction* load_untagged = nullptr;
  LoadIndexedInstr* load_indexed = nullptr;

  ILMatcher cursor(flow_graph, entry);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      {kMatchAndMoveCheckNull, &check_null},
      {kMatchAndMoveLoadField, &load_field},
      kMoveGlob,
      kMatchAndMoveBranchTrue,
      kMoveGlob,
      {kMatchAndMoveGenericCheckBound, &bounds_check},
      {kMatchAndMoveLoadUntagged, &load_untagged},
      kMoveParallelMoves,
      {kMatchAndMoveLoadIndexed, &load_indexed},
      kMoveGlob,
      kMatchReturn,
  }));

  EXPECT(load_field->InputAt(0)->definition()->IsParameter());
  EXPECT(bounds_check->InputAt(0)->definition() == load_field);
  EXPECT(load_untagged->InputAt(0)->definition()->IsParameter());
  EXPECT(load_indexed->InputAt(0)->definition() == load_untagged);
}

// This test asserts that we are not inlining accesses to typed data interfaces
// (e.g. Uint8List) if there are instantiated 3rd party classes (e.g.
// UnmodifiableUint8ListView).
ISOLATE_UNIT_TEST_CASE(IRTest_TypedDataAOT_NotInlining) {
  const char* kScript =
      R"(
      import 'dart:typed_data';

      createThirdPartyUint8List() => UnmodifiableUint8ListView(Uint8List(10));

      void foo(Uint8List list, int from) {
        if (from >= list.length) {
          list[from];
        }
      }
      )";

  const auto& root_library = Library::Handle(LoadTestScript(kScript));

  // Firstly we ensure a non internal/external/view Uint8List is allocated.
  Invoke(root_library, "createThirdPartyUint8List");

  // Now we ensure that we don't perform the inlining of the `list[from]`
  // access.
  const auto& function = Function::Handle(GetFunction(root_library, "foo"));
  TestPipeline pipeline(function, CompilerPass::kAOT);
  FlowGraph* flow_graph = pipeline.RunPasses({});

  auto entry = flow_graph->graph_entry()->normal_entry();
  EXPECT(entry != nullptr);

  InstanceCallInstr* length_call = nullptr;
  PushArgumentInstr* pusharg1 = nullptr;
  PushArgumentInstr* pusharg2 = nullptr;
  InstanceCallInstr* index_get_call = nullptr;

  ILMatcher cursor(flow_graph, entry);
  RELEASE_ASSERT(cursor.TryMatch({
      kMoveGlob,
      {kMatchAndMoveInstanceCall, &length_call},
      kMoveGlob,
      kMatchAndMoveBranchTrue,
      kMoveGlob,
      {kMatchAndMovePushArgument, &pusharg1},
      {kMatchAndMovePushArgument, &pusharg2},
      {kMatchAndMoveInstanceCall, &index_get_call},
      kMoveGlob,
      kMatchReturn,
  }));

  EXPECT(length_call->Selector() == Symbols::GetLength().raw());
  EXPECT(pusharg1->InputAt(0)->definition()->IsParameter());
  EXPECT(pusharg2->InputAt(0)->definition()->IsParameter());
  EXPECT(index_get_call->Selector() == Symbols::IndexToken().raw());
}

// This test asserts that we are inlining get:length, [] and []= for all typed
// data interfaces.  It also ensures that the asserted IR actually works by
// exercising it.
ISOLATE_UNIT_TEST_CASE(IRTest_TypedDataAOT_FunctionalGetSet) {
  const char* kTemplate =
      R"(
      import 'dart:typed_data';

      void reverse%s(%s list) {
        final length = list.length;
        final halfLength = length ~/ 2;
        for (int i = 0; i < halfLength; ++i) {
          final tmp = list[length-i-1];
          list[length-i-1] = list[i];
          list[i] = tmp;
        }
      }
      )";

  std::initializer_list<MatchCode> expected_il = {
      // Before loop
      kMoveGlob,
      kMatchAndMoveCheckNull,
      kMatchAndMoveLoadField,
      kMoveGlob,
      kMatchAndMoveBranchTrue,

      // Loop
      kMoveGlob,
      // Load 1
      kMatchAndMoveGenericCheckBound,
      kMoveGlob,
      kMatchAndMoveLoadUntagged,
      kMoveParallelMoves,
      kMatchAndMoveLoadIndexed,
      kMoveGlob,
      // Load 2
      kMatchAndMoveGenericCheckBound,
      kMoveGlob,
      kMatchAndMoveLoadUntagged,
      kMoveParallelMoves,
      kMatchAndMoveLoadIndexed,
      kMoveGlob,
      // Store 1
      kMatchAndMoveGenericCheckBound,
      kMoveGlob,
      kMoveParallelMoves,
      kMatchAndMoveLoadUntagged,
      kMoveParallelMoves,
      kMatchAndMoveStoreIndexed,
      kMoveGlob,
      // Store 2
      kMoveParallelMoves,
      kMatchAndMoveLoadUntagged,
      kMoveParallelMoves,
      kMatchAndMoveStoreIndexed,
      kMoveGlob,

      // Exit the loop.
      kMatchAndMoveBranchFalse,
      kMoveGlob,
      kMatchReturn,
  };

  char script_buffer[1024];
  char uri_buffer[1024];
  char function_name[1024];
  auto& lib = Library::Handle();
  auto& function = Function::Handle();
  auto& view = TypedDataView::Handle();
  auto& arguments = Array::Handle();
  auto& result = Object::Handle();

  auto run_reverse_list = [&](const char* name, const TypedDataBase& data) {
    // Fill in the template with the [name].
    Utils::SNPrint(script_buffer, sizeof(script_buffer), kTemplate, name, name);
    Utils::SNPrint(uri_buffer, sizeof(uri_buffer), "file:///reverse-%s.dart",
                   name);
    Utils::SNPrint(function_name, sizeof(function_name), "reverse%s", name);

    // Create a new library, load the function and compile it using our AOT
    // pipeline.
    lib = LoadTestScript(script_buffer, nullptr, uri_buffer);
    function = GetFunction(lib, function_name);
    TestPipeline pipeline(function, CompilerPass::kAOT);
    FlowGraph* flow_graph = pipeline.RunPasses({});
    auto entry = flow_graph->graph_entry()->normal_entry();

    // Ensure the IL matches what we expect.
    ILMatcher cursor(flow_graph, entry);
    EXPECT(cursor.TryMatch(expected_il));

    // Compile the graph and attach the code.
    pipeline.CompileGraphAndAttachFunction();

    // Class ids are numbered from internal/view/external.
    const classid_t view_cid = data.GetClassId() + 1;
    ASSERT(RawObject::IsTypedDataViewClassId(view_cid));

    // First and last element are not in the view, i.e.
    //    view[0:view.length()-1] = data[1:data.length()-2]
    const intptr_t length_in_bytes =
        (data.LengthInBytes() - 2 * data.ElementSizeInBytes());
    view = TypedDataView::New(view_cid, data, data.ElementSizeInBytes(),
                              length_in_bytes / data.ElementSizeInBytes());
    ASSERT(data.ElementType() == view.ElementType());

    arguments = Array::New(1);
    arguments.SetAt(0, view);
    result = DartEntry::InvokeFunction(function, arguments);
    EXPECT(result.IsNull());

    // Ensure we didn't deoptimize to unoptimized code.
    EXPECT(function.unoptimized_code() == Code::null());
  };

  const auto& uint8_list =
      TypedData::Handle(TypedData::New(kTypedDataUint8ArrayCid, 16));
  const auto& uint8c_list =
      TypedData::Handle(TypedData::New(kTypedDataUint8ClampedArrayCid, 16));
  const auto& int16_list =
      TypedData::Handle(TypedData::New(kTypedDataInt16ArrayCid, 16));
  const auto& uint16_list =
      TypedData::Handle(TypedData::New(kTypedDataUint16ArrayCid, 16));
  const auto& int32_list =
      TypedData::Handle(TypedData::New(kTypedDataInt32ArrayCid, 16));
  const auto& uint32_list =
      TypedData::Handle(TypedData::New(kTypedDataUint32ArrayCid, 16));
  const auto& int64_list =
      TypedData::Handle(TypedData::New(kTypedDataInt64ArrayCid, 16));
  const auto& uint64_list =
      TypedData::Handle(TypedData::New(kTypedDataUint64ArrayCid, 16));
  const auto& float32_list =
      TypedData::Handle(TypedData::New(kTypedDataFloat32ArrayCid, 16));
  const auto& float64_list =
      TypedData::Handle(TypedData::New(kTypedDataFloat64ArrayCid, 16));
  const auto& int8_list =
      TypedData::Handle(TypedData::New(kTypedDataInt8ArrayCid, 16));
  for (intptr_t i = 0; i < 16; ++i) {
    int8_list.SetInt8(i, i);
    uint8_list.SetUint8(i, i);
    uint8c_list.SetUint8(i, i);
    int16_list.SetInt16(2 * i, i);
    uint16_list.SetUint16(2 * i, i);
    int32_list.SetInt32(4 * i, i);
    uint32_list.SetUint32(4 * i, i);
    int64_list.SetInt64(8 * i, i);
    uint64_list.SetUint64(8 * i, i);
    float32_list.SetFloat32(4 * i, i + 0.5);
    float64_list.SetFloat64(8 * i, i + 0.7);
  }
  run_reverse_list("Uint8List", int8_list);
  run_reverse_list("Int8List", uint8_list);
  run_reverse_list("Uint8ClampedList", uint8c_list);
  run_reverse_list("Int16List", int16_list);
  run_reverse_list("Uint16List", uint16_list);
  run_reverse_list("Int32List", int32_list);
  run_reverse_list("Uint32List", uint32_list);
  run_reverse_list("Int64List", int64_list);
  run_reverse_list("Uint64List", uint64_list);
  run_reverse_list("Float32List", float32_list);
  run_reverse_list("Float64List", float64_list);
  for (intptr_t i = 0; i < 16; ++i) {
    // Only the values in the view are reversed.
    const bool in_view = i >= 1 && i < 15;

    const int64_t expected_value = in_view ? (16 - i - 1) : i;
    const uint64_t expected_uvalue = in_view ? (16 - i - 1) : i;
    const float expected_fvalue = (in_view ? (16 - i - 1) : i) + 0.5;
    const double expected_dvalue = (in_view ? (16 - i - 1) : i) + 0.7;

    EXPECT(int8_list.GetInt8(i) == expected_value);
    EXPECT(uint8_list.GetUint8(i) == expected_uvalue);
    EXPECT(uint8c_list.GetUint8(i) == expected_uvalue);
    EXPECT(int16_list.GetInt16(2 * i) == expected_value);
    EXPECT(uint16_list.GetUint16(2 * i) == expected_uvalue);
    EXPECT(int32_list.GetInt32(4 * i) == expected_value);
    EXPECT(uint32_list.GetUint32(4 * i) == expected_uvalue);
    EXPECT(int64_list.GetInt64(8 * i) == expected_value);
    EXPECT(uint64_list.GetUint64(8 * i) == expected_uvalue);
    EXPECT(float32_list.GetFloat32(4 * i) == expected_fvalue);
    EXPECT(float64_list.GetFloat64(8 * i) == expected_dvalue);
  }
}

// This test asserts that we get errors if receiver, index or value are null.
ISOLATE_UNIT_TEST_CASE(IRTest_TypedDataAOT_FunctionalIndexError) {
  const char* kTemplate =
      R"(
      import 'dart:typed_data';
      void set%s(%s list, int index, %s value) {
        list[index] = value;
      }
      )";

  std::initializer_list<MatchCode> expected_il = {
      // Receiver null check
      kMoveGlob,
      kMatchAndMoveCheckNull,

      // Index null check
      kMoveGlob,
      kMatchAndMoveCheckNull,

      // Value null check
      kMoveGlob,
      kMatchAndMoveCheckNull,

      // LoadField length
      kMoveGlob,
      kMatchAndMoveLoadField,

      // Bounds check
      kMoveGlob,
      kMatchAndMoveGenericCheckBound,

      // Store value.
      kMoveGlob,
      kMatchAndMoveLoadUntagged,
      kMoveParallelMoves,
      kMatchAndMoveOptionalUnbox,
      kMoveParallelMoves,
      kMatchAndMoveStoreIndexed,

      // Return
      kMoveGlob,
      kMatchReturn,
  };

  char script_buffer[1024];
  char uri_buffer[1024];
  char function_name[1024];
  auto& lib = Library::Handle();
  auto& function = Function::Handle();
  auto& arguments = Array::Handle();
  auto& result = Object::Handle();

  const intptr_t kIndex = 1;
  const intptr_t kLastStage = 3;

  auto run_test = [&](const char* name, const char* type,
                      const TypedDataBase& data, const Object& value,
                      int stage) {
    // Fill in the template with the [name].
    Utils::SNPrint(script_buffer, sizeof(script_buffer), kTemplate, name, name,
                   type);
    Utils::SNPrint(uri_buffer, sizeof(uri_buffer), "file:///set-%s.dart", name);
    Utils::SNPrint(function_name, sizeof(function_name), "set%s", name);

    // Create a new library, load the function and compile it using our AOT
    // pipeline.
    lib = LoadTestScript(script_buffer, nullptr, uri_buffer);
    function = GetFunction(lib, function_name);
    TestPipeline pipeline(function, CompilerPass::kAOT);
    FlowGraph* flow_graph = pipeline.RunPasses({});
    auto entry = flow_graph->graph_entry()->normal_entry();

    // Ensure the IL matches what we expect.
    ILMatcher cursor(flow_graph, entry, /*trace=*/true);
    EXPECT(cursor.TryMatch(expected_il));

    // Compile the graph and attach the code.
    pipeline.CompileGraphAndAttachFunction();

    arguments = Array::New(3);
    arguments.SetAt(0, stage == 0 ? Object::null_object() : data);
    arguments.SetAt(
        1, stage == 1 ? Object::null_object() : Smi::Handle(Smi::New(kIndex)));
    arguments.SetAt(2, stage == 2 ? Object::null_object() : value);
    result = DartEntry::InvokeFunction(function, arguments);

    // Ensure we didn't deoptimize to unoptimized code.
    EXPECT(function.unoptimized_code() == Code::null());

    if (stage == kLastStage) {
      // The last stage must be successful
      EXPECT(result.IsNull());
    } else {
      // Ensure we get an error.
      EXPECT(result.IsUnhandledException());
      result = UnhandledException::Cast(result).exception();
    }
  };

  const auto& uint8_list =
      TypedData::Handle(TypedData::New(kTypedDataUint8ArrayCid, 16));
  const auto& uint8c_list =
      TypedData::Handle(TypedData::New(kTypedDataUint8ClampedArrayCid, 16));
  const auto& int16_list =
      TypedData::Handle(TypedData::New(kTypedDataInt16ArrayCid, 16));
  const auto& uint16_list =
      TypedData::Handle(TypedData::New(kTypedDataUint16ArrayCid, 16));
  const auto& int32_list =
      TypedData::Handle(TypedData::New(kTypedDataInt32ArrayCid, 16));
  const auto& uint32_list =
      TypedData::Handle(TypedData::New(kTypedDataUint32ArrayCid, 16));
  const auto& int64_list =
      TypedData::Handle(TypedData::New(kTypedDataInt64ArrayCid, 16));
  const auto& uint64_list =
      TypedData::Handle(TypedData::New(kTypedDataUint64ArrayCid, 16));
  const auto& float32_list =
      TypedData::Handle(TypedData::New(kTypedDataFloat32ArrayCid, 16));
  const auto& float64_list =
      TypedData::Handle(TypedData::New(kTypedDataFloat64ArrayCid, 16));
  const auto& int8_list =
      TypedData::Handle(TypedData::New(kTypedDataInt8ArrayCid, 16));
  const auto& int_value = Integer::Handle(Integer::New(42));
  const auto& float_value = Double::Handle(Double::New(4.2));
  for (intptr_t stage = 0; stage <= kLastStage; ++stage) {
    run_test("Uint8List", "int", int8_list, int_value, stage);
    run_test("Int8List", "int", uint8_list, int_value, stage);
    run_test("Uint8ClampedList", "int", uint8c_list, int_value, stage);
    run_test("Int16List", "int", int16_list, int_value, stage);
    run_test("Uint16List", "int", uint16_list, int_value, stage);
    run_test("Int32List", "int", int32_list, int_value, stage);
    run_test("Uint32List", "int", uint32_list, int_value, stage);
    run_test("Int64List", "int", int64_list, int_value, stage);
    run_test("Uint64List", "int", uint64_list, int_value, stage);
    run_test("Float32List", "double", float32_list, float_value, stage);
    run_test("Float64List", "double", float64_list, float_value, stage);
  }
}

#endif  // defined(DART_PRECOMPILER) && !defined(TARGET_ARCH_DBC)

}  // namespace dart