← Back to branch summary

~ubuntu-branches/ubuntu/quantal/llvm-3.1/quantal

« back to all changes in this revision

Viewing changes to lib/Transforms/Utils/Mem2Reg.cpp

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2012-03-29 19:09:51 UTC
  • Revision ID: package-import@ubuntu.com-20120329190951-aq83ivog4cg8bxun
Tags: upstream-3.1~svn153643
Import upstream version 3.1~svn153643

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/Transforms/Utils/Mem2Reg.cpp
 
1
//===- Mem2Reg.cpp - The -mem2reg pass, a wrapper around the Utils lib ----===//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
// This pass is a simple pass wrapper around the PromoteMemToReg function call
 
11
// exposed by the Utils library.
 
12
//
 
13
//===----------------------------------------------------------------------===//
 
14
 
 
15
#define DEBUG_TYPE "mem2reg"
 
16
#include "llvm/Transforms/Scalar.h"
 
17
#include "llvm/Transforms/Utils/PromoteMemToReg.h"
 
18
#include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
 
19
#include "llvm/Analysis/Dominators.h"
 
20
#include "llvm/Instructions.h"
 
21
#include "llvm/Function.h"
 
22
#include "llvm/ADT/Statistic.h"
 
23
using namespace llvm;
 
24
 
 
25
STATISTIC(NumPromoted, "Number of alloca's promoted");
 
26
 
 
27
namespace {
 
28
  struct PromotePass : public FunctionPass {
 
29
    static char ID; // Pass identification, replacement for typeid
 
30
    PromotePass() : FunctionPass(ID) {
 
31
      initializePromotePassPass(*PassRegistry::getPassRegistry());
 
32
    }
 
33
 
 
34
    // runOnFunction - To run this pass, first we calculate the alloca
 
35
    // instructions that are safe for promotion, then we promote each one.
 
36
    //
 
37
    virtual bool runOnFunction(Function &F);
 
38
 
 
39
    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 
40
      AU.addRequired<DominatorTree>();
 
41
      AU.setPreservesCFG();
 
42
      // This is a cluster of orthogonal Transforms
 
43
      AU.addPreserved<UnifyFunctionExitNodes>();
 
44
      AU.addPreservedID(LowerSwitchID);
 
45
      AU.addPreservedID(LowerInvokePassID);
 
46
    }
 
47
  };
 
48
}  // end of anonymous namespace
 
49
 
 
50
char PromotePass::ID = 0;
 
51
INITIALIZE_PASS_BEGIN(PromotePass, "mem2reg", "Promote Memory to Register",
 
52
                false, false)
 
53
INITIALIZE_PASS_DEPENDENCY(DominatorTree)
 
54
INITIALIZE_PASS_END(PromotePass, "mem2reg", "Promote Memory to Register",
 
55
                false, false)
 
56
 
 
57
bool PromotePass::runOnFunction(Function &F) {
 
58
  std::vector<AllocaInst*> Allocas;
 
59
 
 
60
  BasicBlock &BB = F.getEntryBlock();  // Get the entry node for the function
 
61
 
 
62
  bool Changed  = false;
 
63
 
 
64
  DominatorTree &DT = getAnalysis<DominatorTree>();
 
65
 
 
66
  while (1) {
 
67
    Allocas.clear();
 
68
 
 
69
    // Find allocas that are safe to promote, by looking at all instructions in
 
70
    // the entry node
 
71
    for (BasicBlock::iterator I = BB.begin(), E = --BB.end(); I != E; ++I)
 
72
      if (AllocaInst *AI = dyn_cast<AllocaInst>(I))       // Is it an alloca?
 
73
        if (isAllocaPromotable(AI))
 
74
          Allocas.push_back(AI);
 
75
 
 
76
    if (Allocas.empty()) break;
 
77
 
 
78
    PromoteMemToReg(Allocas, DT);
 
79
    NumPromoted += Allocas.size();
 
80
    Changed = true;
 
81
  }
 
82
 
 
83
  return Changed;
 
84
}
 
85
 
 
86
// createPromoteMemoryToRegister - Provide an entry point to create this pass.
 
87
//
 
88
FunctionPass *llvm::createPromoteMemoryToRegisterPass() {
 
89
  return new PromotePass();
 
90
}