LoopsInRegionAnalysis.h

//===- llvm/Analysis/LoopsInRegionAnalysis.h --------------- -*- C++ -*---===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// LoopInRegionAnalysis is a analysis pass that mapping a region to the loops
// that contained in that region
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_ANALYSIS_LOOPS_IN_REGION_ANALYSIS_H
#define LLVM_ANALYSIS_LOOPS_IN_REGION_ANALYSIS_H

#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/RegionInfo.h"
#include "llvm/Analysis/RegionIterator.h"

#include "llvm/Analysis/RegionPass.h" // for polly filter


#include <map>

namespace llvm {

class LoopsInRegionAnalysis : public FunctionPass {
  //map the region to its containing loops
  std::multimap<Region*, Loop*> RMap;

public:
  static char ID;
  explicit LoopsInRegionAnalysis() : FunctionPass(&ID){}

  virtual void releaseMemory() {
    RMap.clear();
  }

  typedef std::multimap<Region*, Loop*>::iterator iterator;
  typedef std::multimap<Region*, Loop*>::const_iterator const_iterator;

  iterator begin(Region* R) { return RMap.lower_bound(R); }
  iterator end(Region* R)   { return RMap.upper_bound(R); }

  const_iterator begin(Region* R) const { return RMap.lower_bound(R); }
  const_iterator end(Region* R) const   { return RMap.upper_bound(R); }

  virtual bool runOnFunction(Function &F) {
    LoopInfo &LI = getAnalysis<LoopInfo>();

    for (LoopInfo::iterator I = LI.begin(), E = LI.end(); I != E; ++I)
      runOnLoop(*I);

    return false;
  }

  void runOnLoop(Loop *L);

  virtual const char *getPassName() const {
    return "'LoopsInRegionAnalysisPass' Printer";
  }

  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
    // we need the loopinfo and regioninfo to set up the map
    AU.addRequired<LoopInfo>();
    AU.addRequired<RegionInfo>();
    // this pass will change nothing
    AU.setPreservesAll();
  }

  void verifyMap(Loop *L, Region *R) const;

  virtual void print(raw_ostream &OS, const Module *) const {
    for (std::multimap<Region*, Loop*>::const_iterator I = RMap.begin(),
      E = RMap.end(); I != E; ++I)
      OS << I->first->getName() << " -> "
         << I->second->getHeader()->getName() << "\n";

    OS << "End\n";
  }

  virtual void verifyAnalysis() const {
    for (std::multimap<Region*, Loop*>::const_iterator I = RMap.begin(),
      E = RMap.end(); I != E; ++I)
      verifyMap(I->second, I->first);
  }
};
//===--------------------------------------------------------------------===//
//
// createLIRAnalysisPass - This pass setups a map that mapping the smallest
// region to the loops that containing by it.
//
FunctionPass* createLIRAnalysisPass();

//===----------------------------------------------------------------------===//

struct PollyFilter : RegionPass {
  static char ID;

  explicit PollyFilter() : RegionPass(&ID) {}

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

  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
    AU.addRequired<LoopsInRegionAnalysis>();
    AU.setPreservesCFG();
  }

};



} //end namespace llvm

#endif

---