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