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