1 files changed, 339 insertions, 0 deletions
diff --git a/backend/lib/CodeGen/MachineInstr.cpp b/backend/lib/CodeGen/MachineInstr.cpp
new file mode 100644
index 0000000..3b200c5
--- /dev/null
+++ b/backend/lib/CodeGen/MachineInstr.cpp
@@ -0,0 +1,339 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "rcc/CodeGen/MachineInstr.h"
+
+#include "rcc/CodeGen/GenericOpcodes.h"
+#include "rcc/CodeGen/MachineBasicBlock.h"
+#include "rcc/CodeGen/MachineFunction.h"
+#include "rcc/CodeGen/MachineMemOperand.h"
+#include "rcc/CodeGen/MachineRegisterInfo.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <limits>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+
+namespace rcc {
+
+bool MachineInstr::isDebugInstr() const noexcept {
+  return InstructionOpcode == rcc::opcode(GenericOpcode::DBG_VALUE) ||
+         InstructionOpcode == rcc::opcode(GenericOpcode::DBG_VALUE_LIST) ||
+         InstructionOpcode == rcc::opcode(GenericOpcode::DBG_LABEL) ||
+         InstructionOpcode == rcc::opcode(GenericOpcode::DBG_INSTR_REF) ||
+         InstructionOpcode == rcc::opcode(GenericOpcode::DBG_PHI);
+}
+
+MachineInstr::MachineInstr(MachineFunction &OwnerFunction, Opcode InstructionOpcode,
+                           MachineInstrStableID StableID)
+    : OwnerFunction(&OwnerFunction), InstructionOpcode(InstructionOpcode), StableID(StableID) {}
+
+MachineInstr::~MachineInstr() {
+  for (MachineOperand &Operand : Operands)
+    Operand.detachFromInstruction();
+}
+
+Expected<void> MachineInstr::setOpcode(Opcode NewOpcode) {
+  if (!NewOpcode.isValid())
+    return makeUnexpected(ErrorCode::InvalidArgument, "machine opcode must be nonzero");
+  InstructionOpcode = NewOpcode;
+  return {};
+}
+
+Expected<void> MachineInstr::eraseFromParent() {
+  if (ParentBlock == nullptr)
+    return makeUnexpected(ErrorCode::InternalError, "cannot erase a detached machine instruction");
+  return ParentBlock->removeInstruction(*this);
+}
+
+Expected<void> MachineInstr::setDebugInstrNumber(std::uint64_t Number) {
+  if (Number == 0 || Number > std::numeric_limits<std::uint32_t>::max()) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "machine debug instruction number must fit in nonzero uint32");
+  }
+  if (DebugInstrNumber != 0 && DebugInstrNumber != Number) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "machine instruction already has a different debug number");
+  }
+  DebugInstrNumber = static_cast<std::uint32_t>(Number);
+  OwnerFunction->observeDebugInstrNumber(DebugInstrNumber);
+  return {};
+}
+
+Expected<std::uint32_t> MachineInstr::assignDebugInstrNumber() {
+  if (DebugInstrNumber != 0)
+    return DebugInstrNumber;
+  auto Number = OwnerFunction->allocateDebugInstrNumber();
+  if (!Number)
+    return std::unexpected(Number.error());
+  DebugInstrNumber = *Number;
+  return DebugInstrNumber;
+}
+
+MachineOperand *MachineInstr::operandAt(std::size_t Index) noexcept {
+  if (Index >= Operands.size())
+    return nullptr;
+  return &Operands[Index];
+}
+
+const MachineOperand *MachineInstr::operandAt(std::size_t Index) const noexcept {
+  if (Index >= Operands.size())
+    return nullptr;
+  return &Operands[Index];
+}
+
+void MachineInstr::reserveOperands(std::size_t Capacity) {
+  Operands.reserve(Capacity);
+}
+
+Expected<void> MachineInstr::addOperand(MachineOperand &&Operand) {
+  return insertOperand(Operands.size(), std::move(Operand));
+}
+
+Expected<void> MachineInstr::insertOperand(std::size_t Index, MachineOperand &&Operand) {
+  if (Index > Operands.size())
+    return makeUnexpected(ErrorCode::InvalidArgument, "operand insertion index is out of range");
+  if (Operand.Parent != nullptr)
+    return makeUnexpected(ErrorCode::InvalidArgument, "operand already belongs to an instruction");
+  if (Operand.TiedOperandIndex)
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "detached operand cannot carry a tied operand index");
+  if (const auto *BlockOperand = Operand.getIf<BasicBlockOperand>();
+      BlockOperand != nullptr && &BlockOperand->Block->function() != OwnerFunction) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "basic block operand belongs to another machine function");
+  }
+  if (const Register *Reg = Operand.getIf<Register>();
+      Reg != nullptr && Reg->isVirtual() &&
+      !OwnerFunction->registerInfo().isKnownVirtualRegister(*Reg)) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "register operand references an unknown virtual register");
+  }
+  if (Operand.isUse() && isDebugInstr()) {
+    RegisterOperandFlags RegisterFlags = Operand.registerFlags();
+    RegisterFlags.set(RegisterOperandFlag::Debug);
+    auto Updated = Operand.setRegisterFlags(RegisterFlags);
+    if (!Updated)
+      return std::unexpected(Updated.error());
+  }
+
+  Operands.insert(Operands.begin() + static_cast<std::ptrdiff_t>(Index), std::move(Operand));
+  adjustTiesForInsertion(Index);
+  Operands[Index].attachTo(*this, linkedRegisterInfo());
+  return {};
+}
+
+Expected<void> MachineInstr::eraseOperand(std::size_t Index) {
+  if (Index >= Operands.size())
+    return makeUnexpected(ErrorCode::InvalidArgument, "operand erase index is out of range");
+
+  adjustTiesForErasure(Index);
+  Operands.erase(Operands.begin() + static_cast<std::ptrdiff_t>(Index));
+  return {};
+}
+
+Expected<void> MachineInstr::tieOperands(std::size_t DefIndex, std::size_t UseIndex) {
+  if (DefIndex >= Operands.size() || UseIndex >= Operands.size() || DefIndex == UseIndex) {
+    return makeUnexpected(ErrorCode::InvalidArgument, "tied operand indices are invalid");
+  }
+
+  MachineOperand &DefOperand = Operands[DefIndex];
+  MachineOperand &UseOperand = Operands[UseIndex];
+  if (!DefOperand.isRegister() || !UseOperand.isRegister() || !DefOperand.isDef() ||
+      DefOperand.isUse() || !UseOperand.isUse() || UseOperand.isDef()) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "tie must connect a pure register definition and use");
+  }
+  if (DefOperand.TiedOperandIndex || UseOperand.TiedOperandIndex) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "an operand cannot participate in more than one tie");
+  }
+
+  DefOperand.setTiedOperandIndex(UseIndex);
+  UseOperand.setTiedOperandIndex(DefIndex);
+  return {};
+}
+
+Expected<void> MachineInstr::untieOperand(std::size_t Index) {
+  if (Index >= Operands.size())
+    return makeUnexpected(ErrorCode::InvalidArgument, "operand tie index is out of range");
+  const auto OtherIndex = Operands[Index].TiedOperandIndex;
+  if (!OtherIndex)
+    return makeUnexpected(ErrorCode::InvalidArgument, "operand is not tied");
+  if (*OtherIndex >= Operands.size() || Operands[*OtherIndex].TiedOperandIndex != Index) {
+    return makeUnexpected(ErrorCode::VerificationError, "operand tie relation is not reciprocal");
+  }
+
+  Operands[*OtherIndex].setTiedOperandIndex(std::nullopt);
+  Operands[Index].setTiedOperandIndex(std::nullopt);
+  return {};
+}
+
+Expected<void> MachineInstr::setDebugLocation(MachineDebugLocation NewLocation) {
+  if (!NewLocation.isValid()) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "machine instruction debug location must be valid");
+  }
+  DebugLocation = std::move(NewLocation);
+  return {};
+}
+
+std::optional<std::string_view> MachineInstr::preInstrSymbol() const noexcept {
+  if (!PreInstrSymbol)
+    return std::nullopt;
+  return *PreInstrSymbol;
+}
+
+Expected<void> MachineInstr::setPreInstrSymbol(std::string Symbol) {
+  if (Symbol.empty())
+    return makeUnexpected(ErrorCode::InvalidArgument, "pre-instruction symbol cannot be empty");
+  PreInstrSymbol = std::move(Symbol);
+  return {};
+}
+
+std::optional<std::string_view> MachineInstr::postInstrSymbol() const noexcept {
+  if (!PostInstrSymbol)
+    return std::nullopt;
+  return *PostInstrSymbol;
+}
+
+Expected<void> MachineInstr::setPostInstrSymbol(std::string Symbol) {
+  if (Symbol.empty())
+    return makeUnexpected(ErrorCode::InvalidArgument, "post-instruction symbol cannot be empty");
+  PostInstrSymbol = std::move(Symbol);
+  return {};
+}
+
+Expected<void> MachineInstr::setHeapAllocMarker(MachineMetadataReference Marker) {
+  if (!Marker.isValid())
+    return makeUnexpected(ErrorCode::InvalidArgument, "heap-allocation marker must be valid");
+  HeapAllocMarker = Marker;
+  return {};
+}
+
+Expected<void> MachineInstr::setPCSections(MachineMetadataReference Sections) {
+  if (!Sections.isValid())
+    return makeUnexpected(ErrorCode::InvalidArgument, "PC sections metadata must be valid");
+  PCSections = Sections;
+  return {};
+}
+
+Expected<void> MachineInstr::setMMRA(MachineMetadataReference Metadata) {
+  if (!Metadata.isValid())
+    return makeUnexpected(ErrorCode::InvalidArgument, "MMRA metadata must be valid");
+  MMRA = Metadata;
+  return {};
+}
+
+Expected<void> MachineInstr::setCFIType(std::uint64_t Type) {
+  if (Type == 0 || Type > std::numeric_limits<std::uint32_t>::max())
+    return makeUnexpected(ErrorCode::InvalidArgument, "CFI type must fit in nonzero uint32");
+  CFIType = static_cast<std::uint32_t>(Type);
+  return {};
+}
+
+std::optional<std::string_view> MachineInstr::deactivationSymbol() const noexcept {
+  if (!DeactivationSymbol)
+    return std::nullopt;
+  return *DeactivationSymbol;
+}
+
+Expected<void> MachineInstr::setDeactivationSymbol(std::string Symbol) {
+  if (Symbol.empty())
+    return makeUnexpected(ErrorCode::InvalidArgument, "deactivation symbol cannot be empty");
+  DeactivationSymbol = std::move(Symbol);
+  return {};
+}
+
+Expected<void> MachineInstr::addMemOperand(const MachineMemOperand &MemOperand) {
+  if (!OwnerFunction->ownsMemOperand(MemOperand)) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "machine memory operand belongs to another function");
+  }
+  MemOperands.push_back(&MemOperand);
+  return {};
+}
+
+Expected<void> MachineInstr::replaceMemOperand(std::size_t Index,
+                                               const MachineMemOperand &MemOperand) {
+  if (Index >= MemOperands.size()) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "machine memory operand index is out of range");
+  }
+  if (!OwnerFunction->ownsMemOperand(MemOperand)) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "replacement memory operand belongs to another function");
+  }
+  MemOperands[Index] = &MemOperand;
+  return {};
+}
+
+Expected<void> MachineInstr::eraseMemOperand(std::size_t Index) {
+  if (Index >= MemOperands.size()) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "machine memory operand index is out of range");
+  }
+  MemOperands.erase(MemOperands.begin() + static_cast<std::ptrdiff_t>(Index));
+  return {};
+}
+
+MachineRegisterInfo *MachineInstr::linkedRegisterInfo() noexcept {
+  if (!isLinked())
+    return nullptr;
+  return &OwnerFunction->registerInfo();
+}
+
+Expected<void> MachineInstr::attachToBlock(MachineBasicBlock &Block) {
+  if (ParentBlock != nullptr) {
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "instruction is already linked to a basic block");
+  }
+
+  MachineRegisterInfo &RegInfo = OwnerFunction->registerInfo();
+  for (const MachineOperand &Operand : Operands) {
+    const Register *Reg = Operand.getIf<Register>();
+    if (Reg != nullptr && Reg->isVirtual() && !RegInfo.isKnownVirtualRegister(*Reg)) {
+      return makeUnexpected(ErrorCode::InvalidArgument,
+                            "instruction references an unknown virtual register");
+    }
+  }
+
+  ParentBlock = &Block;
+  for (MachineOperand &Operand : Operands) {
+    const Register *Reg = Operand.getIf<Register>();
+    if (Reg != nullptr && !Reg->isNoRegister())
+      Operand.linkToRegInfo(RegInfo);
+  }
+  return {};
+}
+
+void MachineInstr::detachFromBlock() noexcept {
+  for (MachineOperand &Operand : Operands)
+    Operand.unlinkFromRegInfo();
+  ParentBlock = nullptr;
+  PreviousInstruction = nullptr;
+  NextInstruction = nullptr;
+}
+
+void MachineInstr::adjustTiesForInsertion(std::size_t Index) noexcept {
+  for (MachineOperand &Operand : Operands) {
+    if (Operand.TiedOperandIndex && *Operand.TiedOperandIndex >= Index)
+      ++*Operand.TiedOperandIndex;
+  }
+}
+
+void MachineInstr::adjustTiesForErasure(std::size_t Index) noexcept {
+  for (MachineOperand &Operand : Operands) {
+    if (!Operand.TiedOperandIndex)
+      continue;
+    if (*Operand.TiedOperandIndex == Index)
+      Operand.TiedOperandIndex.reset();
+    else if (*Operand.TiedOperandIndex > Index)
+      --*Operand.TiedOperandIndex;
+  }
+}
+
+} // namespace rcc