path: root/willow/include/willow/IR/Instruction.h

#ifndef WILLOW_IR_INSTRUCTION_HPP
#define WILLOW_IR_INSTRUCTION_HPP

#include <willow/IR/Value.h>

#include <cassert>
#include <cstddef>
#include <utility>
#include <vector>

namespace willow {

class Value;
class BasicBlock;
class Function;

/// Defines an SSA value or control-flow effect.
class Instruction : public Value {
public:
  enum class Op {
    Add,
    Mul,
    Sub,
    Div,
    Mod,
    Shl,
    Shr,

    Eq,
    Lt,
    Gt,
    Le,
    Ge,

    And,
    Or,
    Not,

    Jmp,
    Br,
    Call,
    Ret,

    Phi,
    Alloca
  };

private:
  BasicBlock *parent = nullptr;
  Op op;

  std::vector<Value *> operands;

protected:
  void setOperand(std::size_t index, Value *operand) {
    assert(index < operands.size() && "Operand index out of bounds");
    assert(operand && "Operand cannot be null");
    Value *old = operands[index];
    if (old == operand)
      return;

    old->delUse(this);
    operands[index] = operand;
    operand->addUse(this);
  }

public:
  /// \param op Opcode for this instruction.
  /// \param type Type of the result of this instruction
  Instruction(Op op, Type type) : Value(ValueKind::Instruction, type), op(op) {}

  /// \param name Name of the ssa value produced by the instruction.
  /// \param op Opcode for the instruction.
  /// \param type Type of the result of the instruction.
  Instruction(std::string name, Type type, Op op)
      : Value(ValueKind::Instruction, std::move(name), type) {}

  ~Instruction() override {
    for (Value *operand : operands)
      operand->delUse(this);
  }

  bool hasParent() const { return parent != nullptr; }
  BasicBlock *getParent() { return parent; }
  const BasicBlock *getParent() const { return parent; }
  void setParent(BasicBlock *block) { parent = block; }

  Op getOp() const { return op; }
  std::size_t getNumOperands() const { return operands.size(); }

  Value *getOperand(std::size_t index) {
    assert(index < operands.size() && "Operand index out of bounds");
    return operands[index];
  }
  const Value *getOperand(std::size_t index) const {
    assert(index < operands.size() && "Operand index out of bounds");
    return operands[index];
  }

  std::vector<Value *> &getOperands() { return operands; }
  const std::vector<Value *> &getOperands() const { return operands; }

  void addOperand(Value *operand) {
    assert(operand && "Operand cannot be null");
    operands.push_back(operand);
    operand->addUse(this);
  }
};

class UnaryInst : public Instruction {
public:
  UnaryInst(std::string name, Type type, Op op, Value *value)
      : Instruction(std::move(name), type, op) {
    addOperand(value);
  }

  Value *getValue() { return getOperand(0); }
  const Value *getValue() const { return getOperand(0); }
};

class BinaryInst : public Instruction {
public:
  BinaryInst(std::string name, Type type, Op op, Value *lhs, Value *rhs)
      : Instruction(std::move(name), type, op) {
    addOperand(lhs);
    addOperand(rhs);
  }

  Value *getLHS() { return getOperand(0); }
  const Value *getLHS() const { return getOperand(0); }

  Value *getRHS() { return getOperand(1); }
  const Value *getRHS() const { return getOperand(1); }
};

class AddInst : public BinaryInst {
public:
  AddInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Add, lhs, rhs) {}
};

class MulInst : public BinaryInst {
public:
  MulInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Mul, lhs, rhs) {}
};

class SubInst : public BinaryInst {
public:
  SubInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Sub, lhs, rhs) {}
};

class DivInst : public BinaryInst {
public:
  DivInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Div, lhs, rhs) {}
};

class ModInst : public BinaryInst {
public:
  ModInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Mod, lhs, rhs) {}
};

class ShlInst : public BinaryInst {
public:
  ShlInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Shl, lhs, rhs) {}
};

class ShrInst : public BinaryInst {
public:
  ShrInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Shr, lhs, rhs) {}
};

class EqInst : public BinaryInst {
public:
  EqInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Eq, lhs, rhs) {}
};

class LtInst : public BinaryInst {
public:
  LtInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Lt, lhs, rhs) {}
};

class GtInst : public BinaryInst {
public:
  GtInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Gt, lhs, rhs) {}
};

class LeInst : public BinaryInst {
public:
  LeInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Le, lhs, rhs) {}
};

class GeInst : public BinaryInst {
public:
  GeInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Ge, lhs, rhs) {}
};

class AndInst : public BinaryInst {
public:
  AndInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::And, lhs, rhs) {}
};

class OrInst : public BinaryInst {
public:
  OrInst(std::string name, Type type, Value *lhs, Value *rhs)
      : BinaryInst(std::move(name), type, Op::Or, lhs, rhs) {}
};

class NotInst : public UnaryInst {
public:
  explicit NotInst(std::string name, Type type, Value *value)
      : UnaryInst(std::move(name), type, Op::Not, value) {}
};

class JmpInst : public Instruction {
  BasicBlock *target;

public:
  JmpInst(Type type, BasicBlock *target)
      : Instruction(Op::Jmp, type), target(target) {}

  BasicBlock *getTarget() { return target; }
  const BasicBlock *getTarget() const { return target; }
};

class BrInst : public Instruction {
  BasicBlock *true_target;
  BasicBlock *false_target;

public:
  BrInst(Type type, Value *condition, BasicBlock *true_target,
         BasicBlock *false_target)
      : Instruction(Op::Br, type), true_target(true_target),
        false_target(false_target) {
    addOperand(condition);
  }

  Value *getCondition() { return getOperand(0); }
  const Value *getCondition() const { return getOperand(0); }

  BasicBlock *getTrueTarget() { return true_target; }
  const BasicBlock *getTrueTarget() const { return true_target; }

  BasicBlock *getFalseTarget() { return false_target; }
  const BasicBlock *getFalseTarget() const { return false_target; }
};

} // namespace willow

#endif // WILLOW_IR_INSTRUCTION_HPP