// Copyright (c) 2017 The Khronos Group Inc.
// Copyright (c) 2017 Valve Corporation
// Copyright (c) 2017 LunarG Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "source/opt/pass.h"

#include "source/opt/ir_builder.h"
#include "source/opt/iterator.h"

namespace spvtools {
namespace opt {
namespace {
constexpr uint32_t kTypePointerTypeIdInIdx = 1;
}  // namespace

Pass::Pass() : consumer_(nullptr), context_(nullptr), already_run_(false) {}

Pass::Status Pass::Run(IRContext* ctx) {
  if (already_run_) {
    return Status::Failure;
  }
  already_run_ = true;

  context_ = ctx;
  Pass::Status status = Process();
  context_ = nullptr;

  if (status == Status::SuccessWithChange) {
    ctx->InvalidateAnalysesExceptFor(GetPreservedAnalyses());
  }
  if (!(status == Status::Failure || ctx->IsConsistent()))
    assert(false && "An analysis in the context is out of date.");
  return status;
}

uint32_t Pass::GetPointeeTypeId(const Instruction* ptrInst) const {
  const uint32_t ptrTypeId = ptrInst->type_id();
  const Instruction* ptrTypeInst = get_def_use_mgr()->GetDef(ptrTypeId);
  return ptrTypeInst->GetSingleWordInOperand(kTypePointerTypeIdInIdx);
}

Instruction* Pass::GetBaseType(uint32_t ty_id) {
  Instruction* ty_inst = get_def_use_mgr()->GetDef(ty_id);
  if (ty_inst->opcode() == spv::Op::OpTypeMatrix) {
    uint32_t vty_id = ty_inst->GetSingleWordInOperand(0);
    ty_inst = get_def_use_mgr()->GetDef(vty_id);
  }
  if (ty_inst->opcode() == spv::Op::OpTypeVector) {
    uint32_t cty_id = ty_inst->GetSingleWordInOperand(0);
    ty_inst = get_def_use_mgr()->GetDef(cty_id);
  }
  return ty_inst;
}

bool Pass::IsFloat(uint32_t ty_id, uint32_t width) {
  Instruction* ty_inst = GetBaseType(ty_id);
  if (ty_inst->opcode() != spv::Op::OpTypeFloat) return false;
  return ty_inst->GetSingleWordInOperand(0) == width;
}

uint32_t Pass::GetNullId(uint32_t type_id) {
  if (IsFloat(type_id, 16)) context()->AddCapability(spv::Capability::Float16);
  analysis::TypeManager* type_mgr = context()->get_type_mgr();
  analysis::ConstantManager* const_mgr = context()->get_constant_mgr();
  const analysis::Type* type = type_mgr->GetType(type_id);
  const analysis::Constant* null_const = const_mgr->GetConstant(type, {});
  Instruction* null_inst =
      const_mgr->GetDefiningInstruction(null_const, type_id);
  return null_inst->result_id();
}

uint32_t Pass::GenerateCopy(Instruction* object_to_copy, uint32_t new_type_id,
                            Instruction* insertion_position) {
  analysis::ConstantManager* const_mgr = context()->get_constant_mgr();

  uint32_t original_type_id = object_to_copy->type_id();
  if (original_type_id == new_type_id) {
    return object_to_copy->result_id();
  }

  InstructionBuilder ir_builder(
      context(), insertion_position,
      IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisDefUse);

  Instruction* original_type = get_def_use_mgr()->GetDef(original_type_id);
  Instruction* new_type = get_def_use_mgr()->GetDef(new_type_id);

  if (new_type->opcode() != original_type->opcode()) {
    return 0;
  }

  switch (original_type->opcode()) {
    case spv::Op::OpTypeArray: {
      uint32_t original_element_type_id =
          original_type->GetSingleWordInOperand(0);
      uint32_t new_element_type_id = new_type->GetSingleWordInOperand(0);

      std::vector<uint32_t> element_ids;
      uint32_t length_id = original_type->GetSingleWordInOperand(1);
      const analysis::Constant* length_const =
          const_mgr->FindDeclaredConstant(length_id);
      assert(length_const->AsIntConstant());
      uint32_t array_length = length_const->AsIntConstant()->GetU32();
      for (uint32_t i = 0; i < array_length; i++) {
        Instruction* extract = ir_builder.AddCompositeExtract(
            original_element_type_id, object_to_copy->result_id(), {i});
        uint32_t new_id =
            GenerateCopy(extract, new_element_type_id, insertion_position);
        if (new_id == 0) {
          return 0;
        }
        element_ids.push_back(new_id);
      }

      return ir_builder.AddCompositeConstruct(new_type_id, element_ids)
          ->result_id();
    }
    case spv::Op::OpTypeStruct: {
      std::vector<uint32_t> element_ids;
      for (uint32_t i = 0; i < original_type->NumInOperands(); i++) {
        uint32_t orig_member_type_id = original_type->GetSingleWordInOperand(i);
        uint32_t new_member_type_id = new_type->GetSingleWordInOperand(i);
        Instruction* extract = ir_builder.AddCompositeExtract(
            orig_member_type_id, object_to_copy->result_id(), {i});
        uint32_t new_id =
            GenerateCopy(extract, new_member_type_id, insertion_position);
        if (new_id == 0) {
          return 0;
        }
        element_ids.push_back(new_id);
      }
      return ir_builder.AddCompositeConstruct(new_type_id, element_ids)
          ->result_id();
    }
    default:
      // If we do not have an aggregate type, then we have a problem.  Either we
      // found multiple instances of the same type, or we are copying to an
      // incompatible type.  Either way the code is illegal. Leave the code as
      // is and let the caller deal with it.
      return 0;
  }
}

}  // namespace opt
}  // namespace spvtools