← 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/CodeGen/GCMetadata.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/CodeGen/GCMetadata.cpp
 
1
//===-- GCMetadata.cpp - Garbage collector metadata -----------------------===//
 
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 implements the GCFunctionInfo class and GCModuleInfo pass.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#include "llvm/CodeGen/GCMetadata.h"
 
15
#include "llvm/CodeGen/GCStrategy.h"
 
16
#include "llvm/CodeGen/MachineFrameInfo.h"
 
17
#include "llvm/Pass.h"
 
18
#include "llvm/CodeGen/Passes.h"
 
19
#include "llvm/Function.h"
 
20
#include "llvm/Support/Debug.h"
 
21
#include "llvm/Support/ErrorHandling.h"
 
22
#include "llvm/Support/raw_ostream.h"
 
23
using namespace llvm;
 
24
 
 
25
namespace {
 
26
  
 
27
  class Printer : public FunctionPass {
 
28
    static char ID;
 
29
    raw_ostream &OS;
 
30
    
 
31
  public:
 
32
    Printer() : FunctionPass(&ID), OS(errs()) {}
 
33
    explicit Printer(raw_ostream &OS) : FunctionPass(&ID), OS(OS) {}
 
34
 
 
35
    
 
36
    const char *getPassName() const;
 
37
    void getAnalysisUsage(AnalysisUsage &AU) const;
 
38
    
 
39
    bool runOnFunction(Function &F);
 
40
  };
 
41
  
 
42
  class Deleter : public FunctionPass {
 
43
    static char ID;
 
44
    
 
45
  public:
 
46
    Deleter();
 
47
    
 
48
    const char *getPassName() const;
 
49
    void getAnalysisUsage(AnalysisUsage &AU) const;
 
50
    
 
51
    bool runOnFunction(Function &F);
 
52
    bool doFinalization(Module &M);
 
53
  };
 
54
  
 
55
}
 
56
 
 
57
static RegisterPass<GCModuleInfo>
 
58
X("collector-metadata", "Create Garbage Collector Module Metadata");
 
59
 
 
60
// -----------------------------------------------------------------------------
 
61
 
 
62
GCFunctionInfo::GCFunctionInfo(const Function &F, GCStrategy &S)
 
63
  : F(F), S(S), FrameSize(~0LL) {}
 
64
 
 
65
GCFunctionInfo::~GCFunctionInfo() {}
 
66
 
 
67
// -----------------------------------------------------------------------------
 
68
 
 
69
char GCModuleInfo::ID = 0;
 
70
 
 
71
GCModuleInfo::GCModuleInfo()
 
72
  : ImmutablePass(&ID) {}
 
73
 
 
74
GCModuleInfo::~GCModuleInfo() {
 
75
  clear();
 
76
}
 
77
 
 
78
GCStrategy *GCModuleInfo::getOrCreateStrategy(const Module *M,
 
79
                                              const std::string &Name) {
 
80
  strategy_map_type::iterator NMI = StrategyMap.find(Name);
 
81
  if (NMI != StrategyMap.end())
 
82
    return NMI->getValue();
 
83
  
 
84
  for (GCRegistry::iterator I = GCRegistry::begin(),
 
85
                            E = GCRegistry::end(); I != E; ++I) {
 
86
    if (Name == I->getName()) {
 
87
      GCStrategy *S = I->instantiate();
 
88
      S->M = M;
 
89
      S->Name = Name;
 
90
      StrategyMap.GetOrCreateValue(Name).setValue(S);
 
91
      StrategyList.push_back(S);
 
92
      return S;
 
93
    }
 
94
  }
 
95
 
 
96
  dbgs() << "unsupported GC: " << Name << "\n";
 
97
  llvm_unreachable(0);
 
98
}
 
99
 
 
100
GCFunctionInfo &GCModuleInfo::getFunctionInfo(const Function &F) {
 
101
  assert(!F.isDeclaration() && "Can only get GCFunctionInfo for a definition!");
 
102
  assert(F.hasGC());
 
103
  
 
104
  finfo_map_type::iterator I = FInfoMap.find(&F);
 
105
  if (I != FInfoMap.end())
 
106
    return *I->second;
 
107
  
 
108
  GCStrategy *S = getOrCreateStrategy(F.getParent(), F.getGC());
 
109
  GCFunctionInfo *GFI = S->insertFunctionInfo(F);
 
110
  FInfoMap[&F] = GFI;
 
111
  return *GFI;
 
112
}
 
113
 
 
114
void GCModuleInfo::clear() {
 
115
  FInfoMap.clear();
 
116
  StrategyMap.clear();
 
117
  
 
118
  for (iterator I = begin(), E = end(); I != E; ++I)
 
119
    delete *I;
 
120
  StrategyList.clear();
 
121
}
 
122
 
 
123
// -----------------------------------------------------------------------------
 
124
 
 
125
char Printer::ID = 0;
 
126
 
 
127
FunctionPass *llvm::createGCInfoPrinter(raw_ostream &OS) {
 
128
  return new Printer(OS);
 
129
}
 
130
 
 
131
 
 
132
const char *Printer::getPassName() const {
 
133
  return "Print Garbage Collector Information";
 
134
}
 
135
 
 
136
void Printer::getAnalysisUsage(AnalysisUsage &AU) const {
 
137
  FunctionPass::getAnalysisUsage(AU);
 
138
  AU.setPreservesAll();
 
139
  AU.addRequired<GCModuleInfo>();
 
140
}
 
141
 
 
142
static const char *DescKind(GC::PointKind Kind) {
 
143
  switch (Kind) {
 
144
    default: llvm_unreachable("Unknown GC point kind");
 
145
    case GC::Loop:     return "loop";
 
146
    case GC::Return:   return "return";
 
147
    case GC::PreCall:  return "pre-call";
 
148
    case GC::PostCall: return "post-call";
 
149
  }
 
150
}
 
151
 
 
152
bool Printer::runOnFunction(Function &F) {
 
153
  if (!F.hasGC()) {
 
154
    GCFunctionInfo *FD = &getAnalysis<GCModuleInfo>().getFunctionInfo(F);
 
155
    
 
156
    OS << "GC roots for " << FD->getFunction().getNameStr() << ":\n";
 
157
    for (GCFunctionInfo::roots_iterator RI = FD->roots_begin(),
 
158
                                        RE = FD->roots_end(); RI != RE; ++RI)
 
159
      OS << "\t" << RI->Num << "\t" << RI->StackOffset << "[sp]\n";
 
160
    
 
161
    OS << "GC safe points for " << FD->getFunction().getNameStr() << ":\n";
 
162
    for (GCFunctionInfo::iterator PI = FD->begin(),
 
163
                                  PE = FD->end(); PI != PE; ++PI) {
 
164
      
 
165
      OS << "\tlabel " << PI->Num << ": " << DescKind(PI->Kind) << ", live = {";
 
166
      
 
167
      for (GCFunctionInfo::live_iterator RI = FD->live_begin(PI),
 
168
                                         RE = FD->live_end(PI);;) {
 
169
        OS << " " << RI->Num;
 
170
        if (++RI == RE)
 
171
          break;
 
172
        OS << ",";
 
173
      }
 
174
      
 
175
      OS << " }\n";
 
176
    }
 
177
  }
 
178
  
 
179
  return false;
 
180
}
 
181
 
 
182
// -----------------------------------------------------------------------------
 
183
 
 
184
char Deleter::ID = 0;
 
185
 
 
186
FunctionPass *llvm::createGCInfoDeleter() {
 
187
  return new Deleter();
 
188
}
 
189
 
 
190
Deleter::Deleter() : FunctionPass(&ID) {}
 
191
 
 
192
const char *Deleter::getPassName() const {
 
193
  return "Delete Garbage Collector Information";
 
194
}
 
195
 
 
196
void Deleter::getAnalysisUsage(AnalysisUsage &AU) const {
 
197
  AU.setPreservesAll();
 
198
  AU.addRequired<GCModuleInfo>();
 
199
}
 
200
 
 
201
bool Deleter::runOnFunction(Function &MF) {
 
202
  return false;
 
203
}
 
204
 
 
205
bool Deleter::doFinalization(Module &M) {
 
206
  GCModuleInfo *GMI = getAnalysisIfAvailable<GCModuleInfo>();
 
207
  assert(GMI && "Deleter didn't require GCModuleInfo?!");
 
208
  GMI->clear();
 
209
  return false;
 
210
}