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