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