[lldb/Target] Add BorrowedStackFrame and make StackFrame methods virtual

This change makes StackFrame methods virtual to enable subclass overrides
and introduces BorrowedStackFrame, a wrapper that presents an existing
StackFrame with a different frame index.

This enables creating synthetic frame views or renumbering frames without
copying the underlying frame data, which is useful for frame manipulation
scenarios.

This also adds a new borrowed-info format entity to show what was the
original frame index of the borrowed frame.

Signed-off-by: Med Ismail Bennani <[email protected]>

Author: medismailben

lldb/include/lldb/Core/FormatEntity.h

@@ -81,6 +81,7 @@ struct Entry {
     FrameRegisterByName,
     FrameIsArtificial,
     FrameKind,
+    FrameBorrowedInfo,
     ScriptFrame,
     FunctionID,
     FunctionDidChange,

lldb/include/lldb/Target/BorrowedStackFrame.h

@@ -0,0 +1,193 @@
+//===-- BorrowedStackFrame.h ------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_TARGET_BORROWEDSTACKFRAME_H
+#define LLDB_TARGET_BORROWEDSTACKFRAME_H
+
+#include "lldb/Target/StackFrame.h"
+
+namespace lldb_private {
+
+/// \class BorrowedStackFrame BorrowedStackFrame.h
+/// "lldb/Target/BorrowedStackFrame.h"
+///
+/// A wrapper around an existing StackFrame that supersedes its frame index.
+///
+/// This class is useful when you need to present an existing stack frame
+/// with a different index, such as when creating synthetic frame views or
+/// renumbering frames without copying all the underlying data.
+///
+/// All methods delegate to the borrowed frame except for GetFrameIndex()
+/// which uses the overridden index.
+
+class BorrowedStackFrame : public StackFrame {
+public:
+  /// Construct a BorrowedStackFrame that wraps an existing frame.
+  ///
+  /// \param [in] borrowed_frame_sp
+  ///   The existing StackFrame to borrow from. This frame's data will be
+  ///   used for all operations except frame index queries.
+  ///
+  /// \param [in] override_frame_index
+  ///   The frame index to report instead of the borrowed frame's index.
+  BorrowedStackFrame(const lldb::StackFrameSP &borrowed_frame_sp,
+                     uint32_t override_frame_index);
+
+  ~BorrowedStackFrame() override = default;
+
+  // Override frame index methods
+  uint32_t GetFrameIndex() const override { return m_override_frame_index; }
+  void SetFrameIndex(uint32_t index) { m_override_frame_index = index; }
+
+  uint32_t GetConcreteFrameIndex() const override {
+    return m_borrowed_frame_sp->GetConcreteFrameIndex();
+  }
+
+  // Delegate all other virtual methods to the borrowed frame
+  StackID &GetStackID() override { return m_borrowed_frame_sp->GetStackID(); }
+
+  const Address &GetFrameCodeAddress() override {
+    return m_borrowed_frame_sp->GetFrameCodeAddress();
+  }
+
+  Address GetFrameCodeAddressForSymbolication() override {
+    return m_borrowed_frame_sp->GetFrameCodeAddressForSymbolication();
+  }
+
+  bool ChangePC(lldb::addr_t pc) override {
+    return m_borrowed_frame_sp->ChangePC(pc);
+  }
+
+  const SymbolContext &
+  GetSymbolContext(lldb::SymbolContextItem resolve_scope) override {
+    return m_borrowed_frame_sp->GetSymbolContext(resolve_scope);
+  }
+
+  llvm::Error GetFrameBaseValue(Scalar &value) override {
+    return m_borrowed_frame_sp->GetFrameBaseValue(value);
+  }
+
+  DWARFExpressionList *GetFrameBaseExpression(Status *error_ptr) override {
+    return m_borrowed_frame_sp->GetFrameBaseExpression(error_ptr);
+  }
+
+  Block *GetFrameBlock() override {
+    return m_borrowed_frame_sp->GetFrameBlock();
+  }
+
+  lldb::RegisterContextSP GetRegisterContext() override {
+    return m_borrowed_frame_sp->GetRegisterContext();
+  }
+
+  VariableList *GetVariableList(bool get_file_globals,
+                                Status *error_ptr) override {
+    return m_borrowed_frame_sp->GetVariableList(get_file_globals, error_ptr);
+  }
+
+  lldb::VariableListSP
+  GetInScopeVariableList(bool get_file_globals,
+                         bool must_have_valid_location = false) override {
+    return m_borrowed_frame_sp->GetInScopeVariableList(
+        get_file_globals, must_have_valid_location);
+  }
+
+  lldb::ValueObjectSP GetValueForVariableExpressionPath(
+      llvm::StringRef var_expr, lldb::DynamicValueType use_dynamic,
+      uint32_t options, lldb::VariableSP &var_sp, Status &error) override {
+    return m_borrowed_frame_sp->GetValueForVariableExpressionPath(
+        var_expr, use_dynamic, options, var_sp, error);
+  }
+
+  bool HasDebugInformation() override {
+    return m_borrowed_frame_sp->HasDebugInformation();
+  }
+
+  const char *Disassemble() override {
+    return m_borrowed_frame_sp->Disassemble();
+  }
+
+  lldb::ValueObjectSP
+  GetValueObjectForFrameVariable(const lldb::VariableSP &variable_sp,
+                                 lldb::DynamicValueType use_dynamic) override {
+    return m_borrowed_frame_sp->GetValueObjectForFrameVariable(variable_sp,
+                                                               use_dynamic);
+  }
+
+  bool IsInlined() override { return m_borrowed_frame_sp->IsInlined(); }
+
+  bool IsSynthetic() const override {
+    return m_borrowed_frame_sp->IsSynthetic();
+  }
+
+  bool IsHistorical() const override {
+    return m_borrowed_frame_sp->IsHistorical();
+  }
+
+  bool IsArtificial() const override {
+    return m_borrowed_frame_sp->IsArtificial();
+  }
+
+  bool IsHidden() override { return m_borrowed_frame_sp->IsHidden(); }
+
+  const char *GetFunctionName() override {
+    return m_borrowed_frame_sp->GetFunctionName();
+  }
+
+  const char *GetDisplayFunctionName() override {
+    return m_borrowed_frame_sp->GetDisplayFunctionName();
+  }
+
+  lldb::ValueObjectSP FindVariable(ConstString name) override {
+    return m_borrowed_frame_sp->FindVariable(name);
+  }
+
+  SourceLanguage GetLanguage() override {
+    return m_borrowed_frame_sp->GetLanguage();
+  }
+
+  SourceLanguage GuessLanguage() override {
+    return m_borrowed_frame_sp->GuessLanguage();
+  }
+
+  lldb::ValueObjectSP GuessValueForAddress(lldb::addr_t addr) override {
+    return m_borrowed_frame_sp->GuessValueForAddress(addr);
+  }
+
+  lldb::ValueObjectSP GuessValueForRegisterAndOffset(ConstString reg,
+                                                     int64_t offset) override {
+    return m_borrowed_frame_sp->GuessValueForRegisterAndOffset(reg, offset);
+  }
+
+  StructuredData::ObjectSP GetLanguageSpecificData() override {
+    return m_borrowed_frame_sp->GetLanguageSpecificData();
+  }
+
+  lldb::RecognizedStackFrameSP GetRecognizedFrame() override {
+    return m_borrowed_frame_sp->GetRecognizedFrame();
+  }
+
+  /// Get the underlying borrowed frame.
+  lldb::StackFrameSP GetBorrowedFrame() const { return m_borrowed_frame_sp; }
+
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || StackFrame::isA(ClassID);
+  }
+  static bool classof(const StackFrame *obj) { return obj->isA(&ID); }
+
+private:
+  lldb::StackFrameSP m_borrowed_frame_sp;
+  uint32_t m_override_frame_index;
+  static char ID;
+
+  BorrowedStackFrame(const BorrowedStackFrame &) = delete;
+  const BorrowedStackFrame &operator=(const BorrowedStackFrame &) = delete;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_TARGET_BORROWEDSTACKFRAME_H