Write pass

/// FunctionPass class - This class is used to implement most global
/// optimizations.  Optimizations should subclass this class if they meet the
/// following constraints:
///
///  1. Optimizations are organized globally, i.e., a function at a time
///  2. Optimizing a function does not cause the addition or removal of any
///     functions in the module
///
class FunctionPass : public Pass

//===----------------------------------------------------------------------===//
/// ModulePass class - This class is used to implement unstructured
/// interprocedural optimizations and analyses.  ModulePasses may do anything
/// they want to the program.
///
class ModulePass : public Pass


class LoopPass : public Pass 
class MachineFunctionPass : public FunctionPass

/// ImmutablePass class - This class is used to provide information that does
/// not need to be run.  This is useful for things like target information and
/// "basic" versions of AnalysisGroups.
///
class ImmutablePass : public ModulePass {

 #define INITIALIZE_PASS(MyPassName, arg, name, cfg, analysis)     # 使用宏来生成 initializeMyPassNamePass

LiveVariables *LV = getAnalysisIfAvailable<LiveVariables>();

970 INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
 971 INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfo)
 972 INITIALIZE_PASS_END(EarlyIfPredicator, DEBUG_TYPE, "Early If Predicator", false,
 973                     false)
 974
 975 void EarlyIfPredicator::getAnalysisUsage(AnalysisUsage &AU) const {
 976   AU.addRequired<MachineBranchProbabilityInfo>();
 977   AU.addRequired<MachineDominatorTree>();
 978   AU.addPreserved<MachineDominatorTree>();
 979   AU.addRequired<MachineLoopInfo>();
 980   AU.addPreserved<MachineLoopInfo>();
 981   MachineFunctionPass::getAnalysisUsage(AU);
 982 }


1038 bool EarlyIfPredicator::runOnMachineFunction(MachineFunction &MF) {

1050   Loops = getAnalysisIfAvailable<MachineLoopInfo>();
1051   MBPI = &getAnalysis<MachineBranchProbabilityInfo>();
}

getAnalysisIfAvailable 一般用于已经有了，则进行更新

AU.addPreserved<LiveVariables>();

131 INITIALIZE_PASS_BEGIN(PHIElimination, DEBUG_TYPE,
132                       "Eliminate PHI nodes for register allocation",
133                       false, false)
134 INITIALIZE_PASS_DEPENDENCY(LiveVariables)
135 INITIALIZE_PASS_END(PHIElimination, DEBUG_TYPE,
136                     "Eliminate PHI nodes for register allocation", false, false)
137
138 void PHIElimination::getAnalysisUsage(AnalysisUsage &AU) const {
139 //  AU.addUsedIfAvailable<LiveVariables>();
140   AU.addRequired<LiveVariables>();
141   AU.addPreserved<LiveVariables>();
142 //  AU.addPreserved<SlotIndexes>();
143   AU.addPreserved<LiveIntervals>();
144   AU.addPreserved<MachineDominatorTree>();
145   AU.addPreserved<MachineLoopInfo>();
146   MachineFunctionPass::getAnalysisUsage(AU);
147 }
148

  template<class PassClass>
  AnalysisUsage &addUsedIfAvailable() {
    Used.push_back(&PassClass::ID);
    return *this;
  }

  /// Sets of analyses required and preserved by a pass
  // TODO: It's not clear that SmallVector is an appropriate data structure for
  // this usecase.  The sizes were picked to minimize wasted space, but are
  // otherwise fairly meaningless.
  SmallVector<AnalysisID, 8> Required;
  SmallVector<AnalysisID, 2> RequiredTransitive;
  SmallVector<AnalysisID, 2> Preserved;
  SmallVector<AnalysisID, 0> Used

      ProfileVec(AU.getRequiredSet());
      ProfileVec(AU.getRequiredTransitiveSet());
      ProfileVec(AU.getPreservedSet());
      ProfileVec(AU.getUsedSet());


    // Return true if P preserves high level analysis used by other
// passes managed by this manager
bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) {
  AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P);
  if (AnUsage->getPreservesAll())
    return true;

  const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet();
  for (Pass *P1 : HigherLevelAnalysis) {
    if (P1->getAsImmutablePass() == nullptr &&
        !is_contained(PreservedSet, P1->getPassID()))
      return false;
  }

  return true;
}

 375 //      LiveVars = PASS->getAnalysisIfAvailable<LiveVariables>();
 376       LiveVars = &PASS->getAnalysis<LiveVariables>();

 286     void getAnalysisUsage(AnalysisUsage &AU) const override {
 287       AU.setPreservesAll();
 288       AU.addRequired<LiveVariables>();
 289       MachineFunctionPass::getAnalysisUsage(AU);
          }

138 void PHIElimination::getAnalysisUsage(AnalysisUsage &AU) const {
139   AU.addUsedIfAvailable<LiveVariables>();
140 //  AU.addRequired<LiveVariables>();
141   AU.addPreserved<LiveVariables>();
147 }
148
149 bool PHIElimination::runOnMachineFunction(MachineFunction &MF) {
151   LV = getAnalysisIfAvailable<LiveVariables>();
152   if (LV)
153     dbgs() << __LINE__ << " zhangkang LV is not empty.\n";
154   else
155     dbgs() << __LINE__ << " zhangkang LV is empty.\n";