← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/Transforms/Scalar/Reg2Mem.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/Transforms/Scalar/Reg2Mem.cpp
 
1
//===- Reg2Mem.cpp - Convert registers to allocas -------------------------===//
 
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 file demotes all registers to memory references.  It is intented to be
 
11
// the inverse of PromoteMemoryToRegister.  By converting to loads, the only
 
12
// values live accross basic blocks are allocas and loads before phi nodes.
 
13
// It is intended that this should make CFG hacking much easier.
 
14
// To make later hacking easier, the entry block is split into two, such that
 
15
// all introduced allocas and nothing else are in the entry block.
 
16
//
 
17
//===----------------------------------------------------------------------===//
 
18
 
 
19
#define DEBUG_TYPE "reg2mem"
 
20
#include "llvm/Transforms/Scalar.h"
 
21
#include "llvm/Transforms/Utils/Local.h"
 
22
#include "llvm/Pass.h"
 
23
#include "llvm/Function.h"
 
24
#include "llvm/LLVMContext.h"
 
25
#include "llvm/Module.h"
 
26
#include "llvm/BasicBlock.h"
 
27
#include "llvm/Instructions.h"
 
28
#include "llvm/ADT/Statistic.h"
 
29
#include "llvm/Support/CFG.h"
 
30
#include <list>
 
31
using namespace llvm;
 
32
 
 
33
STATISTIC(NumRegsDemoted, "Number of registers demoted");
 
34
STATISTIC(NumPhisDemoted, "Number of phi-nodes demoted");
 
35
 
 
36
namespace {
 
37
  struct RegToMem : public FunctionPass {
 
38
    static char ID; // Pass identification, replacement for typeid
 
39
    RegToMem() : FunctionPass(&ID) {}
 
40
 
 
41
    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 
42
      AU.addRequiredID(BreakCriticalEdgesID);
 
43
      AU.addPreservedID(BreakCriticalEdgesID);
 
44
    }
 
45
 
 
46
   bool valueEscapes(const Instruction *Inst) const {
 
47
     const BasicBlock *BB = Inst->getParent();
 
48
      for (Value::use_const_iterator UI = Inst->use_begin(),E = Inst->use_end();
 
49
           UI != E; ++UI)
 
50
        if (cast<Instruction>(*UI)->getParent() != BB ||
 
51
            isa<PHINode>(*UI))
 
52
          return true;
 
53
      return false;
 
54
    }
 
55
 
 
56
    virtual bool runOnFunction(Function &F);
 
57
  };
 
58
}
 
59
  
 
60
char RegToMem::ID = 0;
 
61
static RegisterPass<RegToMem>
 
62
X("reg2mem", "Demote all values to stack slots");
 
63
 
 
64
 
 
65
bool RegToMem::runOnFunction(Function &F) {
 
66
  if (F.isDeclaration()) 
 
67
    return false;
 
68
  
 
69
  // Insert all new allocas into entry block.
 
70
  BasicBlock *BBEntry = &F.getEntryBlock();
 
71
  assert(pred_begin(BBEntry) == pred_end(BBEntry) &&
 
72
         "Entry block to function must not have predecessors!");
 
73
  
 
74
  // Find first non-alloca instruction and create insertion point. This is
 
75
  // safe if block is well-formed: it always have terminator, otherwise
 
76
  // we'll get and assertion.
 
77
  BasicBlock::iterator I = BBEntry->begin();
 
78
  while (isa<AllocaInst>(I)) ++I;
 
79
  
 
80
  CastInst *AllocaInsertionPoint =
 
81
    new BitCastInst(Constant::getNullValue(Type::getInt32Ty(F.getContext())),
 
82
                    Type::getInt32Ty(F.getContext()),
 
83
                    "reg2mem alloca point", I);
 
84
  
 
85
  // Find the escaped instructions. But don't create stack slots for
 
86
  // allocas in entry block.
 
87
  std::list<Instruction*> WorkList;
 
88
  for (Function::iterator ibb = F.begin(), ibe = F.end();
 
89
       ibb != ibe; ++ibb)
 
90
    for (BasicBlock::iterator iib = ibb->begin(), iie = ibb->end();
 
91
         iib != iie; ++iib) {
 
92
      if (!(isa<AllocaInst>(iib) && iib->getParent() == BBEntry) &&
 
93
          valueEscapes(iib)) {
 
94
        WorkList.push_front(&*iib);
 
95
      }
 
96
    }
 
97
  
 
98
  // Demote escaped instructions
 
99
  NumRegsDemoted += WorkList.size();
 
100
  for (std::list<Instruction*>::iterator ilb = WorkList.begin(), 
 
101
       ile = WorkList.end(); ilb != ile; ++ilb)
 
102
    DemoteRegToStack(**ilb, false, AllocaInsertionPoint);
 
103
  
 
104
  WorkList.clear();
 
105
  
 
106
  // Find all phi's
 
107
  for (Function::iterator ibb = F.begin(), ibe = F.end();
 
108
       ibb != ibe; ++ibb)
 
109
    for (BasicBlock::iterator iib = ibb->begin(), iie = ibb->end();
 
110
         iib != iie; ++iib)
 
111
      if (isa<PHINode>(iib))
 
112
        WorkList.push_front(&*iib);
 
113
  
 
114
  // Demote phi nodes
 
115
  NumPhisDemoted += WorkList.size();
 
116
  for (std::list<Instruction*>::iterator ilb = WorkList.begin(), 
 
117
       ile = WorkList.end(); ilb != ile; ++ilb)
 
118
    DemotePHIToStack(cast<PHINode>(*ilb), AllocaInsertionPoint);
 
119
  
 
120
  return true;
 
121
}
 
122
 
 
123
 
 
124
// createDemoteRegisterToMemory - Provide an entry point to create this pass.
 
125
//
 
126
const PassInfo *const llvm::DemoteRegisterToMemoryID = &X;
 
127
FunctionPass *llvm::createDemoteRegisterToMemoryPass() {
 
128
  return new RegToMem();
 
129
}