Minimal unwinding information (DWARF CFI) checker

llvm/include/llvm/DWARFCFIChecker/DWARFCFIAnalysis.h

@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file declares `DWARFCFIAnalysis` class.
+/// `DWARFCFIAnalysis` is a minimal implementation of a DWARF CFI checker
+/// described in this link:
+/// https://discourse.llvm.org/t/rfc-dwarf-cfi-validation/86936
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DWARFCFICHECKER_DWARFCFIANALYSIS_H
+#define LLVM_DWARFCFICHECKER_DWARFCFIANALYSIS_H
+
+#include "DWARFCFIState.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCDwarf.h"
+#include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/TargetRegistry.h"
+
+namespace llvm {
+
+/// `DWARFCFIAnalysis` validates the DWARF Call Frame Information one machine
+/// instruction at a time. This class maintains an internal CFI state
+/// initialized with the prologue directives and updated with each instruction's
+/// associated directives. In each update, it checks if the CFI state
+/// modifications match the machine instruction influence on the CFI state or
+/// not. This checking may results in errors and warnings.
+///
+/// In current stage, the analysis is only aware of what registers the
+/// instruction modifies. If the modification is happening to a sub-register,
+/// the analysis considers the super-register is modified.
+///
+/// In each update, for each register (or CFA), the following cases can happen:
+/// 1. The unwinding rule is not changed:
+///   a. The registers involved in this rule are not modified: the analysis
+///   proceeds without emitting error or warning.
+///   b. The registers involved in this rule are modified: it emits an error.
+/// 2. The unwinding rule is changed:
+///   a. The rule is structurally modified (i.e., the location is changed): It
+///   emits a warning.
+///   b. The rule is structurally the same, but the register set is changed: it
+///   emits a warning.
+///   c. The rule is structurally the same, using the same set of registers, but
+///   the offset is changed:
+///      i. If the registers included in the rule are modified as well: It
+///      emits a warning.
+///     ii. If the registers included in the rule are not modified: It emits an
+///     error.
+///
+/// The analysis only checks the CFA unwinding rule when the rule is a register
+/// plus some offset. Therefore, for CFA, only cases 1, 2.b, and 2.c are
+/// checked, and in all other case(s), a warning is emitted.
+class DWARFCFIAnalysis {
+public:
+  DWARFCFIAnalysis(MCContext *Context, MCInstrInfo const &MCII, bool IsEH,
+                   ArrayRef<MCCFIInstruction> Prologue);
+
+  void update(const MCInst &Inst, ArrayRef<MCCFIInstruction> Directives);
+
+private:
+  void checkRegDiff(const MCInst &Inst, DWARFRegNum Reg,
+                    const dwarf::UnwindRow &PrevRow,
+                    const dwarf::UnwindRow &NextRow,
+                    const SmallSet<DWARFRegNum, 4> &Reads,
+                    const SmallSet<DWARFRegNum, 4> &Writes);
+
+  void checkCFADiff(const MCInst &Inst, const dwarf::UnwindRow &PrevRow,
+                    const dwarf::UnwindRow &NextRow,
+                    const SmallSet<DWARFRegNum, 4> &Reads,
+                    const SmallSet<DWARFRegNum, 4> &Writes);
+
+private:
+  DWARFCFIState State;
+  MCContext *Context;
+  MCInstrInfo const &MCII;
+  MCRegisterInfo const *MCRI;
+  bool IsEH;
+};
+
+} // namespace llvm
+
+#endif

llvm/include/llvm/DWARFCFIChecker/DWARFCFIFunctionFrameAnalyzer.h

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file declares CFIFunctionFrameAnalyzer class.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DWARFCFICHECKER_DWARFCFIFUNCTIONFRAMEANALYZER_H
+#define LLVM_DWARFCFICHECKER_DWARFCFIFUNCTIONFRAMEANALYZER_H
+
+#include "DWARFCFIAnalysis.h"
+#include "DWARFCFIFunctionFrameReceiver.h"
+#include "llvm/ADT/ArrayRef.h"
+
+namespace llvm {
+
+/// This class implements the `CFIFunctionFrameReceiver` interface to validate
+/// Call Frame Information in a stream of function frames. For validation, it
+/// instantiates a `DWARFCFIAnalysis` for each frame. The errors/warnings are
+/// emitted through the `MCContext` instance to the constructor. If a frame
+/// finishes without being started or if all the frames are not finished before
+/// this classes is destructured, the program fails through an assertion.
+class CFIFunctionFrameAnalyzer : public CFIFunctionFrameReceiver {
+public:
+  CFIFunctionFrameAnalyzer(MCContext &Context, const MCInstrInfo &MCII)
+      : CFIFunctionFrameReceiver(Context), MCII(MCII) {}
+  ~CFIFunctionFrameAnalyzer();
+
+  void startFunctionFrame(bool IsEH,
+                          ArrayRef<MCCFIInstruction> Prologue) override;
+  void
+  emitInstructionAndDirectives(const MCInst &Inst,
+                               ArrayRef<MCCFIInstruction> Directives) override;
+  void finishFunctionFrame() override;
+
+private:
+  MCInstrInfo const &MCII;
+  std::vector<DWARFCFIAnalysis> UIAs;
+};
+
+} // namespace llvm
+
+#endif

llvm/include/llvm/DWARFCFIChecker/DWARFCFIFunctionFrameReceiver.h

@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file declares CFIFunctionFrameReceiver class.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DWARFCFICHECKER_DWARFCFIFUNCTIONFRAMERECEIVER_H
+#define LLVM_DWARFCFICHECKER_DWARFCFIFUNCTIONFRAMERECEIVER_H
+
+#include "llvm/ADT/ArrayRef.h"
+
+namespace llvm {
+
+class MCCFIInstruction;
+class MCContext;
+class MCInst;
+
+/// This abstract base class is an interface for receiving DWARF function frames
+/// Call Frame Information. `DWARFCFIFunctionFrameStreamer` channels the
+/// function frames information gathered from an `MCStreamer` using a pointer to
+/// an instance of this class for the whole program.
+class CFIFunctionFrameReceiver {
+public:
+  CFIFunctionFrameReceiver(const CFIFunctionFrameReceiver &) = delete;
+  CFIFunctionFrameReceiver &
+  operator=(const CFIFunctionFrameReceiver &) = delete;
+  virtual ~CFIFunctionFrameReceiver() = default;
+
+  CFIFunctionFrameReceiver(MCContext &Context) : Context(Context) {}
+
+  MCContext &getContext() const { return Context; }
+
+  virtual void startFunctionFrame(bool IsEH,
+                                  ArrayRef<MCCFIInstruction> Prologue) {}
+  /// Instructions are processed in the program order.
+  virtual void
+  emitInstructionAndDirectives(const MCInst &Inst,
+                               ArrayRef<MCCFIInstruction> Directives) {}
+  virtual void finishFunctionFrame() {}
+
+private:
+  MCContext &Context;
+};
+
+} // namespace llvm
+
+#endif

llvm/include/llvm/DWARFCFIChecker/DWARFCFIFunctionFrameStreamer.h

@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file declares CFIFunctionFrameStreamer class.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DWARFCFICHECKER_DWARFCFIFUNCTIONFRAMESTREAMER_H
+#define LLVM_DWARFCFICHECKER_DWARFCFIFUNCTIONFRAMESTREAMER_H
+
+#include "DWARFCFIFunctionFrameReceiver.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCDwarf.h"
+#include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCStreamer.h"
+#include <memory>
+#include <optional>
+
+namespace llvm {
+
+/// This class is an `MCStreamer` implementation that watches for machine
+/// instructions and CFI directives. It cuts the stream into function frames and
+/// channels them to `CFIFunctionFrameReceiver`. A function frame is the machine
+/// instructions and CFI directives that are between `.cfi_startproc` and
+/// `.cfi_endproc` directives.
+class CFIFunctionFrameStreamer : public MCStreamer {
+public:
+  CFIFunctionFrameStreamer(MCContext &Context,
+                           std::unique_ptr<CFIFunctionFrameReceiver> Receiver)
+      : MCStreamer(Context), LastInstruction(std::nullopt),
+        Receiver(std::move(Receiver)), LastDirectiveIndex(0) {
+    assert(this->Receiver && "Receiver should not be null");
+  }
+
+  bool hasRawTextSupport() const override { return true; }
+  void emitRawTextImpl(StringRef String) override {}
+
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
+    return true;
+  }
+
+  void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+                        Align ByteAlignment) override {}
+  void emitSubsectionsViaSymbols() override {};
+  void beginCOFFSymbolDef(const MCSymbol *Symbol) override {}
+  void emitCOFFSymbolStorageClass(int StorageClass) override {}
+  void emitCOFFSymbolType(int Type) override {}
+  void endCOFFSymbolDef() override {}
+  void emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol,
+                                            MCSymbolAttr Linkage,
+                                            MCSymbolAttr Visibility) override {}
+
+  void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
+  void emitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
+  void emitCFIEndProcImpl(MCDwarfFrameInfo &CurFrame) override;
+
+private:
+  std::pair<unsigned, unsigned> updateDirectivesRange();
+  void updateReceiver();
+
+private:
+  std::vector<unsigned> FrameIndices;
+  std::optional<MCInst> LastInstruction;
+  std::unique_ptr<CFIFunctionFrameReceiver> Receiver;
+  unsigned LastDirectiveIndex;
+};
+
+} // namespace llvm
+
+#endif

llvm/include/llvm/DWARFCFIChecker/DWARFCFIState.h

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file declares DWARFCFIState class.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DWARFCFICHECKER_UNWINDINFOSTATE_H
+#define LLVM_DWARFCFICHECKER_UNWINDINFOSTATE_H
+
+#include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCDwarf.h"
+#include <optional>
+
+namespace llvm {
+
+using DWARFRegNum = uint32_t;
+
+/// This class is used to maintain a CFI state, referred to as an unwinding row,
+/// during CFI analysis. The only way to modify the state is by updating it with
+/// a CFI directive.
+class DWARFCFIState {
+public:
+  DWARFCFIState(MCContext *Context) : Context(Context), IsInitiated(false) {};
+
+  std::optional<dwarf::UnwindRow> getCurrentUnwindRow() const;
+  /// This method updates the state by applying \p Directive to the current
+  /// state. If the directive is not supported by the checker or any error
+  /// happens while applying the CFI directive, a warning or error is reported
+  /// to the user, and the directive is ignored, leaving the state unchanged.
+  void update(const MCCFIInstruction &Directive);
+
+private:
+  dwarf::CFIProgram convert(MCCFIInstruction Directive);
+
+private:
+  dwarf::UnwindRow Row;
+  MCContext *Context;
+  bool IsInitiated;
+};
+
+} // namespace llvm
+
+#endif

llvm/lib/CMakeLists.txt

@@ -31,6 +31,7 @@ add_subdirectory(Option)
 add_subdirectory(Remarks)
 add_subdirectory(Debuginfod)
 add_subdirectory(DebugInfo)
+add_subdirectory(DWARFCFIChecker)
 add_subdirectory(DWP)
 add_subdirectory(ExecutionEngine)
 add_subdirectory(Target)

llvm/lib/DWARFCFIChecker/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_llvm_component_library(LLVMDWARFCFIChecker
+  DWARFCFIAnalysis.cpp
+  DWARFCFIFunctionFrameAnalyzer.cpp
+  DWARFCFIFunctionFrameStreamer.cpp
+  DWARFCFIState.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${LLVM_MAIN_INCLUDE_DIR}/llvm/MCA
+
+  LINK_COMPONENTS
+  MC
+  DebugInfoDWARF
+  Support
+  )