[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.

1 files changed, 81 insertions, 4 deletions

diff --git a/backend/lib/CodeGen/MachineFunctionCloner.cpp b/backend/lib/CodeGen/MachineFunctionCloner.cpp
index d452546..46fed6c 100644
--- a/backend/lib/CodeGen/MachineFunctionCloner.cpp
+++ b/backend/lib/CodeGen/MachineFunctionCloner.cpp
@@ -5,6 +5,7 @@
 #include "rcc/CodeGen/InstructionDescriptor.h"
 #include "rcc/CodeGen/MachineBasicBlock.h"
 #include "rcc/CodeGen/MachineCFGUpdater.h"
+#include "rcc/CodeGen/MachineFrameInfo.h"
 #include "rcc/CodeGen/MachineFunction.h"
 #include "rcc/CodeGen/MachineInstr.h"
 #include "rcc/CodeGen/MachineMemOperand.h"
@@ -86,8 +87,12 @@ struct CloneState final {
     if (Frame == nullptr) {
       return makeUnexpected(ErrorCode::VerificationError, "source frame-index operand is invalid");
     }
-    State.Result.FrameIndices.emplace(Frame->Index, Frame->Index);
-    return SourceOperand.cloneDetached();
+    const auto Position = State.Result.FrameIndices.find(Frame->Index);
+    if (Position == State.Result.FrameIndices.end()) {
+      return makeUnexpected(ErrorCode::VerificationError,
+                            "source operand references an unmapped frame index");
+    }
+    return MachineOperand::frameIndex(Position->second, Frame->Offset, SourceOperand.targetFlags());
   }
   case MachineOperand::Kind::ConstantPoolIndex: {
     const auto *Constant = SourceOperand.getIf<ConstantPoolOperand>();
@@ -123,8 +128,6 @@ struct CloneState final {
 
 void recordMemoryIndexMappings(const MachineMemOperandDesc &Description,
                                MachineFunctionCloneResult &Result) {
-  if (const auto Frame = Description.Base.frameIndex())
-    Result.FrameIndices.emplace(*Frame, *Frame);
   if (const auto Constant = Description.Base.constantPoolIndex())
     Result.ConstantPoolIndices.emplace(*Constant, *Constant);
   if (const auto JumpTable = Description.Base.jumpTableIndex())
@@ -139,6 +142,14 @@ cloneMemOperand(const MachineMemOperand &SourceOperand, CloneState &State) {
 
   MachineMemOperandDesc Description = SourceOperand.description();
   recordMemoryIndexMappings(Description, State.Result);
+  if (const auto Frame = Description.Base.frameIndex()) {
+    const auto Position = State.Result.FrameIndices.find(*Frame);
+    if (Position == State.Result.FrameIndices.end()) {
+      return makeUnexpected(ErrorCode::VerificationError,
+                            "source MMO references an unmapped frame index");
+    }
+    Description.Base = MemoryBase::frameIndex(Position->second);
+  }
   auto DestinationOperand = State.Destination.createMemOperand(std::move(Description));
   if (!DestinationOperand)
     return std::unexpected(DestinationOperand.error());
@@ -207,6 +218,23 @@ cloneMemOperand(const MachineMemOperand &SourceOperand, CloneState &State) {
   return {};
 }
 
+[[nodiscard]] Expected<void> cloneFrameObjects(CloneState &State) {
+  for (const StackObject &SourceObject : State.Source.frameInfo().objects()) {
+    const StackObjectDesc *Description = SourceObject.description();
+    if (Description == nullptr)
+      continue;
+    auto DestinationIndex = State.Destination.frameInfo().createObject(*Description);
+    if (!DestinationIndex)
+      return std::unexpected(DestinationIndex.error());
+    State.Result.FrameIndices.emplace(SourceObject.index(), *DestinationIndex);
+  }
+  auto CallFrameResult = State.Destination.frameInfo().setMaxCallFrameSize(
+      State.Source.frameInfo().maxCallFrameSize());
+  if (!CallFrameResult)
+    return std::unexpected(CallFrameResult.error());
+  return {};
+}
+
 [[nodiscard]] Expected<void> cloneBlocks(CloneState &State) {
   for (const MachineBasicBlock *SourceBlock = State.Source.firstBlock(); SourceBlock != nullptr;
        SourceBlock = SourceBlock->next()) {
@@ -294,6 +322,49 @@ cloneMemOperand(const MachineMemOperand &SourceOperand, CloneState &State) {
   return {};
 }
 
+[[nodiscard]] Expected<void> finalizeFrameClone(CloneState &State) {
+  for (const StackObject &SourceObject : State.Source.frameInfo().objects()) {
+    const StackObjectDesc *SourceDescription = SourceObject.description();
+    if (SourceDescription == nullptr)
+      continue;
+    const auto FramePosition = State.Result.FrameIndices.find(SourceObject.index());
+    if (FramePosition == State.Result.FrameIndices.end()) {
+      return makeUnexpected(ErrorCode::InternalError,
+                            "source stack object was not mapped before frame finalization");
+    }
+
+    StackObjectDesc DestinationDescription = *SourceDescription;
+    for (StackObjectLifetimeRange &Range : DestinationDescription.Lifetime) {
+      const auto Begin = State.Result.InstructionStableIDs.find(Range.Begin);
+      const auto End = State.Result.InstructionStableIDs.find(Range.End);
+      if (Begin == State.Result.InstructionStableIDs.end() ||
+          End == State.Result.InstructionStableIDs.end()) {
+        return makeUnexpected(ErrorCode::VerificationError,
+                              "source stack lifetime references an unmapped instruction");
+      }
+      Range.Begin = Begin->second;
+      Range.End = End->second;
+    }
+    auto UpdateResult = State.Destination.frameInfo().updateObject(
+        FramePosition->second, std::move(DestinationDescription));
+    if (!UpdateResult)
+      return std::unexpected(UpdateResult.error());
+  }
+
+  if (State.Source.frameInfo().isFrozen()) {
+    const auto StackSize = State.Source.frameInfo().staticStackSize();
+    if (!StackSize) {
+      return makeUnexpected(ErrorCode::InternalError,
+                            "verified frozen source frame has no static stack size");
+    }
+    auto FreezeResult =
+        State.Destination.frameInfo().freeze(*StackSize, State.Source.frameInfo().stackAlignment());
+    if (!FreezeResult)
+      return std::unexpected(FreezeResult.error());
+  }
+  return {};
+}
+
 [[nodiscard]] Expected<void> cloneCFG(CloneState &State) {
   MachineCFGUpdater Updater = State.Destination.cfgUpdater();
   for (const MachineBasicBlock *SourceBlock = State.Source.firstBlock(); SourceBlock != nullptr;
@@ -353,12 +424,18 @@ Expected<MachineFunctionCloneResult> cloneMachineFunction(const MachineFunction
   auto RegisterResult = cloneRegisterConfiguration(State);
   if (!RegisterResult)
     return std::unexpected(RegisterResult.error());
+  auto FrameResult = cloneFrameObjects(State);
+  if (!FrameResult)
+    return std::unexpected(FrameResult.error());
   auto BlockResult = cloneBlocks(State);
   if (!BlockResult)
     return std::unexpected(BlockResult.error());
   auto InstructionResult = cloneInstructions(State);
   if (!InstructionResult)
     return std::unexpected(InstructionResult.error());
+  auto FrameFinalizationResult = finalizeFrameClone(State);
+  if (!FrameFinalizationResult)
+    return std::unexpected(FrameFinalizationResult.error());
   auto CFGResult = cloneCFG(State);
   if (!CFGResult)
     return std::unexpected(CFGResult.error());