[CodeGen] Add MachineFrameInfo

Model stable frame indices, stack object kinds, tombstones, lifetimes, and frozen layouts. Validate owned frame references in the builder and verifier, and remap complete frame state during MachineFunction cloning.

3 files changed, 197 insertions, 0 deletions

diff --git a/backend/include/rcc/CodeGen/MachineFrameInfo.h b/backend/include/rcc/CodeGen/MachineFrameInfo.h
new file mode 100644
index 0000000..ad1de53
--- /dev/null
+++ b/backend/include/rcc/CodeGen/MachineFrameInfo.h
@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef RCC_CODEGEN_MACHINEFRAMEINFO_H
+#define RCC_CODEGEN_MACHINEFRAMEINFO_H
+
+#include "rcc/CodeGen/MachineIRTypes.h"
+#include "rcc/CodeGen/MachineMemOperand.h"
+#include "rcc/CodeGen/StableID.h"
+#include "rcc/Support/Error.h"
+
+#include <cstdint>
+#include <optional>
+#include <span>
+#include <utility>
+#include <variant>
+#include <vector>
+
+namespace rcc {
+
+enum class StackObjectKind : std::uint8_t {
+  Default,
+  FixedABI,
+  SpillSlot,
+  VariableSized,
+  DynamicAlloca,
+  CalleeSaved,
+  EmergencySpill,
+  Target,
+  Count,
+};
+
+class StackID final {
+public:
+  constexpr StackID() noexcept = default;
+
+  [[nodiscard]] static constexpr StackID defaultStack() noexcept {
+    return StackID(DefaultStackValue);
+  }
+
+  [[nodiscard]] static constexpr StackID safeStack() noexcept {
+    return StackID(SafeStackValue);
+  }
+
+  [[nodiscard]] static constexpr StackID shadowCallStack() noexcept {
+    return StackID(ShadowCallStackValue);
+  }
+
+  [[nodiscard]] static constexpr StackID scalableVectorStack() noexcept {
+    return StackID(ScalableVectorStackValue);
+  }
+
+  [[nodiscard]] static Expected<StackID> targetStack(std::uint32_t Value);
+
+  [[nodiscard]] constexpr std::uint32_t value() const noexcept {
+    return Value;
+  }
+
+  [[nodiscard]] constexpr bool isTargetStack() const noexcept {
+    return Value >= FirstTargetStackValue;
+  }
+
+  [[nodiscard]] constexpr bool isValid() const noexcept {
+    return Value <= ScalableVectorStackValue || isTargetStack();
+  }
+
+  friend constexpr bool operator==(StackID Left, StackID Right) noexcept = default;
+
+private:
+  static constexpr std::uint32_t DefaultStackValue = 0;
+  static constexpr std::uint32_t SafeStackValue = 1;
+  static constexpr std::uint32_t ShadowCallStackValue = 2;
+  static constexpr std::uint32_t ScalableVectorStackValue = 3;
+  static constexpr std::uint32_t FirstTargetStackValue = 256;
+
+  explicit constexpr StackID(std::uint32_t Value) noexcept : Value(Value) {}
+
+  std::uint32_t Value = DefaultStackValue;
+};
+
+struct StackObjectLifetimeRange final {
+  MachineInstrStableID Begin;
+  MachineInstrStableID End;
+
+  friend constexpr bool operator==(StackObjectLifetimeRange Left,
+                                   StackObjectLifetimeRange Right) noexcept = default;
+};
+
+struct StackObjectDesc final {
+  StackObjectKind Kind = StackObjectKind::Default;
+  std::optional<std::uint64_t> Size;
+  Alignment Align;
+  std::optional<std::int64_t> Offset;
+  StackID Stack;
+  bool IsDead = false;
+  bool IsAliased = false;
+  bool AddressTaken = false;
+  std::vector<StackObjectLifetimeRange> Lifetime;
+  std::uint64_t TargetFlags = 0;
+
+  friend bool operator==(const StackObjectDesc &Left, const StackObjectDesc &Right) = default;
+};
+
+class StackObject final {
+public:
+  [[nodiscard]] FrameIndex index() const noexcept {
+    return Index;
+  }
+
+  [[nodiscard]] bool isTombstone() const noexcept {
+    return std::holds_alternative<std::monostate>(Description);
+  }
+
+  [[nodiscard]] const StackObjectDesc *description() const noexcept {
+    return std::get_if<StackObjectDesc>(&Description);
+  }
+
+  [[nodiscard]] bool isSpill() const noexcept;
+  [[nodiscard]] bool isFixed() const noexcept;
+  [[nodiscard]] bool isVariableSized() const noexcept;
+
+private:
+  StackObject(FrameIndex Index, StackObjectDesc Description)
+      : Index(Index), Description(std::move(Description)) {}
+
+  FrameIndex Index;
+  std::variant<std::monostate, StackObjectDesc> Description;
+
+  friend class MachineFrameInfo;
+};
+
+class MachineFrameInfo final {
+public:
+  MachineFrameInfo() = default;
+  MachineFrameInfo(const MachineFrameInfo &) = delete;
+  MachineFrameInfo &operator=(const MachineFrameInfo &) = delete;
+  MachineFrameInfo(MachineFrameInfo &&) noexcept = default;
+  MachineFrameInfo &operator=(MachineFrameInfo &&) noexcept = default;
+  ~MachineFrameInfo() = default;
+
+  [[nodiscard]] Expected<FrameIndex> createObject(StackObjectDesc Description);
+  [[nodiscard]] Expected<void> updateObject(FrameIndex Index, StackObjectDesc Description);
+  [[nodiscard]] Expected<void> setObjectOffset(FrameIndex Index, std::int64_t Offset);
+  [[nodiscard]] Expected<void> markObjectDead(FrameIndex Index);
+  [[nodiscard]] Expected<void> eraseObject(FrameIndex Index);
+
+  [[nodiscard]] const StackObject *object(FrameIndex Index) const noexcept;
+  [[nodiscard]] std::span<const StackObject> objects() const noexcept {
+    return Objects;
+  }
+
+  [[nodiscard]] std::size_t liveObjectCount() const noexcept;
+
+  [[nodiscard]] bool isFrozen() const noexcept {
+    return Frozen;
+  }
+
+  [[nodiscard]] std::optional<std::uint64_t> staticStackSize() const noexcept {
+    return StaticStackSize;
+  }
+
+  [[nodiscard]] Alignment stackAlignment() const noexcept {
+    return StackAlign;
+  }
+
+  [[nodiscard]] std::uint64_t maxCallFrameSize() const noexcept {
+    return MaxCallFrameSize;
+  }
+
+  [[nodiscard]] Expected<void> setMaxCallFrameSize(std::uint64_t Size);
+  [[nodiscard]] Expected<void> freeze(std::uint64_t Size, Alignment Align);
+  [[nodiscard]] Expected<void> verify() const;
+
+private:
+  [[nodiscard]] static Expected<void> verifyDescription(const StackObjectDesc &Description);
+  [[nodiscard]] Expected<StackObject *> mutableObject(FrameIndex Index);
+
+  std::vector<StackObject> Objects;
+  bool Frozen = false;
+  std::optional<std::uint64_t> StaticStackSize;
+  Alignment StackAlign;
+  std::uint64_t MaxCallFrameSize = 0;
+};
+
+} // namespace rcc
+
+#endif // RCC_CODEGEN_MACHINEFRAMEINFO_H
diff --git a/backend/include/rcc/CodeGen/MachineFunction.h b/backend/include/rcc/CodeGen/MachineFunction.h
index 487fb5b..3e3fecb 100644
--- a/backend/include/rcc/CodeGen/MachineFunction.h
+++ b/backend/include/rcc/CodeGen/MachineFunction.h
@@ -3,6 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINEFUNCTION_H
 #define RCC_CODEGEN_MACHINEFUNCTION_H
 
+#include "rcc/CodeGen/MachineFrameInfo.h"
 #include "rcc/CodeGen/MachineFunctionProperties.h"
 #include "rcc/CodeGen/MachineRegisterInfo.h"
 #include "rcc/CodeGen/StableID.h"
@@ -52,6 +53,14 @@ public:
     return RegInfo;
   }
 
+  [[nodiscard]] MachineFrameInfo &frameInfo() noexcept {
+    return FrameInfo;
+  }
+
+  [[nodiscard]] const MachineFrameInfo &frameInfo() const noexcept {
+    return FrameInfo;
+  }
+
   [[nodiscard]] MachineFunctionProperties &properties() noexcept {
     return Properties;
   }
@@ -110,6 +119,7 @@ private:
   std::string Name;
   MachineFunctionStableID StableID;
   MachineRegisterInfo RegInfo;
+  MachineFrameInfo FrameInfo;
   MachineFunctionProperties Properties;
   MachineBasicBlock *FirstBlock = nullptr;
   MachineBasicBlock *LastBlock = nullptr;
diff --git a/backend/include/rcc/CodeGen/MachineIRBuilder.h b/backend/include/rcc/CodeGen/MachineIRBuilder.h
index 02e47ff..3bd8d67 100644
--- a/backend/include/rcc/CodeGen/MachineIRBuilder.h
+++ b/backend/include/rcc/CodeGen/MachineIRBuilder.h
@@ -96,6 +96,7 @@ private:
 
   [[nodiscard]] Expected<void> ensurePending() const;
   [[nodiscard]] Expected<void> validateInsertionPoint() const;
+  [[nodiscard]] Expected<void> validateFrameReference(FrameIndex Index) const;
   [[nodiscard]] Expected<void> validateOperandOwnership(const MachineOperand &Operand) const;
   [[nodiscard]] std::vector<MachineOperandTie> collectOperandTies() const;
   [[nodiscard]] Expected<void> appendRegister(Register Reg, RegisterOperandFlags Flags,