← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to include/llvm/Analysis/TargetFolder.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

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