RegionPass.h

//===- RegionPass.h - RegionPass class ------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines RegionPass class. All region based analysis optimization
// and transformation passes are derived from RegionPass.
// most of these codes are COPY from LoopPass.h
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_REGION_PASS_H
#define LLVM_REGION_PASS_H

#include "llvm/Analysis/RegionInfo.h"

#include "llvm/Pass.h"
#include "llvm/PassManagers.h"
#include "llvm/Function.h"

namespace llvm {

class RGPassManager;
class Function;
class PMStack;

class RegionPass : public Pass {
public:
  explicit RegionPass(intptr_t pid) : Pass(PT_Region, pid) {}
  explicit RegionPass(void *pid) : Pass(PT_Region, pid) {}

  virtual bool runOnRegion(Region *R, RGPassManager &RGM) = 0;

  virtual bool doInitialization(Region *R, RGPassManager &RGM) {
    return false;
  }

  virtual bool doFinalization() { return false; }

  void preparePassManager(PMStack &PMS);

  virtual void assignPassManager(PMStack &PMS,
    PassManagerType PMT = PMT_RegionPassManager);

  virtual PassManagerType getPotentialPassManagerType() const {
    return PMT_RegionPassManager;
  }

  //===--------------------------------------------------------------------===//
  // SimpleAnalysis - Provides simple interface to update analysis info
  // maintained by various passes. Note, if required this interface can
  // be extracted into a separate abstract class but it would require
  // additional use of multiple inheritance in Pass class hierarchy, something
  // we are trying to avoid.

  virtual void cloneBasicBlockAnalysis(BasicBlock *F, BasicBlock *T,
                                       Region *R) {}

  virtual void deleteAnalysisValue(Value *V, Region *R) {}
};

class RGPassManager : public FunctionPass, public PMDataManager {
public:
  static char ID;
  explicit RGPassManager(int Depth);

  bool runOnFunction(Function &F);

  void getAnalysisUsage(AnalysisUsage &Info) const;

  virtual const char *getPassName() const {
    return "Region Pass Manager";
  }

  virtual PMDataManager *getAsPMDataManager() { return this; }
  virtual Pass *getAsPass() { return this; }

  void dumpPassStructure(unsigned Offset);

  Pass *getContainedPass(unsigned N) {
    assert(N < PassVector.size() && "Pass number out of range!");
    Pass *FP = static_cast<Pass *>(PassVector[N]);
    return FP;
  }

  virtual PassManagerType getPassManagerType() const {
    return PMT_RegionPassManager;
  }

public:
  void deleteRegionFromQueue(Region *R);

  void deleteRegionAndParentsFromQueue(Region *R);

  void insertRegion(Region *R, Region *ParentRegion);

  void insertRegionIntoQueue(Region *R);

  void redoRegion(Region *R);


  //===--------------------------------------------------------------------===//
  // SimpleAnalysis - Provides simple interface to update analysis info
  // maintained by various passes. Note, if required this interface can be
  // extracted into a separate abstract class but it would require additional
  // use of multiple inheritance in Pass class hierarchy, something we are
  // trying to avoid.

  void cloneBasicBlockSimpleAnalysis(BasicBlock *From, BasicBlock *To,
                                     Region *R);

  void deleteSimpleAnalysisValue(Value *V, Region *R);

private:
  std::deque<Region *> RQ;
  bool skipThisRegion;
  bool redoThisRegion;
  RegionInfo *RI;
  Region *CurrentRegion;
};

} // End llvm namespace

#endif

---