LLVM  7.0.0svn
ConstantFold.cpp
Go to the documentation of this file.
1 //===- ConstantFold.cpp - LLVM constant folder ----------------------------===//
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 folding of constants for LLVM. This implements the
11 // (internal) ConstantFold.h interface, which is used by the
12 // ConstantExpr::get* methods to automatically fold constants when possible.
13 //
14 // The current constant folding implementation is implemented in two pieces: the
15 // pieces that don't need DataLayout, and the pieces that do. This is to avoid
16 // a dependence in IR on Target.
17 //
18 //===----------------------------------------------------------------------===//
19 
20 #include "ConstantFold.h"
21 #include "llvm/ADT/APSInt.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/IR/Constants.h"
24 #include "llvm/IR/DerivedTypes.h"
25 #include "llvm/IR/Function.h"
27 #include "llvm/IR/GlobalAlias.h"
28 #include "llvm/IR/GlobalVariable.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Operator.h"
31 #include "llvm/IR/PatternMatch.h"
35 using namespace llvm;
36 using namespace llvm::PatternMatch;
37 
38 //===----------------------------------------------------------------------===//
39 // ConstantFold*Instruction Implementations
40 //===----------------------------------------------------------------------===//
41 
42 /// Convert the specified vector Constant node to the specified vector type.
43 /// At this point, we know that the elements of the input vector constant are
44 /// all simple integer or FP values.
46 
47  if (CV->isAllOnesValue()) return Constant::getAllOnesValue(DstTy);
48  if (CV->isNullValue()) return Constant::getNullValue(DstTy);
49 
50  // If this cast changes element count then we can't handle it here:
51  // doing so requires endianness information. This should be handled by
52  // Analysis/ConstantFolding.cpp
53  unsigned NumElts = DstTy->getNumElements();
54  if (NumElts != CV->getType()->getVectorNumElements())
55  return nullptr;
56 
57  Type *DstEltTy = DstTy->getElementType();
58 
60  Type *Ty = IntegerType::get(CV->getContext(), 32);
61  for (unsigned i = 0; i != NumElts; ++i) {
62  Constant *C =
64  C = ConstantExpr::getBitCast(C, DstEltTy);
65  Result.push_back(C);
66  }
67 
68  return ConstantVector::get(Result);
69 }
70 
71 /// This function determines which opcode to use to fold two constant cast
72 /// expressions together. It uses CastInst::isEliminableCastPair to determine
73 /// the opcode. Consequently its just a wrapper around that function.
74 /// Determine if it is valid to fold a cast of a cast
75 static unsigned
77  unsigned opc, ///< opcode of the second cast constant expression
78  ConstantExpr *Op, ///< the first cast constant expression
79  Type *DstTy ///< destination type of the first cast
80 ) {
81  assert(Op && Op->isCast() && "Can't fold cast of cast without a cast!");
82  assert(DstTy && DstTy->isFirstClassType() && "Invalid cast destination type");
83  assert(CastInst::isCast(opc) && "Invalid cast opcode");
84 
85  // The types and opcodes for the two Cast constant expressions
86  Type *SrcTy = Op->getOperand(0)->getType();
87  Type *MidTy = Op->getType();
90 
91  // Assume that pointers are never more than 64 bits wide, and only use this
92  // for the middle type. Otherwise we could end up folding away illegal
93  // bitcasts between address spaces with different sizes.
94  IntegerType *FakeIntPtrTy = Type::getInt64Ty(DstTy->getContext());
95 
96  // Let CastInst::isEliminableCastPair do the heavy lifting.
97  return CastInst::isEliminableCastPair(firstOp, secondOp, SrcTy, MidTy, DstTy,
98  nullptr, FakeIntPtrTy, nullptr);
99 }
100 
101 static Constant *FoldBitCast(Constant *V, Type *DestTy) {
102  Type *SrcTy = V->getType();
103  if (SrcTy == DestTy)
104  return V; // no-op cast
105 
106  // Check to see if we are casting a pointer to an aggregate to a pointer to
107  // the first element. If so, return the appropriate GEP instruction.
108  if (PointerType *PTy = dyn_cast<PointerType>(V->getType()))
109  if (PointerType *DPTy = dyn_cast<PointerType>(DestTy))
110  if (PTy->getAddressSpace() == DPTy->getAddressSpace()
111  && PTy->getElementType()->isSized()) {
112  SmallVector<Value*, 8> IdxList;
113  Value *Zero =
114  Constant::getNullValue(Type::getInt32Ty(DPTy->getContext()));
115  IdxList.push_back(Zero);
116  Type *ElTy = PTy->getElementType();
117  while (ElTy != DPTy->getElementType()) {
118  if (StructType *STy = dyn_cast<StructType>(ElTy)) {
119  if (STy->getNumElements() == 0) break;
120  ElTy = STy->getElementType(0);
121  IdxList.push_back(Zero);
122  } else if (SequentialType *STy =
123  dyn_cast<SequentialType>(ElTy)) {
124  ElTy = STy->getElementType();
125  IdxList.push_back(Zero);
126  } else {
127  break;
128  }
129  }
130 
131  if (ElTy == DPTy->getElementType())
132  // This GEP is inbounds because all indices are zero.
133  return ConstantExpr::getInBoundsGetElementPtr(PTy->getElementType(),
134  V, IdxList);
135  }
136 
137  // Handle casts from one vector constant to another. We know that the src
138  // and dest type have the same size (otherwise its an illegal cast).
139  if (VectorType *DestPTy = dyn_cast<VectorType>(DestTy)) {
140  if (VectorType *SrcTy = dyn_cast<VectorType>(V->getType())) {
141  assert(DestPTy->getBitWidth() == SrcTy->getBitWidth() &&
142  "Not cast between same sized vectors!");
143  SrcTy = nullptr;
144  // First, check for null. Undef is already handled.
145  if (isa<ConstantAggregateZero>(V))
146  return Constant::getNullValue(DestTy);
147 
148  // Handle ConstantVector and ConstantAggregateVector.
149  return BitCastConstantVector(V, DestPTy);
150  }
151 
152  // Canonicalize scalar-to-vector bitcasts into vector-to-vector bitcasts
153  // This allows for other simplifications (although some of them
154  // can only be handled by Analysis/ConstantFolding.cpp).
155  if (isa<ConstantInt>(V) || isa<ConstantFP>(V))
156  return ConstantExpr::getBitCast(ConstantVector::get(V), DestPTy);
157  }
158 
159  // Finally, implement bitcast folding now. The code below doesn't handle
160  // bitcast right.
161  if (isa<ConstantPointerNull>(V)) // ptr->ptr cast.
162  return ConstantPointerNull::get(cast<PointerType>(DestTy));
163 
164  // Handle integral constant input.
165  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
166  if (DestTy->isIntegerTy())
167  // Integral -> Integral. This is a no-op because the bit widths must
168  // be the same. Consequently, we just fold to V.
169  return V;
170 
171  // See note below regarding the PPC_FP128 restriction.
172  if (DestTy->isFloatingPointTy() && !DestTy->isPPC_FP128Ty())
173  return ConstantFP::get(DestTy->getContext(),
174  APFloat(DestTy->getFltSemantics(),
175  CI->getValue()));
176 
177  // Otherwise, can't fold this (vector?)
178  return nullptr;
179  }
180 
181  // Handle ConstantFP input: FP -> Integral.
182  if (ConstantFP *FP = dyn_cast<ConstantFP>(V)) {
183  // PPC_FP128 is really the sum of two consecutive doubles, where the first
184  // double is always stored first in memory, regardless of the target
185  // endianness. The memory layout of i128, however, depends on the target
186  // endianness, and so we can't fold this without target endianness
187  // information. This should instead be handled by
188  // Analysis/ConstantFolding.cpp
189  if (FP->getType()->isPPC_FP128Ty())
190  return nullptr;
191 
192  // Make sure dest type is compatible with the folded integer constant.
193  if (!DestTy->isIntegerTy())
194  return nullptr;
195 
196  return ConstantInt::get(FP->getContext(),
197  FP->getValueAPF().bitcastToAPInt());
198  }
199 
200  return nullptr;
201 }
202 
203 
204 /// V is an integer constant which only has a subset of its bytes used.
205 /// The bytes used are indicated by ByteStart (which is the first byte used,
206 /// counting from the least significant byte) and ByteSize, which is the number
207 /// of bytes used.
208 ///
209 /// This function analyzes the specified constant to see if the specified byte
210 /// range can be returned as a simplified constant. If so, the constant is
211 /// returned, otherwise null is returned.
212 static Constant *ExtractConstantBytes(Constant *C, unsigned ByteStart,
213  unsigned ByteSize) {
214  assert(C->getType()->isIntegerTy() &&
215  (cast<IntegerType>(C->getType())->getBitWidth() & 7) == 0 &&
216  "Non-byte sized integer input");
217  unsigned CSize = cast<IntegerType>(C->getType())->getBitWidth()/8;
218  assert(ByteSize && "Must be accessing some piece");
219  assert(ByteStart+ByteSize <= CSize && "Extracting invalid piece from input");
220  assert(ByteSize != CSize && "Should not extract everything");
221 
222  // Constant Integers are simple.
223  if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
224  APInt V = CI->getValue();
225  if (ByteStart)
226  V.lshrInPlace(ByteStart*8);
227  V = V.trunc(ByteSize*8);
228  return ConstantInt::get(CI->getContext(), V);
229  }
230 
231  // In the input is a constant expr, we might be able to recursively simplify.
232  // If not, we definitely can't do anything.
234  if (!CE) return nullptr;
235 
236  switch (CE->getOpcode()) {
237  default: return nullptr;
238  case Instruction::Or: {
239  Constant *RHS = ExtractConstantBytes(CE->getOperand(1), ByteStart,ByteSize);
240  if (!RHS)
241  return nullptr;
242 
243  // X | -1 -> -1.
244  if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS))
245  if (RHSC->isMinusOne())
246  return RHSC;
247 
248  Constant *LHS = ExtractConstantBytes(CE->getOperand(0), ByteStart,ByteSize);
249  if (!LHS)
250  return nullptr;
251  return ConstantExpr::getOr(LHS, RHS);
252  }
253  case Instruction::And: {
254  Constant *RHS = ExtractConstantBytes(CE->getOperand(1), ByteStart,ByteSize);
255  if (!RHS)
256  return nullptr;
257 
258  // X & 0 -> 0.
259  if (RHS->isNullValue())
260  return RHS;
261 
262  Constant *LHS = ExtractConstantBytes(CE->getOperand(0), ByteStart,ByteSize);
263  if (!LHS)
264  return nullptr;
265  return ConstantExpr::getAnd(LHS, RHS);
266  }
267  case Instruction::LShr: {
268  ConstantInt *Amt = dyn_cast<ConstantInt>(CE->getOperand(1));
269  if (!Amt)
270  return nullptr;
271  unsigned ShAmt = Amt->getZExtValue();
272  // Cannot analyze non-byte shifts.
273  if ((ShAmt & 7) != 0)
274  return nullptr;
275  ShAmt >>= 3;
276 
277  // If the extract is known to be all zeros, return zero.
278  if (ByteStart >= CSize-ShAmt)
279  return Constant::getNullValue(IntegerType::get(CE->getContext(),
280  ByteSize*8));
281  // If the extract is known to be fully in the input, extract it.
282  if (ByteStart+ByteSize+ShAmt <= CSize)
283  return ExtractConstantBytes(CE->getOperand(0), ByteStart+ShAmt, ByteSize);
284 
285  // TODO: Handle the 'partially zero' case.
286  return nullptr;
287  }
288 
289  case Instruction::Shl: {
290  ConstantInt *Amt = dyn_cast<ConstantInt>(CE->getOperand(1));
291  if (!Amt)
292  return nullptr;
293  unsigned ShAmt = Amt->getZExtValue();
294  // Cannot analyze non-byte shifts.
295  if ((ShAmt & 7) != 0)
296  return nullptr;
297  ShAmt >>= 3;
298 
299  // If the extract is known to be all zeros, return zero.
300  if (ByteStart+ByteSize <= ShAmt)
301  return Constant::getNullValue(IntegerType::get(CE->getContext(),
302  ByteSize*8));
303  // If the extract is known to be fully in the input, extract it.
304  if (ByteStart >= ShAmt)
305  return ExtractConstantBytes(CE->getOperand(0), ByteStart-ShAmt, ByteSize);
306 
307  // TODO: Handle the 'partially zero' case.
308  return nullptr;
309  }
310 
311  case Instruction::ZExt: {
312  unsigned SrcBitSize =
313  cast<IntegerType>(CE->getOperand(0)->getType())->getBitWidth();
314 
315  // If extracting something that is completely zero, return 0.
316  if (ByteStart*8 >= SrcBitSize)
317  return Constant::getNullValue(IntegerType::get(CE->getContext(),
318  ByteSize*8));
319 
320  // If exactly extracting the input, return it.
321  if (ByteStart == 0 && ByteSize*8 == SrcBitSize)
322  return CE->getOperand(0);
323 
324  // If extracting something completely in the input, if the input is a
325  // multiple of 8 bits, recurse.
326  if ((SrcBitSize&7) == 0 && (ByteStart+ByteSize)*8 <= SrcBitSize)
327  return ExtractConstantBytes(CE->getOperand(0), ByteStart, ByteSize);
328 
329  // Otherwise, if extracting a subset of the input, which is not multiple of
330  // 8 bits, do a shift and trunc to get the bits.
331  if ((ByteStart+ByteSize)*8 < SrcBitSize) {
332  assert((SrcBitSize&7) && "Shouldn't get byte sized case here");
333  Constant *Res = CE->getOperand(0);
334  if (ByteStart)
335  Res = ConstantExpr::getLShr(Res,
336  ConstantInt::get(Res->getType(), ByteStart*8));
338  ByteSize*8));
339  }
340 
341  // TODO: Handle the 'partially zero' case.
342  return nullptr;
343  }
344  }
345 }
346 
347 /// Return a ConstantExpr with type DestTy for sizeof on Ty, with any known
348 /// factors factored out. If Folded is false, return null if no factoring was
349 /// possible, to avoid endlessly bouncing an unfoldable expression back into the
350 /// top-level folder.
351 static Constant *getFoldedSizeOf(Type *Ty, Type *DestTy, bool Folded) {
352  if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
353  Constant *N = ConstantInt::get(DestTy, ATy->getNumElements());
354  Constant *E = getFoldedSizeOf(ATy->getElementType(), DestTy, true);
355  return ConstantExpr::getNUWMul(E, N);
356  }
357 
358  if (StructType *STy = dyn_cast<StructType>(Ty))
359  if (!STy->isPacked()) {
360  unsigned NumElems = STy->getNumElements();
361  // An empty struct has size zero.
362  if (NumElems == 0)
363  return ConstantExpr::getNullValue(DestTy);
364  // Check for a struct with all members having the same size.
365  Constant *MemberSize =
366  getFoldedSizeOf(STy->getElementType(0), DestTy, true);
367  bool AllSame = true;
368  for (unsigned i = 1; i != NumElems; ++i)
369  if (MemberSize !=
370  getFoldedSizeOf(STy->getElementType(i), DestTy, true)) {
371  AllSame = false;
372  break;
373  }
374  if (AllSame) {
375  Constant *N = ConstantInt::get(DestTy, NumElems);
376  return ConstantExpr::getNUWMul(MemberSize, N);
377  }
378  }
379 
380  // Pointer size doesn't depend on the pointee type, so canonicalize them
381  // to an arbitrary pointee.
382  if (PointerType *PTy = dyn_cast<PointerType>(Ty))
383  if (!PTy->getElementType()->isIntegerTy(1))
384  return
385  getFoldedSizeOf(PointerType::get(IntegerType::get(PTy->getContext(), 1),
386  PTy->getAddressSpace()),
387  DestTy, true);
388 
389  // If there's no interesting folding happening, bail so that we don't create
390  // a constant that looks like it needs folding but really doesn't.
391  if (!Folded)
392  return nullptr;
393 
394  // Base case: Get a regular sizeof expression.
397  DestTy, false),
398  C, DestTy);
399  return C;
400 }
401 
402 /// Return a ConstantExpr with type DestTy for alignof on Ty, with any known
403 /// factors factored out. If Folded is false, return null if no factoring was
404 /// possible, to avoid endlessly bouncing an unfoldable expression back into the
405 /// top-level folder.
406 static Constant *getFoldedAlignOf(Type *Ty, Type *DestTy, bool Folded) {
407  // The alignment of an array is equal to the alignment of the
408  // array element. Note that this is not always true for vectors.
409  if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
410  Constant *C = ConstantExpr::getAlignOf(ATy->getElementType());
412  DestTy,
413  false),
414  C, DestTy);
415  return C;
416  }
417 
418  if (StructType *STy = dyn_cast<StructType>(Ty)) {
419  // Packed structs always have an alignment of 1.
420  if (STy->isPacked())
421  return ConstantInt::get(DestTy, 1);
422 
423  // Otherwise, struct alignment is the maximum alignment of any member.
424  // Without target data, we can't compare much, but we can check to see
425  // if all the members have the same alignment.
426  unsigned NumElems = STy->getNumElements();
427  // An empty struct has minimal alignment.
428  if (NumElems == 0)
429  return ConstantInt::get(DestTy, 1);
430  // Check for a struct with all members having the same alignment.
431  Constant *MemberAlign =
432  getFoldedAlignOf(STy->getElementType(0), DestTy, true);
433  bool AllSame = true;
434  for (unsigned i = 1; i != NumElems; ++i)
435  if (MemberAlign != getFoldedAlignOf(STy->getElementType(i), DestTy, true)) {
436  AllSame = false;
437  break;
438  }
439  if (AllSame)
440  return MemberAlign;
441  }
442 
443  // Pointer alignment doesn't depend on the pointee type, so canonicalize them
444  // to an arbitrary pointee.
445  if (PointerType *PTy = dyn_cast<PointerType>(Ty))
446  if (!PTy->getElementType()->isIntegerTy(1))
447  return
449  1),
450  PTy->getAddressSpace()),
451  DestTy, true);
452 
453  // If there's no interesting folding happening, bail so that we don't create
454  // a constant that looks like it needs folding but really doesn't.
455  if (!Folded)
456  return nullptr;
457 
458  // Base case: Get a regular alignof expression.
461  DestTy, false),
462  C, DestTy);
463  return C;
464 }
465 
466 /// Return a ConstantExpr with type DestTy for offsetof on Ty and FieldNo, with
467 /// any known factors factored out. If Folded is false, return null if no
468 /// factoring was possible, to avoid endlessly bouncing an unfoldable expression
469 /// back into the top-level folder.
470 static Constant *getFoldedOffsetOf(Type *Ty, Constant *FieldNo, Type *DestTy,
471  bool Folded) {
472  if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
474  DestTy, false),
475  FieldNo, DestTy);
476  Constant *E = getFoldedSizeOf(ATy->getElementType(), DestTy, true);
477  return ConstantExpr::getNUWMul(E, N);
478  }
479 
480  if (StructType *STy = dyn_cast<StructType>(Ty))
481  if (!STy->isPacked()) {
482  unsigned NumElems = STy->getNumElements();
483  // An empty struct has no members.
484  if (NumElems == 0)
485  return nullptr;
486  // Check for a struct with all members having the same size.
487  Constant *MemberSize =
488  getFoldedSizeOf(STy->getElementType(0), DestTy, true);
489  bool AllSame = true;
490  for (unsigned i = 1; i != NumElems; ++i)
491  if (MemberSize !=
492  getFoldedSizeOf(STy->getElementType(i), DestTy, true)) {
493  AllSame = false;
494  break;
495  }
496  if (AllSame) {
498  false,
499  DestTy,
500  false),
501  FieldNo, DestTy);
502  return ConstantExpr::getNUWMul(MemberSize, N);
503  }
504  }
505 
506  // If there's no interesting folding happening, bail so that we don't create
507  // a constant that looks like it needs folding but really doesn't.
508  if (!Folded)
509  return nullptr;
510 
511  // Base case: Get a regular offsetof expression.
512  Constant *C = ConstantExpr::getOffsetOf(Ty, FieldNo);
514  DestTy, false),
515  C, DestTy);
516  return C;
517 }
518 
520  Type *DestTy) {
521  if (isa<UndefValue>(V)) {
522  // zext(undef) = 0, because the top bits will be zero.
523  // sext(undef) = 0, because the top bits will all be the same.
524  // [us]itofp(undef) = 0, because the result value is bounded.
525  if (opc == Instruction::ZExt || opc == Instruction::SExt ||
526  opc == Instruction::UIToFP || opc == Instruction::SIToFP)
527  return Constant::getNullValue(DestTy);
528  return UndefValue::get(DestTy);
529  }
530 
531  if (V->isNullValue() && !DestTy->isX86_MMXTy() &&
532  opc != Instruction::AddrSpaceCast)
533  return Constant::getNullValue(DestTy);
534 
535  // If the cast operand is a constant expression, there's a few things we can
536  // do to try to simplify it.
537  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
538  if (CE->isCast()) {
539  // Try hard to fold cast of cast because they are often eliminable.
540  if (unsigned newOpc = foldConstantCastPair(opc, CE, DestTy))
541  return ConstantExpr::getCast(newOpc, CE->getOperand(0), DestTy);
542  } else if (CE->getOpcode() == Instruction::GetElementPtr &&
543  // Do not fold addrspacecast (gep 0, .., 0). It might make the
544  // addrspacecast uncanonicalized.
545  opc != Instruction::AddrSpaceCast &&
546  // Do not fold bitcast (gep) with inrange index, as this loses
547  // information.
548  !cast<GEPOperator>(CE)->getInRangeIndex().hasValue() &&
549  // Do not fold if the gep type is a vector, as bitcasting
550  // operand 0 of a vector gep will result in a bitcast between
551  // different sizes.
552  !CE->getType()->isVectorTy()) {
553  // If all of the indexes in the GEP are null values, there is no pointer
554  // adjustment going on. We might as well cast the source pointer.
555  bool isAllNull = true;
556  for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i)
557  if (!CE->getOperand(i)->isNullValue()) {
558  isAllNull = false;
559  break;
560  }
561  if (isAllNull)
562  // This is casting one pointer type to another, always BitCast
563  return ConstantExpr::getPointerCast(CE->getOperand(0), DestTy);
564  }
565  }
566 
567  // If the cast operand is a constant vector, perform the cast by
568  // operating on each element. In the cast of bitcasts, the element
569  // count may be mismatched; don't attempt to handle that here.
570  if ((isa<ConstantVector>(V) || isa<ConstantDataVector>(V)) &&
571  DestTy->isVectorTy() &&
572  DestTy->getVectorNumElements() == V->getType()->getVectorNumElements()) {
574  VectorType *DestVecTy = cast<VectorType>(DestTy);
575  Type *DstEltTy = DestVecTy->getElementType();
576  Type *Ty = IntegerType::get(V->getContext(), 32);
577  for (unsigned i = 0, e = V->getType()->getVectorNumElements(); i != e; ++i) {
578  Constant *C =
580  res.push_back(ConstantExpr::getCast(opc, C, DstEltTy));
581  }
582  return ConstantVector::get(res);
583  }
584 
585  // We actually have to do a cast now. Perform the cast according to the
586  // opcode specified.
587  switch (opc) {
588  default:
589  llvm_unreachable("Failed to cast constant expression");
590  case Instruction::FPTrunc:
591  case Instruction::FPExt:
592  if (ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
593  bool ignored;
594  APFloat Val = FPC->getValueAPF();
595  Val.convert(DestTy->isHalfTy() ? APFloat::IEEEhalf() :
596  DestTy->isFloatTy() ? APFloat::IEEEsingle() :
597  DestTy->isDoubleTy() ? APFloat::IEEEdouble() :
599  DestTy->isFP128Ty() ? APFloat::IEEEquad() :
601  APFloat::Bogus(),
602  APFloat::rmNearestTiesToEven, &ignored);
603  return ConstantFP::get(V->getContext(), Val);
604  }
605  return nullptr; // Can't fold.
606  case Instruction::FPToUI:
607  case Instruction::FPToSI:
608  if (ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
609  const APFloat &V = FPC->getValueAPF();
610  bool ignored;
611  uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
612  APSInt IntVal(DestBitWidth, opc == Instruction::FPToUI);
613  if (APFloat::opInvalidOp ==
614  V.convertToInteger(IntVal, APFloat::rmTowardZero, &ignored)) {
615  // Undefined behavior invoked - the destination type can't represent
616  // the input constant.
617  return UndefValue::get(DestTy);
618  }
619  return ConstantInt::get(FPC->getContext(), IntVal);
620  }
621  return nullptr; // Can't fold.
622  case Instruction::IntToPtr: //always treated as unsigned
623  if (V->isNullValue()) // Is it an integral null value?
624  return ConstantPointerNull::get(cast<PointerType>(DestTy));
625  return nullptr; // Other pointer types cannot be casted
626  case Instruction::PtrToInt: // always treated as unsigned
627  // Is it a null pointer value?
628  if (V->isNullValue())
629  return ConstantInt::get(DestTy, 0);
630  // If this is a sizeof-like expression, pull out multiplications by
631  // known factors to expose them to subsequent folding. If it's an
632  // alignof-like expression, factor out known factors.
633  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
634  if (CE->getOpcode() == Instruction::GetElementPtr &&
635  CE->getOperand(0)->isNullValue()) {
636  // FIXME: Looks like getFoldedSizeOf(), getFoldedOffsetOf() and
637  // getFoldedAlignOf() don't handle the case when DestTy is a vector of
638  // pointers yet. We end up in asserts in CastInst::getCastOpcode (see
639  // test/Analysis/ConstantFolding/cast-vector.ll). I've only seen this
640  // happen in one "real" C-code test case, so it does not seem to be an
641  // important optimization to handle vectors here. For now, simply bail
642  // out.
643  if (DestTy->isVectorTy())
644  return nullptr;
645  GEPOperator *GEPO = cast<GEPOperator>(CE);
646  Type *Ty = GEPO->getSourceElementType();
647  if (CE->getNumOperands() == 2) {
648  // Handle a sizeof-like expression.
649  Constant *Idx = CE->getOperand(1);
650  bool isOne = isa<ConstantInt>(Idx) && cast<ConstantInt>(Idx)->isOne();
651  if (Constant *C = getFoldedSizeOf(Ty, DestTy, !isOne)) {
653  DestTy, false),
654  Idx, DestTy);
655  return ConstantExpr::getMul(C, Idx);
656  }
657  } else if (CE->getNumOperands() == 3 &&
658  CE->getOperand(1)->isNullValue()) {
659  // Handle an alignof-like expression.
660  if (StructType *STy = dyn_cast<StructType>(Ty))
661  if (!STy->isPacked()) {
662  ConstantInt *CI = cast<ConstantInt>(CE->getOperand(2));
663  if (CI->isOne() &&
664  STy->getNumElements() == 2 &&
665  STy->getElementType(0)->isIntegerTy(1)) {
666  return getFoldedAlignOf(STy->getElementType(1), DestTy, false);
667  }
668  }
669  // Handle an offsetof-like expression.
670  if (Ty->isStructTy() || Ty->isArrayTy()) {
671  if (Constant *C = getFoldedOffsetOf(Ty, CE->getOperand(2),
672  DestTy, false))
673  return C;
674  }
675  }
676  }
677  // Other pointer types cannot be casted
678  return nullptr;
679  case Instruction::UIToFP:
680  case Instruction::SIToFP:
681  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
682  const APInt &api = CI->getValue();
683  APFloat apf(DestTy->getFltSemantics(),
685  apf.convertFromAPInt(api, opc==Instruction::SIToFP,
687  return ConstantFP::get(V->getContext(), apf);
688  }
689  return nullptr;
690  case Instruction::ZExt:
691  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
692  uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
693  return ConstantInt::get(V->getContext(),
694  CI->getValue().zext(BitWidth));
695  }
696  return nullptr;
697  case Instruction::SExt:
698  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
699  uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
700  return ConstantInt::get(V->getContext(),
701  CI->getValue().sext(BitWidth));
702  }
703  return nullptr;
704  case Instruction::Trunc: {
705  if (V->getType()->isVectorTy())
706  return nullptr;
707 
708  uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
709  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
710  return ConstantInt::get(V->getContext(),
711  CI->getValue().trunc(DestBitWidth));
712  }
713 
714  // The input must be a constantexpr. See if we can simplify this based on
715  // the bytes we are demanding. Only do this if the source and dest are an
716  // even multiple of a byte.
717  if ((DestBitWidth & 7) == 0 &&
718  (cast<IntegerType>(V->getType())->getBitWidth() & 7) == 0)
719  if (Constant *Res = ExtractConstantBytes(V, 0, DestBitWidth / 8))
720  return Res;
721 
722  return nullptr;
723  }
724  case Instruction::BitCast:
725  return FoldBitCast(V, DestTy);
726  case Instruction::AddrSpaceCast:
727  return nullptr;
728  }
729 }
730 
732  Constant *V1, Constant *V2) {
733  // Check for i1 and vector true/false conditions.
734  if (Cond->isNullValue()) return V2;
735  if (Cond->isAllOnesValue()) return V1;
736 
737  // If the condition is a vector constant, fold the result elementwise.
738  if (ConstantVector *CondV = dyn_cast<ConstantVector>(Cond)) {
740  Type *Ty = IntegerType::get(CondV->getContext(), 32);
741  for (unsigned i = 0, e = V1->getType()->getVectorNumElements(); i != e;++i){
742  Constant *V;
744  ConstantInt::get(Ty, i));
746  ConstantInt::get(Ty, i));
747  Constant *Cond = dyn_cast<Constant>(CondV->getOperand(i));
748  if (V1Element == V2Element) {
749  V = V1Element;
750  } else if (isa<UndefValue>(Cond)) {
751  V = isa<UndefValue>(V1Element) ? V1Element : V2Element;
752  } else {
753  if (!isa<ConstantInt>(Cond)) break;
754  V = Cond->isNullValue() ? V2Element : V1Element;
755  }
756  Result.push_back(V);
757  }
758 
759  // If we were able to build the vector, return it.
760  if (Result.size() == V1->getType()->getVectorNumElements())
761  return ConstantVector::get(Result);
762  }
763 
764  if (isa<UndefValue>(Cond)) {
765  if (isa<UndefValue>(V1)) return V1;
766  return V2;
767  }
768  if (isa<UndefValue>(V1)) return V2;
769  if (isa<UndefValue>(V2)) return V1;
770  if (V1 == V2) return V1;
771 
772  if (ConstantExpr *TrueVal = dyn_cast<ConstantExpr>(V1)) {
773  if (TrueVal->getOpcode() == Instruction::Select)
774  if (TrueVal->getOperand(0) == Cond)
775  return ConstantExpr::getSelect(Cond, TrueVal->getOperand(1), V2);
776  }
777  if (ConstantExpr *FalseVal = dyn_cast<ConstantExpr>(V2)) {
778  if (FalseVal->getOpcode() == Instruction::Select)
779  if (FalseVal->getOperand(0) == Cond)
780  return ConstantExpr::getSelect(Cond, V1, FalseVal->getOperand(2));
781  }
782 
783  return nullptr;
784 }
785 
787  Constant *Idx) {
788  if (isa<UndefValue>(Val)) // ee(undef, x) -> undef
789  return UndefValue::get(Val->getType()->getVectorElementType());
790  if (Val->isNullValue()) // ee(zero, x) -> zero
792  // ee({w,x,y,z}, undef) -> undef
793  if (isa<UndefValue>(Idx))
794  return UndefValue::get(Val->getType()->getVectorElementType());
795 
796  if (ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx)) {
797  // ee({w,x,y,z}, wrong_value) -> undef
798  if (CIdx->uge(Val->getType()->getVectorNumElements()))
799  return UndefValue::get(Val->getType()->getVectorElementType());
800  return Val->getAggregateElement(CIdx->getZExtValue());
801  }
802  return nullptr;
803 }
804 
806  Constant *Elt,
807  Constant *Idx) {
808  if (isa<UndefValue>(Idx))
809  return UndefValue::get(Val->getType());
810 
811  ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx);
812  if (!CIdx) return nullptr;
813 
814  unsigned NumElts = Val->getType()->getVectorNumElements();
815  if (CIdx->uge(NumElts))
816  return UndefValue::get(Val->getType());
817 
819  Result.reserve(NumElts);
820  auto *Ty = Type::getInt32Ty(Val->getContext());
821  uint64_t IdxVal = CIdx->getZExtValue();
822  for (unsigned i = 0; i != NumElts; ++i) {
823  if (i == IdxVal) {
824  Result.push_back(Elt);
825  continue;
826  }
827 
829  Result.push_back(C);
830  }
831 
832  return ConstantVector::get(Result);
833 }
834 
836  Constant *V2,
837  Constant *Mask) {
838  unsigned MaskNumElts = Mask->getType()->getVectorNumElements();
839  Type *EltTy = V1->getType()->getVectorElementType();
840 
841  // Undefined shuffle mask -> undefined value.
842  if (isa<UndefValue>(Mask))
843  return UndefValue::get(VectorType::get(EltTy, MaskNumElts));
844 
845  // Don't break the bitcode reader hack.
846  if (isa<ConstantExpr>(Mask)) return nullptr;
847 
848  unsigned SrcNumElts = V1->getType()->getVectorNumElements();
849 
850  // Loop over the shuffle mask, evaluating each element.
852  for (unsigned i = 0; i != MaskNumElts; ++i) {
853  int Elt = ShuffleVectorInst::getMaskValue(Mask, i);
854  if (Elt == -1) {
855  Result.push_back(UndefValue::get(EltTy));
856  continue;
857  }
858  Constant *InElt;
859  if (unsigned(Elt) >= SrcNumElts*2)
860  InElt = UndefValue::get(EltTy);
861  else if (unsigned(Elt) >= SrcNumElts) {
862  Type *Ty = IntegerType::get(V2->getContext(), 32);
863  InElt =
865  ConstantInt::get(Ty, Elt - SrcNumElts));
866  } else {
867  Type *Ty = IntegerType::get(V1->getContext(), 32);
869  }
870  Result.push_back(InElt);
871  }
872 
873  return ConstantVector::get(Result);
874 }
875 
877  ArrayRef<unsigned> Idxs) {
878  // Base case: no indices, so return the entire value.
879  if (Idxs.empty())
880  return Agg;
881 
882  if (Constant *C = Agg->getAggregateElement(Idxs[0]))
884 
885  return nullptr;
886 }
887 
889  Constant *Val,
890  ArrayRef<unsigned> Idxs) {
891  // Base case: no indices, so replace the entire value.
892  if (Idxs.empty())
893  return Val;
894 
895  unsigned NumElts;
896  if (StructType *ST = dyn_cast<StructType>(Agg->getType()))
897  NumElts = ST->getNumElements();
898  else
899  NumElts = cast<SequentialType>(Agg->getType())->getNumElements();
900 
902  for (unsigned i = 0; i != NumElts; ++i) {
903  Constant *C = Agg->getAggregateElement(i);
904  if (!C) return nullptr;
905 
906  if (Idxs[0] == i)
907  C = ConstantFoldInsertValueInstruction(C, Val, Idxs.slice(1));
908 
909  Result.push_back(C);
910  }
911 
912  if (StructType *ST = dyn_cast<StructType>(Agg->getType()))
913  return ConstantStruct::get(ST, Result);
914  if (ArrayType *AT = dyn_cast<ArrayType>(Agg->getType()))
915  return ConstantArray::get(AT, Result);
916  return ConstantVector::get(Result);
917 }
918 
919 
921  Constant *C1, Constant *C2) {
922  assert(Instruction::isBinaryOp(Opcode) && "Non-binary instruction detected");
923 
924  // Handle UndefValue up front.
925  if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) {
926  switch (static_cast<Instruction::BinaryOps>(Opcode)) {
927  case Instruction::Xor:
928  if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
929  // Handle undef ^ undef -> 0 special case. This is a common
930  // idiom (misuse).
931  return Constant::getNullValue(C1->getType());
933  case Instruction::Add:
934  case Instruction::Sub:
935  return UndefValue::get(C1->getType());
936  case Instruction::And:
937  if (isa<UndefValue>(C1) && isa<UndefValue>(C2)) // undef & undef -> undef
938  return C1;
939  return Constant::getNullValue(C1->getType()); // undef & X -> 0
940  case Instruction::Mul: {
941  // undef * undef -> undef
942  if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
943  return C1;
944  const APInt *CV;
945  // X * undef -> undef if X is odd
946  if (match(C1, m_APInt(CV)) || match(C2, m_APInt(CV)))
947  if ((*CV)[0])
948  return UndefValue::get(C1->getType());
949 
950  // X * undef -> 0 otherwise
951  return Constant::getNullValue(C1->getType());
952  }
953  case Instruction::SDiv:
954  case Instruction::UDiv:
955  // X / undef -> undef
956  if (isa<UndefValue>(C2))
957  return C2;
958  // undef / 0 -> undef
959  // undef / 1 -> undef
960  if (match(C2, m_Zero()) || match(C2, m_One()))
961  return C1;
962  // undef / X -> 0 otherwise
963  return Constant::getNullValue(C1->getType());
964  case Instruction::URem:
965  case Instruction::SRem:
966  // X % undef -> undef
967  if (match(C2, m_Undef()))
968  return C2;
969  // undef % 0 -> undef
970  if (match(C2, m_Zero()))
971  return C1;
972  // undef % X -> 0 otherwise
973  return Constant::getNullValue(C1->getType());
974  case Instruction::Or: // X | undef -> -1
975  if (isa<UndefValue>(C1) && isa<UndefValue>(C2)) // undef | undef -> undef
976  return C1;
977  return Constant::getAllOnesValue(C1->getType()); // undef | X -> ~0
978  case Instruction::LShr:
979  // X >>l undef -> undef
980  if (isa<UndefValue>(C2))
981  return C2;
982  // undef >>l 0 -> undef
983  if (match(C2, m_Zero()))
984  return C1;
985  // undef >>l X -> 0
986  return Constant::getNullValue(C1->getType());
987  case Instruction::AShr:
988  // X >>a undef -> undef
989  if (isa<UndefValue>(C2))
990  return C2;
991  // undef >>a 0 -> undef
992  if (match(C2, m_Zero()))
993  return C1;
994  // TODO: undef >>a X -> undef if the shift is exact
995  // undef >>a X -> 0
996  return Constant::getNullValue(C1->getType());
997  case Instruction::Shl:
998  // X << undef -> undef
999  if (isa<UndefValue>(C2))
1000  return C2;
1001  // undef << 0 -> undef
1002  if (match(C2, m_Zero()))
1003  return C1;
1004  // undef << X -> 0
1005  return Constant::getNullValue(C1->getType());
1006  case Instruction::FAdd:
1007  case Instruction::FSub:
1008  case Instruction::FMul:
1009  case Instruction::FDiv:
1010  case Instruction::FRem:
1011  // [any flop] undef, undef -> undef
1012  if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
1013  return C1;
1014  // [any flop] C, undef -> NaN
1015  // [any flop] undef, C -> NaN
1016  // We could potentially specialize NaN/Inf constants vs. 'normal'
1017  // constants (possibly differently depending on opcode and operand). This
1018  // would allow returning undef sometimes. But it is always safe to fold to
1019  // NaN because we can choose the undef operand as NaN, and any FP opcode
1020  // with a NaN operand will propagate NaN.
1021  return ConstantFP::getNaN(C1->getType());
1022  case Instruction::BinaryOpsEnd:
1023  llvm_unreachable("Invalid BinaryOp");
1024  }
1025  }
1026 
1027  // At this point neither constant should be an UndefValue.
1028  assert(!isa<UndefValue>(C1) && !isa<UndefValue>(C2) &&
1029  "Unexpected UndefValue");
1030 
1031  // Handle simplifications when the RHS is a constant int.
1032  if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
1033  switch (Opcode) {
1034  case Instruction::Add:
1035  if (CI2->isZero()) return C1; // X + 0 == X
1036  break;
1037  case Instruction::Sub:
1038  if (CI2->isZero()) return C1; // X - 0 == X
1039  break;
1040  case Instruction::Mul:
1041  if (CI2->isZero()) return C2; // X * 0 == 0
1042  if (CI2->isOne())
1043  return C1; // X * 1 == X
1044  break;
1045  case Instruction::UDiv:
1046  case Instruction::SDiv:
1047  if (CI2->isOne())
1048  return C1; // X / 1 == X
1049  if (CI2->isZero())
1050  return UndefValue::get(CI2->getType()); // X / 0 == undef
1051  break;
1052  case Instruction::URem:
1053  case Instruction::SRem:
1054  if (CI2->isOne())
1055  return Constant::getNullValue(CI2->getType()); // X % 1 == 0
1056  if (CI2->isZero())
1057  return UndefValue::get(CI2->getType()); // X % 0 == undef
1058  break;
1059  case Instruction::And:
1060  if (CI2->isZero()) return C2; // X & 0 == 0
1061  if (CI2->isMinusOne())
1062  return C1; // X & -1 == X
1063 
1064  if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
1065  // (zext i32 to i64) & 4294967295 -> (zext i32 to i64)
1066  if (CE1->getOpcode() == Instruction::ZExt) {
1067  unsigned DstWidth = CI2->getType()->getBitWidth();
1068  unsigned SrcWidth =
1069  CE1->getOperand(0)->getType()->getPrimitiveSizeInBits();
1070  APInt PossiblySetBits(APInt::getLowBitsSet(DstWidth, SrcWidth));
1071  if ((PossiblySetBits & CI2->getValue()) == PossiblySetBits)
1072  return C1;
1073  }
1074 
1075  // If and'ing the address of a global with a constant, fold it.
1076  if (CE1->getOpcode() == Instruction::PtrToInt &&
1077  isa<GlobalValue>(CE1->getOperand(0))) {
1078  GlobalValue *GV = cast<GlobalValue>(CE1->getOperand(0));
1079 
1080  // Functions are at least 4-byte aligned.
1081  unsigned GVAlign = GV->getAlignment();
1082  if (isa<Function>(GV))
1083  GVAlign = std::max(GVAlign, 4U);
1084 
1085  if (GVAlign > 1) {
1086  unsigned DstWidth = CI2->getType()->getBitWidth();
1087  unsigned SrcWidth = std::min(DstWidth, Log2_32(GVAlign));
1088  APInt BitsNotSet(APInt::getLowBitsSet(DstWidth, SrcWidth));
1089 
1090  // If checking bits we know are clear, return zero.
1091  if ((CI2->getValue() & BitsNotSet) == CI2->getValue())
1092  return Constant::getNullValue(CI2->getType());
1093  }
1094  }
1095  }
1096  break;
1097  case Instruction::Or:
1098  if (CI2->isZero()) return C1; // X | 0 == X
1099  if (CI2->isMinusOne())
1100  return C2; // X | -1 == -1
1101  break;
1102  case Instruction::Xor:
1103  if (CI2->isZero()) return C1; // X ^ 0 == X
1104 
1105  if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
1106  switch (CE1->getOpcode()) {
1107  default: break;
1108  case Instruction::ICmp:
1109  case Instruction::FCmp:
1110  // cmp pred ^ true -> cmp !pred
1111  assert(CI2->isOne());
1112  CmpInst::Predicate pred = (CmpInst::Predicate)CE1->getPredicate();
1113  pred = CmpInst::getInversePredicate(pred);
1114  return ConstantExpr::getCompare(pred, CE1->getOperand(0),
1115  CE1->getOperand(1));
1116  }
1117  }
1118  break;
1119  case Instruction::AShr:
1120  // ashr (zext C to Ty), C2 -> lshr (zext C, CSA), C2
1121  if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1))
1122  if (CE1->getOpcode() == Instruction::ZExt) // Top bits known zero.
1123  return ConstantExpr::getLShr(C1, C2);
1124  break;
1125  }
1126  } else if (isa<ConstantInt>(C1)) {
1127  // If C1 is a ConstantInt and C2 is not, swap the operands.
1128  if (Instruction::isCommutative(Opcode))
1129  return ConstantExpr::get(Opcode, C2, C1);
1130  }
1131 
1132  if (ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
1133  if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
1134  const APInt &C1V = CI1->getValue();
1135  const APInt &C2V = CI2->getValue();
1136  switch (Opcode) {
1137  default:
1138  break;
1139  case Instruction::Add:
1140  return ConstantInt::get(CI1->getContext(), C1V + C2V);
1141  case Instruction::Sub:
1142  return ConstantInt::get(CI1->getContext(), C1V - C2V);
1143  case Instruction::Mul:
1144  return ConstantInt::get(CI1->getContext(), C1V * C2V);
1145  case Instruction::UDiv:
1146  assert(!CI2->isZero() && "Div by zero handled above");
1147  return ConstantInt::get(CI1->getContext(), C1V.udiv(C2V));
1148  case Instruction::SDiv:
1149  assert(!CI2->isZero() && "Div by zero handled above");
1150  if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
1151  return UndefValue::get(CI1->getType()); // MIN_INT / -1 -> undef
1152  return ConstantInt::get(CI1->getContext(), C1V.sdiv(C2V));
1153  case Instruction::URem:
1154  assert(!CI2->isZero() && "Div by zero handled above");
1155  return ConstantInt::get(CI1->getContext(), C1V.urem(C2V));
1156  case Instruction::SRem:
1157  assert(!CI2->isZero() && "Div by zero handled above");
1158  if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
1159  return UndefValue::get(CI1->getType()); // MIN_INT % -1 -> undef
1160  return ConstantInt::get(CI1->getContext(), C1V.srem(C2V));
1161  case Instruction::And:
1162  return ConstantInt::get(CI1->getContext(), C1V & C2V);
1163  case Instruction::Or:
1164  return ConstantInt::get(CI1->getContext(), C1V | C2V);
1165  case Instruction::Xor:
1166  return ConstantInt::get(CI1->getContext(), C1V ^ C2V);
1167  case Instruction::Shl:
1168  if (C2V.ult(C1V.getBitWidth()))
1169  return ConstantInt::get(CI1->getContext(), C1V.shl(C2V));
1170  return UndefValue::get(C1->getType()); // too big shift is undef
1171  case Instruction::LShr:
1172  if (C2V.ult(C1V.getBitWidth()))
1173  return ConstantInt::get(CI1->getContext(), C1V.lshr(C2V));
1174  return UndefValue::get(C1->getType()); // too big shift is undef
1175  case Instruction::AShr:
1176  if (C2V.ult(C1V.getBitWidth()))
1177  return ConstantInt::get(CI1->getContext(), C1V.ashr(C2V));
1178  return UndefValue::get(C1->getType()); // too big shift is undef
1179  }
1180  }
1181 
1182  switch (Opcode) {
1183  case Instruction::SDiv:
1184  case Instruction::UDiv:
1185  case Instruction::URem:
1186  case Instruction::SRem:
1187  case Instruction::LShr:
1188  case Instruction::AShr:
1189  case Instruction::Shl:
1190  if (CI1->isZero()) return C1;
1191  break;
1192  default:
1193  break;
1194  }
1195  } else if (ConstantFP *CFP1 = dyn_cast<ConstantFP>(C1)) {
1196  if (ConstantFP *CFP2 = dyn_cast<ConstantFP>(C2)) {
1197  const APFloat &C1V = CFP1->getValueAPF();
1198  const APFloat &C2V = CFP2->getValueAPF();
1199  APFloat C3V = C1V; // copy for modification
1200  switch (Opcode) {
1201  default:
1202  break;
1203  case Instruction::FAdd:
1204  (void)C3V.add(C2V, APFloat::rmNearestTiesToEven);
1205  return ConstantFP::get(C1->getContext(), C3V);
1206  case Instruction::FSub:
1207  (void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven);
1208  return ConstantFP::get(C1->getContext(), C3V);
1209  case Instruction::FMul:
1210  (void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven);
1211  return ConstantFP::get(C1->getContext(), C3V);
1212  case Instruction::FDiv:
1213  (void)C3V.divide(C2V, APFloat::rmNearestTiesToEven);
1214  return ConstantFP::get(C1->getContext(), C3V);
1215  case Instruction::FRem:
1216  (void)C3V.mod(C2V);
1217  return ConstantFP::get(C1->getContext(), C3V);
1218  }
1219  }
1220  } else if (VectorType *VTy = dyn_cast<VectorType>(C1->getType())) {
1221  // Perform elementwise folding.
1223  Type *Ty = IntegerType::get(VTy->getContext(), 32);
1224  for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
1225  Constant *ExtractIdx = ConstantInt::get(Ty, i);
1226  Constant *LHS = ConstantExpr::getExtractElement(C1, ExtractIdx);
1227  Constant *RHS = ConstantExpr::getExtractElement(C2, ExtractIdx);
1228 
1229  // If any element of a divisor vector is zero, the whole op is undef.
1230  if ((Opcode == Instruction::SDiv || Opcode == Instruction::UDiv ||
1231  Opcode == Instruction::SRem || Opcode == Instruction::URem) &&
1232  RHS->isNullValue())
1233  return UndefValue::get(VTy);
1234 
1235  Result.push_back(ConstantExpr::get(Opcode, LHS, RHS));
1236  }
1237 
1238  return ConstantVector::get(Result);
1239  }
1240 
1241  if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
1242  // There are many possible foldings we could do here. We should probably
1243  // at least fold add of a pointer with an integer into the appropriate
1244  // getelementptr. This will improve alias analysis a bit.
1245 
1246  // Given ((a + b) + c), if (b + c) folds to something interesting, return
1247  // (a + (b + c)).
1248  if (Instruction::isAssociative(Opcode) && CE1->getOpcode() == Opcode) {
1249  Constant *T = ConstantExpr::get(Opcode, CE1->getOperand(1), C2);
1250  if (!isa<ConstantExpr>(T) || cast<ConstantExpr>(T)->getOpcode() != Opcode)
1251  return ConstantExpr::get(Opcode, CE1->getOperand(0), T);
1252  }
1253  } else if (isa<ConstantExpr>(C2)) {
1254  // If C2 is a constant expr and C1 isn't, flop them around and fold the
1255  // other way if possible.
1256  if (Instruction::isCommutative(Opcode))
1257  return ConstantFoldBinaryInstruction(Opcode, C2, C1);
1258  }
1259 
1260  // i1 can be simplified in many cases.
1261  if (C1->getType()->isIntegerTy(1)) {
1262  switch (Opcode) {
1263  case Instruction::Add:
1264  case Instruction::Sub:
1265  return ConstantExpr::getXor(C1, C2);
1266  case Instruction::Mul:
1267  return ConstantExpr::getAnd(C1, C2);
1268  case Instruction::Shl:
1269  case Instruction::LShr:
1270  case Instruction::AShr:
1271  // We can assume that C2 == 0. If it were one the result would be
1272  // undefined because the shift value is as large as the bitwidth.
1273  return C1;
1274  case Instruction::SDiv:
1275  case Instruction::UDiv:
1276  // We can assume that C2 == 1. If it were zero the result would be
1277  // undefined through division by zero.
1278  return C1;
1279  case Instruction::URem:
1280  case Instruction::SRem:
1281  // We can assume that C2 == 1. If it were zero the result would be
1282  // undefined through division by zero.
1283  return ConstantInt::getFalse(C1->getContext());
1284  default:
1285  break;
1286  }
1287  }
1288 
1289  // We don't know how to fold this.
1290  return nullptr;
1291 }
1292 
1293 /// This type is zero-sized if it's an array or structure of zero-sized types.
1294 /// The only leaf zero-sized type is an empty structure.
1295 static bool isMaybeZeroSizedType(Type *Ty) {
1296  if (StructType *STy = dyn_cast<StructType>(Ty)) {
1297  if (STy->isOpaque()) return true; // Can't say.
1298 
1299  // If all of elements have zero size, this does too.
1300  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
1301  if (!isMaybeZeroSizedType(STy->getElementType(i))) return false;
1302  return true;
1303 
1304  } else if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
1305  return isMaybeZeroSizedType(ATy->getElementType());
1306  }
1307  return false;
1308 }
1309 
1310 /// Compare the two constants as though they were getelementptr indices.
1311 /// This allows coercion of the types to be the same thing.
1312 ///
1313 /// If the two constants are the "same" (after coercion), return 0. If the
1314 /// first is less than the second, return -1, if the second is less than the
1315 /// first, return 1. If the constants are not integral, return -2.
1316 ///
1317 static int IdxCompare(Constant *C1, Constant *C2, Type *ElTy) {
1318  if (C1 == C2) return 0;
1319 
1320  // Ok, we found a different index. If they are not ConstantInt, we can't do
1321  // anything with them.
1322  if (!isa<ConstantInt>(C1) || !isa<ConstantInt>(C2))
1323  return -2; // don't know!
1324 
1325  // We cannot compare the indices if they don't fit in an int64_t.
1326  if (cast<ConstantInt>(C1)->getValue().getActiveBits() > 64 ||
1327  cast<ConstantInt>(C2)->getValue().getActiveBits() > 64)
1328  return -2; // don't know!
1329 
1330  // Ok, we have two differing integer indices. Sign extend them to be the same
1331  // type.
1332  int64_t C1Val = cast<ConstantInt>(C1)->getSExtValue();
1333  int64_t C2Val = cast<ConstantInt>(C2)->getSExtValue();
1334 
1335  if (C1Val == C2Val) return 0; // They are equal
1336 
1337  // If the type being indexed over is really just a zero sized type, there is
1338  // no pointer difference being made here.
1339  if (isMaybeZeroSizedType(ElTy))
1340  return -2; // dunno.
1341 
1342  // If they are really different, now that they are the same type, then we
1343  // found a difference!
1344  if (C1Val < C2Val)
1345  return -1;
1346  else
1347  return 1;
1348 }
1349 
1350 /// This function determines if there is anything we can decide about the two
1351 /// constants provided. This doesn't need to handle simple things like
1352 /// ConstantFP comparisons, but should instead handle ConstantExprs.
1353 /// If we can determine that the two constants have a particular relation to
1354 /// each other, we should return the corresponding FCmpInst predicate,
1355 /// otherwise return FCmpInst::BAD_FCMP_PREDICATE. This is used below in
1356 /// ConstantFoldCompareInstruction.
1357 ///
1358 /// To simplify this code we canonicalize the relation so that the first
1359 /// operand is always the most "complex" of the two. We consider ConstantFP
1360 /// to be the simplest, and ConstantExprs to be the most complex.
1362  assert(V1->getType() == V2->getType() &&
1363  "Cannot compare values of different types!");
1364 
1365  // Handle degenerate case quickly
1366  if (V1 == V2) return FCmpInst::FCMP_OEQ;
1367 
1368  if (!isa<ConstantExpr>(V1)) {
1369  if (!isa<ConstantExpr>(V2)) {
1370  // Simple case, use the standard constant folder.
1371  ConstantInt *R = nullptr;
1372  R = dyn_cast<ConstantInt>(
1374  if (R && !R->isZero())
1375  return FCmpInst::FCMP_OEQ;
1376  R = dyn_cast<ConstantInt>(
1378  if (R && !R->isZero())
1379  return FCmpInst::FCMP_OLT;
1380  R = dyn_cast<ConstantInt>(
1382  if (R && !R->isZero())
1383  return FCmpInst::FCMP_OGT;
1384 
1385  // Nothing more we can do
1387  }
1388 
1389  // If the first operand is simple and second is ConstantExpr, swap operands.
1390  FCmpInst::Predicate SwappedRelation = evaluateFCmpRelation(V2, V1);
1391  if (SwappedRelation != FCmpInst::BAD_FCMP_PREDICATE)
1392  return FCmpInst::getSwappedPredicate(SwappedRelation);
1393  } else {
1394  // Ok, the LHS is known to be a constantexpr. The RHS can be any of a
1395  // constantexpr or a simple constant.
1396  ConstantExpr *CE1 = cast<ConstantExpr>(V1);
1397  switch (CE1->getOpcode()) {
1398  case Instruction::FPTrunc:
1399  case Instruction::FPExt:
1400  case Instruction::UIToFP:
1401  case Instruction::SIToFP:
1402  // We might be able to do something with these but we don't right now.
1403  break;
1404  default:
1405  break;
1406  }
1407  }
1408  // There are MANY other foldings that we could perform here. They will
1409  // probably be added on demand, as they seem needed.
1411 }
1412 
1414  const GlobalValue *GV2) {
1415  auto isGlobalUnsafeForEquality = [](const GlobalValue *GV) {
1416  if (GV->hasExternalWeakLinkage() || GV->hasWeakAnyLinkage())
1417  return true;
1418  if (const auto *GVar = dyn_cast<GlobalVariable>(GV)) {
1419  Type *Ty = GVar->getValueType();
1420  // A global with opaque type might end up being zero sized.
1421  if (!Ty->isSized())
1422  return true;
1423  // A global with an empty type might lie at the address of any other
1424  // global.
1425  if (Ty->isEmptyTy())
1426  return true;
1427  }
1428  return false;
1429  };
1430  // Don't try to decide equality of aliases.
1431  if (!isa<GlobalAlias>(GV1) && !isa<GlobalAlias>(GV2))
1432  if (!isGlobalUnsafeForEquality(GV1) && !isGlobalUnsafeForEquality(GV2))
1433  return ICmpInst::ICMP_NE;
1435 }
1436 
1437 /// This function determines if there is anything we can decide about the two
1438 /// constants provided. This doesn't need to handle simple things like integer
1439 /// comparisons, but should instead handle ConstantExprs and GlobalValues.
1440 /// If we can determine that the two constants have a particular relation to
1441 /// each other, we should return the corresponding ICmp predicate, otherwise
1442 /// return ICmpInst::BAD_ICMP_PREDICATE.
1443 ///
1444 /// To simplify this code we canonicalize the relation so that the first
1445 /// operand is always the most "complex" of the two. We consider simple
1446 /// constants (like ConstantInt) to be the simplest, followed by
1447 /// GlobalValues, followed by ConstantExpr's (the most complex).
1448 ///
1450  bool isSigned) {
1451  assert(V1->getType() == V2->getType() &&
1452  "Cannot compare different types of values!");
1453  if (V1 == V2) return ICmpInst::ICMP_EQ;
1454 
1455  if (!isa<ConstantExpr>(V1) && !isa<GlobalValue>(V1) &&
1456  !isa<BlockAddress>(V1)) {
1457  if (!isa<GlobalValue>(V2) && !isa<ConstantExpr>(V2) &&
1458  !isa<BlockAddress>(V2)) {
1459  // We distilled this down to a simple case, use the standard constant
1460  // folder.
1461  ConstantInt *R = nullptr;
1463  R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
1464  if (R && !R->isZero())
1465  return pred;
1466  pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
1467  R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
1468  if (R && !R->isZero())
1469  return pred;
1470  pred = isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
1471  R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
1472  if (R && !R->isZero())
1473  return pred;
1474 
1475  // If we couldn't figure it out, bail.
1477  }
1478 
1479  // If the first operand is simple, swap operands.
1480  ICmpInst::Predicate SwappedRelation =
1481  evaluateICmpRelation(V2, V1, isSigned);
1482  if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
1483  return ICmpInst::getSwappedPredicate(SwappedRelation);
1484 
1485  } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V1)) {
1486  if (isa<ConstantExpr>(V2)) { // Swap as necessary.
1487  ICmpInst::Predicate SwappedRelation =
1488  evaluateICmpRelation(V2, V1, isSigned);
1489  if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
1490  return ICmpInst::getSwappedPredicate(SwappedRelation);
1492  }
1493 
1494  // Now we know that the RHS is a GlobalValue, BlockAddress or simple
1495  // constant (which, since the types must match, means that it's a
1496  // ConstantPointerNull).
1497  if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2)) {
1498  return areGlobalsPotentiallyEqual(GV, GV2);
1499  } else if (isa<BlockAddress>(V2)) {
1500  return ICmpInst::ICMP_NE; // Globals never equal labels.
1501  } else {
1502  assert(isa<ConstantPointerNull>(V2) && "Canonicalization guarantee!");
1503  // GlobalVals can never be null unless they have external weak linkage.
1504  // We don't try to evaluate aliases here.
1505  if (!GV->hasExternalWeakLinkage() && !isa<GlobalAlias>(GV))
1506  return ICmpInst::ICMP_NE;
1507  }
1508  } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(V1)) {
1509  if (isa<ConstantExpr>(V2)) { // Swap as necessary.
1510  ICmpInst::Predicate SwappedRelation =
1511  evaluateICmpRelation(V2, V1, isSigned);
1512  if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
1513  return ICmpInst::getSwappedPredicate(SwappedRelation);
1515  }
1516 
1517  // Now we know that the RHS is a GlobalValue, BlockAddress or simple
1518  // constant (which, since the types must match, means that it is a
1519  // ConstantPointerNull).
1520  if (const BlockAddress *BA2 = dyn_cast<BlockAddress>(V2)) {
1521  // Block address in another function can't equal this one, but block
1522  // addresses in the current function might be the same if blocks are
1523  // empty.
1524  if (BA2->getFunction() != BA->getFunction())
1525  return ICmpInst::ICMP_NE;
1526  } else {
1527  // Block addresses aren't null, don't equal the address of globals.
1528  assert((isa<ConstantPointerNull>(V2) || isa<GlobalValue>(V2)) &&
1529  "Canonicalization guarantee!");
1530  return ICmpInst::ICMP_NE;
1531  }
1532  } else {
1533  // Ok, the LHS is known to be a constantexpr. The RHS can be any of a
1534  // constantexpr, a global, block address, or a simple constant.
1535  ConstantExpr *CE1 = cast<ConstantExpr>(V1);
1536  Constant *CE1Op0 = CE1->getOperand(0);
1537 
1538  switch (CE1->getOpcode()) {
1539  case Instruction::Trunc:
1540  case Instruction::FPTrunc:
1541  case Instruction::FPExt:
1542  case Instruction::FPToUI:
1543  case Instruction::FPToSI:
1544  break; // We can't evaluate floating point casts or truncations.
1545 
1546  case Instruction::UIToFP:
1547  case Instruction::SIToFP:
1548  case Instruction::BitCast:
1549  case Instruction::ZExt:
1550  case Instruction::SExt:
1551  // We can't evaluate floating point casts or truncations.
1552  if (CE1Op0->getType()->isFloatingPointTy())
1553  break;
1554 
1555  // If the cast is not actually changing bits, and the second operand is a
1556  // null pointer, do the comparison with the pre-casted value.
1557  if (V2->isNullValue() &&
1558  (CE1->getType()->isPointerTy() || CE1->getType()->isIntegerTy())) {
1559  if (CE1->getOpcode() == Instruction::ZExt) isSigned = false;
1560  if (CE1->getOpcode() == Instruction::SExt) isSigned = true;
1561  return evaluateICmpRelation(CE1Op0,
1562  Constant::getNullValue(CE1Op0->getType()),
1563  isSigned);
1564  }
1565  break;
1566 
1567  case Instruction::GetElementPtr: {
1568  GEPOperator *CE1GEP = cast<GEPOperator>(CE1);
1569  // Ok, since this is a getelementptr, we know that the constant has a
1570  // pointer type. Check the various cases.
1571  if (isa<ConstantPointerNull>(V2)) {
1572  // If we are comparing a GEP to a null pointer, check to see if the base
1573  // of the GEP equals the null pointer.
1574  if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0)) {
1575  if (GV->hasExternalWeakLinkage())
1576  // Weak linkage GVals could be zero or not. We're comparing that
1577  // to null pointer so its greater-or-equal
1578  return isSigned ? ICmpInst::ICMP_SGE : ICmpInst::ICMP_UGE;
1579  else
1580  // If its not weak linkage, the GVal must have a non-zero address
1581  // so the result is greater-than
1582  return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
1583  } else if (isa<ConstantPointerNull>(CE1Op0)) {
1584  // If we are indexing from a null pointer, check to see if we have any
1585  // non-zero indices.
1586  for (unsigned i = 1, e = CE1->getNumOperands(); i != e; ++i)
1587  if (!CE1->getOperand(i)->isNullValue())
1588  // Offsetting from null, must not be equal.
1589  return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
1590  // Only zero indexes from null, must still be zero.
1591  return ICmpInst::ICMP_EQ;
1592  }
1593  // Otherwise, we can't really say if the first operand is null or not.
1594  } else if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2)) {
1595  if (isa<ConstantPointerNull>(CE1Op0)) {
1596  if (GV2->hasExternalWeakLinkage())
1597  // Weak linkage GVals could be zero or not. We're comparing it to
1598  // a null pointer, so its less-or-equal
1599  return isSigned ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE;
1600  else
1601  // If its not weak linkage, the GVal must have a non-zero address
1602  // so the result is less-than
1603  return isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
1604  } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0)) {
1605  if (GV == GV2) {
1606  // If this is a getelementptr of the same global, then it must be
1607  // different. Because the types must match, the getelementptr could
1608  // only have at most one index, and because we fold getelementptr's
1609  // with a single zero index, it must be nonzero.
1610  assert(CE1->getNumOperands() == 2 &&
1611  !CE1->getOperand(1)->isNullValue() &&
1612  "Surprising getelementptr!");
1613  return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
1614  } else {
1615  if (CE1GEP->hasAllZeroIndices())
1616  return areGlobalsPotentiallyEqual(GV, GV2);
1618  }
1619  }
1620  } else {
1621  ConstantExpr *CE2 = cast<ConstantExpr>(V2);
1622  Constant *CE2Op0 = CE2->getOperand(0);
1623 
1624  // There are MANY other foldings that we could perform here. They will
1625  // probably be added on demand, as they seem needed.
1626  switch (CE2->getOpcode()) {
1627  default: break;
1628  case Instruction::GetElementPtr:
1629  // By far the most common case to handle is when the base pointers are
1630  // obviously to the same global.
1631  if (isa<GlobalValue>(CE1Op0) && isa<GlobalValue>(CE2Op0)) {
1632  // Don't know relative ordering, but check for inequality.
1633  if (CE1Op0 != CE2Op0) {
1634  GEPOperator *CE2GEP = cast<GEPOperator>(CE2);
1635  if (CE1GEP->hasAllZeroIndices() && CE2GEP->hasAllZeroIndices())
1636  return areGlobalsPotentiallyEqual(cast<GlobalValue>(CE1Op0),
1637  cast<GlobalValue>(CE2Op0));
1639  }
1640  // Ok, we know that both getelementptr instructions are based on the
1641  // same global. From this, we can precisely determine the relative
1642  // ordering of the resultant pointers.
1643  unsigned i = 1;
1644 
1645  // The logic below assumes that the result of the comparison
1646  // can be determined by finding the first index that differs.
1647  // This doesn't work if there is over-indexing in any
1648  // subsequent indices, so check for that case first.
1649  if (!CE1->isGEPWithNoNotionalOverIndexing() ||
1651  return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal.
1652 
1653  // Compare all of the operands the GEP's have in common.
1654  gep_type_iterator GTI = gep_type_begin(CE1);
1655  for (;i != CE1->getNumOperands() && i != CE2->getNumOperands();
1656  ++i, ++GTI)
1657  switch (IdxCompare(CE1->getOperand(i),
1658  CE2->getOperand(i), GTI.getIndexedType())) {
1659  case -1: return isSigned ? ICmpInst::ICMP_SLT:ICmpInst::ICMP_ULT;
1660  case 1: return isSigned ? ICmpInst::ICMP_SGT:ICmpInst::ICMP_UGT;
1661  case -2: return ICmpInst::BAD_ICMP_PREDICATE;
1662  }
1663 
1664  // Ok, we ran out of things they have in common. If any leftovers
1665  // are non-zero then we have a difference, otherwise we are equal.
1666  for (; i < CE1->getNumOperands(); ++i)
1667  if (!CE1->getOperand(i)->isNullValue()) {
1668  if (isa<ConstantInt>(CE1->getOperand(i)))
1669  return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
1670  else
1671  return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal.
1672  }
1673 
1674  for (; i < CE2->getNumOperands(); ++i)
1675  if (!CE2->getOperand(i)->isNullValue()) {
1676  if (isa<ConstantInt>(CE2->getOperand(i)))
1677  return isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
1678  else
1679  return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal.
1680  }
1681  return ICmpInst::ICMP_EQ;
1682  }
1683  }
1684  }
1685  break;
1686  }
1687  default:
1688  break;
1689  }
1690  }
1691 
1693 }
1694 
1696  Constant *C1, Constant *C2) {
1697  Type *ResultTy;
1698  if (VectorType *VT = dyn_cast<VectorType>(C1->getType()))
1699  ResultTy = VectorType::get(Type::getInt1Ty(C1->getContext()),
1700  VT->getNumElements());
1701  else
1702  ResultTy = Type::getInt1Ty(C1->getContext());
1703 
1704  // Fold FCMP_FALSE/FCMP_TRUE unconditionally.
1705  if (pred == FCmpInst::FCMP_FALSE)
1706  return Constant::getNullValue(ResultTy);
1707 
1708  if (pred == FCmpInst::FCMP_TRUE)
1709  return Constant::getAllOnesValue(ResultTy);
1710 
1711  // Handle some degenerate cases first
1712  if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) {
1714  bool isIntegerPredicate = ICmpInst::isIntPredicate(Predicate);
1715  // For EQ and NE, we can always pick a value for the undef to make the
1716  // predicate pass or fail, so we can return undef.
1717  // Also, if both operands are undef, we can return undef for int comparison.
1718  if (ICmpInst::isEquality(Predicate) || (isIntegerPredicate && C1 == C2))
1719  return UndefValue::get(ResultTy);
1720 
1721  // Otherwise, for integer compare, pick the same value as the non-undef
1722  // operand, and fold it to true or false.
1723  if (isIntegerPredicate)
1724  return ConstantInt::get(ResultTy, CmpInst::isTrueWhenEqual(Predicate));
1725 
1726  // Choosing NaN for the undef will always make unordered comparison succeed
1727  // and ordered comparison fails.
1728  return ConstantInt::get(ResultTy, CmpInst::isUnordered(Predicate));
1729  }
1730 
1731  // icmp eq/ne(null,GV) -> false/true
1732  if (C1->isNullValue()) {
1733  if (const GlobalValue *GV = dyn_cast<GlobalValue>(C2))
1734  // Don't try to evaluate aliases. External weak GV can be null.
1735  if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) {
1736  if (pred == ICmpInst::ICMP_EQ)
1737  return ConstantInt::getFalse(C1->getContext());
1738  else if (pred == ICmpInst::ICMP_NE)
1739  return ConstantInt::getTrue(C1->getContext());
1740  }
1741  // icmp eq/ne(GV,null) -> false/true
1742  } else if (C2->isNullValue()) {
1743  if (const GlobalValue *GV = dyn_cast<GlobalValue>(C1))
1744  // Don't try to evaluate aliases. External weak GV can be null.
1745  if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) {
1746  if (pred == ICmpInst::ICMP_EQ)
1747  return ConstantInt::getFalse(C1->getContext());
1748  else if (pred == ICmpInst::ICMP_NE)
1749  return ConstantInt::getTrue(C1->getContext());
1750  }
1751  }
1752 
1753  // If the comparison is a comparison between two i1's, simplify it.
1754  if (C1->getType()->isIntegerTy(1)) {
1755  switch(pred) {
1756  case ICmpInst::ICMP_EQ:
1757  if (isa<ConstantInt>(C2))
1760  case ICmpInst::ICMP_NE:
1761  return ConstantExpr::getXor(C1, C2);
1762  default:
1763  break;
1764  }
1765  }
1766 
1767  if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2)) {
1768  const APInt &V1 = cast<ConstantInt>(C1)->getValue();
1769  const APInt &V2 = cast<ConstantInt>(C2)->getValue();
1770  switch (pred) {
1771  default: llvm_unreachable("Invalid ICmp Predicate");
1772  case ICmpInst::ICMP_EQ: return ConstantInt::get(ResultTy, V1 == V2);
1773  case ICmpInst::ICMP_NE: return ConstantInt::get(ResultTy, V1 != V2);
1774  case ICmpInst::ICMP_SLT: return ConstantInt::get(ResultTy, V1.slt(V2));
1775  case ICmpInst::ICMP_SGT: return ConstantInt::get(ResultTy, V1.sgt(V2));
1776  case ICmpInst::ICMP_SLE: return ConstantInt::get(ResultTy, V1.sle(V2));
1777  case ICmpInst::ICMP_SGE: return ConstantInt::get(ResultTy, V1.sge(V2));
1778  case ICmpInst::ICMP_ULT: return ConstantInt::get(ResultTy, V1.ult(V2));
1779  case ICmpInst::ICMP_UGT: return ConstantInt::get(ResultTy, V1.ugt(V2));
1780  case ICmpInst::ICMP_ULE: return ConstantInt::get(ResultTy, V1.ule(V2));
1781  case ICmpInst::ICMP_UGE: return ConstantInt::get(ResultTy, V1.uge(V2));
1782  }
1783  } else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) {
1784  const APFloat &C1V = cast<ConstantFP>(C1)->getValueAPF();
1785  const APFloat &C2V = cast<ConstantFP>(C2)->getValueAPF();
1786  APFloat::cmpResult R = C1V.compare(C2V);
1787  switch (pred) {
1788  default: llvm_unreachable("Invalid FCmp Predicate");
1789  case FCmpInst::FCMP_FALSE: return Constant::getNullValue(ResultTy);
1790  case FCmpInst::FCMP_TRUE: return Constant::getAllOnesValue(ResultTy);
1791  case FCmpInst::FCMP_UNO:
1792  return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered);
1793  case FCmpInst::FCMP_ORD:
1794  return ConstantInt::get(ResultTy, R!=APFloat::cmpUnordered);
1795  case FCmpInst::FCMP_UEQ:
1796  return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1797  R==APFloat::cmpEqual);
1798  case FCmpInst::FCMP_OEQ:
1799  return ConstantInt::get(ResultTy, R==APFloat::cmpEqual);
1800  case FCmpInst::FCMP_UNE:
1801  return ConstantInt::get(ResultTy, R!=APFloat::cmpEqual);
1802  case FCmpInst::FCMP_ONE:
1803  return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan ||
1805  case FCmpInst::FCMP_ULT:
1806  return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1808  case FCmpInst::FCMP_OLT:
1809  return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan);
1810  case FCmpInst::FCMP_UGT:
1811  return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1813  case FCmpInst::FCMP_OGT:
1814  return ConstantInt::get(ResultTy, R==APFloat::cmpGreaterThan);
1815  case FCmpInst::FCMP_ULE:
1816  return ConstantInt::get(ResultTy, R!=APFloat::cmpGreaterThan);
1817  case FCmpInst::FCMP_OLE:
1818  return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan ||
1819  R==APFloat::cmpEqual);
1820  case FCmpInst::FCMP_UGE:
1821  return ConstantInt::get(ResultTy, R!=APFloat::cmpLessThan);
1822  case FCmpInst::FCMP_OGE:
1823  return ConstantInt::get(ResultTy, R==APFloat::cmpGreaterThan ||
1824  R==APFloat::cmpEqual);
1825  }
1826  } else if (C1->getType()->isVectorTy()) {
1827  // If we can constant fold the comparison of each element, constant fold
1828  // the whole vector comparison.
1829  SmallVector<Constant*, 4> ResElts;
1830  Type *Ty = IntegerType::get(C1->getContext(), 32);
1831  // Compare the elements, producing an i1 result or constant expr.
1832  for (unsigned i = 0, e = C1->getType()->getVectorNumElements(); i != e;++i){
1833  Constant *C1E =
1835  Constant *C2E =
1837 
1838  ResElts.push_back(ConstantExpr::getCompare(pred, C1E, C2E));
1839  }
1840 
1841  return ConstantVector::get(ResElts);
1842  }
1843 
1844  if (C1->getType()->isFloatingPointTy() &&
1845  // Only call evaluateFCmpRelation if we have a constant expr to avoid
1846  // infinite recursive loop
1847  (isa<ConstantExpr>(C1) || isa<ConstantExpr>(C2))) {
1848  int Result = -1; // -1 = unknown, 0 = known false, 1 = known true.
1849  switch (evaluateFCmpRelation(C1, C2)) {
1850  default: llvm_unreachable("Unknown relation!");
1851  case FCmpInst::FCMP_UNO:
1852  case FCmpInst::FCMP_ORD:
1853  case FCmpInst::FCMP_UEQ:
1854  case FCmpInst::FCMP_UNE:
1855  case FCmpInst::FCMP_ULT:
1856  case FCmpInst::FCMP_UGT:
1857  case FCmpInst::FCMP_ULE:
1858  case FCmpInst::FCMP_UGE:
1859  case FCmpInst::FCMP_TRUE:
1860  case FCmpInst::FCMP_FALSE:
1862  break; // Couldn't determine anything about these constants.
1863  case FCmpInst::FCMP_OEQ: // We know that C1 == C2
1864  Result = (pred == FCmpInst::FCMP_UEQ || pred == FCmpInst::FCMP_OEQ ||
1865  pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE ||
1866  pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
1867  break;
1868  case FCmpInst::FCMP_OLT: // We know that C1 < C2
1869  Result = (pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
1870  pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT ||
1871  pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE);
1872  break;
1873  case FCmpInst::FCMP_OGT: // We know that C1 > C2
1874  Result = (pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
1875  pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT ||
1876  pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
1877  break;
1878  case FCmpInst::FCMP_OLE: // We know that C1 <= C2
1879  // We can only partially decide this relation.
1880  if (pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT)
1881  Result = 0;
1882  else if (pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT)
1883  Result = 1;
1884  break;
1885  case FCmpInst::FCMP_OGE: // We known that C1 >= C2
1886  // We can only partially decide this relation.
1887  if (pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT)
1888  Result = 0;
1889  else if (pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT)
1890  Result = 1;
1891  break;
1892  case FCmpInst::FCMP_ONE: // We know that C1 != C2
1893  // We can only partially decide this relation.
1894  if (pred == FCmpInst::FCMP_OEQ || pred == FCmpInst::FCMP_UEQ)
1895  Result = 0;
1896  else if (pred == FCmpInst::FCMP_ONE || pred == FCmpInst::FCMP_UNE)
1897  Result = 1;
1898  break;
1899  }
1900 
1901  // If we evaluated the result, return it now.
1902  if (Result != -1)
1903  return ConstantInt::get(ResultTy, Result);
1904 
1905  } else {
1906  // Evaluate the relation between the two constants, per the predicate.
1907  int Result = -1; // -1 = unknown, 0 = known false, 1 = known true.
1908  switch (evaluateICmpRelation(C1, C2,
1910  default: llvm_unreachable("Unknown relational!");
1912  break; // Couldn't determine anything about these constants.
1913  case ICmpInst::ICMP_EQ: // We know the constants are equal!
1914  // If we know the constants are equal, we can decide the result of this
1915  // computation precisely.
1917  break;
1918  case ICmpInst::ICMP_ULT:
1919  switch (pred) {
1921  Result = 1; break;
1923  Result = 0; break;
1924  }
1925  break;
1926  case ICmpInst::ICMP_SLT:
1927  switch (pred) {
1929  Result = 1; break;
1931  Result = 0; break;
1932  }
1933  break;
1934  case ICmpInst::ICMP_UGT:
1935  switch (pred) {
1937  Result = 1; break;
1939  Result = 0; break;
1940  }
1941  break;
1942  case ICmpInst::ICMP_SGT:
1943  switch (pred) {
1945  Result = 1; break;
1947  Result = 0; break;
1948  }
1949  break;
1950  case ICmpInst::ICMP_ULE:
1951  if (pred == ICmpInst::ICMP_UGT) Result = 0;
1952  if (pred == ICmpInst::ICMP_ULT || pred == ICmpInst::ICMP_ULE) Result = 1;
1953  break;
1954  case ICmpInst::ICMP_SLE:
1955  if (pred == ICmpInst::ICMP_SGT) Result = 0;
1956  if (pred == ICmpInst::ICMP_SLT || pred == ICmpInst::ICMP_SLE) Result = 1;
1957  break;
1958  case ICmpInst::ICMP_UGE:
1959  if (pred == ICmpInst::ICMP_ULT) Result = 0;
1960  if (pred == ICmpInst::ICMP_UGT || pred == ICmpInst::ICMP_UGE) Result = 1;
1961  break;
1962  case ICmpInst::ICMP_SGE:
1963  if (pred == ICmpInst::ICMP_SLT) Result = 0;
1964  if (pred == ICmpInst::ICMP_SGT || pred == ICmpInst::ICMP_SGE) Result = 1;
1965  break;
1966  case ICmpInst::ICMP_NE:
1967  if (pred == ICmpInst::ICMP_EQ) Result = 0;
1968  if (pred == ICmpInst::ICMP_NE) Result = 1;
1969  break;
1970  }
1971 
1972  // If we evaluated the result, return it now.
1973  if (Result != -1)
1974  return ConstantInt::get(ResultTy, Result);
1975 
1976  // If the right hand side is a bitcast, try using its inverse to simplify
1977  // it by moving it to the left hand side. We can't do this if it would turn
1978  // a vector compare into a scalar compare or visa versa.
1979  if (ConstantExpr *CE2 = dyn_cast<ConstantExpr>(C2)) {
1980  Constant *CE2Op0 = CE2->getOperand(0);
1981  if (CE2->getOpcode() == Instruction::BitCast &&
1982  CE2->getType()->isVectorTy() == CE2Op0->getType()->isVectorTy()) {
1984  return ConstantExpr::getICmp(pred, Inverse, CE2Op0);
1985  }
1986  }
1987 
1988  // If the left hand side is an extension, try eliminating it.
1989  if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
1990  if ((CE1->getOpcode() == Instruction::SExt &&
1992  (CE1->getOpcode() == Instruction::ZExt &&
1994  Constant *CE1Op0 = CE1->getOperand(0);
1995  Constant *CE1Inverse = ConstantExpr::getTrunc(CE1, CE1Op0->getType());
1996  if (CE1Inverse == CE1Op0) {
1997  // Check whether we can safely truncate the right hand side.
1998  Constant *C2Inverse = ConstantExpr::getTrunc(C2, CE1Op0->getType());
1999  if (ConstantExpr::getCast(CE1->getOpcode(), C2Inverse,
2000  C2->getType()) == C2)
2001  return ConstantExpr::getICmp(pred, CE1Inverse, C2Inverse);
2002  }
2003  }
2004  }
2005 
2006  if ((!isa<ConstantExpr>(C1) && isa<ConstantExpr>(C2)) ||
2007  (C1->isNullValue() && !C2->isNullValue())) {
2008  // If C2 is a constant expr and C1 isn't, flip them around and fold the
2009  // other way if possible.
2010  // Also, if C1 is null and C2 isn't, flip them around.
2012  return ConstantExpr::getICmp(pred, C2, C1);
2013  }
2014  }
2015  return nullptr;
2016 }
2017 
2018 /// Test whether the given sequence of *normalized* indices is "inbounds".
2019 template<typename IndexTy>
2021  // No indices means nothing that could be out of bounds.
2022  if (Idxs.empty()) return true;
2023 
2024  // If the first index is zero, it's in bounds.
2025  if (cast<Constant>(Idxs[0])->isNullValue()) return true;
2026 
2027  // If the first index is one and all the rest are zero, it's in bounds,
2028  // by the one-past-the-end rule.
2029  if (auto *CI = dyn_cast<ConstantInt>(Idxs[0])) {
2030  if (!CI->isOne())
2031  return false;
2032  } else {
2033  auto *CV = cast<ConstantDataVector>(Idxs[0]);
2034  CI = dyn_cast_or_null<ConstantInt>(CV->getSplatValue());
2035  if (!CI || !CI->isOne())
2036  return false;
2037  }
2038 
2039  for (unsigned i = 1, e = Idxs.size(); i != e; ++i)
2040  if (!cast<Constant>(Idxs[i])->isNullValue())
2041  return false;
2042  return true;
2043 }
2044 
2045 /// Test whether a given ConstantInt is in-range for a SequentialType.
2046 static bool isIndexInRangeOfArrayType(uint64_t NumElements,
2047  const ConstantInt *CI) {
2048  // We cannot bounds check the index if it doesn't fit in an int64_t.
2049  if (CI->getValue().getActiveBits() > 64)
2050  return false;
2051 
2052  // A negative index or an index past the end of our sequential type is
2053  // considered out-of-range.
2054  int64_t IndexVal = CI->getSExtValue();
2055  if (IndexVal < 0 || (NumElements > 0 && (uint64_t)IndexVal >= NumElements))
2056  return false;
2057 
2058  // Otherwise, it is in-range.
2059  return true;
2060 }
2061 
2063  bool InBounds,
2064  Optional<unsigned> InRangeIndex,
2065  ArrayRef<Value *> Idxs) {
2066  if (Idxs.empty()) return C;
2067 
2069  C, makeArrayRef((Value *const *)Idxs.data(), Idxs.size()));
2070 
2071  if (isa<UndefValue>(C))
2072  return UndefValue::get(GEPTy);
2073 
2074  Constant *Idx0 = cast<Constant>(Idxs[0]);
2075  if (Idxs.size() == 1 && (Idx0->isNullValue() || isa<UndefValue>(Idx0)))
2076  return GEPTy->isVectorTy() && !C->getType()->isVectorTy()
2078  cast<VectorType>(GEPTy)->getNumElements(), C)
2079  : C;
2080 
2081  if (C->isNullValue()) {
2082  bool isNull = true;
2083  for (unsigned i = 0, e = Idxs.size(); i != e; ++i)
2084  if (!isa<UndefValue>(Idxs[i]) &&
2085  !cast<Constant>(Idxs[i])->isNullValue()) {
2086  isNull = false;
2087  break;
2088  }
2089  if (isNull) {
2090  PointerType *PtrTy = cast<PointerType>(C->getType()->getScalarType());
2091  Type *Ty = GetElementPtrInst::getIndexedType(PointeeTy, Idxs);
2092 
2093  assert(Ty && "Invalid indices for GEP!");
2094  Type *OrigGEPTy = PointerType::get(Ty, PtrTy->getAddressSpace());
2095  Type *GEPTy = PointerType::get(Ty, PtrTy->getAddressSpace());
2096  if (VectorType *VT = dyn_cast<VectorType>(C->getType()))
2097  GEPTy = VectorType::get(OrigGEPTy, VT->getNumElements());
2098 
2099  // The GEP returns a vector of pointers when one of more of
2100  // its arguments is a vector.
2101  for (unsigned i = 0, e = Idxs.size(); i != e; ++i) {
2102  if (auto *VT = dyn_cast<VectorType>(Idxs[i]->getType())) {
2103  GEPTy = VectorType::get(OrigGEPTy, VT->getNumElements());
2104  break;
2105  }
2106  }
2107 
2108  return Constant::getNullValue(GEPTy);
2109  }
2110  }
2111 
2112  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
2113  // Combine Indices - If the source pointer to this getelementptr instruction
2114  // is a getelementptr instruction, combine the indices of the two
2115  // getelementptr instructions into a single instruction.
2116  //
2117  if (CE->getOpcode() == Instruction::GetElementPtr) {
2118  gep_type_iterator LastI = gep_type_end(CE);
2119  for (gep_type_iterator I = gep_type_begin(CE), E = gep_type_end(CE);
2120  I != E; ++I)
2121  LastI = I;
2122 
2123  // We cannot combine indices if doing so would take us outside of an
2124  // array or vector. Doing otherwise could trick us if we evaluated such a
2125  // GEP as part of a load.
2126  //
2127  // e.g. Consider if the original GEP was:
2128  // i8* getelementptr ({ [2 x i8], i32, i8, [3 x i8] }* @main.c,
2129  // i32 0, i32 0, i64 0)
2130  //
2131  // If we then tried to offset it by '8' to get to the third element,
2132  // an i8, we should *not* get:
2133  // i8* getelementptr ({ [2 x i8], i32, i8, [3 x i8] }* @main.c,
2134  // i32 0, i32 0, i64 8)
2135  //
2136  // This GEP tries to index array element '8 which runs out-of-bounds.
2137  // Subsequent evaluation would get confused and produce erroneous results.
2138  //
2139  // The following prohibits such a GEP from being formed by checking to see
2140  // if the index is in-range with respect to an array.
2141  // TODO: This code may be extended to handle vectors as well.
2142  bool PerformFold = false;
2143  if (Idx0->isNullValue())
2144  PerformFold = true;
2145  else if (LastI.isSequential())
2146  if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx0))
2147  PerformFold = (!LastI.isBoundedSequential() ||
2149  LastI.getSequentialNumElements(), CI)) &&
2150  !CE->getOperand(CE->getNumOperands() - 1)
2151  ->getType()
2152  ->isVectorTy();
2153 
2154  if (PerformFold) {
2155  SmallVector<Value*, 16> NewIndices;
2156  NewIndices.reserve(Idxs.size() + CE->getNumOperands());
2157  NewIndices.append(CE->op_begin() + 1, CE->op_end() - 1);
2158 
2159  // Add the last index of the source with the first index of the new GEP.
2160  // Make sure to handle the case when they are actually different types.
2161  Constant *Combined = CE->getOperand(CE->getNumOperands()-1);
2162  // Otherwise it must be an array.
2163  if (!Idx0->isNullValue()) {
2164  Type *IdxTy = Combined->getType();
2165  if (IdxTy != Idx0->getType()) {
2166  unsigned CommonExtendedWidth =
2167  std::max(IdxTy->getIntegerBitWidth(),
2168  Idx0->getType()->getIntegerBitWidth());
2169  CommonExtendedWidth = std::max(CommonExtendedWidth, 64U);
2170 
2171  Type *CommonTy =
2172  Type::getIntNTy(IdxTy->getContext(), CommonExtendedWidth);
2173  Constant *C1 = ConstantExpr::getSExtOrBitCast(Idx0, CommonTy);
2174  Constant *C2 = ConstantExpr::getSExtOrBitCast(Combined, CommonTy);
2175  Combined = ConstantExpr::get(Instruction::Add, C1, C2);
2176  } else {
2177  Combined =
2178  ConstantExpr::get(Instruction::Add, Idx0, Combined);
2179  }
2180  }
2181 
2182  NewIndices.push_back(Combined);
2183  NewIndices.append(Idxs.begin() + 1, Idxs.end());
2184 
2185  // The combined GEP normally inherits its index inrange attribute from
2186  // the inner GEP, but if the inner GEP's last index was adjusted by the
2187  // outer GEP, any inbounds attribute on that index is invalidated.
2188  Optional<unsigned> IRIndex = cast<GEPOperator>(CE)->getInRangeIndex();
2189  if (IRIndex && *IRIndex == CE->getNumOperands() - 2 && !Idx0->isNullValue())
2190  IRIndex = None;
2191 
2193  cast<GEPOperator>(CE)->getSourceElementType(), CE->getOperand(0),
2194  NewIndices, InBounds && cast<GEPOperator>(CE)->isInBounds(),
2195  IRIndex);
2196  }
2197  }
2198 
2199  // Attempt to fold casts to the same type away. For example, folding:
2200  //
2201  // i32* getelementptr ([2 x i32]* bitcast ([3 x i32]* %X to [2 x i32]*),
2202  // i64 0, i64 0)
2203  // into:
2204  //
2205  // i32* getelementptr ([3 x i32]* %X, i64 0, i64 0)
2206  //
2207  // Don't fold if the cast is changing address spaces.
2208  if (CE->isCast() && Idxs.size() > 1 && Idx0->isNullValue()) {
2209  PointerType *SrcPtrTy =
2210  dyn_cast<PointerType>(CE->getOperand(0)->getType());
2211  PointerType *DstPtrTy = dyn_cast<PointerType>(CE->getType());
2212  if (SrcPtrTy && DstPtrTy) {
2213  ArrayType *SrcArrayTy =
2214  dyn_cast<ArrayType>(SrcPtrTy->getElementType());
2215  ArrayType *DstArrayTy =
2216  dyn_cast<ArrayType>(DstPtrTy->getElementType());
2217  if (SrcArrayTy && DstArrayTy
2218  && SrcArrayTy->getElementType() == DstArrayTy->getElementType()
2219  && SrcPtrTy->getAddressSpace() == DstPtrTy->getAddressSpace())
2220  return ConstantExpr::getGetElementPtr(SrcArrayTy,
2221  (Constant *)CE->getOperand(0),
2222  Idxs, InBounds, InRangeIndex);
2223  }
2224  }
2225  }
2226 
2227  // Check to see if any array indices are not within the corresponding
2228  // notional array or vector bounds. If so, try to determine if they can be
2229  // factored out into preceding dimensions.
2231  Type *Ty = PointeeTy;
2232  Type *Prev = C->getType();
2233  bool Unknown =
2234  !isa<ConstantInt>(Idxs[0]) && !isa<ConstantDataVector>(Idxs[0]);
2235  for (unsigned i = 1, e = Idxs.size(); i != e;
2236  Prev = Ty, Ty = cast<CompositeType>(Ty)->getTypeAtIndex(Idxs[i]), ++i) {
2237  if (!isa<ConstantInt>(Idxs[i]) && !isa<ConstantDataVector>(Idxs[i])) {
2238  // We don't know if it's in range or not.
2239  Unknown = true;
2240  continue;
2241  }
2242  if (!isa<ConstantInt>(Idxs[i - 1]) && !isa<ConstantDataVector>(Idxs[i - 1]))
2243  // Skip if the type of the previous index is not supported.
2244  continue;
2245  if (InRangeIndex && i == *InRangeIndex + 1) {
2246  // If an index is marked inrange, we cannot apply this canonicalization to
2247  // the following index, as that will cause the inrange index to point to
2248  // the wrong element.
2249  continue;
2250  }
2251  if (isa<StructType>(Ty)) {
2252  // The verify makes sure that GEPs into a struct are in range.
2253  continue;
2254  }
2255  auto *STy = cast<SequentialType>(Ty);
2256  if (isa<VectorType>(STy)) {
2257  // There can be awkward padding in after a non-power of two vector.
2258  Unknown = true;
2259  continue;
2260  }
2261  if (ConstantInt *CI = dyn_cast<ConstantInt>(Idxs[i])) {
2262  if (isIndexInRangeOfArrayType(STy->getNumElements(), CI))
2263  // It's in range, skip to the next index.
2264  continue;
2265  if (CI->getSExtValue() < 0) {
2266  // It's out of range and negative, don't try to factor it.
2267  Unknown = true;
2268  continue;
2269  }
2270  } else {
2271  auto *CV = cast<ConstantDataVector>(Idxs[i]);
2272  bool InRange = true;
2273  for (unsigned I = 0, E = CV->getNumElements(); I != E; ++I) {
2274  auto *CI = cast<ConstantInt>(CV->getElementAsConstant(I));
2275  InRange &= isIndexInRangeOfArrayType(STy->getNumElements(), CI);
2276  if (CI->getSExtValue() < 0) {
2277  Unknown = true;
2278  break;
2279  }
2280  }
2281  if (InRange || Unknown)
2282  // It's in range, skip to the next index.
2283  // It's out of range and negative, don't try to factor it.
2284  continue;
2285  }
2286  if (isa<StructType>(Prev)) {
2287  // It's out of range, but the prior dimension is a struct
2288  // so we can't do anything about it.
2289  Unknown = true;
2290  continue;
2291  }
2292  // It's out of range, but we can factor it into the prior
2293  // dimension.
2294  NewIdxs.resize(Idxs.size());
2295  // Determine the number of elements in our sequential type.
2296  uint64_t NumElements = STy->getArrayNumElements();
2297 
2298  // Expand the current index or the previous index to a vector from a scalar
2299  // if necessary.
2300  Constant *CurrIdx = cast<Constant>(Idxs[i]);
2301  auto *PrevIdx =
2302  NewIdxs[i - 1] ? NewIdxs[i - 1] : cast<Constant>(Idxs[i - 1]);
2303  bool IsCurrIdxVector = CurrIdx->getType()->isVectorTy();
2304  bool IsPrevIdxVector = PrevIdx->getType()->isVectorTy();
2305  bool UseVector = IsCurrIdxVector || IsPrevIdxVector;
2306 
2307  if (!IsCurrIdxVector && IsPrevIdxVector)
2308  CurrIdx = ConstantDataVector::getSplat(
2309  PrevIdx->getType()->getVectorNumElements(), CurrIdx);
2310 
2311  if (!IsPrevIdxVector && IsCurrIdxVector)
2312  PrevIdx = ConstantDataVector::getSplat(
2313  CurrIdx->getType()->getVectorNumElements(), PrevIdx);
2314 
2315  Constant *Factor =
2316  ConstantInt::get(CurrIdx->getType()->getScalarType(), NumElements);
2317  if (UseVector)
2319  IsPrevIdxVector ? PrevIdx->getType()->getVectorNumElements()
2320  : CurrIdx->getType()->getVectorNumElements(),
2321  Factor);
2322 
2323  NewIdxs[i] = ConstantExpr::getSRem(CurrIdx, Factor);
2324 
2325  Constant *Div = ConstantExpr::getSDiv(CurrIdx, Factor);
2326 
2327  unsigned CommonExtendedWidth =
2328  std::max(PrevIdx->getType()->getScalarSizeInBits(),
2329  Div->getType()->getScalarSizeInBits());
2330  CommonExtendedWidth = std::max(CommonExtendedWidth, 64U);
2331 
2332  // Before adding, extend both operands to i64 to avoid
2333  // overflow trouble.
2334  Type *ExtendedTy = Type::getIntNTy(Div->getContext(), CommonExtendedWidth);
2335  if (UseVector)
2336  ExtendedTy = VectorType::get(
2337  ExtendedTy, IsPrevIdxVector
2338  ? PrevIdx->getType()->getVectorNumElements()
2339  : CurrIdx->getType()->getVectorNumElements());
2340 
2341  if (!PrevIdx->getType()->isIntOrIntVectorTy(CommonExtendedWidth))
2342  PrevIdx = ConstantExpr::getSExt(PrevIdx, ExtendedTy);
2343 
2344  if (!Div->getType()->isIntOrIntVectorTy(CommonExtendedWidth))
2345  Div = ConstantExpr::getSExt(Div, ExtendedTy);
2346 
2347  NewIdxs[i - 1] = ConstantExpr::getAdd(PrevIdx, Div);
2348  }
2349 
2350  // If we did any factoring, start over with the adjusted indices.
2351  if (!NewIdxs.empty()) {
2352  for (unsigned i = 0, e = Idxs.size(); i != e; ++i)
2353  if (!NewIdxs[i]) NewIdxs[i] = cast<Constant>(Idxs[i]);
2354  return ConstantExpr::getGetElementPtr(PointeeTy, C, NewIdxs, InBounds,
2355  InRangeIndex);
2356  }
2357 
2358  // If all indices are known integers and normalized, we can do a simple
2359  // check for the "inbounds" property.
2360  if (!Unknown && !InBounds)
2361  if (auto *GV = dyn_cast<GlobalVariable>(C))
2362  if (!GV->hasExternalWeakLinkage() && isInBoundsIndices(Idxs))
2363  return ConstantExpr::getGetElementPtr(PointeeTy, C, Idxs,
2364  /*InBounds=*/true, InRangeIndex);
2365 
2366  return nullptr;
2367 }
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
Type * getVectorElementType() const
Definition: Type.h:368
uint64_t CallInst * C
static const fltSemantics & IEEEquad() LLVM_READNONE
Definition: APFloat.cpp:126
static Constant * FoldBitCast(Constant *V, Type *DestTy)
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:574
class_match< UndefValue > m_Undef()
Match an arbitrary undef constant.
Definition: PatternMatch.h:88
bool isAllOnesValue() const
Return true if this is the value that would be returned by getAllOnesValue.
Definition: Constants.cpp:100
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:173
opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)
Definition: APFloat.h:1077
unsigned getOpcode() const
Return the opcode at the root of this constant expression.
Definition: Constants.h:1194
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
Definition: PatternMatch.h:373
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static Constant * getNaN(Type *Ty, bool Negative=false, unsigned type=0)
Definition: Constants.cpp:715
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant *> IdxList, bool InBounds=false, Optional< unsigned > InRangeIndex=None, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
Definition: Constants.h:1138
bool isSized(SmallPtrSetImpl< Type *> *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:262
iterator begin() const
Definition: ArrayRef.h:137
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:137
APInt sdiv(const APInt &RHS) const
Signed division function for APInt.
Definition: APInt.cpp:1601
bool isFP128Ty() const
Return true if this is &#39;fp128&#39;.
Definition: Type.h:156
Constant * ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx)
Attempt to constant fold an extractelement instruction with the specified operands and indices...
bool slt(const APInt &RHS) const
Signed less than comparison.
Definition: APInt.h:1188
APInt udiv(const APInt &RHS) const
Unsigned division operation.
Definition: APInt.cpp:1530
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Get a value with low bits set.
Definition: APInt.h:641
static Constant * getFoldedOffsetOf(Type *Ty, Constant *FieldNo, Type *DestTy, bool Folded)
Return a ConstantExpr with type DestTy for offsetof on Ty and FieldNo, with any known factors factore...
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space...
Definition: Type.cpp:617
gep_type_iterator gep_type_end(const User *GEP)
unsigned less or equal
Definition: InstrTypes.h:911
unsigned less than
Definition: InstrTypes.h:910
Constant * ConstantFoldCastInstruction(unsigned opcode, Constant *V, Type *DestTy)
static Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2042
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:891
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:713
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:901
bool sgt(const APInt &RHS) const
Signed greather than comparison.
Definition: APInt.h:1258
APInt trunc(unsigned width) const
Truncate to new width.
Definition: APInt.cpp:817
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:177
static Constant * getCompare(unsigned short pred, Constant *C1, Constant *C2, bool OnlyIfReduced=false)
Return an ICmp or FCmp comparison operator constant expression.
Definition: Constants.cpp:1894
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:227
static Constant * getFoldedAlignOf(Type *Ty, Type *DestTy, bool Folded)
Return a ConstantExpr with type DestTy for alignof on Ty, with any known factors factored out...
void reserve(size_type N)
Definition: SmallVector.h:377
bool sle(const APInt &RHS) const
Signed less or equal comparison.
Definition: APInt.h:1223
bool isPPC_FP128Ty() const
Return true if this is powerpc long double.
Definition: Type.h:159
static Constant * get(ArrayType *T, ArrayRef< Constant *> V)
Definition: Constants.cpp:950
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1493
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:130
static Constant * getNullValue(Type *Ty)
Constructor to create a &#39;0&#39; constant of arbitrary type.
Definition: Constants.cpp:258
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2177
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
Definition: APFloat.h:1069
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:896
static bool InRange(int64_t Value, unsigned short Shift, int LBound, int HBound)
opStatus divide(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:968
The address of a basic block.
Definition: Constants.h:836
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:895
bool isSigned() const
Definition: InstrTypes.h:1054
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
Definition: InstrTypes.h:983
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
bool isFloatingPointTy() const
Return true if this is one of the six floating-point types.
Definition: Type.h:162
APInt shl(unsigned shiftAmt) const
Left-shift function.
Definition: APInt.h:986
Class to represent struct types.
Definition: DerivedTypes.h:201
static Constant * getLShr(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2255
static ICmpInst::Predicate evaluateICmpRelation(Constant *V1, Constant *V2, bool isSigned)
This function determines if there is anything we can decide about the two constants provided...
static Constant * BitCastConstantVector(Constant *CV, VectorType *DstTy)
Convert the specified vector Constant node to the specified vector type.
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:197
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:892
static Constant * getSExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1618
uint64_t getNumElements() const
Definition: DerivedTypes.h:359
void lshrInPlace(unsigned ShiftAmt)
Logical right-shift this APInt by ShiftAmt in place.
Definition: APInt.h:971
unsigned getActiveBits() const
Compute the number of active bits in the value.
Definition: APInt.h:1517
bool isOne() const
This is just a convenience method to make client code smaller for a common case.
Definition: Constants.h:201
static Constant * get(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags=0, Type *OnlyIfReducedTy=nullptr)
get - Return a binary or shift operator constant expression, folding if possible. ...
Definition: Constants.cpp:1773
static Constant * getSizeOf(Type *Ty)
getSizeOf constant expr - computes the (alloc) size of a type (in address-units, not bits) in a targe...
Definition: Constants.cpp:1853
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:85
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:885
static unsigned foldConstantCastPair(unsigned opc, ConstantExpr *Op, Type *DstTy)
This function determines which opcode to use to fold two constant cast expressions together...
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
bool isFirstClassType() const
Return true if the type is "first class", meaning it is a valid type for a Value. ...
Definition: Type.h:241
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition: APFloat.cpp:4444
static int IdxCompare(Constant *C1, Constant *C2, Type *ElTy)
Compare the two constants as though they were getelementptr indices.
#define T
Class to represent array types.
Definition: DerivedTypes.h:369
static Constant * getSelect(Constant *C, Constant *V1, Constant *V2, Type *OnlyIfReducedTy=nullptr)
Select constant expr.
Definition: Constants.cpp:1916
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:138
bool isGEPWithNoNotionalOverIndexing() const
Return true if this is a getelementptr expression and all the index operands are compile-time known i...
Definition: Constants.cpp:1120
opStatus subtract(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:950
cmpResult
IEEE-754R 5.11: Floating Point Comparison Relations.
Definition: APFloat.h:166
Constant * ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs)
ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue instruction with the spe...
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:203
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:123
unsigned getAlignment() const
Definition: Globals.cpp:97
Value * getOperand(unsigned i) const
Definition: User.h:170
Class to represent pointers.
Definition: DerivedTypes.h:467
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:328
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return &#39;this&#39;.
Definition: Type.h:301
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1740
static ICmpInst::Predicate areGlobalsPotentiallyEqual(const GlobalValue *GV1, const GlobalValue *GV2)
bool isFloatTy() const
Return true if this is &#39;float&#39;, a 32-bit IEEE fp type.
Definition: Type.h:147
Constant * ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, Constant *Mask)
Attempt to constant fold a shufflevector instruction with the specified operands and indices...
bool hasAllZeroIndices() const
Return true if all of the indices of this GEP are zeros.
Definition: Operator.h:494
bool isAllOnesValue() const
Determine if all bits are set.
Definition: APInt.h:389
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:149
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt...
Definition: PatternMatch.h:177
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1368
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
Definition: APInt.cpp:1623
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
bool ult(const APInt &RHS) const
Unsigned less than comparison.
Definition: APInt.h:1169
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:42
static Constant * getFoldedSizeOf(Type *Ty, Type *DestTy, bool Folded)
Return a ConstantExpr with type DestTy for sizeof on Ty, with any known factors factored out...
This file contains the declarations for the subclasses of Constant, which represent the different fla...
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:221
static Constant * getAnd(Constant *C1, Constant *C2)
Definition: Constants.cpp:2236
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:264
static Constant * getSExtOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:1542
bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
bool isMinSignedValue() const
Determine if this is the smallest signed value.
Definition: APInt.h:436
bool isHalfTy() const
Return true if this is &#39;half&#39;, a 16-bit IEEE fp type.
Definition: Type.h:144
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:885
bool isBinaryOp() const
Definition: Instruction.h:130
opStatus multiply(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:959
static Constant * get(StructType *T, ArrayRef< Constant *> V)
Definition: Constants.cpp:1011
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:894
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:495
bool isX86_MMXTy() const
Return true if this is X86 MMX.
Definition: Type.h:182
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
Definition: Constants.cpp:1992
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition: APFloat.cpp:129
Class to represent integer types.
Definition: DerivedTypes.h:40
Constant Vector Declarations.
Definition: Constants.h:496
static Constant * getSplat(unsigned NumElts, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
Definition: Constants.cpp:2550
static Constant * getNot(Constant *C)
Definition: Constants.cpp:2171
static Constant * getAllOnesValue(Type *Ty)
Definition: Constants.cpp:312
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:902
static UndefValue * get(Type *T)
Static factory methods - Return an &#39;undef&#39; object of the specified type.
Definition: Constants.cpp:1382
bool isCast() const
Definition: Instruction.h:132
static wasm::ValType getType(const TargetRegisterClass *RC)
Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
static int getMaskValue(const Constant *Mask, unsigned Elt)
Return the shuffle mask value for the specified element of the mask.
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:900
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
const T * data() const
Definition: ArrayRef.h:146
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
Definition: APInt.h:964
signed greater than
Definition: InstrTypes.h:912
hexagon gen pred
static Constant * getFCmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
Definition: Constants.cpp:2017
This is the superclass of the array and vector type classes.
Definition: DerivedTypes.h:343
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:889
static Constant * getPointerCast(Constant *C, Type *Ty)
Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant expression.
Definition: Constants.cpp:1554
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
Definition: APInt.h:940
static Constant * getSplat(unsigned NumElts, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
Definition: Constants.cpp:1086
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:240
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:120
static Constant * ExtractConstantBytes(Constant *C, unsigned ByteStart, unsigned ByteSize)
V is an integer constant which only has a subset of its bytes used.
unsigned getNumOperands() const
Definition: User.h:192
static bool isIndexInRangeOfArrayType(uint64_t NumElements, const ConstantInt *CI)
Test whether a given ConstantInt is in-range for a SequentialType.
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
static const fltSemantics & IEEEhalf() LLVM_READNONE
Definition: APFloat.cpp:117
static Constant * getSDiv(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2215
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type...
Definition: Type.cpp:130
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:899
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
iterator end() const
Definition: ArrayRef.h:138
static Constant * getNUWMul(Constant *C1, Constant *C2)
Definition: Constants.h:993
signed less than
Definition: InstrTypes.h:914
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
Definition: Type.cpp:180
static unsigned isEliminableCastPair(Instruction::CastOps firstOpcode, Instruction::CastOps secondOpcode, Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy, Type *DstIntPtrTy)
Determine how a pair of casts can be eliminated, if they can be at all.
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1604
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:611
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
Definition: Constants.cpp:674
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
Definition: APInt.h:1277
static bool isMaybeZeroSizedType(Type *Ty)
This type is zero-sized if it&#39;s an array or structure of zero-sized types.
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:567
bool isCommutative() const
Return true if the instruction is commutative:
Definition: Instruction.h:452
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
Definition: MathExtras.h:531
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:462
bool isIntPredicate() const
Definition: InstrTypes.h:977
bool isTrueWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:1079
signed less or equal
Definition: InstrTypes.h:915
Class to represent vector types.
Definition: DerivedTypes.h:393
Class for arbitrary precision integers.
Definition: APInt.h:69
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
Definition: APInt.h:1207
bool sge(const APInt &RHS) const
Signed greater or equal comparison.
Definition: APInt.h:1293
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:1497
opStatus mod(const APFloat &RHS)
Definition: APFloat.h:986
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array...
Definition: ArrayRef.h:179
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:395
bool isX86_FP80Ty() const
Return true if this is x86 long double.
Definition: Type.h:153
static const fltSemantics & PPCDoubleDouble() LLVM_READNONE
Definition: APFloat.cpp:135
Constant * ConstantFoldCompareInstruction(unsigned short predicate, Constant *C1, Constant *C2)
opStatus add(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:941
bool ugt(const APInt &RHS) const
Unsigned greather than comparison.
Definition: APInt.h:1239
Constant * ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2)
Attempt to constant fold a select instruction with the specified operands.
static Type * getIndexedType(Type *Ty, ArrayRef< Value *> IdxList)
Returns the type of the element that would be loaded with a load instruction with the specified param...
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:176
unsigned getIntegerBitWidth() const
Definition: DerivedTypes.h:97
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:62
static Constant * getOffsetOf(StructType *STy, unsigned FieldNo)
getOffsetOf constant expr - computes the offset of a struct field in a target independent way (Note: ...
Definition: Constants.cpp:1876
unsigned greater or equal
Definition: InstrTypes.h:909
static bool isUnordered(Predicate predicate)
Determine if the predicate is an unordered operation.
static bool isInBoundsIndices(ArrayRef< IndexTy > Idxs)
Test whether the given sequence of normalized indices is "inbounds".
APInt srem(const APInt &RHS) const
Function for signed remainder operation.
Definition: APInt.cpp:1693
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant *> IdxList)
Create an "inbounds" getelementptr.
Definition: Constants.h:1165
bool isEquality() const
Return true if this predicate is either EQ or NE.
static Instruction::CastOps getCastOpcode(const Value *Val, bool SrcIsSigned, Type *Ty, bool DstIsSigned)
Returns the opcode necessary to cast Val into Ty using usual casting rules.
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
static Constant * getOr(Constant *C1, Constant *C2)
Definition: Constants.cpp:2240
static const fltSemantics & Bogus() LLVM_READNONE
A Pseudo fltsemantic used to construct APFloats that cannot conflict with anything real...
Definition: APFloat.cpp:132
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:193
Constant * ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt, Constant *Idx)
Attempt to constant fold an insertelement instruction with the specified operands and indices...
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:893
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:897
Constant * ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool InBounds, Optional< unsigned > InRangeIndex, ArrayRef< Value *> Idxs)
static Type * getGEPReturnType(Value *Ptr, ArrayRef< Value *> IdxList)
Returns the pointer type returned by the GEP instruction, which may be a vector of pointers...
Definition: Instructions.h:998
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static Constant * getSRem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2228
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:115
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:888
LLVM Value Representation.
Definition: Value.h:73
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:898
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:352
static VectorType * get(Type *ElementType, unsigned NumElements)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:593
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:235
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:81
bool isCast() const
Return true if this is a convert constant expression.
Definition: Constants.cpp:1112
Type * getElementType() const
Definition: DerivedTypes.h:360
unsigned greater than
Definition: InstrTypes.h:908
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Definition: InstrTypes.h:999
Type * getSourceElementType() const
Definition: Operator.cpp:23
Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)
Attempt to constant fold an extractvalue instruction with the specified operands and indices...
bool isEmptyTy() const
Return true if this type is empty, that is, it has no elements or all of its elements are empty...
Definition: Type.cpp:98
static APInt getNullValue(unsigned numBits)
Get the &#39;0&#39; value.
Definition: APInt.h:562
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
Definition: Constants.h:157
static Constant * getAlignOf(Type *Ty)
getAlignOf constant expr - computes the alignment of a type in a target independent way (Note: the re...
Definition: Constants.cpp:1863
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2199
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:890
bool isDoubleTy() const
Return true if this is &#39;double&#39;, a 64-bit IEEE fp type.
Definition: Type.h:150
static Constant * get(ArrayRef< Constant *> V)
Definition: Constants.cpp:1046
Type * getElementType() const
Definition: DerivedTypes.h:486
static FCmpInst::Predicate evaluateFCmpRelation(Constant *V1, Constant *V2)
This function determines if there is anything we can decide about the two constants provided...
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:887
signed greater or equal
Definition: InstrTypes.h:913
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144
cmpResult compare(const APFloat &RHS) const
Definition: APFloat.h:1102
static Constant * getXor(Constant *C1, Constant *C2)
Definition: Constants.cpp:2244
const fltSemantics & getFltSemantics() const
Definition: Type.h:169
gep_type_iterator gep_type_begin(const User *GEP)
void resize(size_type N)
Definition: SmallVector.h:352