← 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/Utils/CloneModule.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/Utils/CloneModule.cpp
 
1
//===- CloneModule.cpp - Clone an entire module ---------------------------===//
 
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 CloneModule interface which makes a copy of an
 
11
// entire module.
 
12
//
 
13
//===----------------------------------------------------------------------===//
 
14
 
 
15
#include "llvm/Transforms/Utils/Cloning.h"
 
16
#include "llvm/Module.h"
 
17
#include "llvm/DerivedTypes.h"
 
18
#include "llvm/TypeSymbolTable.h"
 
19
#include "llvm/Constant.h"
 
20
#include "llvm/Transforms/Utils/ValueMapper.h"
 
21
using namespace llvm;
 
22
 
 
23
/// CloneModule - Return an exact copy of the specified module.  This is not as
 
24
/// easy as it might seem because we have to worry about making copies of global
 
25
/// variables and functions, and making their (initializers and references,
 
26
/// respectively) refer to the right globals.
 
27
///
 
28
Module *llvm::CloneModule(const Module *M) {
 
29
  // Create the value map that maps things from the old module over to the new
 
30
  // module.
 
31
  DenseMap<const Value*, Value*> ValueMap;
 
32
  return CloneModule(M, ValueMap);
 
33
}
 
34
 
 
35
Module *llvm::CloneModule(const Module *M,
 
36
                          DenseMap<const Value*, Value*> &ValueMap) {
 
37
  // First off, we need to create the new module...
 
38
  Module *New = new Module(M->getModuleIdentifier(), M->getContext());
 
39
  New->setDataLayout(M->getDataLayout());
 
40
  New->setTargetTriple(M->getTargetTriple());
 
41
  New->setModuleInlineAsm(M->getModuleInlineAsm());
 
42
 
 
43
  // Copy all of the type symbol table entries over.
 
44
  const TypeSymbolTable &TST = M->getTypeSymbolTable();
 
45
  for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end(); 
 
46
       TI != TE; ++TI)
 
47
    New->addTypeName(TI->first, TI->second);
 
48
  
 
49
  // Copy all of the dependent libraries over.
 
50
  for (Module::lib_iterator I = M->lib_begin(), E = M->lib_end(); I != E; ++I)
 
51
    New->addLibrary(*I);
 
52
 
 
53
  // Loop over all of the global variables, making corresponding globals in the
 
54
  // new module.  Here we add them to the ValueMap and to the new Module.  We
 
55
  // don't worry about attributes or initializers, they will come later.
 
56
  //
 
57
  for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
 
58
       I != E; ++I) {
 
59
    GlobalVariable *GV = new GlobalVariable(*New, 
 
60
                                            I->getType()->getElementType(),
 
61
                                            false,
 
62
                                            GlobalValue::ExternalLinkage, 0,
 
63
                                            I->getName());
 
64
    GV->setAlignment(I->getAlignment());
 
65
    ValueMap[I] = GV;
 
66
  }
 
67
 
 
68
  // Loop over the functions in the module, making external functions as before
 
69
  for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) {
 
70
    Function *NF =
 
71
      Function::Create(cast<FunctionType>(I->getType()->getElementType()),
 
72
                       GlobalValue::ExternalLinkage, I->getName(), New);
 
73
    NF->copyAttributesFrom(I);
 
74
    ValueMap[I] = NF;
 
75
  }
 
76
 
 
77
  // Loop over the aliases in the module
 
78
  for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
 
79
       I != E; ++I)
 
80
    ValueMap[I] = new GlobalAlias(I->getType(), GlobalAlias::ExternalLinkage,
 
81
                                  I->getName(), NULL, New);
 
82
  
 
83
  // Now that all of the things that global variable initializer can refer to
 
84
  // have been created, loop through and copy the global variable referrers
 
85
  // over...  We also set the attributes on the global now.
 
86
  //
 
87
  for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
 
88
       I != E; ++I) {
 
89
    GlobalVariable *GV = cast<GlobalVariable>(ValueMap[I]);
 
90
    if (I->hasInitializer())
 
91
      GV->setInitializer(cast<Constant>(MapValue(I->getInitializer(),
 
92
                                                 ValueMap)));
 
93
    GV->setLinkage(I->getLinkage());
 
94
    GV->setThreadLocal(I->isThreadLocal());
 
95
    GV->setConstant(I->isConstant());
 
96
  }
 
97
 
 
98
  // Similarly, copy over function bodies now...
 
99
  //
 
100
  for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) {
 
101
    Function *F = cast<Function>(ValueMap[I]);
 
102
    if (!I->isDeclaration()) {
 
103
      Function::arg_iterator DestI = F->arg_begin();
 
104
      for (Function::const_arg_iterator J = I->arg_begin(); J != I->arg_end();
 
105
           ++J) {
 
106
        DestI->setName(J->getName());
 
107
        ValueMap[J] = DestI++;
 
108
      }
 
109
 
 
110
      SmallVector<ReturnInst*, 8> Returns;  // Ignore returns cloned.
 
111
      CloneFunctionInto(F, I, ValueMap, Returns);
 
112
    }
 
113
 
 
114
    F->setLinkage(I->getLinkage());
 
115
  }
 
116
 
 
117
  // And aliases
 
118
  for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
 
119
       I != E; ++I) {
 
120
    GlobalAlias *GA = cast<GlobalAlias>(ValueMap[I]);
 
121
    GA->setLinkage(I->getLinkage());
 
122
    if (const Constant* C = I->getAliasee())
 
123
      GA->setAliasee(cast<Constant>(MapValue(C, ValueMap)));
 
124
  }
 
125
  
 
126
  return New;
 
127
}