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