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