← Back to branch summary

~ubuntu-branches/debian/sid/clamav/sid

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/Support/TargetFolder.h

  • Committer: Package Import Robot
  • Author(s): Andreas Cadhalpun, Andreas Cadhalpun, Sebastian Andrzej Siewior, Frans Spiesschaert
  • Date: 2014-10-15 06:50:20 UTC
  • mfrom: (1.3.13) (42.1.4 experimental)
  • Revision ID: package-import@ubuntu.com-20141015065020-0cpy1hdueggaw35s
Tags: 0.98.5~rc1+dfsg-1
http://bugs.debian.org/763634
[ Andreas Cadhalpun ]
* Import new upstream release candidate.
* Drop patches included upstream and update the others.
* Add 4 new symbols to libclamav6.symbols.
* Fix debian/copyright.
* Update lintian overrides.
* Update Standards-Version to 3.9.6 (no changes needed).
* Add Breaks and Replaces for old clamd package to clamdscan.
* Remove unnecessary shlibs:Depends from clamav-dbg.
* Add patches to support LLVM 3.5.

[ Sebastian Andrzej Siewior ]
* Add embedded copy of libmspack to be used as fallback, when libmspack-dev
  is not available.

[ Frans Spiesschaert ]
* Updated Dutch Debconf template translation (Closes: #763634)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/Support/TargetFolder.h
1
 
//====-- llvm/Support/TargetFolder.h - Constant folding helper -*- C++ -*-====//
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 defines the TargetFolder class, a helper for IRBuilder.
11
 
// It provides IRBuilder with a set of methods for creating constants with
12
 
// target dependent folding, in addition to the same target-independent
13
 
// folding that the ConstantFolder class provides.  For general constant
14
 
// creation and folding, use ConstantExpr and the routines in
15
 
// llvm/Analysis/ConstantFolding.h.
16
 
//
17
 
//===----------------------------------------------------------------------===//
18
 
 
19
 
#ifndef LLVM_SUPPORT_TARGETFOLDER_H
20
 
#define LLVM_SUPPORT_TARGETFOLDER_H
21
 
 
22
 
#include "llvm/Constants.h"
23
 
#include "llvm/InstrTypes.h"
24
 
#include "llvm/Analysis/ConstantFolding.h"
25
 
 
26
 
namespace llvm {
27
 
 
28
 
class TargetData;
29
 
 
30
 
/// TargetFolder - Create constants with target dependent folding.
31
 
class TargetFolder {
32
 
  const TargetData *TD;
33
 
 
34
 
  /// Fold - Fold the constant using target specific information.
35
 
  Constant *Fold(Constant *C) const {
36
 
    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
37
 
      if (Constant *CF = ConstantFoldConstantExpression(CE, TD))
38
 
        return CF;
39
 
    return C;
40
 
  }
41
 
 
42
 
public:
43
 
  explicit TargetFolder(const TargetData *TheTD) : TD(TheTD) {}
44
 
 
45
 
  //===--------------------------------------------------------------------===//
46
 
  // Binary Operators
47
 
  //===--------------------------------------------------------------------===//
48
 
 
49
 
  Constant *CreateAdd(Constant *LHS, Constant *RHS) const {
50
 
    return Fold(ConstantExpr::getAdd(LHS, RHS));
51
 
  }
52
 
  Constant *CreateNSWAdd(Constant *LHS, Constant *RHS) const {
53
 
    return Fold(ConstantExpr::getNSWAdd(LHS, RHS));
54
 
  }
55
 
  Constant *CreateNUWAdd(Constant *LHS, Constant *RHS) const {
56
 
    return Fold(ConstantExpr::getNUWAdd(LHS, RHS));
57
 
  }
58
 
  Constant *CreateFAdd(Constant *LHS, Constant *RHS) const {
59
 
    return Fold(ConstantExpr::getFAdd(LHS, RHS));
60
 
  }
61
 
  Constant *CreateSub(Constant *LHS, Constant *RHS) const {
62
 
    return Fold(ConstantExpr::getSub(LHS, RHS));
63
 
  }
64
 
  Constant *CreateNSWSub(Constant *LHS, Constant *RHS) const {
65
 
    return Fold(ConstantExpr::getNSWSub(LHS, RHS));
66
 
  }
67
 
  Constant *CreateNUWSub(Constant *LHS, Constant *RHS) const {
68
 
    return Fold(ConstantExpr::getNUWSub(LHS, RHS));
69
 
  }
70
 
  Constant *CreateFSub(Constant *LHS, Constant *RHS) const {
71
 
    return Fold(ConstantExpr::getFSub(LHS, RHS));
72
 
  }
73
 
  Constant *CreateMul(Constant *LHS, Constant *RHS) const {
74
 
    return Fold(ConstantExpr::getMul(LHS, RHS));
75
 
  }
76
 
  Constant *CreateNSWMul(Constant *LHS, Constant *RHS) const {
77
 
    return Fold(ConstantExpr::getNSWMul(LHS, RHS));
78
 
  }
79
 
  Constant *CreateNUWMul(Constant *LHS, Constant *RHS) const {
80
 
    return Fold(ConstantExpr::getNUWMul(LHS, RHS));
81
 
  }
82
 
  Constant *CreateFMul(Constant *LHS, Constant *RHS) const {
83
 
    return Fold(ConstantExpr::getFMul(LHS, RHS));
84
 
  }
85
 
  Constant *CreateUDiv(Constant *LHS, Constant *RHS) const {
86
 
    return Fold(ConstantExpr::getUDiv(LHS, RHS));
87
 
  }
88
 
  Constant *CreateSDiv(Constant *LHS, Constant *RHS) const {
89
 
    return Fold(ConstantExpr::getSDiv(LHS, RHS));
90
 
  }
91
 
  Constant *CreateExactSDiv(Constant *LHS, Constant *RHS) const {
92
 
    return Fold(ConstantExpr::getExactSDiv(LHS, RHS));
93
 
  }
94
 
  Constant *CreateFDiv(Constant *LHS, Constant *RHS) const {
95
 
    return Fold(ConstantExpr::getFDiv(LHS, RHS));
96
 
  }
97
 
  Constant *CreateURem(Constant *LHS, Constant *RHS) const {
98
 
    return Fold(ConstantExpr::getURem(LHS, RHS));
99
 
  }
100
 
  Constant *CreateSRem(Constant *LHS, Constant *RHS) const {
101
 
    return Fold(ConstantExpr::getSRem(LHS, RHS));
102
 
  }
103
 
  Constant *CreateFRem(Constant *LHS, Constant *RHS) const {
104
 
    return Fold(ConstantExpr::getFRem(LHS, RHS));
105
 
  }
106
 
  Constant *CreateShl(Constant *LHS, Constant *RHS) const {
107
 
    return Fold(ConstantExpr::getShl(LHS, RHS));
108
 
  }
109
 
  Constant *CreateLShr(Constant *LHS, Constant *RHS) const {
110
 
    return Fold(ConstantExpr::getLShr(LHS, RHS));
111
 
  }
112
 
  Constant *CreateAShr(Constant *LHS, Constant *RHS) const {
113
 
    return Fold(ConstantExpr::getAShr(LHS, RHS));
114
 
  }
115
 
  Constant *CreateAnd(Constant *LHS, Constant *RHS) const {
116
 
    return Fold(ConstantExpr::getAnd(LHS, RHS));
117
 
  }
118
 
  Constant *CreateOr(Constant *LHS, Constant *RHS) const {
119
 
    return Fold(ConstantExpr::getOr(LHS, RHS));
120
 
  }
121
 
  Constant *CreateXor(Constant *LHS, Constant *RHS) const {
122
 
    return Fold(ConstantExpr::getXor(LHS, RHS));
123
 
  }
124
 
 
125
 
  Constant *CreateBinOp(Instruction::BinaryOps Opc,
126
 
                        Constant *LHS, Constant *RHS) const {
127
 
    return Fold(ConstantExpr::get(Opc, LHS, RHS));
128
 
  }
129
 
 
130
 
  //===--------------------------------------------------------------------===//
131
 
  // Unary Operators
132
 
  //===--------------------------------------------------------------------===//
133
 
 
134
 
  Constant *CreateNeg(Constant *C) const {
135
 
    return Fold(ConstantExpr::getNeg(C));
136
 
  }
137
 
  Constant *CreateNSWNeg(Constant *C) const {
138
 
    return Fold(ConstantExpr::getNSWNeg(C));
139
 
  }
140
 
  Constant *CreateNUWNeg(Constant *C) const {
141
 
    return Fold(ConstantExpr::getNUWNeg(C));
142
 
  }
143
 
  Constant *CreateFNeg(Constant *C) const {
144
 
    return Fold(ConstantExpr::getFNeg(C));
145
 
  }
146
 
  Constant *CreateNot(Constant *C) const {
147
 
    return Fold(ConstantExpr::getNot(C));
148
 
  }
149
 
 
150
 
  //===--------------------------------------------------------------------===//
151
 
  // Memory Instructions
152
 
  //===--------------------------------------------------------------------===//
153
 
 
154
 
  Constant *CreateGetElementPtr(Constant *C, Constant* const *IdxList,
155
 
                                unsigned NumIdx) const {
156
 
    return Fold(ConstantExpr::getGetElementPtr(C, IdxList, NumIdx));
157
 
  }
158
 
  Constant *CreateGetElementPtr(Constant *C, Value* const *IdxList,
159
 
                                unsigned NumIdx) const {
160
 
    return Fold(ConstantExpr::getGetElementPtr(C, IdxList, NumIdx));
161
 
  }
162
 
 
163
 
  Constant *CreateInBoundsGetElementPtr(Constant *C, Constant* const *IdxList,
164
 
                                        unsigned NumIdx) const {
165
 
    return Fold(ConstantExpr::getInBoundsGetElementPtr(C, IdxList, NumIdx));
166
 
  }
167
 
  Constant *CreateInBoundsGetElementPtr(Constant *C, Value* const *IdxList,
168
 
                                        unsigned NumIdx) const {
169
 
    return Fold(ConstantExpr::getInBoundsGetElementPtr(C, IdxList, NumIdx));
170
 
  }
171
 
 
172
 
  //===--------------------------------------------------------------------===//
173
 
  // Cast/Conversion Operators
174
 
  //===--------------------------------------------------------------------===//
175
 
 
176
 
  Constant *CreateCast(Instruction::CastOps Op, Constant *C,
177
 
                       const Type *DestTy) const {
178
 
    if (C->getType() == DestTy)
179
 
      return C; // avoid calling Fold
180
 
    return Fold(ConstantExpr::getCast(Op, C, DestTy));
181
 
  }
182
 
  Constant *CreateIntCast(Constant *C, const Type *DestTy,
183
 
                          bool isSigned) const {
184
 
    if (C->getType() == DestTy)
185
 
      return C; // avoid calling Fold
186
 
    return Fold(ConstantExpr::getIntegerCast(C, DestTy, isSigned));
187
 
  }
188
 
  Constant *CreatePointerCast(Constant *C, const Type *DestTy) const {
189
 
    return ConstantExpr::getPointerCast(C, DestTy);
190
 
  }
191
 
  Constant *CreateBitCast(Constant *C, const Type *DestTy) const {
192
 
    return CreateCast(Instruction::BitCast, C, DestTy);
193
 
  }
194
 
  Constant *CreateIntToPtr(Constant *C, const Type *DestTy) const {
195
 
    return CreateCast(Instruction::IntToPtr, C, DestTy);
196
 
  }
197
 
  Constant *CreatePtrToInt(Constant *C, const Type *DestTy) const {
198
 
    return CreateCast(Instruction::PtrToInt, C, DestTy);
199
 
  }
200
 
  Constant *CreateZExtOrBitCast(Constant *C, const Type *DestTy) const {
201
 
    if (C->getType() == DestTy)
202
 
      return C; // avoid calling Fold
203
 
    return Fold(ConstantExpr::getZExtOrBitCast(C, DestTy));
204
 
  }
205
 
  Constant *CreateSExtOrBitCast(Constant *C, const Type *DestTy) const {
206
 
    if (C->getType() == DestTy)
207
 
      return C; // avoid calling Fold
208
 
    return Fold(ConstantExpr::getSExtOrBitCast(C, DestTy));
209
 
  }
210
 
  Constant *CreateTruncOrBitCast(Constant *C, const Type *DestTy) const {
211
 
    if (C->getType() == DestTy)
212
 
      return C; // avoid calling Fold
213
 
    return Fold(ConstantExpr::getTruncOrBitCast(C, DestTy));
214
 
  }
215
 
 
216
 
  //===--------------------------------------------------------------------===//
217
 
  // Compare Instructions
218
 
  //===--------------------------------------------------------------------===//
219
 
 
220
 
  Constant *CreateICmp(CmpInst::Predicate P, Constant *LHS,
221
 
                       Constant *RHS) const {
222
 
    return Fold(ConstantExpr::getCompare(P, LHS, RHS));
223
 
  }
224
 
  Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
225
 
                       Constant *RHS) const {
226
 
    return Fold(ConstantExpr::getCompare(P, LHS, RHS));
227
 
  }
228
 
 
229
 
  //===--------------------------------------------------------------------===//
230
 
  // Other Instructions
231
 
  //===--------------------------------------------------------------------===//
232
 
 
233
 
  Constant *CreateSelect(Constant *C, Constant *True, Constant *False) const {
234
 
    return Fold(ConstantExpr::getSelect(C, True, False));
235
 
  }
236
 
 
237
 
  Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const {
238
 
    return Fold(ConstantExpr::getExtractElement(Vec, Idx));
239
 
  }
240
 
 
241
 
  Constant *CreateInsertElement(Constant *Vec, Constant *NewElt,
242
 
                                Constant *Idx) const {
243
 
    return Fold(ConstantExpr::getInsertElement(Vec, NewElt, Idx));
244
 
  }
245
 
 
246
 
  Constant *CreateShuffleVector(Constant *V1, Constant *V2,
247
 
                                Constant *Mask) const {
248
 
    return Fold(ConstantExpr::getShuffleVector(V1, V2, Mask));
249
 
  }
250
 
 
251
 
  Constant *CreateExtractValue(Constant *Agg, const unsigned *IdxList,
252
 
                               unsigned NumIdx) const {
253
 
    return Fold(ConstantExpr::getExtractValue(Agg, IdxList, NumIdx));
254
 
  }
255
 
 
256
 
  Constant *CreateInsertValue(Constant *Agg, Constant *Val,
257
 
                              const unsigned *IdxList, unsigned NumIdx) const {
258
 
    return Fold(ConstantExpr::getInsertValue(Agg, Val, IdxList, NumIdx));
259
 
  }
260
 
};
261
 
 
262
 
}
263
 
 
264
 
#endif