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