LLVM  6.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  GEPOperator *GEPO = cast<GEPOperator>(CE);
633  Type *Ty = GEPO->getSourceElementType();
634  if (CE->getNumOperands() == 2) {
635  // Handle a sizeof-like expression.
636  Constant *Idx = CE->getOperand(1);
637  bool isOne = isa<ConstantInt>(Idx) && cast<ConstantInt>(Idx)->isOne();
638  if (Constant *C = getFoldedSizeOf(Ty, DestTy, !isOne)) {
640  DestTy, false),
641  Idx, DestTy);
642  return ConstantExpr::getMul(C, Idx);
643  }
644  } else if (CE->getNumOperands() == 3 &&
645  CE->getOperand(1)->isNullValue()) {
646  // Handle an alignof-like expression.
647  if (StructType *STy = dyn_cast<StructType>(Ty))
648  if (!STy->isPacked()) {
649  ConstantInt *CI = cast<ConstantInt>(CE->getOperand(2));
650  if (CI->isOne() &&
651  STy->getNumElements() == 2 &&
652  STy->getElementType(0)->isIntegerTy(1)) {
653  return getFoldedAlignOf(STy->getElementType(1), DestTy, false);
654  }
655  }
656  // Handle an offsetof-like expression.
657  if (Ty->isStructTy() || Ty->isArrayTy()) {
658  if (Constant *C = getFoldedOffsetOf(Ty, CE->getOperand(2),
659  DestTy, false))
660  return C;
661  }
662  }
663  }
664  // Other pointer types cannot be casted
665  return nullptr;
666  case Instruction::UIToFP:
667  case Instruction::SIToFP:
668  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
669  const APInt &api = CI->getValue();
670  APFloat apf(DestTy->getFltSemantics(),
672  if (APFloat::opOverflow &
673  apf.convertFromAPInt(api, opc==Instruction::SIToFP,
675  // Undefined behavior invoked - the destination type can't represent
676  // the input constant.
677  return UndefValue::get(DestTy);
678  }
679  return ConstantFP::get(V->getContext(), apf);
680  }
681  return nullptr;
682  case Instruction::ZExt:
683  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
684  uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
685  return ConstantInt::get(V->getContext(),
686  CI->getValue().zext(BitWidth));
687  }
688  return nullptr;
689  case Instruction::SExt:
690  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
691  uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
692  return ConstantInt::get(V->getContext(),
693  CI->getValue().sext(BitWidth));
694  }
695  return nullptr;
696  case Instruction::Trunc: {
697  if (V->getType()->isVectorTy())
698  return nullptr;
699 
700  uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
701  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
702  return ConstantInt::get(V->getContext(),
703  CI->getValue().trunc(DestBitWidth));
704  }
705 
706  // The input must be a constantexpr. See if we can simplify this based on
707  // the bytes we are demanding. Only do this if the source and dest are an
708  // even multiple of a byte.
709  if ((DestBitWidth & 7) == 0 &&
710  (cast<IntegerType>(V->getType())->getBitWidth() & 7) == 0)
711  if (Constant *Res = ExtractConstantBytes(V, 0, DestBitWidth / 8))
712  return Res;
713 
714  return nullptr;
715  }
716  case Instruction::BitCast:
717  return FoldBitCast(V, DestTy);
718  case Instruction::AddrSpaceCast:
719  return nullptr;
720  }
721 }
722 
724  Constant *V1, Constant *V2) {
725  // Check for i1 and vector true/false conditions.
726  if (Cond->isNullValue()) return V2;
727  if (Cond->isAllOnesValue()) return V1;
728 
729  // If the condition is a vector constant, fold the result elementwise.
730  if (ConstantVector *CondV = dyn_cast<ConstantVector>(Cond)) {
732  Type *Ty = IntegerType::get(CondV->getContext(), 32);
733  for (unsigned i = 0, e = V1->getType()->getVectorNumElements(); i != e;++i){
734  Constant *V;
736  ConstantInt::get(Ty, i));
738  ConstantInt::get(Ty, i));
739  Constant *Cond = dyn_cast<Constant>(CondV->getOperand(i));
740  if (V1Element == V2Element) {
741  V = V1Element;
742  } else if (isa<UndefValue>(Cond)) {
743  V = isa<UndefValue>(V1Element) ? V1Element : V2Element;
744  } else {
745  if (!isa<ConstantInt>(Cond)) break;
746  V = Cond->isNullValue() ? V2Element : V1Element;
747  }
748  Result.push_back(V);
749  }
750 
751  // If we were able to build the vector, return it.
752  if (Result.size() == V1->getType()->getVectorNumElements())
753  return ConstantVector::get(Result);
754  }
755 
756  if (isa<UndefValue>(Cond)) {
757  if (isa<UndefValue>(V1)) return V1;
758  return V2;
759  }
760  if (isa<UndefValue>(V1)) return V2;
761  if (isa<UndefValue>(V2)) return V1;
762  if (V1 == V2) return V1;
763 
764  if (ConstantExpr *TrueVal = dyn_cast<ConstantExpr>(V1)) {
765  if (TrueVal->getOpcode() == Instruction::Select)
766  if (TrueVal->getOperand(0) == Cond)
767  return ConstantExpr::getSelect(Cond, TrueVal->getOperand(1), V2);
768  }
769  if (ConstantExpr *FalseVal = dyn_cast<ConstantExpr>(V2)) {
770  if (FalseVal->getOpcode() == Instruction::Select)
771  if (FalseVal->getOperand(0) == Cond)
772  return ConstantExpr::getSelect(Cond, V1, FalseVal->getOperand(2));
773  }
774 
775  return nullptr;
776 }
777 
779  Constant *Idx) {
780  if (isa<UndefValue>(Val)) // ee(undef, x) -> undef
781  return UndefValue::get(Val->getType()->getVectorElementType());
782  if (Val->isNullValue()) // ee(zero, x) -> zero
784  // ee({w,x,y,z}, undef) -> undef
785  if (isa<UndefValue>(Idx))
786  return UndefValue::get(Val->getType()->getVectorElementType());
787 
788  if (ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx)) {
789  // ee({w,x,y,z}, wrong_value) -> undef
790  if (CIdx->uge(Val->getType()->getVectorNumElements()))
791  return UndefValue::get(Val->getType()->getVectorElementType());
792  return Val->getAggregateElement(CIdx->getZExtValue());
793  }
794  return nullptr;
795 }
796 
798  Constant *Elt,
799  Constant *Idx) {
800  if (isa<UndefValue>(Idx))
801  return UndefValue::get(Val->getType());
802 
803  ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx);
804  if (!CIdx) return nullptr;
805 
806  unsigned NumElts = Val->getType()->getVectorNumElements();
807  if (CIdx->uge(NumElts))
808  return UndefValue::get(Val->getType());
809 
811  Result.reserve(NumElts);
812  auto *Ty = Type::getInt32Ty(Val->getContext());
813  uint64_t IdxVal = CIdx->getZExtValue();
814  for (unsigned i = 0; i != NumElts; ++i) {
815  if (i == IdxVal) {
816  Result.push_back(Elt);
817  continue;
818  }
819 
821  Result.push_back(C);
822  }
823 
824  return ConstantVector::get(Result);
825 }
826 
828  Constant *V2,
829  Constant *Mask) {
830  unsigned MaskNumElts = Mask->getType()->getVectorNumElements();
831  Type *EltTy = V1->getType()->getVectorElementType();
832 
833  // Undefined shuffle mask -> undefined value.
834  if (isa<UndefValue>(Mask))
835  return UndefValue::get(VectorType::get(EltTy, MaskNumElts));
836 
837  // Don't break the bitcode reader hack.
838  if (isa<ConstantExpr>(Mask)) return nullptr;
839 
840  unsigned SrcNumElts = V1->getType()->getVectorNumElements();
841 
842  // Loop over the shuffle mask, evaluating each element.
844  for (unsigned i = 0; i != MaskNumElts; ++i) {
845  int Elt = ShuffleVectorInst::getMaskValue(Mask, i);
846  if (Elt == -1) {
847  Result.push_back(UndefValue::get(EltTy));
848  continue;
849  }
850  Constant *InElt;
851  if (unsigned(Elt) >= SrcNumElts*2)
852  InElt = UndefValue::get(EltTy);
853  else if (unsigned(Elt) >= SrcNumElts) {
854  Type *Ty = IntegerType::get(V2->getContext(), 32);
855  InElt =
857  ConstantInt::get(Ty, Elt - SrcNumElts));
858  } else {
859  Type *Ty = IntegerType::get(V1->getContext(), 32);
861  }
862  Result.push_back(InElt);
863  }
864 
865  return ConstantVector::get(Result);
866 }
867 
869  ArrayRef<unsigned> Idxs) {
870  // Base case: no indices, so return the entire value.
871  if (Idxs.empty())
872  return Agg;
873 
874  if (Constant *C = Agg->getAggregateElement(Idxs[0]))
876 
877  return nullptr;
878 }
879 
881  Constant *Val,
882  ArrayRef<unsigned> Idxs) {
883  // Base case: no indices, so replace the entire value.
884  if (Idxs.empty())
885  return Val;
886 
887  unsigned NumElts;
888  if (StructType *ST = dyn_cast<StructType>(Agg->getType()))
889  NumElts = ST->getNumElements();
890  else
891  NumElts = cast<SequentialType>(Agg->getType())->getNumElements();
892 
894  for (unsigned i = 0; i != NumElts; ++i) {
895  Constant *C = Agg->getAggregateElement(i);
896  if (!C) return nullptr;
897 
898  if (Idxs[0] == i)
899  C = ConstantFoldInsertValueInstruction(C, Val, Idxs.slice(1));
900 
901  Result.push_back(C);
902  }
903 
904  if (StructType *ST = dyn_cast<StructType>(Agg->getType()))
905  return ConstantStruct::get(ST, Result);
906  if (ArrayType *AT = dyn_cast<ArrayType>(Agg->getType()))
907  return ConstantArray::get(AT, Result);
908  return ConstantVector::get(Result);
909 }
910 
911 
913  Constant *C1, Constant *C2) {
914  assert(Instruction::isBinaryOp(Opcode) && "Non-binary instruction detected");
915 
916  // Handle UndefValue up front.
917  if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) {
918  switch (static_cast<Instruction::BinaryOps>(Opcode)) {
919  case Instruction::Xor:
920  if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
921  // Handle undef ^ undef -> 0 special case. This is a common
922  // idiom (misuse).
923  return Constant::getNullValue(C1->getType());
925  case Instruction::Add:
926  case Instruction::Sub:
927  return UndefValue::get(C1->getType());
928  case Instruction::And:
929  if (isa<UndefValue>(C1) && isa<UndefValue>(C2)) // undef & undef -> undef
930  return C1;
931  return Constant::getNullValue(C1->getType()); // undef & X -> 0
932  case Instruction::Mul: {
933  // undef * undef -> undef
934  if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
935  return C1;
936  const APInt *CV;
937  // X * undef -> undef if X is odd
938  if (match(C1, m_APInt(CV)) || match(C2, m_APInt(CV)))
939  if ((*CV)[0])
940  return UndefValue::get(C1->getType());
941 
942  // X * undef -> 0 otherwise
943  return Constant::getNullValue(C1->getType());
944  }
945  case Instruction::SDiv:
946  case Instruction::UDiv:
947  // X / undef -> undef
948  if (isa<UndefValue>(C2))
949  return C2;
950  // undef / 0 -> undef
951  // undef / 1 -> undef
952  if (match(C2, m_Zero()) || match(C2, m_One()))
953  return C1;
954  // undef / X -> 0 otherwise
955  return Constant::getNullValue(C1->getType());
956  case Instruction::URem:
957  case Instruction::SRem:
958  // X % undef -> undef
959  if (match(C2, m_Undef()))
960  return C2;
961  // undef % 0 -> undef
962  if (match(C2, m_Zero()))
963  return C1;
964  // undef % X -> 0 otherwise
965  return Constant::getNullValue(C1->getType());
966  case Instruction::Or: // X | undef -> -1
967  if (isa<UndefValue>(C1) && isa<UndefValue>(C2)) // undef | undef -> undef
968  return C1;
969  return Constant::getAllOnesValue(C1->getType()); // undef | X -> ~0
970  case Instruction::LShr:
971  // X >>l undef -> undef
972  if (isa<UndefValue>(C2))
973  return C2;
974  // undef >>l 0 -> undef
975  if (match(C2, m_Zero()))
976  return C1;
977  // undef >>l X -> 0
978  return Constant::getNullValue(C1->getType());
979  case Instruction::AShr:
980  // X >>a undef -> undef
981  if (isa<UndefValue>(C2))
982  return C2;
983  // undef >>a 0 -> undef
984  if (match(C2, m_Zero()))
985  return C1;
986  // TODO: undef >>a X -> undef if the shift is exact
987  // undef >>a X -> 0
988  return Constant::getNullValue(C1->getType());
989  case Instruction::Shl:
990  // X << undef -> undef
991  if (isa<UndefValue>(C2))
992  return C2;
993  // undef << 0 -> undef
994  if (match(C2, m_Zero()))
995  return C1;
996  // undef << X -> 0
997  return Constant::getNullValue(C1->getType());
998  case Instruction::FAdd:
999  case Instruction::FSub:
1000  case Instruction::FMul:
1001  case Instruction::FDiv:
1002  case Instruction::FRem:
1003  // TODO: UNDEF handling for binary float instructions.
1004  return nullptr;
1005  case Instruction::BinaryOpsEnd:
1006  llvm_unreachable("Invalid BinaryOp");
1007  }
1008  }
1009 
1010  // At this point neither constant should be an UndefValue.
1011  assert(!isa<UndefValue>(C1) && !isa<UndefValue>(C2) &&
1012  "Unexpected UndefValue");
1013 
1014  // Handle simplifications when the RHS is a constant int.
1015  if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
1016  switch (Opcode) {
1017  case Instruction::Add:
1018  if (CI2->isZero()) return C1; // X + 0 == X
1019  break;
1020  case Instruction::Sub:
1021  if (CI2->isZero()) return C1; // X - 0 == X
1022  break;
1023  case Instruction::Mul:
1024  if (CI2->isZero()) return C2; // X * 0 == 0
1025  if (CI2->isOne())
1026  return C1; // X * 1 == X
1027  break;
1028  case Instruction::UDiv:
1029  case Instruction::SDiv:
1030  if (CI2->isOne())
1031  return C1; // X / 1 == X
1032  if (CI2->isZero())
1033  return UndefValue::get(CI2->getType()); // X / 0 == undef
1034  break;
1035  case Instruction::URem:
1036  case Instruction::SRem:
1037  if (CI2->isOne())
1038  return Constant::getNullValue(CI2->getType()); // X % 1 == 0
1039  if (CI2->isZero())
1040  return UndefValue::get(CI2->getType()); // X % 0 == undef
1041  break;
1042  case Instruction::And:
1043  if (CI2->isZero()) return C2; // X & 0 == 0
1044  if (CI2->isMinusOne())
1045  return C1; // X & -1 == X
1046 
1047  if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
1048  // (zext i32 to i64) & 4294967295 -> (zext i32 to i64)
1049  if (CE1->getOpcode() == Instruction::ZExt) {
1050  unsigned DstWidth = CI2->getType()->getBitWidth();
1051  unsigned SrcWidth =
1052  CE1->getOperand(0)->getType()->getPrimitiveSizeInBits();
1053  APInt PossiblySetBits(APInt::getLowBitsSet(DstWidth, SrcWidth));
1054  if ((PossiblySetBits & CI2->getValue()) == PossiblySetBits)
1055  return C1;
1056  }
1057 
1058  // If and'ing the address of a global with a constant, fold it.
1059  if (CE1->getOpcode() == Instruction::PtrToInt &&
1060  isa<GlobalValue>(CE1->getOperand(0))) {
1061  GlobalValue *GV = cast<GlobalValue>(CE1->getOperand(0));
1062 
1063  // Functions are at least 4-byte aligned.
1064  unsigned GVAlign = GV->getAlignment();
1065  if (isa<Function>(GV))
1066  GVAlign = std::max(GVAlign, 4U);
1067 
1068  if (GVAlign > 1) {
1069  unsigned DstWidth = CI2->getType()->getBitWidth();
1070  unsigned SrcWidth = std::min(DstWidth, Log2_32(GVAlign));
1071  APInt BitsNotSet(APInt::getLowBitsSet(DstWidth, SrcWidth));
1072 
1073  // If checking bits we know are clear, return zero.
1074  if ((CI2->getValue() & BitsNotSet) == CI2->getValue())
1075  return Constant::getNullValue(CI2->getType());
1076  }
1077  }
1078  }
1079  break;
1080  case Instruction::Or:
1081  if (CI2->isZero()) return C1; // X | 0 == X
1082  if (CI2->isMinusOne())
1083  return C2; // X | -1 == -1
1084  break;
1085  case Instruction::Xor:
1086  if (CI2->isZero()) return C1; // X ^ 0 == X
1087 
1088  if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
1089  switch (CE1->getOpcode()) {
1090  default: break;
1091  case Instruction::ICmp:
1092  case Instruction::FCmp:
1093  // cmp pred ^ true -> cmp !pred
1094  assert(CI2->isOne());
1095  CmpInst::Predicate pred = (CmpInst::Predicate)CE1->getPredicate();
1096  pred = CmpInst::getInversePredicate(pred);
1097  return ConstantExpr::getCompare(pred, CE1->getOperand(0),
1098  CE1->getOperand(1));
1099  }
1100  }
1101  break;
1102  case Instruction::AShr:
1103  // ashr (zext C to Ty), C2 -> lshr (zext C, CSA), C2
1104  if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1))
1105  if (CE1->getOpcode() == Instruction::ZExt) // Top bits known zero.
1106  return ConstantExpr::getLShr(C1, C2);
1107  break;
1108  }
1109  } else if (isa<ConstantInt>(C1)) {
1110  // If C1 is a ConstantInt and C2 is not, swap the operands.
1111  if (Instruction::isCommutative(Opcode))
1112  return ConstantExpr::get(Opcode, C2, C1);
1113  }
1114 
1115  if (ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
1116  if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
1117  const APInt &C1V = CI1->getValue();
1118  const APInt &C2V = CI2->getValue();
1119  switch (Opcode) {
1120  default:
1121  break;
1122  case Instruction::Add:
1123  return ConstantInt::get(CI1->getContext(), C1V + C2V);
1124  case Instruction::Sub:
1125  return ConstantInt::get(CI1->getContext(), C1V - C2V);
1126  case Instruction::Mul:
1127  return ConstantInt::get(CI1->getContext(), C1V * C2V);
1128  case Instruction::UDiv:
1129  assert(!CI2->isZero() && "Div by zero handled above");
1130  return ConstantInt::get(CI1->getContext(), C1V.udiv(C2V));
1131  case Instruction::SDiv:
1132  assert(!CI2->isZero() && "Div by zero handled above");
1133  if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
1134  return UndefValue::get(CI1->getType()); // MIN_INT / -1 -> undef
1135  return ConstantInt::get(CI1->getContext(), C1V.sdiv(C2V));
1136  case Instruction::URem:
1137  assert(!CI2->isZero() && "Div by zero handled above");
1138  return ConstantInt::get(CI1->getContext(), C1V.urem(C2V));
1139  case Instruction::SRem:
1140  assert(!CI2->isZero() && "Div by zero handled above");
1141  if (C2V.isAllOnesValue() && C1V.isMinSignedValue())
1142  return UndefValue::get(CI1->getType()); // MIN_INT % -1 -> undef
1143  return ConstantInt::get(CI1->getContext(), C1V.srem(C2V));
1144  case Instruction::And:
1145  return ConstantInt::get(CI1->getContext(), C1V & C2V);
1146  case Instruction::Or:
1147  return ConstantInt::get(CI1->getContext(), C1V | C2V);
1148  case Instruction::Xor:
1149  return ConstantInt::get(CI1->getContext(), C1V ^ C2V);
1150  case Instruction::Shl:
1151  if (C2V.ult(C1V.getBitWidth()))
1152  return ConstantInt::get(CI1->getContext(), C1V.shl(C2V));
1153  return UndefValue::get(C1->getType()); // too big shift is undef
1154  case Instruction::LShr:
1155  if (C2V.ult(C1V.getBitWidth()))
1156  return ConstantInt::get(CI1->getContext(), C1V.lshr(C2V));
1157  return UndefValue::get(C1->getType()); // too big shift is undef
1158  case Instruction::AShr:
1159  if (C2V.ult(C1V.getBitWidth()))
1160  return ConstantInt::get(CI1->getContext(), C1V.ashr(C2V));
1161  return UndefValue::get(C1->getType()); // too big shift is undef
1162  }
1163  }
1164 
1165  switch (Opcode) {
1166  case Instruction::SDiv:
1167  case Instruction::UDiv:
1168  case Instruction::URem:
1169  case Instruction::SRem:
1170  case Instruction::LShr:
1171  case Instruction::AShr:
1172  case Instruction::Shl:
1173  if (CI1->isZero()) return C1;
1174  break;
1175  default:
1176  break;
1177  }
1178  } else if (ConstantFP *CFP1 = dyn_cast<ConstantFP>(C1)) {
1179  if (ConstantFP *CFP2 = dyn_cast<ConstantFP>(C2)) {
1180  const APFloat &C1V = CFP1->getValueAPF();
1181  const APFloat &C2V = CFP2->getValueAPF();
1182  APFloat C3V = C1V; // copy for modification
1183  switch (Opcode) {
1184  default:
1185  break;
1186  case Instruction::FAdd:
1187  (void)C3V.add(C2V, APFloat::rmNearestTiesToEven);
1188  return ConstantFP::get(C1->getContext(), C3V);
1189  case Instruction::FSub:
1190  (void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven);
1191  return ConstantFP::get(C1->getContext(), C3V);
1192  case Instruction::FMul:
1193  (void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven);
1194  return ConstantFP::get(C1->getContext(), C3V);
1195  case Instruction::FDiv:
1196  (void)C3V.divide(C2V, APFloat::rmNearestTiesToEven);
1197  return ConstantFP::get(C1->getContext(), C3V);
1198  case Instruction::FRem:
1199  (void)C3V.mod(C2V);
1200  return ConstantFP::get(C1->getContext(), C3V);
1201  }
1202  }
1203  } else if (VectorType *VTy = dyn_cast<VectorType>(C1->getType())) {
1204  // Perform elementwise folding.
1206  Type *Ty = IntegerType::get(VTy->getContext(), 32);
1207  for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
1208  Constant *ExtractIdx = ConstantInt::get(Ty, i);
1209  Constant *LHS = ConstantExpr::getExtractElement(C1, ExtractIdx);
1210  Constant *RHS = ConstantExpr::getExtractElement(C2, ExtractIdx);
1211 
1212  // If any element of a divisor vector is zero, the whole op is undef.
1213  if ((Opcode == Instruction::SDiv || Opcode == Instruction::UDiv ||
1214  Opcode == Instruction::SRem || Opcode == Instruction::URem) &&
1215  RHS->isNullValue())
1216  return UndefValue::get(VTy);
1217 
1218  Result.push_back(ConstantExpr::get(Opcode, LHS, RHS));
1219  }
1220 
1221  return ConstantVector::get(Result);
1222  }
1223 
1224  if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
1225  // There are many possible foldings we could do here. We should probably
1226  // at least fold add of a pointer with an integer into the appropriate
1227  // getelementptr. This will improve alias analysis a bit.
1228 
1229  // Given ((a + b) + c), if (b + c) folds to something interesting, return
1230  // (a + (b + c)).
1231  if (Instruction::isAssociative(Opcode) && CE1->getOpcode() == Opcode) {
1232  Constant *T = ConstantExpr::get(Opcode, CE1->getOperand(1), C2);
1233  if (!isa<ConstantExpr>(T) || cast<ConstantExpr>(T)->getOpcode() != Opcode)
1234  return ConstantExpr::get(Opcode, CE1->getOperand(0), T);
1235  }
1236  } else if (isa<ConstantExpr>(C2)) {
1237  // If C2 is a constant expr and C1 isn't, flop them around and fold the
1238  // other way if possible.
1239  if (Instruction::isCommutative(Opcode))
1240  return ConstantFoldBinaryInstruction(Opcode, C2, C1);
1241  }
1242 
1243  // i1 can be simplified in many cases.
1244  if (C1->getType()->isIntegerTy(1)) {
1245  switch (Opcode) {
1246  case Instruction::Add:
1247  case Instruction::Sub:
1248  return ConstantExpr::getXor(C1, C2);
1249  case Instruction::Mul:
1250  return ConstantExpr::getAnd(C1, C2);
1251  case Instruction::Shl:
1252  case Instruction::LShr:
1253  case Instruction::AShr:
1254  // We can assume that C2 == 0. If it were one the result would be
1255  // undefined because the shift value is as large as the bitwidth.
1256  return C1;
1257  case Instruction::SDiv:
1258  case Instruction::UDiv:
1259  // We can assume that C2 == 1. If it were zero the result would be
1260  // undefined through division by zero.
1261  return C1;
1262  case Instruction::URem:
1263  case Instruction::SRem:
1264  // We can assume that C2 == 1. If it were zero the result would be
1265  // undefined through division by zero.
1266  return ConstantInt::getFalse(C1->getContext());
1267  default:
1268  break;
1269  }
1270  }
1271 
1272  // We don't know how to fold this.
1273  return nullptr;
1274 }
1275 
1276 /// This type is zero-sized if it's an array or structure of zero-sized types.
1277 /// The only leaf zero-sized type is an empty structure.
1278 static bool isMaybeZeroSizedType(Type *Ty) {
1279  if (StructType *STy = dyn_cast<StructType>(Ty)) {
1280  if (STy->isOpaque()) return true; // Can't say.
1281 
1282  // If all of elements have zero size, this does too.
1283  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
1284  if (!isMaybeZeroSizedType(STy->getElementType(i))) return false;
1285  return true;
1286 
1287  } else if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
1288  return isMaybeZeroSizedType(ATy->getElementType());
1289  }
1290  return false;
1291 }
1292 
1293 /// Compare the two constants as though they were getelementptr indices.
1294 /// This allows coercion of the types to be the same thing.
1295 ///
1296 /// If the two constants are the "same" (after coercion), return 0. If the
1297 /// first is less than the second, return -1, if the second is less than the
1298 /// first, return 1. If the constants are not integral, return -2.
1299 ///
1300 static int IdxCompare(Constant *C1, Constant *C2, Type *ElTy) {
1301  if (C1 == C2) return 0;
1302 
1303  // Ok, we found a different index. If they are not ConstantInt, we can't do
1304  // anything with them.
1305  if (!isa<ConstantInt>(C1) || !isa<ConstantInt>(C2))
1306  return -2; // don't know!
1307 
1308  // We cannot compare the indices if they don't fit in an int64_t.
1309  if (cast<ConstantInt>(C1)->getValue().getActiveBits() > 64 ||
1310  cast<ConstantInt>(C2)->getValue().getActiveBits() > 64)
1311  return -2; // don't know!
1312 
1313  // Ok, we have two differing integer indices. Sign extend them to be the same
1314  // type.
1315  int64_t C1Val = cast<ConstantInt>(C1)->getSExtValue();
1316  int64_t C2Val = cast<ConstantInt>(C2)->getSExtValue();
1317 
1318  if (C1Val == C2Val) return 0; // They are equal
1319 
1320  // If the type being indexed over is really just a zero sized type, there is
1321  // no pointer difference being made here.
1322  if (isMaybeZeroSizedType(ElTy))
1323  return -2; // dunno.
1324 
1325  // If they are really different, now that they are the same type, then we
1326  // found a difference!
1327  if (C1Val < C2Val)
1328  return -1;
1329  else
1330  return 1;
1331 }
1332 
1333 /// This function determines if there is anything we can decide about the two
1334 /// constants provided. This doesn't need to handle simple things like
1335 /// ConstantFP comparisons, but should instead handle ConstantExprs.
1336 /// If we can determine that the two constants have a particular relation to
1337 /// each other, we should return the corresponding FCmpInst predicate,
1338 /// otherwise return FCmpInst::BAD_FCMP_PREDICATE. This is used below in
1339 /// ConstantFoldCompareInstruction.
1340 ///
1341 /// To simplify this code we canonicalize the relation so that the first
1342 /// operand is always the most "complex" of the two. We consider ConstantFP
1343 /// to be the simplest, and ConstantExprs to be the most complex.
1345  assert(V1->getType() == V2->getType() &&
1346  "Cannot compare values of different types!");
1347 
1348  // Handle degenerate case quickly
1349  if (V1 == V2) return FCmpInst::FCMP_OEQ;
1350 
1351  if (!isa<ConstantExpr>(V1)) {
1352  if (!isa<ConstantExpr>(V2)) {
1353  // Simple case, use the standard constant folder.
1354  ConstantInt *R = nullptr;
1355  R = dyn_cast<ConstantInt>(
1357  if (R && !R->isZero())
1358  return FCmpInst::FCMP_OEQ;
1359  R = dyn_cast<ConstantInt>(
1361  if (R && !R->isZero())
1362  return FCmpInst::FCMP_OLT;
1363  R = dyn_cast<ConstantInt>(
1365  if (R && !R->isZero())
1366  return FCmpInst::FCMP_OGT;
1367 
1368  // Nothing more we can do
1370  }
1371 
1372  // If the first operand is simple and second is ConstantExpr, swap operands.
1373  FCmpInst::Predicate SwappedRelation = evaluateFCmpRelation(V2, V1);
1374  if (SwappedRelation != FCmpInst::BAD_FCMP_PREDICATE)
1375  return FCmpInst::getSwappedPredicate(SwappedRelation);
1376  } else {
1377  // Ok, the LHS is known to be a constantexpr. The RHS can be any of a
1378  // constantexpr or a simple constant.
1379  ConstantExpr *CE1 = cast<ConstantExpr>(V1);
1380  switch (CE1->getOpcode()) {
1381  case Instruction::FPTrunc:
1382  case Instruction::FPExt:
1383  case Instruction::UIToFP:
1384  case Instruction::SIToFP:
1385  // We might be able to do something with these but we don't right now.
1386  break;
1387  default:
1388  break;
1389  }
1390  }
1391  // There are MANY other foldings that we could perform here. They will
1392  // probably be added on demand, as they seem needed.
1394 }
1395 
1397  const GlobalValue *GV2) {
1398  auto isGlobalUnsafeForEquality = [](const GlobalValue *GV) {
1399  if (GV->hasExternalWeakLinkage() || GV->hasWeakAnyLinkage())
1400  return true;
1401  if (const auto *GVar = dyn_cast<GlobalVariable>(GV)) {
1402  Type *Ty = GVar->getValueType();
1403  // A global with opaque type might end up being zero sized.
1404  if (!Ty->isSized())
1405  return true;
1406  // A global with an empty type might lie at the address of any other
1407  // global.
1408  if (Ty->isEmptyTy())
1409  return true;
1410  }
1411  return false;
1412  };
1413  // Don't try to decide equality of aliases.
1414  if (!isa<GlobalAlias>(GV1) && !isa<GlobalAlias>(GV2))
1415  if (!isGlobalUnsafeForEquality(GV1) && !isGlobalUnsafeForEquality(GV2))
1416  return ICmpInst::ICMP_NE;
1418 }
1419 
1420 /// This function determines if there is anything we can decide about the two
1421 /// constants provided. This doesn't need to handle simple things like integer
1422 /// comparisons, but should instead handle ConstantExprs and GlobalValues.
1423 /// If we can determine that the two constants have a particular relation to
1424 /// each other, we should return the corresponding ICmp predicate, otherwise
1425 /// return ICmpInst::BAD_ICMP_PREDICATE.
1426 ///
1427 /// To simplify this code we canonicalize the relation so that the first
1428 /// operand is always the most "complex" of the two. We consider simple
1429 /// constants (like ConstantInt) to be the simplest, followed by
1430 /// GlobalValues, followed by ConstantExpr's (the most complex).
1431 ///
1433  bool isSigned) {
1434  assert(V1->getType() == V2->getType() &&
1435  "Cannot compare different types of values!");
1436  if (V1 == V2) return ICmpInst::ICMP_EQ;
1437 
1438  if (!isa<ConstantExpr>(V1) && !isa<GlobalValue>(V1) &&
1439  !isa<BlockAddress>(V1)) {
1440  if (!isa<GlobalValue>(V2) && !isa<ConstantExpr>(V2) &&
1441  !isa<BlockAddress>(V2)) {
1442  // We distilled this down to a simple case, use the standard constant
1443  // folder.
1444  ConstantInt *R = nullptr;
1446  R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
1447  if (R && !R->isZero())
1448  return pred;
1449  pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
1450  R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
1451  if (R && !R->isZero())
1452  return pred;
1453  pred = isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
1454  R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
1455  if (R && !R->isZero())
1456  return pred;
1457 
1458  // If we couldn't figure it out, bail.
1460  }
1461 
1462  // If the first operand is simple, swap operands.
1463  ICmpInst::Predicate SwappedRelation =
1464  evaluateICmpRelation(V2, V1, isSigned);
1465  if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
1466  return ICmpInst::getSwappedPredicate(SwappedRelation);
1467 
1468  } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V1)) {
1469  if (isa<ConstantExpr>(V2)) { // Swap as necessary.
1470  ICmpInst::Predicate SwappedRelation =
1471  evaluateICmpRelation(V2, V1, isSigned);
1472  if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
1473  return ICmpInst::getSwappedPredicate(SwappedRelation);
1475  }
1476 
1477  // Now we know that the RHS is a GlobalValue, BlockAddress or simple
1478  // constant (which, since the types must match, means that it's a
1479  // ConstantPointerNull).
1480  if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2)) {
1481  return areGlobalsPotentiallyEqual(GV, GV2);
1482  } else if (isa<BlockAddress>(V2)) {
1483  return ICmpInst::ICMP_NE; // Globals never equal labels.
1484  } else {
1485  assert(isa<ConstantPointerNull>(V2) && "Canonicalization guarantee!");
1486  // GlobalVals can never be null unless they have external weak linkage.
1487  // We don't try to evaluate aliases here.
1488  if (!GV->hasExternalWeakLinkage() && !isa<GlobalAlias>(GV))
1489  return ICmpInst::ICMP_NE;
1490  }
1491  } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(V1)) {
1492  if (isa<ConstantExpr>(V2)) { // Swap as necessary.
1493  ICmpInst::Predicate SwappedRelation =
1494  evaluateICmpRelation(V2, V1, isSigned);
1495  if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
1496  return ICmpInst::getSwappedPredicate(SwappedRelation);
1498  }
1499 
1500  // Now we know that the RHS is a GlobalValue, BlockAddress or simple
1501  // constant (which, since the types must match, means that it is a
1502  // ConstantPointerNull).
1503  if (const BlockAddress *BA2 = dyn_cast<BlockAddress>(V2)) {
1504  // Block address in another function can't equal this one, but block
1505  // addresses in the current function might be the same if blocks are
1506  // empty.
1507  if (BA2->getFunction() != BA->getFunction())
1508  return ICmpInst::ICMP_NE;
1509  } else {
1510  // Block addresses aren't null, don't equal the address of globals.
1511  assert((isa<ConstantPointerNull>(V2) || isa<GlobalValue>(V2)) &&
1512  "Canonicalization guarantee!");
1513  return ICmpInst::ICMP_NE;
1514  }
1515  } else {
1516  // Ok, the LHS is known to be a constantexpr. The RHS can be any of a
1517  // constantexpr, a global, block address, or a simple constant.
1518  ConstantExpr *CE1 = cast<ConstantExpr>(V1);
1519  Constant *CE1Op0 = CE1->getOperand(0);
1520 
1521  switch (CE1->getOpcode()) {
1522  case Instruction::Trunc:
1523  case Instruction::FPTrunc:
1524  case Instruction::FPExt:
1525  case Instruction::FPToUI:
1526  case Instruction::FPToSI:
1527  break; // We can't evaluate floating point casts or truncations.
1528 
1529  case Instruction::UIToFP:
1530  case Instruction::SIToFP:
1531  case Instruction::BitCast:
1532  case Instruction::ZExt:
1533  case Instruction::SExt:
1534  // We can't evaluate floating point casts or truncations.
1535  if (CE1Op0->getType()->isFloatingPointTy())
1536  break;
1537 
1538  // If the cast is not actually changing bits, and the second operand is a
1539  // null pointer, do the comparison with the pre-casted value.
1540  if (V2->isNullValue() &&
1541  (CE1->getType()->isPointerTy() || CE1->getType()->isIntegerTy())) {
1542  if (CE1->getOpcode() == Instruction::ZExt) isSigned = false;
1543  if (CE1->getOpcode() == Instruction::SExt) isSigned = true;
1544  return evaluateICmpRelation(CE1Op0,
1545  Constant::getNullValue(CE1Op0->getType()),
1546  isSigned);
1547  }
1548  break;
1549 
1550  case Instruction::GetElementPtr: {
1551  GEPOperator *CE1GEP = cast<GEPOperator>(CE1);
1552  // Ok, since this is a getelementptr, we know that the constant has a
1553  // pointer type. Check the various cases.
1554  if (isa<ConstantPointerNull>(V2)) {
1555  // If we are comparing a GEP to a null pointer, check to see if the base
1556  // of the GEP equals the null pointer.
1557  if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0)) {
1558  if (GV->hasExternalWeakLinkage())
1559  // Weak linkage GVals could be zero or not. We're comparing that
1560  // to null pointer so its greater-or-equal
1561  return isSigned ? ICmpInst::ICMP_SGE : ICmpInst::ICMP_UGE;
1562  else
1563  // If its not weak linkage, the GVal must have a non-zero address
1564  // so the result is greater-than
1565  return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
1566  } else if (isa<ConstantPointerNull>(CE1Op0)) {
1567  // If we are indexing from a null pointer, check to see if we have any
1568  // non-zero indices.
1569  for (unsigned i = 1, e = CE1->getNumOperands(); i != e; ++i)
1570  if (!CE1->getOperand(i)->isNullValue())
1571  // Offsetting from null, must not be equal.
1572  return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
1573  // Only zero indexes from null, must still be zero.
1574  return ICmpInst::ICMP_EQ;
1575  }
1576  // Otherwise, we can't really say if the first operand is null or not.
1577  } else if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2)) {
1578  if (isa<ConstantPointerNull>(CE1Op0)) {
1579  if (GV2->hasExternalWeakLinkage())
1580  // Weak linkage GVals could be zero or not. We're comparing it to
1581  // a null pointer, so its less-or-equal
1582  return isSigned ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE;
1583  else
1584  // If its not weak linkage, the GVal must have a non-zero address
1585  // so the result is less-than
1586  return isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
1587  } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0)) {
1588  if (GV == GV2) {
1589  // If this is a getelementptr of the same global, then it must be
1590  // different. Because the types must match, the getelementptr could
1591  // only have at most one index, and because we fold getelementptr's
1592  // with a single zero index, it must be nonzero.
1593  assert(CE1->getNumOperands() == 2 &&
1594  !CE1->getOperand(1)->isNullValue() &&
1595  "Surprising getelementptr!");
1596  return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
1597  } else {
1598  if (CE1GEP->hasAllZeroIndices())
1599  return areGlobalsPotentiallyEqual(GV, GV2);
1601  }
1602  }
1603  } else {
1604  ConstantExpr *CE2 = cast<ConstantExpr>(V2);
1605  Constant *CE2Op0 = CE2->getOperand(0);
1606 
1607  // There are MANY other foldings that we could perform here. They will
1608  // probably be added on demand, as they seem needed.
1609  switch (CE2->getOpcode()) {
1610  default: break;
1611  case Instruction::GetElementPtr:
1612  // By far the most common case to handle is when the base pointers are
1613  // obviously to the same global.
1614  if (isa<GlobalValue>(CE1Op0) && isa<GlobalValue>(CE2Op0)) {
1615  // Don't know relative ordering, but check for inequality.
1616  if (CE1Op0 != CE2Op0) {
1617  GEPOperator *CE2GEP = cast<GEPOperator>(CE2);
1618  if (CE1GEP->hasAllZeroIndices() && CE2GEP->hasAllZeroIndices())
1619  return areGlobalsPotentiallyEqual(cast<GlobalValue>(CE1Op0),
1620  cast<GlobalValue>(CE2Op0));
1622  }
1623  // Ok, we know that both getelementptr instructions are based on the
1624  // same global. From this, we can precisely determine the relative
1625  // ordering of the resultant pointers.
1626  unsigned i = 1;
1627 
1628  // The logic below assumes that the result of the comparison
1629  // can be determined by finding the first index that differs.
1630  // This doesn't work if there is over-indexing in any
1631  // subsequent indices, so check for that case first.
1632  if (!CE1->isGEPWithNoNotionalOverIndexing() ||
1634  return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal.
1635 
1636  // Compare all of the operands the GEP's have in common.
1637  gep_type_iterator GTI = gep_type_begin(CE1);
1638  for (;i != CE1->getNumOperands() && i != CE2->getNumOperands();
1639  ++i, ++GTI)
1640  switch (IdxCompare(CE1->getOperand(i),
1641  CE2->getOperand(i), GTI.getIndexedType())) {
1642  case -1: return isSigned ? ICmpInst::ICMP_SLT:ICmpInst::ICMP_ULT;
1643  case 1: return isSigned ? ICmpInst::ICMP_SGT:ICmpInst::ICMP_UGT;
1644  case -2: return ICmpInst::BAD_ICMP_PREDICATE;
1645  }
1646 
1647  // Ok, we ran out of things they have in common. If any leftovers
1648  // are non-zero then we have a difference, otherwise we are equal.
1649  for (; i < CE1->getNumOperands(); ++i)
1650  if (!CE1->getOperand(i)->isNullValue()) {
1651  if (isa<ConstantInt>(CE1->getOperand(i)))
1652  return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
1653  else
1654  return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal.
1655  }
1656 
1657  for (; i < CE2->getNumOperands(); ++i)
1658  if (!CE2->getOperand(i)->isNullValue()) {
1659  if (isa<ConstantInt>(CE2->getOperand(i)))
1660  return isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
1661  else
1662  return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal.
1663  }
1664  return ICmpInst::ICMP_EQ;
1665  }
1666  }
1667  }
1668  }
1669  default:
1670  break;
1671  }
1672  }
1673 
1675 }
1676 
1678  Constant *C1, Constant *C2) {
1679  Type *ResultTy;
1680  if (VectorType *VT = dyn_cast<VectorType>(C1->getType()))
1681  ResultTy = VectorType::get(Type::getInt1Ty(C1->getContext()),
1682  VT->getNumElements());
1683  else
1684  ResultTy = Type::getInt1Ty(C1->getContext());
1685 
1686  // Fold FCMP_FALSE/FCMP_TRUE unconditionally.
1687  if (pred == FCmpInst::FCMP_FALSE)
1688  return Constant::getNullValue(ResultTy);
1689 
1690  if (pred == FCmpInst::FCMP_TRUE)
1691  return Constant::getAllOnesValue(ResultTy);
1692 
1693  // Handle some degenerate cases first
1694  if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) {
1696  bool isIntegerPredicate = ICmpInst::isIntPredicate(Predicate);
1697  // For EQ and NE, we can always pick a value for the undef to make the
1698  // predicate pass or fail, so we can return undef.
1699  // Also, if both operands are undef, we can return undef for int comparison.
1700  if (ICmpInst::isEquality(Predicate) || (isIntegerPredicate && C1 == C2))
1701  return UndefValue::get(ResultTy);
1702 
1703  // Otherwise, for integer compare, pick the same value as the non-undef
1704  // operand, and fold it to true or false.
1705  if (isIntegerPredicate)
1706  return ConstantInt::get(ResultTy, CmpInst::isTrueWhenEqual(Predicate));
1707 
1708  // Choosing NaN for the undef will always make unordered comparison succeed
1709  // and ordered comparison fails.
1710  return ConstantInt::get(ResultTy, CmpInst::isUnordered(Predicate));
1711  }
1712 
1713  // icmp eq/ne(null,GV) -> false/true
1714  if (C1->isNullValue()) {
1715  if (const GlobalValue *GV = dyn_cast<GlobalValue>(C2))
1716  // Don't try to evaluate aliases. External weak GV can be null.
1717  if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) {
1718  if (pred == ICmpInst::ICMP_EQ)
1719  return ConstantInt::getFalse(C1->getContext());
1720  else if (pred == ICmpInst::ICMP_NE)
1721  return ConstantInt::getTrue(C1->getContext());
1722  }
1723  // icmp eq/ne(GV,null) -> false/true
1724  } else if (C2->isNullValue()) {
1725  if (const GlobalValue *GV = dyn_cast<GlobalValue>(C1))
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  }
1734 
1735  // If the comparison is a comparison between two i1's, simplify it.
1736  if (C1->getType()->isIntegerTy(1)) {
1737  switch(pred) {
1738  case ICmpInst::ICMP_EQ:
1739  if (isa<ConstantInt>(C2))
1742  case ICmpInst::ICMP_NE:
1743  return ConstantExpr::getXor(C1, C2);
1744  default:
1745  break;
1746  }
1747  }
1748 
1749  if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2)) {
1750  const APInt &V1 = cast<ConstantInt>(C1)->getValue();
1751  const APInt &V2 = cast<ConstantInt>(C2)->getValue();
1752  switch (pred) {
1753  default: llvm_unreachable("Invalid ICmp Predicate");
1754  case ICmpInst::ICMP_EQ: return ConstantInt::get(ResultTy, V1 == V2);
1755  case ICmpInst::ICMP_NE: return ConstantInt::get(ResultTy, V1 != V2);
1756  case ICmpInst::ICMP_SLT: return ConstantInt::get(ResultTy, V1.slt(V2));
1757  case ICmpInst::ICMP_SGT: return ConstantInt::get(ResultTy, V1.sgt(V2));
1758  case ICmpInst::ICMP_SLE: return ConstantInt::get(ResultTy, V1.sle(V2));
1759  case ICmpInst::ICMP_SGE: return ConstantInt::get(ResultTy, V1.sge(V2));
1760  case ICmpInst::ICMP_ULT: return ConstantInt::get(ResultTy, V1.ult(V2));
1761  case ICmpInst::ICMP_UGT: return ConstantInt::get(ResultTy, V1.ugt(V2));
1762  case ICmpInst::ICMP_ULE: return ConstantInt::get(ResultTy, V1.ule(V2));
1763  case ICmpInst::ICMP_UGE: return ConstantInt::get(ResultTy, V1.uge(V2));
1764  }
1765  } else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) {
1766  const APFloat &C1V = cast<ConstantFP>(C1)->getValueAPF();
1767  const APFloat &C2V = cast<ConstantFP>(C2)->getValueAPF();
1768  APFloat::cmpResult R = C1V.compare(C2V);
1769  switch (pred) {
1770  default: llvm_unreachable("Invalid FCmp Predicate");
1771  case FCmpInst::FCMP_FALSE: return Constant::getNullValue(ResultTy);
1772  case FCmpInst::FCMP_TRUE: return Constant::getAllOnesValue(ResultTy);
1773  case FCmpInst::FCMP_UNO:
1774  return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered);
1775  case FCmpInst::FCMP_ORD:
1776  return ConstantInt::get(ResultTy, R!=APFloat::cmpUnordered);
1777  case FCmpInst::FCMP_UEQ:
1778  return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1779  R==APFloat::cmpEqual);
1780  case FCmpInst::FCMP_OEQ:
1781  return ConstantInt::get(ResultTy, R==APFloat::cmpEqual);
1782  case FCmpInst::FCMP_UNE:
1783  return ConstantInt::get(ResultTy, R!=APFloat::cmpEqual);
1784  case FCmpInst::FCMP_ONE:
1785  return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan ||
1787  case FCmpInst::FCMP_ULT:
1788  return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1790  case FCmpInst::FCMP_OLT:
1791  return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan);
1792  case FCmpInst::FCMP_UGT:
1793  return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1795  case FCmpInst::FCMP_OGT:
1796  return ConstantInt::get(ResultTy, R==APFloat::cmpGreaterThan);
1797  case FCmpInst::FCMP_ULE:
1798  return ConstantInt::get(ResultTy, R!=APFloat::cmpGreaterThan);
1799  case FCmpInst::FCMP_OLE:
1800  return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan ||
1801  R==APFloat::cmpEqual);
1802  case FCmpInst::FCMP_UGE:
1803  return ConstantInt::get(ResultTy, R!=APFloat::cmpLessThan);
1804  case FCmpInst::FCMP_OGE:
1805  return ConstantInt::get(ResultTy, R==APFloat::cmpGreaterThan ||
1806  R==APFloat::cmpEqual);
1807  }
1808  } else if (C1->getType()->isVectorTy()) {
1809  // If we can constant fold the comparison of each element, constant fold
1810  // the whole vector comparison.
1811  SmallVector<Constant*, 4> ResElts;
1812  Type *Ty = IntegerType::get(C1->getContext(), 32);
1813  // Compare the elements, producing an i1 result or constant expr.
1814  for (unsigned i = 0, e = C1->getType()->getVectorNumElements(); i != e;++i){
1815  Constant *C1E =
1817  Constant *C2E =
1819 
1820  ResElts.push_back(ConstantExpr::getCompare(pred, C1E, C2E));
1821  }
1822 
1823  return ConstantVector::get(ResElts);
1824  }
1825 
1826  if (C1->getType()->isFloatingPointTy() &&
1827  // Only call evaluateFCmpRelation if we have a constant expr to avoid
1828  // infinite recursive loop
1829  (isa<ConstantExpr>(C1) || isa<ConstantExpr>(C2))) {
1830  int Result = -1; // -1 = unknown, 0 = known false, 1 = known true.
1831  switch (evaluateFCmpRelation(C1, C2)) {
1832  default: llvm_unreachable("Unknown relation!");
1833  case FCmpInst::FCMP_UNO:
1834  case FCmpInst::FCMP_ORD:
1835  case FCmpInst::FCMP_UEQ:
1836  case FCmpInst::FCMP_UNE:
1837  case FCmpInst::FCMP_ULT:
1838  case FCmpInst::FCMP_UGT:
1839  case FCmpInst::FCMP_ULE:
1840  case FCmpInst::FCMP_UGE:
1841  case FCmpInst::FCMP_TRUE:
1842  case FCmpInst::FCMP_FALSE:
1844  break; // Couldn't determine anything about these constants.
1845  case FCmpInst::FCMP_OEQ: // We know that C1 == C2
1846  Result = (pred == FCmpInst::FCMP_UEQ || pred == FCmpInst::FCMP_OEQ ||
1847  pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE ||
1848  pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
1849  break;
1850  case FCmpInst::FCMP_OLT: // We know that C1 < C2
1851  Result = (pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
1852  pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT ||
1853  pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE);
1854  break;
1855  case FCmpInst::FCMP_OGT: // We know that C1 > C2
1856  Result = (pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
1857  pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT ||
1858  pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
1859  break;
1860  case FCmpInst::FCMP_OLE: // We know that C1 <= C2
1861  // We can only partially decide this relation.
1862  if (pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT)
1863  Result = 0;
1864  else if (pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT)
1865  Result = 1;
1866  break;
1867  case FCmpInst::FCMP_OGE: // We known that C1 >= C2
1868  // We can only partially decide this relation.
1869  if (pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT)
1870  Result = 0;
1871  else if (pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT)
1872  Result = 1;
1873  break;
1874  case FCmpInst::FCMP_ONE: // We know that C1 != C2
1875  // We can only partially decide this relation.
1876  if (pred == FCmpInst::FCMP_OEQ || pred == FCmpInst::FCMP_UEQ)
1877  Result = 0;
1878  else if (pred == FCmpInst::FCMP_ONE || pred == FCmpInst::FCMP_UNE)
1879  Result = 1;
1880  break;
1881  }
1882 
1883  // If we evaluated the result, return it now.
1884  if (Result != -1)
1885  return ConstantInt::get(ResultTy, Result);
1886 
1887  } else {
1888  // Evaluate the relation between the two constants, per the predicate.
1889  int Result = -1; // -1 = unknown, 0 = known false, 1 = known true.
1890  switch (evaluateICmpRelation(C1, C2,
1892  default: llvm_unreachable("Unknown relational!");
1894  break; // Couldn't determine anything about these constants.
1895  case ICmpInst::ICMP_EQ: // We know the constants are equal!
1896  // If we know the constants are equal, we can decide the result of this
1897  // computation precisely.
1899  break;
1900  case ICmpInst::ICMP_ULT:
1901  switch (pred) {
1903  Result = 1; break;
1905  Result = 0; break;
1906  }
1907  break;
1908  case ICmpInst::ICMP_SLT:
1909  switch (pred) {
1911  Result = 1; break;
1913  Result = 0; break;
1914  }
1915  break;
1916  case ICmpInst::ICMP_UGT:
1917  switch (pred) {
1919  Result = 1; break;
1921  Result = 0; break;
1922  }
1923  break;
1924  case ICmpInst::ICMP_SGT:
1925  switch (pred) {
1927  Result = 1; break;
1929  Result = 0; break;
1930  }
1931  break;
1932  case ICmpInst::ICMP_ULE:
1933  if (pred == ICmpInst::ICMP_UGT) Result = 0;
1934  if (pred == ICmpInst::ICMP_ULT || pred == ICmpInst::ICMP_ULE) Result = 1;
1935  break;
1936  case ICmpInst::ICMP_SLE:
1937  if (pred == ICmpInst::ICMP_SGT) Result = 0;
1938  if (pred == ICmpInst::ICMP_SLT || pred == ICmpInst::ICMP_SLE) Result = 1;
1939  break;
1940  case ICmpInst::ICMP_UGE:
1941  if (pred == ICmpInst::ICMP_ULT) Result = 0;
1942  if (pred == ICmpInst::ICMP_UGT || pred == ICmpInst::ICMP_UGE) Result = 1;
1943  break;
1944  case ICmpInst::ICMP_SGE:
1945  if (pred == ICmpInst::ICMP_SLT) Result = 0;
1946  if (pred == ICmpInst::ICMP_SGT || pred == ICmpInst::ICMP_SGE) Result = 1;
1947  break;
1948  case ICmpInst::ICMP_NE:
1949  if (pred == ICmpInst::ICMP_EQ) Result = 0;
1950  if (pred == ICmpInst::ICMP_NE) Result = 1;
1951  break;
1952  }
1953 
1954  // If we evaluated the result, return it now.
1955  if (Result != -1)
1956  return ConstantInt::get(ResultTy, Result);
1957 
1958  // If the right hand side is a bitcast, try using its inverse to simplify
1959  // it by moving it to the left hand side. We can't do this if it would turn
1960  // a vector compare into a scalar compare or visa versa.
1961  if (ConstantExpr *CE2 = dyn_cast<ConstantExpr>(C2)) {
1962  Constant *CE2Op0 = CE2->getOperand(0);
1963  if (CE2->getOpcode() == Instruction::BitCast &&
1964  CE2->getType()->isVectorTy() == CE2Op0->getType()->isVectorTy()) {
1966  return ConstantExpr::getICmp(pred, Inverse, CE2Op0);
1967  }
1968  }
1969 
1970  // If the left hand side is an extension, try eliminating it.
1971  if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
1972  if ((CE1->getOpcode() == Instruction::SExt &&
1974  (CE1->getOpcode() == Instruction::ZExt &&
1976  Constant *CE1Op0 = CE1->getOperand(0);
1977  Constant *CE1Inverse = ConstantExpr::getTrunc(CE1, CE1Op0->getType());
1978  if (CE1Inverse == CE1Op0) {
1979  // Check whether we can safely truncate the right hand side.
1980  Constant *C2Inverse = ConstantExpr::getTrunc(C2, CE1Op0->getType());
1981  if (ConstantExpr::getCast(CE1->getOpcode(), C2Inverse,
1982  C2->getType()) == C2)
1983  return ConstantExpr::getICmp(pred, CE1Inverse, C2Inverse);
1984  }
1985  }
1986  }
1987 
1988  if ((!isa<ConstantExpr>(C1) && isa<ConstantExpr>(C2)) ||
1989  (C1->isNullValue() && !C2->isNullValue())) {
1990  // If C2 is a constant expr and C1 isn't, flip them around and fold the
1991  // other way if possible.
1992  // Also, if C1 is null and C2 isn't, flip them around.
1994  return ConstantExpr::getICmp(pred, C2, C1);
1995  }
1996  }
1997  return nullptr;
1998 }
1999 
2000 /// Test whether the given sequence of *normalized* indices is "inbounds".
2001 template<typename IndexTy>
2003  // No indices means nothing that could be out of bounds.
2004  if (Idxs.empty()) return true;
2005 
2006  // If the first index is zero, it's in bounds.
2007  if (cast<Constant>(Idxs[0])->isNullValue()) return true;
2008 
2009  // If the first index is one and all the rest are zero, it's in bounds,
2010  // by the one-past-the-end rule.
2011  if (!cast<ConstantInt>(Idxs[0])->isOne())
2012  return false;
2013  for (unsigned i = 1, e = Idxs.size(); i != e; ++i)
2014  if (!cast<Constant>(Idxs[i])->isNullValue())
2015  return false;
2016  return true;
2017 }
2018 
2019 /// Test whether a given ConstantInt is in-range for a SequentialType.
2020 static bool isIndexInRangeOfArrayType(uint64_t NumElements,
2021  const ConstantInt *CI) {
2022  // We cannot bounds check the index if it doesn't fit in an int64_t.
2023  if (CI->getValue().getActiveBits() > 64)
2024  return false;
2025 
2026  // A negative index or an index past the end of our sequential type is
2027  // considered out-of-range.
2028  int64_t IndexVal = CI->getSExtValue();
2029  if (IndexVal < 0 || (NumElements > 0 && (uint64_t)IndexVal >= NumElements))
2030  return false;
2031 
2032  // Otherwise, it is in-range.
2033  return true;
2034 }
2035 
2037  bool InBounds,
2038  Optional<unsigned> InRangeIndex,
2039  ArrayRef<Value *> Idxs) {
2040  if (Idxs.empty()) return C;
2041 
2042  if (isa<UndefValue>(C)) {
2044  C, makeArrayRef((Value * const *)Idxs.data(), Idxs.size()));
2045  return UndefValue::get(GEPTy);
2046  }
2047 
2048  Constant *Idx0 = cast<Constant>(Idxs[0]);
2049  if (Idxs.size() == 1 && (Idx0->isNullValue() || isa<UndefValue>(Idx0)))
2050  return C;
2051 
2052  if (C->isNullValue()) {
2053  bool isNull = true;
2054  for (unsigned i = 0, e = Idxs.size(); i != e; ++i)
2055  if (!isa<UndefValue>(Idxs[i]) &&
2056  !cast<Constant>(Idxs[i])->isNullValue()) {
2057  isNull = false;
2058  break;
2059  }
2060  if (isNull) {
2061  PointerType *PtrTy = cast<PointerType>(C->getType()->getScalarType());
2062  Type *Ty = GetElementPtrInst::getIndexedType(PointeeTy, Idxs);
2063 
2064  assert(Ty && "Invalid indices for GEP!");
2065  Type *OrigGEPTy = PointerType::get(Ty, PtrTy->getAddressSpace());
2066  Type *GEPTy = PointerType::get(Ty, PtrTy->getAddressSpace());
2067  if (VectorType *VT = dyn_cast<VectorType>(C->getType()))
2068  GEPTy = VectorType::get(OrigGEPTy, VT->getNumElements());
2069 
2070  // The GEP returns a vector of pointers when one of more of
2071  // its arguments is a vector.
2072  for (unsigned i = 0, e = Idxs.size(); i != e; ++i) {
2073  if (auto *VT = dyn_cast<VectorType>(Idxs[i]->getType())) {
2074  GEPTy = VectorType::get(OrigGEPTy, VT->getNumElements());
2075  break;
2076  }
2077  }
2078 
2079  return Constant::getNullValue(GEPTy);
2080  }
2081  }
2082 
2083  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
2084  // Combine Indices - If the source pointer to this getelementptr instruction
2085  // is a getelementptr instruction, combine the indices of the two
2086  // getelementptr instructions into a single instruction.
2087  //
2088  if (CE->getOpcode() == Instruction::GetElementPtr) {
2089  gep_type_iterator LastI = gep_type_end(CE);
2090  for (gep_type_iterator I = gep_type_begin(CE), E = gep_type_end(CE);
2091  I != E; ++I)
2092  LastI = I;
2093 
2094  // We cannot combine indices if doing so would take us outside of an
2095  // array or vector. Doing otherwise could trick us if we evaluated such a
2096  // GEP as part of a load.
2097  //
2098  // e.g. Consider if the original GEP was:
2099  // i8* getelementptr ({ [2 x i8], i32, i8, [3 x i8] }* @main.c,
2100  // i32 0, i32 0, i64 0)
2101  //
2102  // If we then tried to offset it by '8' to get to the third element,
2103  // an i8, we should *not* get:
2104  // i8* getelementptr ({ [2 x i8], i32, i8, [3 x i8] }* @main.c,
2105  // i32 0, i32 0, i64 8)
2106  //
2107  // This GEP tries to index array element '8 which runs out-of-bounds.
2108  // Subsequent evaluation would get confused and produce erroneous results.
2109  //
2110  // The following prohibits such a GEP from being formed by checking to see
2111  // if the index is in-range with respect to an array.
2112  // TODO: This code may be extended to handle vectors as well.
2113  bool PerformFold = false;
2114  if (Idx0->isNullValue())
2115  PerformFold = true;
2116  else if (LastI.isSequential())
2117  if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx0))
2118  PerformFold = (!LastI.isBoundedSequential() ||
2120  LastI.getSequentialNumElements(), CI)) &&
2121  !CE->getOperand(CE->getNumOperands() - 1)
2122  ->getType()
2123  ->isVectorTy();
2124 
2125  if (PerformFold) {
2126  SmallVector<Value*, 16> NewIndices;
2127  NewIndices.reserve(Idxs.size() + CE->getNumOperands());
2128  NewIndices.append(CE->op_begin() + 1, CE->op_end() - 1);
2129 
2130  // Add the last index of the source with the first index of the new GEP.
2131  // Make sure to handle the case when they are actually different types.
2132  Constant *Combined = CE->getOperand(CE->getNumOperands()-1);
2133  // Otherwise it must be an array.
2134  if (!Idx0->isNullValue()) {
2135  Type *IdxTy = Combined->getType();
2136  if (IdxTy != Idx0->getType()) {
2137  unsigned CommonExtendedWidth =
2138  std::max(IdxTy->getIntegerBitWidth(),
2139  Idx0->getType()->getIntegerBitWidth());
2140  CommonExtendedWidth = std::max(CommonExtendedWidth, 64U);
2141 
2142  Type *CommonTy =
2143  Type::getIntNTy(IdxTy->getContext(), CommonExtendedWidth);
2144  Constant *C1 = ConstantExpr::getSExtOrBitCast(Idx0, CommonTy);
2145  Constant *C2 = ConstantExpr::getSExtOrBitCast(Combined, CommonTy);
2146  Combined = ConstantExpr::get(Instruction::Add, C1, C2);
2147  } else {
2148  Combined =
2149  ConstantExpr::get(Instruction::Add, Idx0, Combined);
2150  }
2151  }
2152 
2153  NewIndices.push_back(Combined);
2154  NewIndices.append(Idxs.begin() + 1, Idxs.end());
2155 
2156  // The combined GEP normally inherits its index inrange attribute from
2157  // the inner GEP, but if the inner GEP's last index was adjusted by the
2158  // outer GEP, any inbounds attribute on that index is invalidated.
2159  Optional<unsigned> IRIndex = cast<GEPOperator>(CE)->getInRangeIndex();
2160  if (IRIndex && *IRIndex == CE->getNumOperands() - 2 && !Idx0->isNullValue())
2161  IRIndex = None;
2162 
2164  cast<GEPOperator>(CE)->getSourceElementType(), CE->getOperand(0),
2165  NewIndices, InBounds && cast<GEPOperator>(CE)->isInBounds(),
2166  IRIndex);
2167  }
2168  }
2169 
2170  // Attempt to fold casts to the same type away. For example, folding:
2171  //
2172  // i32* getelementptr ([2 x i32]* bitcast ([3 x i32]* %X to [2 x i32]*),
2173  // i64 0, i64 0)
2174  // into:
2175  //
2176  // i32* getelementptr ([3 x i32]* %X, i64 0, i64 0)
2177  //
2178  // Don't fold if the cast is changing address spaces.
2179  if (CE->isCast() && Idxs.size() > 1 && Idx0->isNullValue()) {
2180  PointerType *SrcPtrTy =
2181  dyn_cast<PointerType>(CE->getOperand(0)->getType());
2182  PointerType *DstPtrTy = dyn_cast<PointerType>(CE->getType());
2183  if (SrcPtrTy && DstPtrTy) {
2184  ArrayType *SrcArrayTy =
2185  dyn_cast<ArrayType>(SrcPtrTy->getElementType());
2186  ArrayType *DstArrayTy =
2187  dyn_cast<ArrayType>(DstPtrTy->getElementType());
2188  if (SrcArrayTy && DstArrayTy
2189  && SrcArrayTy->getElementType() == DstArrayTy->getElementType()
2190  && SrcPtrTy->getAddressSpace() == DstPtrTy->getAddressSpace())
2191  return ConstantExpr::getGetElementPtr(SrcArrayTy,
2192  (Constant *)CE->getOperand(0),
2193  Idxs, InBounds, InRangeIndex);
2194  }
2195  }
2196  }
2197 
2198  // Check to see if any array indices are not within the corresponding
2199  // notional array or vector bounds. If so, try to determine if they can be
2200  // factored out into preceding dimensions.
2202  Type *Ty = PointeeTy;
2203  Type *Prev = C->getType();
2204  bool Unknown = !isa<ConstantInt>(Idxs[0]);
2205  for (unsigned i = 1, e = Idxs.size(); i != e;
2206  Prev = Ty, Ty = cast<CompositeType>(Ty)->getTypeAtIndex(Idxs[i]), ++i) {
2207  auto *CI = dyn_cast<ConstantInt>(Idxs[i]);
2208  if (!CI) {
2209  // We don't know if it's in range or not.
2210  Unknown = true;
2211  continue;
2212  }
2213  if (InRangeIndex && i == *InRangeIndex + 1) {
2214  // If an index is marked inrange, we cannot apply this canonicalization to
2215  // the following index, as that will cause the inrange index to point to
2216  // the wrong element.
2217  continue;
2218  }
2219  if (isa<StructType>(Ty)) {
2220  // The verify makes sure that GEPs into a struct are in range.
2221  continue;
2222  }
2223  auto *STy = cast<SequentialType>(Ty);
2224  if (isa<VectorType>(STy)) {
2225  // There can be awkward padding in after a non-power of two vector.
2226  Unknown = true;
2227  continue;
2228  }
2229  if (isIndexInRangeOfArrayType(STy->getNumElements(), CI))
2230  // It's in range, skip to the next index.
2231  continue;
2232  if (isa<StructType>(Prev)) {
2233  // It's out of range, but the prior dimension is a struct
2234  // so we can't do anything about it.
2235  Unknown = true;
2236  continue;
2237  }
2238  if (CI->getSExtValue() < 0) {
2239  // It's out of range and negative, don't try to factor it.
2240  Unknown = true;
2241  continue;
2242  }
2243  // It's out of range, but we can factor it into the prior
2244  // dimension.
2245  NewIdxs.resize(Idxs.size());
2246  // Determine the number of elements in our sequential type.
2247  uint64_t NumElements = STy->getArrayNumElements();
2248 
2249  ConstantInt *Factor = ConstantInt::get(CI->getType(), NumElements);
2250  NewIdxs[i] = ConstantExpr::getSRem(CI, Factor);
2251 
2252  Constant *PrevIdx = NewIdxs[i-1] ? NewIdxs[i-1] :
2253  cast<Constant>(Idxs[i - 1]);
2254  Constant *Div = ConstantExpr::getSDiv(CI, Factor);
2255 
2256  unsigned CommonExtendedWidth =
2257  std::max(PrevIdx->getType()->getIntegerBitWidth(),
2258  Div->getType()->getIntegerBitWidth());
2259  CommonExtendedWidth = std::max(CommonExtendedWidth, 64U);
2260 
2261  // Before adding, extend both operands to i64 to avoid
2262  // overflow trouble.
2263  if (!PrevIdx->getType()->isIntegerTy(CommonExtendedWidth))
2264  PrevIdx = ConstantExpr::getSExt(
2265  PrevIdx, Type::getIntNTy(Div->getContext(), CommonExtendedWidth));
2266  if (!Div->getType()->isIntegerTy(CommonExtendedWidth))
2267  Div = ConstantExpr::getSExt(
2268  Div, Type::getIntNTy(Div->getContext(), CommonExtendedWidth));
2269 
2270  NewIdxs[i - 1] = ConstantExpr::getAdd(PrevIdx, Div);
2271  }
2272 
2273  // If we did any factoring, start over with the adjusted indices.
2274  if (!NewIdxs.empty()) {
2275  for (unsigned i = 0, e = Idxs.size(); i != e; ++i)
2276  if (!NewIdxs[i]) NewIdxs[i] = cast<Constant>(Idxs[i]);
2277  return ConstantExpr::getGetElementPtr(PointeeTy, C, NewIdxs, InBounds,
2278  InRangeIndex);
2279  }
2280 
2281  // If all indices are known integers and normalized, we can do a simple
2282  // check for the "inbounds" property.
2283  if (!Unknown && !InBounds)
2284  if (auto *GV = dyn_cast<GlobalVariable>(C))
2285  if (!GV->hasExternalWeakLinkage() && isInBoundsIndices(Idxs))
2286  return ConstantExpr::getGetElementPtr(PointeeTy, C, Idxs,
2287  /*InBounds=*/true, InRangeIndex);
2288 
2289  return nullptr;
2290 }
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:523
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:101
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:1171
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:1115
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:1590
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:1519
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:886
unsigned less than
Definition: InstrTypes.h:885
Constant * ConstantFoldCastInstruction(unsigned opcode, Constant *V, Type *DestTy)
static Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:1980
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:866
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:697
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:876
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:818
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:1832
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:380
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:888
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:207
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2115
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:871
opStatus divide(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:968
The address of a basic block.
Definition: Constants.h:813
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:870
bool isSigned() const
Determine if this instruction is using a signed comparison.
Definition: InstrTypes.h:1001
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
Definition: InstrTypes.h:958
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:2193
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:867
static Constant * getSExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1556
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:1711
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:1791
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:86
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:862
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:4438
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:1854
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:1058
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...
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:122
unsigned getAlignment() const
Definition: Globals.cpp:96
Value * getOperand(unsigned i) const
Definition: User.h: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:277
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:1678
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:454
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:260
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1306
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
Definition: APInt.cpp:1612
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h: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:2174
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:264
static Constant * getSExtOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:1480
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:860
bool isBinaryOp() const
Definition: Instruction.h:129
opStatus multiply(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:959
static Constant * get(StructType *T, ArrayRef< Constant *> V)
Definition: Constants.cpp:949
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:869
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:1930
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:491
static Constant * getNot(Constant *C)
Definition: Constants.cpp:2109
static Constant * getAllOnesValue(Type *Ty)
Get the all ones value.
Definition: Constants.cpp:261
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:877
static UndefValue * get(Type *T)
Static factory methods - Return an &#39;undef&#39; object of the specified type.
Definition: Constants.cpp:1320
bool isCast() const
Definition: Instruction.h:131
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:875
#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:887
hexagon gen pred
static Constant * getFCmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
Definition: Constants.cpp:1955
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:864
static Constant * getPointerCast(Constant *C, Type *Ty)
Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant expression.
Definition: Constants.cpp:1492
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:2153
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:874
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
iterator end() const
Definition: ArrayRef.h:138
static Constant * getNUWMul(Constant *C1, Constant *C2)
Definition: Constants.h:970
signed less than
Definition: InstrTypes.h:889
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:1542
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:560
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:623
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:516
bool isCommutative() const
Return true if the instruction is commutative:
Definition: Instruction.h:420
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:952
bool isTrueWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:1026
signed less or equal
Definition: InstrTypes.h:890
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 greather 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:1435
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:398
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)
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:1814
unsigned greater or equal
Definition: InstrTypes.h:884
static bool isUnordered(Predicate predicate)
Determine if the predicate is an unordered operation.
match_one m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:194
static bool isInBoundsIndices(ArrayRef< IndexTy > Idxs)
Test whether the given sequence of normalized indices is "inbounds".
APInt srem(const APInt &RHS) const
Function for signed remainder operation.
Definition: APInt.cpp:1682
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant *> IdxList)
Create an "inbounds" getelementptr.
Definition: Constants.h:1142
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:2178
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)
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:868
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:872
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:2166
bool isNull(StringRef S)
Definition: YAMLTraits.h:488
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:863
LLVM Value Representation.
Definition: Value.h:73
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:873
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:1050
Type * getElementType() const
Definition: DerivedTypes.h:360
unsigned greater than
Definition: InstrTypes.h:883
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Definition: InstrTypes.h:974
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:1801
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2137
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:865
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:984
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:862
signed greater or equal
Definition: InstrTypes.h:888
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:2182
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:355