reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/CodeGen/FunctionLoweringInfo.h

   39 class LegacyDivergenceAnalysis;

include/llvm/CodeGen/SelectionDAG.h

   68 class LegacyDivergenceAnalysis;

include/llvm/CodeGen/TargetLowering.h

   78 class LegacyDivergenceAnalysis;

References

include/llvm/CodeGen/FunctionLoweringInfo.h

   60   const LegacyDivergenceAnalysis *DA;

include/llvm/CodeGen/SelectionDAG.h

  231   LegacyDivergenceAnalysis * DA = nullptr;
  404             LegacyDivergenceAnalysis * Divergence);
  423   const LegacyDivergenceAnalysis *getDivergenceAnalysis() const { return DA; }

include/llvm/CodeGen/TargetLowering.h

 2958                                           LegacyDivergenceAnalysis *DA) const {

include/llvm/Pass.h

  213   AnalysisType &getAnalysisID(AnalysisID PI) const;

include/llvm/PassAnalysisSupport.h

   66     return addRequiredID(PassClass::ID);
   89     Preserved.push_back(&PassClass::ID);
  201 AnalysisType *Pass::getAnalysisIfAvailable() const {
  204   const void *PI = &AnalysisType::ID;
  220 AnalysisType &Pass::getAnalysis() const {
  222   return getAnalysisID<AnalysisType>(&AnalysisType::ID);
  222   return getAnalysisID<AnalysisType>(&AnalysisType::ID);

include/llvm/PassSupport.h

   76 template <typename PassName> Pass *callDefaultCtor() { return new PassName(); }

lib/Analysis/LegacyDivergenceAnalysis.cpp

  293   return new LegacyDivergenceAnalysis();

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

  451    getAnalysisIfAvailable<LegacyDivergenceAnalysis>());

lib/Target/AMDGPU/AMDGPUAnnotateUniformValues.cpp

   33   LegacyDivergenceAnalysis *DA;
   49     AU.addRequired<LegacyDivergenceAnalysis>();
  169   DA  = &getAnalysis<LegacyDivergenceAnalysis>();

lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp

   43   const LegacyDivergenceAnalysis *DA;
   64     AU.addRequired<LegacyDivergenceAnalysis>();
   83   DA = &getAnalysis<LegacyDivergenceAnalysis>();

lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

   68   LegacyDivergenceAnalysis *DA = nullptr;
  195     AU.addRequired<LegacyDivergenceAnalysis>();
 1034   DA = &getAnalysis<LegacyDivergenceAnalysis>();

lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp

  142     AU.addRequired<LegacyDivergenceAnalysis>();

lib/Target/AMDGPU/AMDGPUUnifyDivergentExitNodes.cpp

   80   AU.addRequired<LegacyDivergenceAnalysis>();
   83   AU.addPreserved<LegacyDivergenceAnalysis>();
   97 static bool isUniformlyReached(const LegacyDivergenceAnalysis &DA,
  165   LegacyDivergenceAnalysis &DA = getAnalysis<LegacyDivergenceAnalysis>();
  165   LegacyDivergenceAnalysis &DA = getAnalysis<LegacyDivergenceAnalysis>();

lib/Target/AMDGPU/SIAnnotateControlFlow.cpp

   56   LegacyDivergenceAnalysis *DA;
  117     AU.addRequired<LegacyDivergenceAnalysis>();
  324   DA = &getAnalysis<LegacyDivergenceAnalysis>();

lib/Target/AMDGPU/SIISelLowering.cpp

10826   FunctionLoweringInfo * FLI, LegacyDivergenceAnalysis * KDA) const

lib/Target/AMDGPU/SIISelLowering.h

  387     FunctionLoweringInfo *FLI, LegacyDivergenceAnalysis *DA) const override;

lib/Transforms/Scalar/LoopUnswitch.cpp

  226         AU.addRequired<LegacyDivergenceAnalysis>();
  892       getAnalysis<LegacyDivergenceAnalysis>().isDivergent(LoopCond)) {

lib/Transforms/Scalar/StructurizeCFG.cpp

  191   LegacyDivergenceAnalysis *DA;
  277       AU.addRequired<LegacyDivergenceAnalysis>();
  940                                    const LegacyDivergenceAnalysis &DA) {
 1010     DA = &getAnalysis<LegacyDivergenceAnalysis>();