DroppedVariableStats.h

Go to the documentation of this file.

///===- DroppedVariableStats.h - Opt Diagnostics -*- 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
///
///===---------------------------------------------------------------------===//
/// \file
/// Dropped Variable Statistics for Debug Information. Reports any number
/// of #dbg_value that get dropped due to an optimization pass.
///
///===---------------------------------------------------------------------===//
 
#ifndef LLVM_CODEGEN_DROPPEDVARIABLESTATS_H
#define LLVM_CODEGEN_DROPPEDVARIABLESTATS_H
 
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/Support/Compiler.h"
 
namespace llvm {
 
class Function;
class DebugLoc;
class StringRef;
 
/// A unique key that represents one instance of a debug variable.
using VarID = DebugVariableAggregate;
 
/// A base class to collect and print dropped debug information variable
/// statistics.
class DroppedVariableStats {
public:
  LLVM_ABI DroppedVariableStats(bool DroppedVarStatsEnabled);
 
  virtual ~DroppedVariableStats() = default;
 
  // We intend this to be unique per-compilation, thus no copies.
  DroppedVariableStats(const DroppedVariableStats &) = delete;
  void operator=(const DroppedVariableStats &) = delete;
 
  bool getPassDroppedVariables() { return PassDroppedVariables; }
 
protected:
  LLVM_ABI void setup();
 
  LLVM_ABI void cleanup();
 
  bool DroppedVariableStatsEnabled = false;
  struct DebugVariables {
    /// DenseSet of VarIDs before an optimization pass has run.
    DenseSet<VarID> DebugVariablesBefore;
    /// DenseSet of VarIDs after an optimization pass has run.
    DenseSet<VarID> DebugVariablesAfter;
  };
 
  /// A stack of a DenseMap, that maps DebugVariables for every pass to an
  /// llvm::Function. A stack is used because an optimization pass can call
  /// other passes.
  SmallVector<DenseMap<const Function *, DebugVariables>> DebugVariablesStack;
 
  /// Calculate the number of dropped variables in an llvm::Function or
  /// llvm::MachineFunction and print the relevant information to stdout.
  LLVM_ABI void calculateDroppedStatsAndPrint(DebugVariables &DbgVariables,
                                              StringRef PassID,
                                              StringRef FuncOrModName,
                                              StringRef PassLevel,
                                              const Function *Func);
 
  /// Check if a \p Var has been dropped or is a false positive. Also update the
  /// \p DroppedCount if a debug variable is dropped.
  LLVM_ABI bool updateDroppedCount(const DILocation *DbgLoc, VarID Var,
                                   unsigned &DroppedCount);
 
  /// Run code to populate relevant data structures over an llvm::Function or
  /// llvm::MachineFunction.
  LLVM_ABI void run(DebugVariables &DbgVariables, bool Before);
 
  /// Add the VarID of the debug record of \p DbgVar at \p DbgLoc to
  /// \p VarIDSet.
  LLVM_ABI void populateVarIDSet(const DILocalVariable *DbgVar, DebugLoc DbgLoc,
                                 DenseSet<VarID> &VarIDSet);
 
  /// Visit every llvm::Instruction or llvm::MachineInstruction and check if the
  /// debug variable denoted by its ID \p Var may have been dropped by an
  /// optimization pass.
  virtual void visitEveryInstruction(unsigned &DroppedCount, VarID Var) = 0;
  /// Visit every debug record in an llvm::Function or llvm::MachineFunction
  /// and call populateVarIDSet on it.
  virtual void visitEveryDebugRecord(DenseSet<VarID> &VarIDSet) = 0;
 
private:
  /// Remove a dropped debug variable's VarID from all Sets in the
  /// DroppedVariablesBefore stack.
  void removeVarFromAllSets(VarID Var, const Function *F);
 
  /// Return true if \p Scope is the same as \p VarScope or a child scope of
  /// \p VarScope, return false otherwise.
  static bool isScopeChildOfOrEqualTo(const DIScope *Scope,
                                      const DIScope *VarScope);
 
  /// Return true if a debugger stopped at \p Loc can observe \p Var, in the
  /// frame of \p Loc or in a frame \p Loc was inlined into.
  static bool isVarInScopeAt(const DILocation *Loc, VarID Var);
 
  bool PassDroppedVariables = false;
};
 
} // namespace llvm
 
#endif