Minimal unwinding information (DWARF CFI) checker (#145633)

This PR adds a minimal version of `UnwindInfoChecker` described in
[here](https://discourse.llvm.org/t/rfc-dwarf-cfi-validation/86936).

This implementation looks into the modified registers by each
instruction and checks:
- If one of them is the CFA register, and it informs the user if the CFA
data is not modified as well.
- If one of them is used in another register's unwinding rule, it
informs the user if the unwind info is not modified after this
instruction.

This implementation does not support DWARF expressions and treats them
as unknown unwinding rules.

Author: amsen20

llvm/include/llvm/DWARFCFIChecker/DWARFCFIAnalysis.h

@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+///
+/// The goal of the checker is to validate DWARF CFI directives using the
+/// prologue directives and the machine instructions. The main proposed
+/// algorithm validates the directives by comparing the CFI state in each
+/// instruction with the state achieved by abstract execution of the instruction
+/// on the CFI state. However, the current version implemented here is a simple
+/// conditional check based on the registers modified by each instruction.
+///
+//===----------------------------------------------------------------------===//
+
+#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/LowLevel/DWARFUnwindTable.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 machine
+/// instruction changes the CFI state in a way that matches the changes
+/// from the CFI directives. 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,50 @@
+//===----------------------------------------------------------------------===//
+//
+// 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"
+#include "llvm/ADT/SmallVector.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 destructed, 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;
+  SmallVector<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,90 @@
+//===----------------------------------------------------------------------===//
+//
+// 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/ADT/SmallVector.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), Receiver(std::move(Receiver)) {
+    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:
+  /// This method sends the last instruction, along with its associated
+  /// directives, to the receiver and then updates the internal state of the
+  /// class. It moves the directive index to after the last directive and sets
+  /// the last instruction to \p NewInst . This method assumes it is called in
+  /// the middle of an unfinished DWARF debug frame; if not, an assertion will
+  /// fail.
+  void updateReceiver(const std::optional<MCInst> &NewInst);
+
+private:
+  /// The following fields are stacks that store the state of the stream sent to
+  /// the receiver in each frame. This class, like `MCStreamer`, assumes that
+  /// the debug frames are intertwined with each other only in stack form.
+
+  /// The last instruction that is not sent to the receiver for each frame.
+  SmallVector<std::optional<MCInst>> LastInstructions;
+  /// The index of the last directive that is not sent to the receiver for each
+  /// frame.
+  SmallVector<unsigned> LastDirectiveIndices;
+  /// The index of each frame in `DwarfFrameInfos` field in `MCStreamer`.
+  SmallVector<unsigned> FrameIndices;
+
+  std::unique_ptr<CFIFunctionFrameReceiver> Receiver;
+};
+
+} // namespace llvm
+
+#endif

llvm/include/llvm/DWARFCFIChecker/DWARFCFIState.h

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// 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/LowLevel/DWARFUnwindTable.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
+  DebugInfoDWARFLowLevel
+  Support
+  )