// Copyright 2023 Google LLC
//
// 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
//
//     https://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.

#ifndef MPACT_SIM_DECODER_INSTRUCTION_H_
#define MPACT_SIM_DECODER_INSTRUCTION_H_

#include <string>
#include <vector>

#include "absl/container/flat_hash_map.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "mpact/sim/decoder/opcode.h"
#include "mpact/sim/decoder/template_expression.h"

namespace mpact {
namespace sim {
namespace machine_description {
namespace instruction_set {

struct ResourceReference;
class Slot;
class TemplateExpression;

// This class models an instruction in a slot by combining an opcode (which is
// a globally unique in an instruction set definition), with instance specific
// attributes for disassembly, semantic functions, resource specification, and
// instruction attributes. This allows an instruction to be inherited from one
// slot to another, override individual attributes, while keeping the opcode
// globally unique.
class Instruction {
 public:
  Instruction(Opcode *opcode, Slot *slot);
  Instruction(Opcode *opcode, Instruction *child, Slot *slot);
  virtual ~Instruction();

  // Append a child instruction.
  void AppendChild(Instruction *child);
  // Create an instruction object that inherits from another. This may require
  // evaluation of expressions within the instruction/opcode that rely on
  // template instantiation arguments.
  absl::StatusOr<Instruction *> CreateDerivedInstruction(
      TemplateInstantiationArgs *args) const;
  // Resources used and acquired/released.
  void AppendResourceUse(const ResourceReference *resource_ref);
  void AppendResourceAcquire(const ResourceReference *resource_ref);
  // Instruction attributes. These methods add the instruction attribute to the
  // opcode if it does not already exist. If it exists, then the new attribute
  // definition overrides the previous (replaces the expression).
  void AddInstructionAttribute(absl::string_view attr_name,
                               TemplateExpression *expression);
  void AddInstructionAttribute(absl::string_view attr_name);
  // Append disassembly format string and info.
  void AppendDisasmFormat(DisasmFormat *disasm_format);

  // Searches opcodes in the instruction (and any child instructions) for the
  // destination op with name op_name.
  DestinationOperand *GetDestOp(absl::string_view op_name) const;

  // Methods to clear parts of the instructions that may be overridden when
  // inherited.
  void ClearDisasmFormat();
  void ClearSemfuncCodeString();
  void ClearResourceSpecs();
  void ClearAttributeSpecs();

  // Getters and setters.
  Opcode *opcode() const { return opcode_; }
  Instruction *child() const { return child_; }
  Slot *slot() const { return slot_; }
  void set_semfunc_code_string(std::string code_string) {
    semfunc_code_string_ = code_string;
  }
  const std::string &semfunc_code_string() const {
    return semfunc_code_string_;
  }

  const std::vector<const ResourceReference *> &resource_use_vec() const {
    return resource_use_vec_;
  }
  const std::vector<const ResourceReference *> &resource_acquire_vec() const {
    return resource_acquire_vec_;
  }

  const std::vector<DisasmFormat *> &disasm_format_vec() const {
    return disasm_format_vec_;
  }

  const absl::flat_hash_map<std::string, TemplateExpression *> &attribute_map()
      const {
    return attribute_map_;
  }

 private:
  absl::StatusOr<ResourceReference *> CreateDerivedResourceRef(
      const ResourceReference *ref, TemplateInstantiationArgs *args) const;
  Opcode *opcode_;
  Instruction *child_;
  Slot *slot_;
  std::vector<const ResourceReference *> resource_use_vec_;
  std::vector<const ResourceReference *> resource_acquire_vec_;
  std::string semfunc_code_string_;
  std::vector<DisasmFormat *> disasm_format_vec_;
  absl::flat_hash_map<std::string, TemplateExpression *> attribute_map_;
};

}  // namespace instruction_set
}  // namespace machine_description
}  // namespace sim
}  // namespace mpact

#endif  // MPACT_SIM_DECODER_INSTRUCTION_H_