LLVM  4.0.0
InstCombineCasts.cpp
Go to the documentation of this file.
1 //===- InstCombineCasts.cpp -----------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the visit functions for cast operations.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "InstCombineInternal.h"
15 #include "llvm/ADT/SetVector.h"
17 #include "llvm/IR/DataLayout.h"
18 #include "llvm/IR/PatternMatch.h"
20 using namespace llvm;
21 using namespace PatternMatch;
22 
23 #define DEBUG_TYPE "instcombine"
24 
25 /// Analyze 'Val', seeing if it is a simple linear expression.
26 /// If so, decompose it, returning some value X, such that Val is
27 /// X*Scale+Offset.
28 ///
29 static Value *decomposeSimpleLinearExpr(Value *Val, unsigned &Scale,
30  uint64_t &Offset) {
31  if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {
32  Offset = CI->getZExtValue();
33  Scale = 0;
34  return ConstantInt::get(Val->getType(), 0);
35  }
36 
37  if (BinaryOperator *I = dyn_cast<BinaryOperator>(Val)) {
38  // Cannot look past anything that might overflow.
40  if (OBI && !OBI->hasNoUnsignedWrap() && !OBI->hasNoSignedWrap()) {
41  Scale = 1;
42  Offset = 0;
43  return Val;
44  }
45 
46  if (ConstantInt *RHS = dyn_cast<ConstantInt>(I->getOperand(1))) {
47  if (I->getOpcode() == Instruction::Shl) {
48  // This is a value scaled by '1 << the shift amt'.
49  Scale = UINT64_C(1) << RHS->getZExtValue();
50  Offset = 0;
51  return I->getOperand(0);
52  }
53 
54  if (I->getOpcode() == Instruction::Mul) {
55  // This value is scaled by 'RHS'.
56  Scale = RHS->getZExtValue();
57  Offset = 0;
58  return I->getOperand(0);
59  }
60 
61  if (I->getOpcode() == Instruction::Add) {
62  // We have X+C. Check to see if we really have (X*C2)+C1,
63  // where C1 is divisible by C2.
64  unsigned SubScale;
65  Value *SubVal =
66  decomposeSimpleLinearExpr(I->getOperand(0), SubScale, Offset);
67  Offset += RHS->getZExtValue();
68  Scale = SubScale;
69  return SubVal;
70  }
71  }
72  }
73 
74  // Otherwise, we can't look past this.
75  Scale = 1;
76  Offset = 0;
77  return Val;
78 }
79 
80 /// If we find a cast of an allocation instruction, try to eliminate the cast by
81 /// moving the type information into the alloc.
82 Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
83  AllocaInst &AI) {
84  PointerType *PTy = cast<PointerType>(CI.getType());
85 
86  BuilderTy AllocaBuilder(*Builder);
87  AllocaBuilder.SetInsertPoint(&AI);
88 
89  // Get the type really allocated and the type casted to.
90  Type *AllocElTy = AI.getAllocatedType();
91  Type *CastElTy = PTy->getElementType();
92  if (!AllocElTy->isSized() || !CastElTy->isSized()) return nullptr;
93 
94  unsigned AllocElTyAlign = DL.getABITypeAlignment(AllocElTy);
95  unsigned CastElTyAlign = DL.getABITypeAlignment(CastElTy);
96  if (CastElTyAlign < AllocElTyAlign) return nullptr;
97 
98  // If the allocation has multiple uses, only promote it if we are strictly
99  // increasing the alignment of the resultant allocation. If we keep it the
100  // same, we open the door to infinite loops of various kinds.
101  if (!AI.hasOneUse() && CastElTyAlign == AllocElTyAlign) return nullptr;
102 
103  uint64_t AllocElTySize = DL.getTypeAllocSize(AllocElTy);
104  uint64_t CastElTySize = DL.getTypeAllocSize(CastElTy);
105  if (CastElTySize == 0 || AllocElTySize == 0) return nullptr;
106 
107  // If the allocation has multiple uses, only promote it if we're not
108  // shrinking the amount of memory being allocated.
109  uint64_t AllocElTyStoreSize = DL.getTypeStoreSize(AllocElTy);
110  uint64_t CastElTyStoreSize = DL.getTypeStoreSize(CastElTy);
111  if (!AI.hasOneUse() && CastElTyStoreSize < AllocElTyStoreSize) return nullptr;
112 
113  // See if we can satisfy the modulus by pulling a scale out of the array
114  // size argument.
115  unsigned ArraySizeScale;
116  uint64_t ArrayOffset;
117  Value *NumElements = // See if the array size is a decomposable linear expr.
118  decomposeSimpleLinearExpr(AI.getOperand(0), ArraySizeScale, ArrayOffset);
119 
120  // If we can now satisfy the modulus, by using a non-1 scale, we really can
121  // do the xform.
122  if ((AllocElTySize*ArraySizeScale) % CastElTySize != 0 ||
123  (AllocElTySize*ArrayOffset ) % CastElTySize != 0) return nullptr;
124 
125  unsigned Scale = (AllocElTySize*ArraySizeScale)/CastElTySize;
126  Value *Amt = nullptr;
127  if (Scale == 1) {
128  Amt = NumElements;
129  } else {
130  Amt = ConstantInt::get(AI.getArraySize()->getType(), Scale);
131  // Insert before the alloca, not before the cast.
132  Amt = AllocaBuilder.CreateMul(Amt, NumElements);
133  }
134 
135  if (uint64_t Offset = (AllocElTySize*ArrayOffset)/CastElTySize) {
137  Offset, true);
138  Amt = AllocaBuilder.CreateAdd(Amt, Off);
139  }
140 
141  AllocaInst *New = AllocaBuilder.CreateAlloca(CastElTy, Amt);
142  New->setAlignment(AI.getAlignment());
143  New->takeName(&AI);
145 
146  // If the allocation has multiple real uses, insert a cast and change all
147  // things that used it to use the new cast. This will also hack on CI, but it
148  // will die soon.
149  if (!AI.hasOneUse()) {
150  // New is the allocation instruction, pointer typed. AI is the original
151  // allocation instruction, also pointer typed. Thus, cast to use is BitCast.
152  Value *NewCast = AllocaBuilder.CreateBitCast(New, AI.getType(), "tmpcast");
153  replaceInstUsesWith(AI, NewCast);
154  }
155  return replaceInstUsesWith(CI, New);
156 }
157 
158 /// Given an expression that CanEvaluateTruncated or CanEvaluateSExtd returns
159 /// true for, actually insert the code to evaluate the expression.
160 Value *InstCombiner::EvaluateInDifferentType(Value *V, Type *Ty,
161  bool isSigned) {
162  if (Constant *C = dyn_cast<Constant>(V)) {
163  C = ConstantExpr::getIntegerCast(C, Ty, isSigned /*Sext or ZExt*/);
164  // If we got a constantexpr back, try to simplify it with DL info.
165  if (Constant *FoldedC = ConstantFoldConstant(C, DL, &TLI))
166  C = FoldedC;
167  return C;
168  }
169 
170  // Otherwise, it must be an instruction.
171  Instruction *I = cast<Instruction>(V);
172  Instruction *Res = nullptr;
173  unsigned Opc = I->getOpcode();
174  switch (Opc) {
175  case Instruction::Add:
176  case Instruction::Sub:
177  case Instruction::Mul:
178  case Instruction::And:
179  case Instruction::Or:
180  case Instruction::Xor:
181  case Instruction::AShr:
182  case Instruction::LShr:
183  case Instruction::Shl:
184  case Instruction::UDiv:
185  case Instruction::URem: {
186  Value *LHS = EvaluateInDifferentType(I->getOperand(0), Ty, isSigned);
187  Value *RHS = EvaluateInDifferentType(I->getOperand(1), Ty, isSigned);
188  Res = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
189  break;
190  }
191  case Instruction::Trunc:
192  case Instruction::ZExt:
193  case Instruction::SExt:
194  // If the source type of the cast is the type we're trying for then we can
195  // just return the source. There's no need to insert it because it is not
196  // new.
197  if (I->getOperand(0)->getType() == Ty)
198  return I->getOperand(0);
199 
200  // Otherwise, must be the same type of cast, so just reinsert a new one.
201  // This also handles the case of zext(trunc(x)) -> zext(x).
202  Res = CastInst::CreateIntegerCast(I->getOperand(0), Ty,
203  Opc == Instruction::SExt);
204  break;
205  case Instruction::Select: {
206  Value *True = EvaluateInDifferentType(I->getOperand(1), Ty, isSigned);
207  Value *False = EvaluateInDifferentType(I->getOperand(2), Ty, isSigned);
208  Res = SelectInst::Create(I->getOperand(0), True, False);
209  break;
210  }
211  case Instruction::PHI: {
212  PHINode *OPN = cast<PHINode>(I);
213  PHINode *NPN = PHINode::Create(Ty, OPN->getNumIncomingValues());
214  for (unsigned i = 0, e = OPN->getNumIncomingValues(); i != e; ++i) {
215  Value *V =
216  EvaluateInDifferentType(OPN->getIncomingValue(i), Ty, isSigned);
217  NPN->addIncoming(V, OPN->getIncomingBlock(i));
218  }
219  Res = NPN;
220  break;
221  }
222  default:
223  // TODO: Can handle more cases here.
224  llvm_unreachable("Unreachable!");
225  }
226 
227  Res->takeName(I);
228  return InsertNewInstWith(Res, *I);
229 }
230 
231 Instruction::CastOps InstCombiner::isEliminableCastPair(const CastInst *CI1,
232  const CastInst *CI2) {
233  Type *SrcTy = CI1->getSrcTy();
234  Type *MidTy = CI1->getDestTy();
235  Type *DstTy = CI2->getDestTy();
236 
239  Type *SrcIntPtrTy =
240  SrcTy->isPtrOrPtrVectorTy() ? DL.getIntPtrType(SrcTy) : nullptr;
241  Type *MidIntPtrTy =
242  MidTy->isPtrOrPtrVectorTy() ? DL.getIntPtrType(MidTy) : nullptr;
243  Type *DstIntPtrTy =
244  DstTy->isPtrOrPtrVectorTy() ? DL.getIntPtrType(DstTy) : nullptr;
245  unsigned Res = CastInst::isEliminableCastPair(firstOp, secondOp, SrcTy, MidTy,
246  DstTy, SrcIntPtrTy, MidIntPtrTy,
247  DstIntPtrTy);
248 
249  // We don't want to form an inttoptr or ptrtoint that converts to an integer
250  // type that differs from the pointer size.
251  if ((Res == Instruction::IntToPtr && SrcTy != DstIntPtrTy) ||
252  (Res == Instruction::PtrToInt && DstTy != SrcIntPtrTy))
253  Res = 0;
254 
255  return Instruction::CastOps(Res);
256 }
257 
258 /// @brief Implement the transforms common to all CastInst visitors.
260  Value *Src = CI.getOperand(0);
261 
262  // Try to eliminate a cast of a cast.
263  if (auto *CSrc = dyn_cast<CastInst>(Src)) { // A->B->C cast
264  if (Instruction::CastOps NewOpc = isEliminableCastPair(CSrc, &CI)) {
265  // The first cast (CSrc) is eliminable so we need to fix up or replace
266  // the second cast (CI). CSrc will then have a good chance of being dead.
267  return CastInst::Create(NewOpc, CSrc->getOperand(0), CI.getType());
268  }
269  }
270 
271  // If we are casting a select, then fold the cast into the select.
272  if (auto *SI = dyn_cast<SelectInst>(Src))
273  if (Instruction *NV = FoldOpIntoSelect(CI, SI))
274  return NV;
275 
276  // If we are casting a PHI, then fold the cast into the PHI.
277  if (isa<PHINode>(Src)) {
278  // Don't do this if it would create a PHI node with an illegal type from a
279  // legal type.
280  if (!Src->getType()->isIntegerTy() || !CI.getType()->isIntegerTy() ||
281  ShouldChangeType(CI.getType(), Src->getType()))
282  if (Instruction *NV = FoldOpIntoPhi(CI))
283  return NV;
284  }
285 
286  return nullptr;
287 }
288 
289 /// Return true if we can evaluate the specified expression tree as type Ty
290 /// instead of its larger type, and arrive with the same value.
291 /// This is used by code that tries to eliminate truncates.
292 ///
293 /// Ty will always be a type smaller than V. We should return true if trunc(V)
294 /// can be computed by computing V in the smaller type. If V is an instruction,
295 /// then trunc(inst(x,y)) can be computed as inst(trunc(x),trunc(y)), which only
296 /// makes sense if x and y can be efficiently truncated.
297 ///
298 /// This function works on both vectors and scalars.
299 ///
300 static bool canEvaluateTruncated(Value *V, Type *Ty, InstCombiner &IC,
301  Instruction *CxtI) {
302  // We can always evaluate constants in another type.
303  if (isa<Constant>(V))
304  return true;
305 
307  if (!I) return false;
308 
309  Type *OrigTy = V->getType();
310 
311  // If this is an extension from the dest type, we can eliminate it, even if it
312  // has multiple uses.
313  if ((isa<ZExtInst>(I) || isa<SExtInst>(I)) &&
314  I->getOperand(0)->getType() == Ty)
315  return true;
316 
317  // We can't extend or shrink something that has multiple uses: doing so would
318  // require duplicating the instruction in general, which isn't profitable.
319  if (!I->hasOneUse()) return false;
320 
321  unsigned Opc = I->getOpcode();
322  switch (Opc) {
323  case Instruction::Add:
324  case Instruction::Sub:
325  case Instruction::Mul:
326  case Instruction::And:
327  case Instruction::Or:
328  case Instruction::Xor:
329  // These operators can all arbitrarily be extended or truncated.
330  return canEvaluateTruncated(I->getOperand(0), Ty, IC, CxtI) &&
331  canEvaluateTruncated(I->getOperand(1), Ty, IC, CxtI);
332 
333  case Instruction::UDiv:
334  case Instruction::URem: {
335  // UDiv and URem can be truncated if all the truncated bits are zero.
336  uint32_t OrigBitWidth = OrigTy->getScalarSizeInBits();
337  uint32_t BitWidth = Ty->getScalarSizeInBits();
338  if (BitWidth < OrigBitWidth) {
339  APInt Mask = APInt::getHighBitsSet(OrigBitWidth, OrigBitWidth-BitWidth);
340  if (IC.MaskedValueIsZero(I->getOperand(0), Mask, 0, CxtI) &&
341  IC.MaskedValueIsZero(I->getOperand(1), Mask, 0, CxtI)) {
342  return canEvaluateTruncated(I->getOperand(0), Ty, IC, CxtI) &&
343  canEvaluateTruncated(I->getOperand(1), Ty, IC, CxtI);
344  }
345  }
346  break;
347  }
348  case Instruction::Shl:
349  // If we are truncating the result of this SHL, and if it's a shift of a
350  // constant amount, we can always perform a SHL in a smaller type.
351  if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) {
352  uint32_t BitWidth = Ty->getScalarSizeInBits();
353  if (CI->getLimitedValue(BitWidth) < BitWidth)
354  return canEvaluateTruncated(I->getOperand(0), Ty, IC, CxtI);
355  }
356  break;
357  case Instruction::LShr:
358  // If this is a truncate of a logical shr, we can truncate it to a smaller
359  // lshr iff we know that the bits we would otherwise be shifting in are
360  // already zeros.
361  if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) {
362  uint32_t OrigBitWidth = OrigTy->getScalarSizeInBits();
363  uint32_t BitWidth = Ty->getScalarSizeInBits();
364  if (IC.MaskedValueIsZero(I->getOperand(0),
365  APInt::getHighBitsSet(OrigBitWidth, OrigBitWidth-BitWidth), 0, CxtI) &&
366  CI->getLimitedValue(BitWidth) < BitWidth) {
367  return canEvaluateTruncated(I->getOperand(0), Ty, IC, CxtI);
368  }
369  }
370  break;
371  case Instruction::Trunc:
372  // trunc(trunc(x)) -> trunc(x)
373  return true;
374  case Instruction::ZExt:
375  case Instruction::SExt:
376  // trunc(ext(x)) -> ext(x) if the source type is smaller than the new dest
377  // trunc(ext(x)) -> trunc(x) if the source type is larger than the new dest
378  return true;
379  case Instruction::Select: {
380  SelectInst *SI = cast<SelectInst>(I);
381  return canEvaluateTruncated(SI->getTrueValue(), Ty, IC, CxtI) &&
382  canEvaluateTruncated(SI->getFalseValue(), Ty, IC, CxtI);
383  }
384  case Instruction::PHI: {
385  // We can change a phi if we can change all operands. Note that we never
386  // get into trouble with cyclic PHIs here because we only consider
387  // instructions with a single use.
388  PHINode *PN = cast<PHINode>(I);
389  for (Value *IncValue : PN->incoming_values())
390  if (!canEvaluateTruncated(IncValue, Ty, IC, CxtI))
391  return false;
392  return true;
393  }
394  default:
395  // TODO: Can handle more cases here.
396  break;
397  }
398 
399  return false;
400 }
401 
402 /// Given a vector that is bitcast to an integer, optionally logically
403 /// right-shifted, and truncated, convert it to an extractelement.
404 /// Example (big endian):
405 /// trunc (lshr (bitcast <4 x i32> %X to i128), 32) to i32
406 /// --->
407 /// extractelement <4 x i32> %X, 1
409  const DataLayout &DL) {
410  Value *TruncOp = Trunc.getOperand(0);
411  Type *DestType = Trunc.getType();
412  if (!TruncOp->hasOneUse() || !isa<IntegerType>(DestType))
413  return nullptr;
414 
415  Value *VecInput = nullptr;
416  ConstantInt *ShiftVal = nullptr;
417  if (!match(TruncOp, m_CombineOr(m_BitCast(m_Value(VecInput)),
418  m_LShr(m_BitCast(m_Value(VecInput)),
419  m_ConstantInt(ShiftVal)))) ||
420  !isa<VectorType>(VecInput->getType()))
421  return nullptr;
422 
423  VectorType *VecType = cast<VectorType>(VecInput->getType());
424  unsigned VecWidth = VecType->getPrimitiveSizeInBits();
425  unsigned DestWidth = DestType->getPrimitiveSizeInBits();
426  unsigned ShiftAmount = ShiftVal ? ShiftVal->getZExtValue() : 0;
427 
428  if ((VecWidth % DestWidth != 0) || (ShiftAmount % DestWidth != 0))
429  return nullptr;
430 
431  // If the element type of the vector doesn't match the result type,
432  // bitcast it to a vector type that we can extract from.
433  unsigned NumVecElts = VecWidth / DestWidth;
434  if (VecType->getElementType() != DestType) {
435  VecType = VectorType::get(DestType, NumVecElts);
436  VecInput = IC.Builder->CreateBitCast(VecInput, VecType, "bc");
437  }
438 
439  unsigned Elt = ShiftAmount / DestWidth;
440  if (DL.isBigEndian())
441  Elt = NumVecElts - 1 - Elt;
442 
443  return ExtractElementInst::Create(VecInput, IC.Builder->getInt32(Elt));
444 }
445 
446 /// Try to narrow the width of bitwise logic instructions with constants.
447 Instruction *InstCombiner::shrinkBitwiseLogic(TruncInst &Trunc) {
448  Type *SrcTy = Trunc.getSrcTy();
449  Type *DestTy = Trunc.getType();
450  if (isa<IntegerType>(SrcTy) && !ShouldChangeType(SrcTy, DestTy))
451  return nullptr;
452 
453  BinaryOperator *LogicOp;
454  Constant *C;
455  if (!match(Trunc.getOperand(0), m_OneUse(m_BinOp(LogicOp))) ||
456  !LogicOp->isBitwiseLogicOp() ||
457  !match(LogicOp->getOperand(1), m_Constant(C)))
458  return nullptr;
459 
460  // trunc (logic X, C) --> logic (trunc X, C')
461  Constant *NarrowC = ConstantExpr::getTrunc(C, DestTy);
462  Value *NarrowOp0 = Builder->CreateTrunc(LogicOp->getOperand(0), DestTy);
463  return BinaryOperator::Create(LogicOp->getOpcode(), NarrowOp0, NarrowC);
464 }
465 
467  if (Instruction *Result = commonCastTransforms(CI))
468  return Result;
469 
470  // Test if the trunc is the user of a select which is part of a
471  // minimum or maximum operation. If so, don't do any more simplification.
472  // Even simplifying demanded bits can break the canonical form of a
473  // min/max.
474  Value *LHS, *RHS;
475  if (SelectInst *SI = dyn_cast<SelectInst>(CI.getOperand(0)))
476  if (matchSelectPattern(SI, LHS, RHS).Flavor != SPF_UNKNOWN)
477  return nullptr;
478 
479  // See if we can simplify any instructions used by the input whose sole
480  // purpose is to compute bits we don't care about.
481  if (SimplifyDemandedInstructionBits(CI))
482  return &CI;
483 
484  Value *Src = CI.getOperand(0);
485  Type *DestTy = CI.getType(), *SrcTy = Src->getType();
486 
487  // Attempt to truncate the entire input expression tree to the destination
488  // type. Only do this if the dest type is a simple type, don't convert the
489  // expression tree to something weird like i93 unless the source is also
490  // strange.
491  if ((DestTy->isVectorTy() || ShouldChangeType(SrcTy, DestTy)) &&
492  canEvaluateTruncated(Src, DestTy, *this, &CI)) {
493 
494  // If this cast is a truncate, evaluting in a different type always
495  // eliminates the cast, so it is always a win.
496  DEBUG(dbgs() << "ICE: EvaluateInDifferentType converting expression type"
497  " to avoid cast: " << CI << '\n');
498  Value *Res = EvaluateInDifferentType(Src, DestTy, false);
499  assert(Res->getType() == DestTy);
500  return replaceInstUsesWith(CI, Res);
501  }
502 
503  // Canonicalize trunc x to i1 -> (icmp ne (and x, 1), 0), likewise for vector.
504  if (DestTy->getScalarSizeInBits() == 1) {
505  Constant *One = ConstantInt::get(SrcTy, 1);
506  Src = Builder->CreateAnd(Src, One);
508  return new ICmpInst(ICmpInst::ICMP_NE, Src, Zero);
509  }
510 
511  // Transform trunc(lshr (zext A), Cst) to eliminate one type conversion.
512  Value *A = nullptr; ConstantInt *Cst = nullptr;
513  if (Src->hasOneUse() &&
514  match(Src, m_LShr(m_ZExt(m_Value(A)), m_ConstantInt(Cst)))) {
515  // We have three types to worry about here, the type of A, the source of
516  // the truncate (MidSize), and the destination of the truncate. We know that
517  // ASize < MidSize and MidSize > ResultSize, but don't know the relation
518  // between ASize and ResultSize.
519  unsigned ASize = A->getType()->getPrimitiveSizeInBits();
520 
521  // If the shift amount is larger than the size of A, then the result is
522  // known to be zero because all the input bits got shifted out.
523  if (Cst->getZExtValue() >= ASize)
524  return replaceInstUsesWith(CI, Constant::getNullValue(DestTy));
525 
526  // Since we're doing an lshr and a zero extend, and know that the shift
527  // amount is smaller than ASize, it is always safe to do the shift in A's
528  // type, then zero extend or truncate to the result.
529  Value *Shift = Builder->CreateLShr(A, Cst->getZExtValue());
530  Shift->takeName(Src);
531  return CastInst::CreateIntegerCast(Shift, DestTy, false);
532  }
533 
534  // Transform trunc(lshr (sext A), Cst) to ashr A, Cst to eliminate type
535  // conversion.
536  // It works because bits coming from sign extension have the same value as
537  // the sign bit of the original value; performing ashr instead of lshr
538  // generates bits of the same value as the sign bit.
539  if (Src->hasOneUse() &&
540  match(Src, m_LShr(m_SExt(m_Value(A)), m_ConstantInt(Cst))) &&
541  cast<Instruction>(Src)->getOperand(0)->hasOneUse()) {
542  const unsigned ASize = A->getType()->getPrimitiveSizeInBits();
543  // This optimization can be only performed when zero bits generated by
544  // the original lshr aren't pulled into the value after truncation, so we
545  // can only shift by values smaller than the size of destination type (in
546  // bits).
547  if (Cst->getValue().ult(ASize)) {
548  Value *Shift = Builder->CreateAShr(A, Cst->getZExtValue());
549  Shift->takeName(Src);
550  return CastInst::CreateIntegerCast(Shift, CI.getType(), true);
551  }
552  }
553 
554  if (Instruction *I = shrinkBitwiseLogic(CI))
555  return I;
556 
557  if (Src->hasOneUse() && isa<IntegerType>(SrcTy) &&
558  ShouldChangeType(SrcTy, DestTy)) {
559  // Transform "trunc (shl X, cst)" -> "shl (trunc X), cst" so long as the
560  // dest type is native and cst < dest size.
561  if (match(Src, m_Shl(m_Value(A), m_ConstantInt(Cst))) &&
562  !match(A, m_Shr(m_Value(), m_Constant()))) {
563  // Skip shifts of shift by constants. It undoes a combine in
564  // FoldShiftByConstant and is the extend in reg pattern.
565  const unsigned DestSize = DestTy->getScalarSizeInBits();
566  if (Cst->getValue().ult(DestSize)) {
567  Value *NewTrunc = Builder->CreateTrunc(A, DestTy, A->getName() + ".tr");
568 
569  return BinaryOperator::Create(
570  Instruction::Shl, NewTrunc,
571  ConstantInt::get(DestTy, Cst->getValue().trunc(DestSize)));
572  }
573  }
574  }
575 
576  if (Instruction *I = foldVecTruncToExtElt(CI, *this, DL))
577  return I;
578 
579  return nullptr;
580 }
581 
582 Instruction *InstCombiner::transformZExtICmp(ICmpInst *ICI, ZExtInst &CI,
583  bool DoTransform) {
584  // If we are just checking for a icmp eq of a single bit and zext'ing it
585  // to an integer, then shift the bit to the appropriate place and then
586  // cast to integer to avoid the comparison.
587  if (ConstantInt *Op1C = dyn_cast<ConstantInt>(ICI->getOperand(1))) {
588  const APInt &Op1CV = Op1C->getValue();
589 
590  // zext (x <s 0) to i32 --> x>>u31 true if signbit set.
591  // zext (x >s -1) to i32 --> (x>>u31)^1 true if signbit clear.
592  if ((ICI->getPredicate() == ICmpInst::ICMP_SLT && Op1CV == 0) ||
593  (ICI->getPredicate() == ICmpInst::ICMP_SGT && Op1CV.isAllOnesValue())) {
594  if (!DoTransform) return ICI;
595 
596  Value *In = ICI->getOperand(0);
597  Value *Sh = ConstantInt::get(In->getType(),
598  In->getType()->getScalarSizeInBits() - 1);
599  In = Builder->CreateLShr(In, Sh, In->getName() + ".lobit");
600  if (In->getType() != CI.getType())
601  In = Builder->CreateIntCast(In, CI.getType(), false/*ZExt*/);
602 
603  if (ICI->getPredicate() == ICmpInst::ICMP_SGT) {
604  Constant *One = ConstantInt::get(In->getType(), 1);
605  In = Builder->CreateXor(In, One, In->getName() + ".not");
606  }
607 
608  return replaceInstUsesWith(CI, In);
609  }
610 
611  // zext (X == 0) to i32 --> X^1 iff X has only the low bit set.
612  // zext (X == 0) to i32 --> (X>>1)^1 iff X has only the 2nd bit set.
613  // zext (X == 1) to i32 --> X iff X has only the low bit set.
614  // zext (X == 2) to i32 --> X>>1 iff X has only the 2nd bit set.
615  // zext (X != 0) to i32 --> X iff X has only the low bit set.
616  // zext (X != 0) to i32 --> X>>1 iff X has only the 2nd bit set.
617  // zext (X != 1) to i32 --> X^1 iff X has only the low bit set.
618  // zext (X != 2) to i32 --> (X>>1)^1 iff X has only the 2nd bit set.
619  if ((Op1CV == 0 || Op1CV.isPowerOf2()) &&
620  // This only works for EQ and NE
621  ICI->isEquality()) {
622  // If Op1C some other power of two, convert:
623  uint32_t BitWidth = Op1C->getType()->getBitWidth();
624  APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
625  computeKnownBits(ICI->getOperand(0), KnownZero, KnownOne, 0, &CI);
626 
627  APInt KnownZeroMask(~KnownZero);
628  if (KnownZeroMask.isPowerOf2()) { // Exactly 1 possible 1?
629  if (!DoTransform) return ICI;
630 
631  bool isNE = ICI->getPredicate() == ICmpInst::ICMP_NE;
632  if (Op1CV != 0 && (Op1CV != KnownZeroMask)) {
633  // (X&4) == 2 --> false
634  // (X&4) != 2 --> true
636  isNE);
637  Res = ConstantExpr::getZExt(Res, CI.getType());
638  return replaceInstUsesWith(CI, Res);
639  }
640 
641  uint32_t ShAmt = KnownZeroMask.logBase2();
642  Value *In = ICI->getOperand(0);
643  if (ShAmt) {
644  // Perform a logical shr by shiftamt.
645  // Insert the shift to put the result in the low bit.
646  In = Builder->CreateLShr(In, ConstantInt::get(In->getType(), ShAmt),
647  In->getName() + ".lobit");
648  }
649 
650  if ((Op1CV != 0) == isNE) { // Toggle the low bit.
651  Constant *One = ConstantInt::get(In->getType(), 1);
652  In = Builder->CreateXor(In, One);
653  }
654 
655  if (CI.getType() == In->getType())
656  return replaceInstUsesWith(CI, In);
657 
658  Value *IntCast = Builder->CreateIntCast(In, CI.getType(), false);
659  return replaceInstUsesWith(CI, IntCast);
660  }
661  }
662  }
663 
664  // icmp ne A, B is equal to xor A, B when A and B only really have one bit.
665  // It is also profitable to transform icmp eq into not(xor(A, B)) because that
666  // may lead to additional simplifications.
667  if (ICI->isEquality() && CI.getType() == ICI->getOperand(0)->getType()) {
668  if (IntegerType *ITy = dyn_cast<IntegerType>(CI.getType())) {
669  uint32_t BitWidth = ITy->getBitWidth();
670  Value *LHS = ICI->getOperand(0);
671  Value *RHS = ICI->getOperand(1);
672 
673  APInt KnownZeroLHS(BitWidth, 0), KnownOneLHS(BitWidth, 0);
674  APInt KnownZeroRHS(BitWidth, 0), KnownOneRHS(BitWidth, 0);
675  computeKnownBits(LHS, KnownZeroLHS, KnownOneLHS, 0, &CI);
676  computeKnownBits(RHS, KnownZeroRHS, KnownOneRHS, 0, &CI);
677 
678  if (KnownZeroLHS == KnownZeroRHS && KnownOneLHS == KnownOneRHS) {
679  APInt KnownBits = KnownZeroLHS | KnownOneLHS;
680  APInt UnknownBit = ~KnownBits;
681  if (UnknownBit.countPopulation() == 1) {
682  if (!DoTransform) return ICI;
683 
684  Value *Result = Builder->CreateXor(LHS, RHS);
685 
686  // Mask off any bits that are set and won't be shifted away.
687  if (KnownOneLHS.uge(UnknownBit))
688  Result = Builder->CreateAnd(Result,
689  ConstantInt::get(ITy, UnknownBit));
690 
691  // Shift the bit we're testing down to the lsb.
692  Result = Builder->CreateLShr(
693  Result, ConstantInt::get(ITy, UnknownBit.countTrailingZeros()));
694 
695  if (ICI->getPredicate() == ICmpInst::ICMP_EQ)
696  Result = Builder->CreateXor(Result, ConstantInt::get(ITy, 1));
697  Result->takeName(ICI);
698  return replaceInstUsesWith(CI, Result);
699  }
700  }
701  }
702  }
703 
704  return nullptr;
705 }
706 
707 /// Determine if the specified value can be computed in the specified wider type
708 /// and produce the same low bits. If not, return false.
709 ///
710 /// If this function returns true, it can also return a non-zero number of bits
711 /// (in BitsToClear) which indicates that the value it computes is correct for
712 /// the zero extend, but that the additional BitsToClear bits need to be zero'd
713 /// out. For example, to promote something like:
714 ///
715 /// %B = trunc i64 %A to i32
716 /// %C = lshr i32 %B, 8
717 /// %E = zext i32 %C to i64
718 ///
719 /// CanEvaluateZExtd for the 'lshr' will return true, and BitsToClear will be
720 /// set to 8 to indicate that the promoted value needs to have bits 24-31
721 /// cleared in addition to bits 32-63. Since an 'and' will be generated to
722 /// clear the top bits anyway, doing this has no extra cost.
723 ///
724 /// This function works on both vectors and scalars.
725 static bool canEvaluateZExtd(Value *V, Type *Ty, unsigned &BitsToClear,
726  InstCombiner &IC, Instruction *CxtI) {
727  BitsToClear = 0;
728  if (isa<Constant>(V))
729  return true;
730 
732  if (!I) return false;
733 
734  // If the input is a truncate from the destination type, we can trivially
735  // eliminate it.
736  if (isa<TruncInst>(I) && I->getOperand(0)->getType() == Ty)
737  return true;
738 
739  // We can't extend or shrink something that has multiple uses: doing so would
740  // require duplicating the instruction in general, which isn't profitable.
741  if (!I->hasOneUse()) return false;
742 
743  unsigned Opc = I->getOpcode(), Tmp;
744  switch (Opc) {
745  case Instruction::ZExt: // zext(zext(x)) -> zext(x).
746  case Instruction::SExt: // zext(sext(x)) -> sext(x).
747  case Instruction::Trunc: // zext(trunc(x)) -> trunc(x) or zext(x)
748  return true;
749  case Instruction::And:
750  case Instruction::Or:
751  case Instruction::Xor:
752  case Instruction::Add:
753  case Instruction::Sub:
754  case Instruction::Mul:
755  if (!canEvaluateZExtd(I->getOperand(0), Ty, BitsToClear, IC, CxtI) ||
756  !canEvaluateZExtd(I->getOperand(1), Ty, Tmp, IC, CxtI))
757  return false;
758  // These can all be promoted if neither operand has 'bits to clear'.
759  if (BitsToClear == 0 && Tmp == 0)
760  return true;
761 
762  // If the operation is an AND/OR/XOR and the bits to clear are zero in the
763  // other side, BitsToClear is ok.
764  if (Tmp == 0 && I->isBitwiseLogicOp()) {
765  // We use MaskedValueIsZero here for generality, but the case we care
766  // about the most is constant RHS.
767  unsigned VSize = V->getType()->getScalarSizeInBits();
768  if (IC.MaskedValueIsZero(I->getOperand(1),
769  APInt::getHighBitsSet(VSize, BitsToClear),
770  0, CxtI))
771  return true;
772  }
773 
774  // Otherwise, we don't know how to analyze this BitsToClear case yet.
775  return false;
776 
777  case Instruction::Shl:
778  // We can promote shl(x, cst) if we can promote x. Since shl overwrites the
779  // upper bits we can reduce BitsToClear by the shift amount.
780  if (ConstantInt *Amt = dyn_cast<ConstantInt>(I->getOperand(1))) {
781  if (!canEvaluateZExtd(I->getOperand(0), Ty, BitsToClear, IC, CxtI))
782  return false;
783  uint64_t ShiftAmt = Amt->getZExtValue();
784  BitsToClear = ShiftAmt < BitsToClear ? BitsToClear - ShiftAmt : 0;
785  return true;
786  }
787  return false;
788  case Instruction::LShr:
789  // We can promote lshr(x, cst) if we can promote x. This requires the
790  // ultimate 'and' to clear out the high zero bits we're clearing out though.
791  if (ConstantInt *Amt = dyn_cast<ConstantInt>(I->getOperand(1))) {
792  if (!canEvaluateZExtd(I->getOperand(0), Ty, BitsToClear, IC, CxtI))
793  return false;
794  BitsToClear += Amt->getZExtValue();
795  if (BitsToClear > V->getType()->getScalarSizeInBits())
796  BitsToClear = V->getType()->getScalarSizeInBits();
797  return true;
798  }
799  // Cannot promote variable LSHR.
800  return false;
801  case Instruction::Select:
802  if (!canEvaluateZExtd(I->getOperand(1), Ty, Tmp, IC, CxtI) ||
803  !canEvaluateZExtd(I->getOperand(2), Ty, BitsToClear, IC, CxtI) ||
804  // TODO: If important, we could handle the case when the BitsToClear are
805  // known zero in the disagreeing side.
806  Tmp != BitsToClear)
807  return false;
808  return true;
809 
810  case Instruction::PHI: {
811  // We can change a phi if we can change all operands. Note that we never
812  // get into trouble with cyclic PHIs here because we only consider
813  // instructions with a single use.
814  PHINode *PN = cast<PHINode>(I);
815  if (!canEvaluateZExtd(PN->getIncomingValue(0), Ty, BitsToClear, IC, CxtI))
816  return false;
817  for (unsigned i = 1, e = PN->getNumIncomingValues(); i != e; ++i)
818  if (!canEvaluateZExtd(PN->getIncomingValue(i), Ty, Tmp, IC, CxtI) ||
819  // TODO: If important, we could handle the case when the BitsToClear
820  // are known zero in the disagreeing input.
821  Tmp != BitsToClear)
822  return false;
823  return true;
824  }
825  default:
826  // TODO: Can handle more cases here.
827  return false;
828  }
829 }
830 
832  // If this zero extend is only used by a truncate, let the truncate be
833  // eliminated before we try to optimize this zext.
834  if (CI.hasOneUse() && isa<TruncInst>(CI.user_back()))
835  return nullptr;
836 
837  // If one of the common conversion will work, do it.
838  if (Instruction *Result = commonCastTransforms(CI))
839  return Result;
840 
841  // See if we can simplify any instructions used by the input whose sole
842  // purpose is to compute bits we don't care about.
843  if (SimplifyDemandedInstructionBits(CI))
844  return &CI;
845 
846  Value *Src = CI.getOperand(0);
847  Type *SrcTy = Src->getType(), *DestTy = CI.getType();
848 
849  // Attempt to extend the entire input expression tree to the destination
850  // type. Only do this if the dest type is a simple type, don't convert the
851  // expression tree to something weird like i93 unless the source is also
852  // strange.
853  unsigned BitsToClear;
854  if ((DestTy->isVectorTy() || ShouldChangeType(SrcTy, DestTy)) &&
855  canEvaluateZExtd(Src, DestTy, BitsToClear, *this, &CI)) {
856  assert(BitsToClear < SrcTy->getScalarSizeInBits() &&
857  "Unreasonable BitsToClear");
858 
859  // Okay, we can transform this! Insert the new expression now.
860  DEBUG(dbgs() << "ICE: EvaluateInDifferentType converting expression type"
861  " to avoid zero extend: " << CI << '\n');
862  Value *Res = EvaluateInDifferentType(Src, DestTy, false);
863  assert(Res->getType() == DestTy);
864 
865  uint32_t SrcBitsKept = SrcTy->getScalarSizeInBits()-BitsToClear;
866  uint32_t DestBitSize = DestTy->getScalarSizeInBits();
867 
868  // If the high bits are already filled with zeros, just replace this
869  // cast with the result.
870  if (MaskedValueIsZero(Res,
871  APInt::getHighBitsSet(DestBitSize,
872  DestBitSize-SrcBitsKept),
873  0, &CI))
874  return replaceInstUsesWith(CI, Res);
875 
876  // We need to emit an AND to clear the high bits.
877  Constant *C = ConstantInt::get(Res->getType(),
878  APInt::getLowBitsSet(DestBitSize, SrcBitsKept));
879  return BinaryOperator::CreateAnd(Res, C);
880  }
881 
882  // If this is a TRUNC followed by a ZEXT then we are dealing with integral
883  // types and if the sizes are just right we can convert this into a logical
884  // 'and' which will be much cheaper than the pair of casts.
885  if (TruncInst *CSrc = dyn_cast<TruncInst>(Src)) { // A->B->C cast
886  // TODO: Subsume this into EvaluateInDifferentType.
887 
888  // Get the sizes of the types involved. We know that the intermediate type
889  // will be smaller than A or C, but don't know the relation between A and C.
890  Value *A = CSrc->getOperand(0);
891  unsigned SrcSize = A->getType()->getScalarSizeInBits();
892  unsigned MidSize = CSrc->getType()->getScalarSizeInBits();
893  unsigned DstSize = CI.getType()->getScalarSizeInBits();
894  // If we're actually extending zero bits, then if
895  // SrcSize < DstSize: zext(a & mask)
896  // SrcSize == DstSize: a & mask
897  // SrcSize > DstSize: trunc(a) & mask
898  if (SrcSize < DstSize) {
899  APInt AndValue(APInt::getLowBitsSet(SrcSize, MidSize));
900  Constant *AndConst = ConstantInt::get(A->getType(), AndValue);
901  Value *And = Builder->CreateAnd(A, AndConst, CSrc->getName()+".mask");
902  return new ZExtInst(And, CI.getType());
903  }
904 
905  if (SrcSize == DstSize) {
906  APInt AndValue(APInt::getLowBitsSet(SrcSize, MidSize));
907  return BinaryOperator::CreateAnd(A, ConstantInt::get(A->getType(),
908  AndValue));
909  }
910  if (SrcSize > DstSize) {
911  Value *Trunc = Builder->CreateTrunc(A, CI.getType());
912  APInt AndValue(APInt::getLowBitsSet(DstSize, MidSize));
913  return BinaryOperator::CreateAnd(Trunc,
914  ConstantInt::get(Trunc->getType(),
915  AndValue));
916  }
917  }
918 
919  if (ICmpInst *ICI = dyn_cast<ICmpInst>(Src))
920  return transformZExtICmp(ICI, CI);
921 
922  BinaryOperator *SrcI = dyn_cast<BinaryOperator>(Src);
923  if (SrcI && SrcI->getOpcode() == Instruction::Or) {
924  // zext (or icmp, icmp) -> or (zext icmp), (zext icmp) if at least one
925  // of the (zext icmp) can be eliminated. If so, immediately perform the
926  // according elimination.
927  ICmpInst *LHS = dyn_cast<ICmpInst>(SrcI->getOperand(0));
928  ICmpInst *RHS = dyn_cast<ICmpInst>(SrcI->getOperand(1));
929  if (LHS && RHS && LHS->hasOneUse() && RHS->hasOneUse() &&
930  (transformZExtICmp(LHS, CI, false) ||
931  transformZExtICmp(RHS, CI, false))) {
932  // zext (or icmp, icmp) -> or (zext icmp), (zext icmp)
933  Value *LCast = Builder->CreateZExt(LHS, CI.getType(), LHS->getName());
934  Value *RCast = Builder->CreateZExt(RHS, CI.getType(), RHS->getName());
936 
937  // Perform the elimination.
938  if (auto *LZExt = dyn_cast<ZExtInst>(LCast))
939  transformZExtICmp(LHS, *LZExt);
940  if (auto *RZExt = dyn_cast<ZExtInst>(RCast))
941  transformZExtICmp(RHS, *RZExt);
942 
943  return Or;
944  }
945  }
946 
947  // zext(trunc(X) & C) -> (X & zext(C)).
948  Constant *C;
949  Value *X;
950  if (SrcI &&
951  match(SrcI, m_OneUse(m_And(m_Trunc(m_Value(X)), m_Constant(C)))) &&
952  X->getType() == CI.getType())
953  return BinaryOperator::CreateAnd(X, ConstantExpr::getZExt(C, CI.getType()));
954 
955  // zext((trunc(X) & C) ^ C) -> ((X & zext(C)) ^ zext(C)).
956  Value *And;
957  if (SrcI && match(SrcI, m_OneUse(m_Xor(m_Value(And), m_Constant(C)))) &&
958  match(And, m_OneUse(m_And(m_Trunc(m_Value(X)), m_Specific(C)))) &&
959  X->getType() == CI.getType()) {
960  Constant *ZC = ConstantExpr::getZExt(C, CI.getType());
961  return BinaryOperator::CreateXor(Builder->CreateAnd(X, ZC), ZC);
962  }
963 
964  return nullptr;
965 }
966 
967 /// Transform (sext icmp) to bitwise / integer operations to eliminate the icmp.
968 Instruction *InstCombiner::transformSExtICmp(ICmpInst *ICI, Instruction &CI) {
969  Value *Op0 = ICI->getOperand(0), *Op1 = ICI->getOperand(1);
970  ICmpInst::Predicate Pred = ICI->getPredicate();
971 
972  // Don't bother if Op1 isn't of vector or integer type.
973  if (!Op1->getType()->isIntOrIntVectorTy())
974  return nullptr;
975 
976  if (Constant *Op1C = dyn_cast<Constant>(Op1)) {
977  // (x <s 0) ? -1 : 0 -> ashr x, 31 -> all ones if negative
978  // (x >s -1) ? -1 : 0 -> not (ashr x, 31) -> all ones if positive
979  if ((Pred == ICmpInst::ICMP_SLT && Op1C->isNullValue()) ||
980  (Pred == ICmpInst::ICMP_SGT && Op1C->isAllOnesValue())) {
981 
982  Value *Sh = ConstantInt::get(Op0->getType(),
983  Op0->getType()->getScalarSizeInBits()-1);
984  Value *In = Builder->CreateAShr(Op0, Sh, Op0->getName()+".lobit");
985  if (In->getType() != CI.getType())
986  In = Builder->CreateIntCast(In, CI.getType(), true/*SExt*/);
987 
988  if (Pred == ICmpInst::ICMP_SGT)
989  In = Builder->CreateNot(In, In->getName()+".not");
990  return replaceInstUsesWith(CI, In);
991  }
992  }
993 
994  if (ConstantInt *Op1C = dyn_cast<ConstantInt>(Op1)) {
995  // If we know that only one bit of the LHS of the icmp can be set and we
996  // have an equality comparison with zero or a power of 2, we can transform
997  // the icmp and sext into bitwise/integer operations.
998  if (ICI->hasOneUse() &&
999  ICI->isEquality() && (Op1C->isZero() || Op1C->getValue().isPowerOf2())){
1000  unsigned BitWidth = Op1C->getType()->getBitWidth();
1001  APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
1002  computeKnownBits(Op0, KnownZero, KnownOne, 0, &CI);
1003 
1004  APInt KnownZeroMask(~KnownZero);
1005  if (KnownZeroMask.isPowerOf2()) {
1006  Value *In = ICI->getOperand(0);
1007 
1008  // If the icmp tests for a known zero bit we can constant fold it.
1009  if (!Op1C->isZero() && Op1C->getValue() != KnownZeroMask) {
1010  Value *V = Pred == ICmpInst::ICMP_NE ?
1013  return replaceInstUsesWith(CI, V);
1014  }
1015 
1016  if (!Op1C->isZero() == (Pred == ICmpInst::ICMP_NE)) {
1017  // sext ((x & 2^n) == 0) -> (x >> n) - 1
1018  // sext ((x & 2^n) != 2^n) -> (x >> n) - 1
1019  unsigned ShiftAmt = KnownZeroMask.countTrailingZeros();
1020  // Perform a right shift to place the desired bit in the LSB.
1021  if (ShiftAmt)
1022  In = Builder->CreateLShr(In,
1023  ConstantInt::get(In->getType(), ShiftAmt));
1024 
1025  // At this point "In" is either 1 or 0. Subtract 1 to turn
1026  // {1, 0} -> {0, -1}.
1027  In = Builder->CreateAdd(In,
1029  "sext");
1030  } else {
1031  // sext ((x & 2^n) != 0) -> (x << bitwidth-n) a>> bitwidth-1
1032  // sext ((x & 2^n) == 2^n) -> (x << bitwidth-n) a>> bitwidth-1
1033  unsigned ShiftAmt = KnownZeroMask.countLeadingZeros();
1034  // Perform a left shift to place the desired bit in the MSB.
1035  if (ShiftAmt)
1036  In = Builder->CreateShl(In,
1037  ConstantInt::get(In->getType(), ShiftAmt));
1038 
1039  // Distribute the bit over the whole bit width.
1040  In = Builder->CreateAShr(In, ConstantInt::get(In->getType(),
1041  BitWidth - 1), "sext");
1042  }
1043 
1044  if (CI.getType() == In->getType())
1045  return replaceInstUsesWith(CI, In);
1046  return CastInst::CreateIntegerCast(In, CI.getType(), true/*SExt*/);
1047  }
1048  }
1049  }
1050 
1051  return nullptr;
1052 }
1053 
1054 /// Return true if we can take the specified value and return it as type Ty
1055 /// without inserting any new casts and without changing the value of the common
1056 /// low bits. This is used by code that tries to promote integer operations to
1057 /// a wider types will allow us to eliminate the extension.
1058 ///
1059 /// This function works on both vectors and scalars.
1060 ///
1061 static bool canEvaluateSExtd(Value *V, Type *Ty) {
1063  "Can't sign extend type to a smaller type");
1064  // If this is a constant, it can be trivially promoted.
1065  if (isa<Constant>(V))
1066  return true;
1067 
1068  Instruction *I = dyn_cast<Instruction>(V);
1069  if (!I) return false;
1070 
1071  // If this is a truncate from the dest type, we can trivially eliminate it.
1072  if (isa<TruncInst>(I) && I->getOperand(0)->getType() == Ty)
1073  return true;
1074 
1075  // We can't extend or shrink something that has multiple uses: doing so would
1076  // require duplicating the instruction in general, which isn't profitable.
1077  if (!I->hasOneUse()) return false;
1078 
1079  switch (I->getOpcode()) {
1080  case Instruction::SExt: // sext(sext(x)) -> sext(x)
1081  case Instruction::ZExt: // sext(zext(x)) -> zext(x)
1082  case Instruction::Trunc: // sext(trunc(x)) -> trunc(x) or sext(x)
1083  return true;
1084  case Instruction::And:
1085  case Instruction::Or:
1086  case Instruction::Xor:
1087  case Instruction::Add:
1088  case Instruction::Sub:
1089  case Instruction::Mul:
1090  // These operators can all arbitrarily be extended if their inputs can.
1091  return canEvaluateSExtd(I->getOperand(0), Ty) &&
1092  canEvaluateSExtd(I->getOperand(1), Ty);
1093 
1094  //case Instruction::Shl: TODO
1095  //case Instruction::LShr: TODO
1096 
1097  case Instruction::Select:
1098  return canEvaluateSExtd(I->getOperand(1), Ty) &&
1099  canEvaluateSExtd(I->getOperand(2), Ty);
1100 
1101  case Instruction::PHI: {
1102  // We can change a phi if we can change all operands. Note that we never
1103  // get into trouble with cyclic PHIs here because we only consider
1104  // instructions with a single use.
1105  PHINode *PN = cast<PHINode>(I);
1106  for (Value *IncValue : PN->incoming_values())
1107  if (!canEvaluateSExtd(IncValue, Ty)) return false;
1108  return true;
1109  }
1110  default:
1111  // TODO: Can handle more cases here.
1112  break;
1113  }
1114 
1115  return false;
1116 }
1117 
1119  // If this sign extend is only used by a truncate, let the truncate be
1120  // eliminated before we try to optimize this sext.
1121  if (CI.hasOneUse() && isa<TruncInst>(CI.user_back()))
1122  return nullptr;
1123 
1124  if (Instruction *I = commonCastTransforms(CI))
1125  return I;
1126 
1127  // See if we can simplify any instructions used by the input whose sole
1128  // purpose is to compute bits we don't care about.
1129  if (SimplifyDemandedInstructionBits(CI))
1130  return &CI;
1131 
1132  Value *Src = CI.getOperand(0);
1133  Type *SrcTy = Src->getType(), *DestTy = CI.getType();
1134 
1135  // If we know that the value being extended is positive, we can use a zext
1136  // instead.
1137  bool KnownZero, KnownOne;
1138  ComputeSignBit(Src, KnownZero, KnownOne, 0, &CI);
1139  if (KnownZero) {
1140  Value *ZExt = Builder->CreateZExt(Src, DestTy);
1141  return replaceInstUsesWith(CI, ZExt);
1142  }
1143 
1144  // Attempt to extend the entire input expression tree to the destination
1145  // type. Only do this if the dest type is a simple type, don't convert the
1146  // expression tree to something weird like i93 unless the source is also
1147  // strange.
1148  if ((DestTy->isVectorTy() || ShouldChangeType(SrcTy, DestTy)) &&
1149  canEvaluateSExtd(Src, DestTy)) {
1150  // Okay, we can transform this! Insert the new expression now.
1151  DEBUG(dbgs() << "ICE: EvaluateInDifferentType converting expression type"
1152  " to avoid sign extend: " << CI << '\n');
1153  Value *Res = EvaluateInDifferentType(Src, DestTy, true);
1154  assert(Res->getType() == DestTy);
1155 
1156  uint32_t SrcBitSize = SrcTy->getScalarSizeInBits();
1157  uint32_t DestBitSize = DestTy->getScalarSizeInBits();
1158 
1159  // If the high bits are already filled with sign bit, just replace this
1160  // cast with the result.
1161  if (ComputeNumSignBits(Res, 0, &CI) > DestBitSize - SrcBitSize)
1162  return replaceInstUsesWith(CI, Res);
1163 
1164  // We need to emit a shl + ashr to do the sign extend.
1165  Value *ShAmt = ConstantInt::get(DestTy, DestBitSize-SrcBitSize);
1166  return BinaryOperator::CreateAShr(Builder->CreateShl(Res, ShAmt, "sext"),
1167  ShAmt);
1168  }
1169 
1170  // If this input is a trunc from our destination, then turn sext(trunc(x))
1171  // into shifts.
1172  if (TruncInst *TI = dyn_cast<TruncInst>(Src))
1173  if (TI->hasOneUse() && TI->getOperand(0)->getType() == DestTy) {
1174  uint32_t SrcBitSize = SrcTy->getScalarSizeInBits();
1175  uint32_t DestBitSize = DestTy->getScalarSizeInBits();
1176 
1177  // We need to emit a shl + ashr to do the sign extend.
1178  Value *ShAmt = ConstantInt::get(DestTy, DestBitSize-SrcBitSize);
1179  Value *Res = Builder->CreateShl(TI->getOperand(0), ShAmt, "sext");
1180  return BinaryOperator::CreateAShr(Res, ShAmt);
1181  }
1182 
1183  if (ICmpInst *ICI = dyn_cast<ICmpInst>(Src))
1184  return transformSExtICmp(ICI, CI);
1185 
1186  // If the input is a shl/ashr pair of a same constant, then this is a sign
1187  // extension from a smaller value. If we could trust arbitrary bitwidth
1188  // integers, we could turn this into a truncate to the smaller bit and then
1189  // use a sext for the whole extension. Since we don't, look deeper and check
1190  // for a truncate. If the source and dest are the same type, eliminate the
1191  // trunc and extend and just do shifts. For example, turn:
1192  // %a = trunc i32 %i to i8
1193  // %b = shl i8 %a, 6
1194  // %c = ashr i8 %b, 6
1195  // %d = sext i8 %c to i32
1196  // into:
1197  // %a = shl i32 %i, 30
1198  // %d = ashr i32 %a, 30
1199  Value *A = nullptr;
1200  // TODO: Eventually this could be subsumed by EvaluateInDifferentType.
1201  ConstantInt *BA = nullptr, *CA = nullptr;
1202  if (match(Src, m_AShr(m_Shl(m_Trunc(m_Value(A)), m_ConstantInt(BA)),
1203  m_ConstantInt(CA))) &&
1204  BA == CA && A->getType() == CI.getType()) {
1205  unsigned MidSize = Src->getType()->getScalarSizeInBits();
1206  unsigned SrcDstSize = CI.getType()->getScalarSizeInBits();
1207  unsigned ShAmt = CA->getZExtValue()+SrcDstSize-MidSize;
1208  Constant *ShAmtV = ConstantInt::get(CI.getType(), ShAmt);
1209  A = Builder->CreateShl(A, ShAmtV, CI.getName());
1210  return BinaryOperator::CreateAShr(A, ShAmtV);
1211  }
1212 
1213  return nullptr;
1214 }
1215 
1216 
1217 /// Return a Constant* for the specified floating-point constant if it fits
1218 /// in the specified FP type without changing its value.
1219 static Constant *fitsInFPType(ConstantFP *CFP, const fltSemantics &Sem) {
1220  bool losesInfo;
1221  APFloat F = CFP->getValueAPF();
1222  (void)F.convert(Sem, APFloat::rmNearestTiesToEven, &losesInfo);
1223  if (!losesInfo)
1224  return ConstantFP::get(CFP->getContext(), F);
1225  return nullptr;
1226 }
1227 
1228 /// If this is a floating-point extension instruction, look
1229 /// through it until we get the source value.
1231  if (Instruction *I = dyn_cast<Instruction>(V))
1232  if (I->getOpcode() == Instruction::FPExt)
1233  return lookThroughFPExtensions(I->getOperand(0));
1234 
1235  // If this value is a constant, return the constant in the smallest FP type
1236  // that can accurately represent it. This allows us to turn
1237  // (float)((double)X+2.0) into x+2.0f.
1238  if (ConstantFP *CFP = dyn_cast<ConstantFP>(V)) {
1239  if (CFP->getType() == Type::getPPC_FP128Ty(V->getContext()))
1240  return V; // No constant folding of this.
1241  // See if the value can be truncated to half and then reextended.
1242  if (Value *V = fitsInFPType(CFP, APFloat::IEEEhalf()))
1243  return V;
1244  // See if the value can be truncated to float and then reextended.
1245  if (Value *V = fitsInFPType(CFP, APFloat::IEEEsingle()))
1246  return V;
1247  if (CFP->getType()->isDoubleTy())
1248  return V; // Won't shrink.
1249  if (Value *V = fitsInFPType(CFP, APFloat::IEEEdouble()))
1250  return V;
1251  // Don't try to shrink to various long double types.
1252  }
1253 
1254  return V;
1255 }
1256 
1258  if (Instruction *I = commonCastTransforms(CI))
1259  return I;
1260  // If we have fptrunc(OpI (fpextend x), (fpextend y)), we would like to
1261  // simplify this expression to avoid one or more of the trunc/extend
1262  // operations if we can do so without changing the numerical results.
1263  //
1264  // The exact manner in which the widths of the operands interact to limit
1265  // what we can and cannot do safely varies from operation to operation, and
1266  // is explained below in the various case statements.
1268  if (OpI && OpI->hasOneUse()) {
1269  Value *LHSOrig = lookThroughFPExtensions(OpI->getOperand(0));
1270  Value *RHSOrig = lookThroughFPExtensions(OpI->getOperand(1));
1271  unsigned OpWidth = OpI->getType()->getFPMantissaWidth();
1272  unsigned LHSWidth = LHSOrig->getType()->getFPMantissaWidth();
1273  unsigned RHSWidth = RHSOrig->getType()->getFPMantissaWidth();
1274  unsigned SrcWidth = std::max(LHSWidth, RHSWidth);
1275  unsigned DstWidth = CI.getType()->getFPMantissaWidth();
1276  switch (OpI->getOpcode()) {
1277  default: break;
1278  case Instruction::FAdd:
1279  case Instruction::FSub:
1280  // For addition and subtraction, the infinitely precise result can
1281  // essentially be arbitrarily wide; proving that double rounding
1282  // will not occur because the result of OpI is exact (as we will for
1283  // FMul, for example) is hopeless. However, we *can* nonetheless
1284  // frequently know that double rounding cannot occur (or that it is
1285  // innocuous) by taking advantage of the specific structure of
1286  // infinitely-precise results that admit double rounding.
1287  //
1288  // Specifically, if OpWidth >= 2*DstWdith+1 and DstWidth is sufficient
1289  // to represent both sources, we can guarantee that the double
1290  // rounding is innocuous (See p50 of Figueroa's 2000 PhD thesis,
1291  // "A Rigorous Framework for Fully Supporting the IEEE Standard ..."
1292  // for proof of this fact).
1293  //
1294  // Note: Figueroa does not consider the case where DstFormat !=
1295  // SrcFormat. It's possible (likely even!) that this analysis
1296  // could be tightened for those cases, but they are rare (the main
1297  // case of interest here is (float)((double)float + float)).
1298  if (OpWidth >= 2*DstWidth+1 && DstWidth >= SrcWidth) {
1299  if (LHSOrig->getType() != CI.getType())
1300  LHSOrig = Builder->CreateFPExt(LHSOrig, CI.getType());
1301  if (RHSOrig->getType() != CI.getType())
1302  RHSOrig = Builder->CreateFPExt(RHSOrig, CI.getType());
1303  Instruction *RI =
1304  BinaryOperator::Create(OpI->getOpcode(), LHSOrig, RHSOrig);
1305  RI->copyFastMathFlags(OpI);
1306  return RI;
1307  }
1308  break;
1309  case Instruction::FMul:
1310  // For multiplication, the infinitely precise result has at most
1311  // LHSWidth + RHSWidth significant bits; if OpWidth is sufficient
1312  // that such a value can be exactly represented, then no double
1313  // rounding can possibly occur; we can safely perform the operation
1314  // in the destination format if it can represent both sources.
1315  if (OpWidth >= LHSWidth + RHSWidth && DstWidth >= SrcWidth) {
1316  if (LHSOrig->getType() != CI.getType())
1317  LHSOrig = Builder->CreateFPExt(LHSOrig, CI.getType());
1318  if (RHSOrig->getType() != CI.getType())
1319  RHSOrig = Builder->CreateFPExt(RHSOrig, CI.getType());
1320  Instruction *RI =
1321  BinaryOperator::CreateFMul(LHSOrig, RHSOrig);
1322  RI->copyFastMathFlags(OpI);
1323  return RI;
1324  }
1325  break;
1326  case Instruction::FDiv:
1327  // For division, we use again use the bound from Figueroa's
1328  // dissertation. I am entirely certain that this bound can be
1329  // tightened in the unbalanced operand case by an analysis based on
1330  // the diophantine rational approximation bound, but the well-known
1331  // condition used here is a good conservative first pass.
1332  // TODO: Tighten bound via rigorous analysis of the unbalanced case.
1333  if (OpWidth >= 2*DstWidth && DstWidth >= SrcWidth) {
1334  if (LHSOrig->getType() != CI.getType())
1335  LHSOrig = Builder->CreateFPExt(LHSOrig, CI.getType());
1336  if (RHSOrig->getType() != CI.getType())
1337  RHSOrig = Builder->CreateFPExt(RHSOrig, CI.getType());
1338  Instruction *RI =
1339  BinaryOperator::CreateFDiv(LHSOrig, RHSOrig);
1340  RI->copyFastMathFlags(OpI);
1341  return RI;
1342  }
1343  break;
1344  case Instruction::FRem:
1345  // Remainder is straightforward. Remainder is always exact, so the
1346  // type of OpI doesn't enter into things at all. We simply evaluate
1347  // in whichever source type is larger, then convert to the
1348  // destination type.
1349  if (SrcWidth == OpWidth)
1350  break;
1351  if (LHSWidth < SrcWidth)
1352  LHSOrig = Builder->CreateFPExt(LHSOrig, RHSOrig->getType());
1353  else if (RHSWidth <= SrcWidth)
1354  RHSOrig = Builder->CreateFPExt(RHSOrig, LHSOrig->getType());
1355  if (LHSOrig != OpI->getOperand(0) || RHSOrig != OpI->getOperand(1)) {
1356  Value *ExactResult = Builder->CreateFRem(LHSOrig, RHSOrig);
1357  if (Instruction *RI = dyn_cast<Instruction>(ExactResult))
1358  RI->copyFastMathFlags(OpI);
1359  return CastInst::CreateFPCast(ExactResult, CI.getType());
1360  }
1361  }
1362 
1363  // (fptrunc (fneg x)) -> (fneg (fptrunc x))
1364  if (BinaryOperator::isFNeg(OpI)) {
1365  Value *InnerTrunc = Builder->CreateFPTrunc(OpI->getOperand(1),
1366  CI.getType());
1367  Instruction *RI = BinaryOperator::CreateFNeg(InnerTrunc);
1368  RI->copyFastMathFlags(OpI);
1369  return RI;
1370  }
1371  }
1372 
1373  // (fptrunc (select cond, R1, Cst)) -->
1374  // (select cond, (fptrunc R1), (fptrunc Cst))
1375  //
1376  // - but only if this isn't part of a min/max operation, else we'll
1377  // ruin min/max canonical form which is to have the select and
1378  // compare's operands be of the same type with no casts to look through.
1379  Value *LHS, *RHS;
1381  if (SI &&
1382  (isa<ConstantFP>(SI->getOperand(1)) ||
1383  isa<ConstantFP>(SI->getOperand(2))) &&
1384  matchSelectPattern(SI, LHS, RHS).Flavor == SPF_UNKNOWN) {
1385  Value *LHSTrunc = Builder->CreateFPTrunc(SI->getOperand(1),
1386  CI.getType());
1387  Value *RHSTrunc = Builder->CreateFPTrunc(SI->getOperand(2),
1388  CI.getType());
1389  return SelectInst::Create(SI->getOperand(0), LHSTrunc, RHSTrunc);
1390  }
1391 
1393  if (II) {
1394  switch (II->getIntrinsicID()) {
1395  default: break;
1396  case Intrinsic::fabs: {
1397  // (fptrunc (fabs x)) -> (fabs (fptrunc x))
1398  Value *InnerTrunc = Builder->CreateFPTrunc(II->getArgOperand(0),
1399  CI.getType());
1400  Type *IntrinsicType[] = { CI.getType() };
1401  Function *Overload = Intrinsic::getDeclaration(
1402  CI.getModule(), II->getIntrinsicID(), IntrinsicType);
1403 
1405  II->getOperandBundlesAsDefs(OpBundles);
1406 
1407  Value *Args[] = { InnerTrunc };
1408  return CallInst::Create(Overload, Args, OpBundles, II->getName());
1409  }
1410  }
1411  }
1412 
1413  return nullptr;
1414 }
1415 
1417  return commonCastTransforms(CI);
1418 }
1419 
1420 // fpto{s/u}i({u/s}itofp(X)) --> X or zext(X) or sext(X) or trunc(X)
1421 // This is safe if the intermediate type has enough bits in its mantissa to
1422 // accurately represent all values of X. For example, this won't work with
1423 // i64 -> float -> i64.
1425  if (!isa<UIToFPInst>(FI.getOperand(0)) && !isa<SIToFPInst>(FI.getOperand(0)))
1426  return nullptr;
1427  Instruction *OpI = cast<Instruction>(FI.getOperand(0));
1428 
1429  Value *SrcI = OpI->getOperand(0);
1430  Type *FITy = FI.getType();
1431  Type *OpITy = OpI->getType();
1432  Type *SrcTy = SrcI->getType();
1433  bool IsInputSigned = isa<SIToFPInst>(OpI);
1434  bool IsOutputSigned = isa<FPToSIInst>(FI);
1435 
1436  // We can safely assume the conversion won't overflow the output range,
1437  // because (for example) (uint8_t)18293.f is undefined behavior.
1438 
1439  // Since we can assume the conversion won't overflow, our decision as to
1440  // whether the input will fit in the float should depend on the minimum
1441  // of the input range and output range.
1442 
1443  // This means this is also safe for a signed input and unsigned output, since
1444  // a negative input would lead to undefined behavior.
1445  int InputSize = (int)SrcTy->getScalarSizeInBits() - IsInputSigned;
1446  int OutputSize = (int)FITy->getScalarSizeInBits() - IsOutputSigned;
1447  int ActualSize = std::min(InputSize, OutputSize);
1448 
1449  if (ActualSize <= OpITy->getFPMantissaWidth()) {
1450  if (FITy->getScalarSizeInBits() > SrcTy->getScalarSizeInBits()) {
1451  if (IsInputSigned && IsOutputSigned)
1452  return new SExtInst(SrcI, FITy);
1453  return new ZExtInst(SrcI, FITy);
1454  }
1455  if (FITy->getScalarSizeInBits() < SrcTy->getScalarSizeInBits())
1456  return new TruncInst(SrcI, FITy);
1457  if (SrcTy == FITy)
1458  return replaceInstUsesWith(FI, SrcI);
1459  return new BitCastInst(SrcI, FITy);
1460  }
1461  return nullptr;
1462 }
1463 
1465  Instruction *OpI = dyn_cast<Instruction>(FI.getOperand(0));
1466  if (!OpI)
1467  return commonCastTransforms(FI);
1468 
1469  if (Instruction *I = FoldItoFPtoI(FI))
1470  return I;
1471 
1472  return commonCastTransforms(FI);
1473 }
1474 
1476  Instruction *OpI = dyn_cast<Instruction>(FI.getOperand(0));
1477  if (!OpI)
1478  return commonCastTransforms(FI);
1479 
1480  if (Instruction *I = FoldItoFPtoI(FI))
1481  return I;
1482 
1483  return commonCastTransforms(FI);
1484 }
1485 
1487  return commonCastTransforms(CI);
1488 }
1489 
1491  return commonCastTransforms(CI);
1492 }
1493 
1495  // If the source integer type is not the intptr_t type for this target, do a
1496  // trunc or zext to the intptr_t type, then inttoptr of it. This allows the
1497  // cast to be exposed to other transforms.
1498  unsigned AS = CI.getAddressSpace();
1499  if (CI.getOperand(0)->getType()->getScalarSizeInBits() !=
1500  DL.getPointerSizeInBits(AS)) {
1501  Type *Ty = DL.getIntPtrType(CI.getContext(), AS);
1502  if (CI.getType()->isVectorTy()) // Handle vectors of pointers.
1503  Ty = VectorType::get(Ty, CI.getType()->getVectorNumElements());
1504 
1505  Value *P = Builder->CreateZExtOrTrunc(CI.getOperand(0), Ty);
1506  return new IntToPtrInst(P, CI.getType());
1507  }
1508 
1509  if (Instruction *I = commonCastTransforms(CI))
1510  return I;
1511 
1512  return nullptr;
1513 }
1514 
1515 /// @brief Implement the transforms for cast of pointer (bitcast/ptrtoint)
1517  Value *Src = CI.getOperand(0);
1518 
1519  if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Src)) {
1520  // If casting the result of a getelementptr instruction with no offset, turn
1521  // this into a cast of the original pointer!
1522  if (GEP->hasAllZeroIndices() &&
1523  // If CI is an addrspacecast and GEP changes the poiner type, merging
1524  // GEP into CI would undo canonicalizing addrspacecast with different
1525  // pointer types, causing infinite loops.
1526  (!isa<AddrSpaceCastInst>(CI) ||
1527  GEP->getType() == GEP->getPointerOperand()->getType())) {
1528  // Changing the cast operand is usually not a good idea but it is safe
1529  // here because the pointer operand is being replaced with another
1530  // pointer operand so the opcode doesn't need to change.
1531  Worklist.Add(GEP);
1532  CI.setOperand(0, GEP->getOperand(0));
1533  return &CI;
1534  }
1535  }
1536 
1537  return commonCastTransforms(CI);
1538 }
1539 
1541  // If the destination integer type is not the intptr_t type for this target,
1542  // do a ptrtoint to intptr_t then do a trunc or zext. This allows the cast
1543  // to be exposed to other transforms.
1544 
1545  Type *Ty = CI.getType();
1546  unsigned AS = CI.getPointerAddressSpace();
1547 
1548  if (Ty->getScalarSizeInBits() == DL.getPointerSizeInBits(AS))
1549  return commonPointerCastTransforms(CI);
1550 
1551  Type *PtrTy = DL.getIntPtrType(CI.getContext(), AS);
1552  if (Ty->isVectorTy()) // Handle vectors of pointers.
1553  PtrTy = VectorType::get(PtrTy, Ty->getVectorNumElements());
1554 
1555  Value *P = Builder->CreatePtrToInt(CI.getOperand(0), PtrTy);
1556  return CastInst::CreateIntegerCast(P, Ty, /*isSigned=*/false);
1557 }
1558 
1559 /// This input value (which is known to have vector type) is being zero extended
1560 /// or truncated to the specified vector type.
1561 /// Try to replace it with a shuffle (and vector/vector bitcast) if possible.
1562 ///
1563 /// The source and destination vector types may have different element types.
1565  InstCombiner &IC) {
1566  // We can only do this optimization if the output is a multiple of the input
1567  // element size, or the input is a multiple of the output element size.
1568  // Convert the input type to have the same element type as the output.
1569  VectorType *SrcTy = cast<VectorType>(InVal->getType());
1570 
1571  if (SrcTy->getElementType() != DestTy->getElementType()) {
1572  // The input types don't need to be identical, but for now they must be the
1573  // same size. There is no specific reason we couldn't handle things like
1574  // <4 x i16> -> <4 x i32> by bitcasting to <2 x i32> but haven't gotten
1575  // there yet.
1576  if (SrcTy->getElementType()->getPrimitiveSizeInBits() !=
1578  return nullptr;
1579 
1580  SrcTy = VectorType::get(DestTy->getElementType(), SrcTy->getNumElements());
1581  InVal = IC.Builder->CreateBitCast(InVal, SrcTy);
1582  }
1583 
1584  // Now that the element types match, get the shuffle mask and RHS of the
1585  // shuffle to use, which depends on whether we're increasing or decreasing the
1586  // size of the input.
1587  SmallVector<uint32_t, 16> ShuffleMask;
1588  Value *V2;
1589 
1590  if (SrcTy->getNumElements() > DestTy->getNumElements()) {
1591  // If we're shrinking the number of elements, just shuffle in the low
1592  // elements from the input and use undef as the second shuffle input.
1593  V2 = UndefValue::get(SrcTy);
1594  for (unsigned i = 0, e = DestTy->getNumElements(); i != e; ++i)
1595  ShuffleMask.push_back(i);
1596 
1597  } else {
1598  // If we're increasing the number of elements, shuffle in all of the
1599  // elements from InVal and fill the rest of the result elements with zeros
1600  // from a constant zero.
1601  V2 = Constant::getNullValue(SrcTy);
1602  unsigned SrcElts = SrcTy->getNumElements();
1603  for (unsigned i = 0, e = SrcElts; i != e; ++i)
1604  ShuffleMask.push_back(i);
1605 
1606  // The excess elements reference the first element of the zero input.
1607  for (unsigned i = 0, e = DestTy->getNumElements()-SrcElts; i != e; ++i)
1608  ShuffleMask.push_back(SrcElts);
1609  }
1610 
1611  return new ShuffleVectorInst(InVal, V2,
1613  ShuffleMask));
1614 }
1615 
1616 static bool isMultipleOfTypeSize(unsigned Value, Type *Ty) {
1617  return Value % Ty->getPrimitiveSizeInBits() == 0;
1618 }
1619 
1620 static unsigned getTypeSizeIndex(unsigned Value, Type *Ty) {
1621  return Value / Ty->getPrimitiveSizeInBits();
1622 }
1623 
1624 /// V is a value which is inserted into a vector of VecEltTy.
1625 /// Look through the value to see if we can decompose it into
1626 /// insertions into the vector. See the example in the comment for
1627 /// OptimizeIntegerToVectorInsertions for the pattern this handles.
1628 /// The type of V is always a non-zero multiple of VecEltTy's size.
1629 /// Shift is the number of bits between the lsb of V and the lsb of
1630 /// the vector.
1631 ///
1632 /// This returns false if the pattern can't be matched or true if it can,
1633 /// filling in Elements with the elements found here.
1634 static bool collectInsertionElements(Value *V, unsigned Shift,
1635  SmallVectorImpl<Value *> &Elements,
1636  Type *VecEltTy, bool isBigEndian) {
1637  assert(isMultipleOfTypeSize(Shift, VecEltTy) &&
1638  "Shift should be a multiple of the element type size");
1639 
1640  // Undef values never contribute useful bits to the result.
1641  if (isa<UndefValue>(V)) return true;
1642 
1643  // If we got down to a value of the right type, we win, try inserting into the
1644  // right element.
1645  if (V->getType() == VecEltTy) {
1646  // Inserting null doesn't actually insert any elements.
1647  if (Constant *C = dyn_cast<Constant>(V))
1648  if (C->isNullValue())
1649  return true;
1650 
1651  unsigned ElementIndex = getTypeSizeIndex(Shift, VecEltTy);
1652  if (isBigEndian)
1653  ElementIndex = Elements.size() - ElementIndex - 1;
1654 
1655  // Fail if multiple elements are inserted into this slot.
1656  if (Elements[ElementIndex])
1657  return false;
1658 
1659  Elements[ElementIndex] = V;
1660  return true;
1661  }
1662 
1663  if (Constant *C = dyn_cast<Constant>(V)) {
1664  // Figure out the # elements this provides, and bitcast it or slice it up
1665  // as required.
1666  unsigned NumElts = getTypeSizeIndex(C->getType()->getPrimitiveSizeInBits(),
1667  VecEltTy);
1668  // If the constant is the size of a vector element, we just need to bitcast
1669  // it to the right type so it gets properly inserted.
1670  if (NumElts == 1)
1672  Shift, Elements, VecEltTy, isBigEndian);
1673 
1674  // Okay, this is a constant that covers multiple elements. Slice it up into
1675  // pieces and insert each element-sized piece into the vector.
1676  if (!isa<IntegerType>(C->getType()))
1678  C->getType()->getPrimitiveSizeInBits()));
1679  unsigned ElementSize = VecEltTy->getPrimitiveSizeInBits();
1680  Type *ElementIntTy = IntegerType::get(C->getContext(), ElementSize);
1681 
1682  for (unsigned i = 0; i != NumElts; ++i) {
1683  unsigned ShiftI = Shift+i*ElementSize;
1685  ShiftI));
1686  Piece = ConstantExpr::getTrunc(Piece, ElementIntTy);
1687  if (!collectInsertionElements(Piece, ShiftI, Elements, VecEltTy,
1688  isBigEndian))
1689  return false;
1690  }
1691  return true;
1692  }
1693 
1694  if (!V->hasOneUse()) return false;
1695 
1696  Instruction *I = dyn_cast<Instruction>(V);
1697  if (!I) return false;
1698  switch (I->getOpcode()) {
1699  default: return false; // Unhandled case.
1700  case Instruction::BitCast:
1701  return collectInsertionElements(I->getOperand(0), Shift, Elements, VecEltTy,
1702  isBigEndian);
1703  case Instruction::ZExt:
1704  if (!isMultipleOfTypeSize(
1706  VecEltTy))
1707  return false;
1708  return collectInsertionElements(I->getOperand(0), Shift, Elements, VecEltTy,
1709  isBigEndian);
1710  case Instruction::Or:
1711  return collectInsertionElements(I->getOperand(0), Shift, Elements, VecEltTy,
1712  isBigEndian) &&
1713  collectInsertionElements(I->getOperand(1), Shift, Elements, VecEltTy,
1714  isBigEndian);
1715  case Instruction::Shl: {
1716  // Must be shifting by a constant that is a multiple of the element size.
1718  if (!CI) return false;
1719  Shift += CI->getZExtValue();
1720  if (!isMultipleOfTypeSize(Shift, VecEltTy)) return false;
1721  return collectInsertionElements(I->getOperand(0), Shift, Elements, VecEltTy,
1722  isBigEndian);
1723  }
1724 
1725  }
1726 }
1727 
1728 
1729 /// If the input is an 'or' instruction, we may be doing shifts and ors to
1730 /// assemble the elements of the vector manually.
1731 /// Try to rip the code out and replace it with insertelements. This is to
1732 /// optimize code like this:
1733 ///
1734 /// %tmp37 = bitcast float %inc to i32
1735 /// %tmp38 = zext i32 %tmp37 to i64
1736 /// %tmp31 = bitcast float %inc5 to i32
1737 /// %tmp32 = zext i32 %tmp31 to i64
1738 /// %tmp33 = shl i64 %tmp32, 32
1739 /// %ins35 = or i64 %tmp33, %tmp38
1740 /// %tmp43 = bitcast i64 %ins35 to <2 x float>
1741 ///
1742 /// Into two insertelements that do "buildvector{%inc, %inc5}".
1744  InstCombiner &IC) {
1745  VectorType *DestVecTy = cast<VectorType>(CI.getType());
1746  Value *IntInput = CI.getOperand(0);
1747 
1748  SmallVector<Value*, 8> Elements(DestVecTy->getNumElements());
1749  if (!collectInsertionElements(IntInput, 0, Elements,
1750  DestVecTy->getElementType(),
1751  IC.getDataLayout().isBigEndian()))
1752  return nullptr;
1753 
1754  // If we succeeded, we know that all of the element are specified by Elements
1755  // or are zero if Elements has a null entry. Recast this as a set of
1756  // insertions.
1757  Value *Result = Constant::getNullValue(CI.getType());
1758  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
1759  if (!Elements[i]) continue; // Unset element.
1760 
1761  Result = IC.Builder->CreateInsertElement(Result, Elements[i],
1762  IC.Builder->getInt32(i));
1763  }
1764 
1765  return Result;
1766 }
1767 
1768 /// Canonicalize scalar bitcasts of extracted elements into a bitcast of the
1769 /// vector followed by extract element. The backend tends to handle bitcasts of
1770 /// vectors better than bitcasts of scalars because vector registers are
1771 /// usually not type-specific like scalar integer or scalar floating-point.
1773  InstCombiner &IC,
1774  const DataLayout &DL) {
1775  // TODO: Create and use a pattern matcher for ExtractElementInst.
1776  auto *ExtElt = dyn_cast<ExtractElementInst>(BitCast.getOperand(0));
1777  if (!ExtElt || !ExtElt->hasOneUse())
1778  return nullptr;
1779 
1780  // The bitcast must be to a vectorizable type, otherwise we can't make a new
1781  // type to extract from.
1782  Type *DestType = BitCast.getType();
1783  if (!VectorType::isValidElementType(DestType))
1784  return nullptr;
1785 
1786  unsigned NumElts = ExtElt->getVectorOperandType()->getNumElements();
1787  auto *NewVecType = VectorType::get(DestType, NumElts);
1788  auto *NewBC = IC.Builder->CreateBitCast(ExtElt->getVectorOperand(),
1789  NewVecType, "bc");
1790  return ExtractElementInst::Create(NewBC, ExtElt->getIndexOperand());
1791 }
1792 
1793 /// Change the type of a bitwise logic operation if we can eliminate a bitcast.
1795  InstCombiner::BuilderTy &Builder) {
1796  Type *DestTy = BitCast.getType();
1797  BinaryOperator *BO;
1798  if (!DestTy->getScalarType()->isIntegerTy() ||
1799  !match(BitCast.getOperand(0), m_OneUse(m_BinOp(BO))) ||
1800  !BO->isBitwiseLogicOp())
1801  return nullptr;
1802 
1803  // FIXME: This transform is restricted to vector types to avoid backend
1804  // problems caused by creating potentially illegal operations. If a fix-up is
1805  // added to handle that situation, we can remove this check.
1806  if (!DestTy->isVectorTy() || !BO->getType()->isVectorTy())
1807  return nullptr;
1808 
1809  Value *X;
1810  if (match(BO->getOperand(0), m_OneUse(m_BitCast(m_Value(X)))) &&
1811  X->getType() == DestTy && !isa<Constant>(X)) {
1812  // bitcast(logic(bitcast(X), Y)) --> logic'(X, bitcast(Y))
1813  Value *CastedOp1 = Builder.CreateBitCast(BO->getOperand(1), DestTy);
1814  return BinaryOperator::Create(BO->getOpcode(), X, CastedOp1);
1815  }
1816 
1817  if (match(BO->getOperand(1), m_OneUse(m_BitCast(m_Value(X)))) &&
1818  X->getType() == DestTy && !isa<Constant>(X)) {
1819  // bitcast(logic(Y, bitcast(X))) --> logic'(bitcast(Y), X)
1820  Value *CastedOp0 = Builder.CreateBitCast(BO->getOperand(0), DestTy);
1821  return BinaryOperator::Create(BO->getOpcode(), CastedOp0, X);
1822  }
1823 
1824  return nullptr;
1825 }
1826 
1827 /// Change the type of a select if we can eliminate a bitcast.
1829  InstCombiner::BuilderTy &Builder) {
1830  Value *Cond, *TVal, *FVal;
1831  if (!match(BitCast.getOperand(0),
1832  m_OneUse(m_Select(m_Value(Cond), m_Value(TVal), m_Value(FVal)))))
1833  return nullptr;
1834 
1835  // A vector select must maintain the same number of elements in its operands.
1836  Type *CondTy = Cond->getType();
1837  Type *DestTy = BitCast.getType();
1838  if (CondTy->isVectorTy()) {
1839  if (!DestTy->isVectorTy())
1840  return nullptr;
1841  if (DestTy->getVectorNumElements() != CondTy->getVectorNumElements())
1842  return nullptr;
1843  }
1844 
1845  // FIXME: This transform is restricted from changing the select between
1846  // scalars and vectors to avoid backend problems caused by creating
1847  // potentially illegal operations. If a fix-up is added to handle that
1848  // situation, we can remove this check.
1849  if (DestTy->isVectorTy() != TVal->getType()->isVectorTy())
1850  return nullptr;
1851 
1852  auto *Sel = cast<Instruction>(BitCast.getOperand(0));
1853  Value *X;
1854  if (match(TVal, m_OneUse(m_BitCast(m_Value(X)))) && X->getType() == DestTy &&
1855  !isa<Constant>(X)) {
1856  // bitcast(select(Cond, bitcast(X), Y)) --> select'(Cond, X, bitcast(Y))
1857  Value *CastedVal = Builder.CreateBitCast(FVal, DestTy);
1858  return SelectInst::Create(Cond, X, CastedVal, "", nullptr, Sel);
1859  }
1860 
1861  if (match(FVal, m_OneUse(m_BitCast(m_Value(X)))) && X->getType() == DestTy &&
1862  !isa<Constant>(X)) {
1863  // bitcast(select(Cond, Y, bitcast(X))) --> select'(Cond, bitcast(Y), X)
1864  Value *CastedVal = Builder.CreateBitCast(TVal, DestTy);
1865  return SelectInst::Create(Cond, CastedVal, X, "", nullptr, Sel);
1866  }
1867 
1868  return nullptr;
1869 }
1870 
1871 /// Check if all users of CI are StoreInsts.
1872 static bool hasStoreUsersOnly(CastInst &CI) {
1873  for (User *U : CI.users()) {
1874  if (!isa<StoreInst>(U))
1875  return false;
1876  }
1877  return true;
1878 }
1879 
1880 /// This function handles following case
1881 ///
1882 /// A -> B cast
1883 /// PHI
1884 /// B -> A cast
1885 ///
1886 /// All the related PHI nodes can be replaced by new PHI nodes with type A.
1887 /// The uses of \p CI can be changed to the new PHI node corresponding to \p PN.
1888 Instruction *InstCombiner::optimizeBitCastFromPhi(CastInst &CI, PHINode *PN) {
1889  // BitCast used by Store can be handled in InstCombineLoadStoreAlloca.cpp.
1890  if (hasStoreUsersOnly(CI))
1891  return nullptr;
1892 
1893  Value *Src = CI.getOperand(0);
1894  Type *SrcTy = Src->getType(); // Type B
1895  Type *DestTy = CI.getType(); // Type A
1896 
1897  SmallVector<PHINode *, 4> PhiWorklist;
1898  SmallSetVector<PHINode *, 4> OldPhiNodes;
1899 
1900  // Find all of the A->B casts and PHI nodes.
1901  // We need to inpect all related PHI nodes, but PHIs can be cyclic, so
1902  // OldPhiNodes is used to track all known PHI nodes, before adding a new
1903  // PHI to PhiWorklist, it is checked against and added to OldPhiNodes first.
1904  PhiWorklist.push_back(PN);
1905  OldPhiNodes.insert(PN);
1906  while (!PhiWorklist.empty()) {
1907  auto *OldPN = PhiWorklist.pop_back_val();
1908  for (Value *IncValue : OldPN->incoming_values()) {
1909  if (isa<Constant>(IncValue))
1910  continue;
1911 
1912  if (auto *LI = dyn_cast<LoadInst>(IncValue)) {
1913  // If there is a sequence of one or more load instructions, each loaded
1914  // value is used as address of later load instruction, bitcast is
1915  // necessary to change the value type, don't optimize it. For
1916  // simplicity we give up if the load address comes from another load.
1917  Value *Addr = LI->getOperand(0);
1918  if (Addr == &CI || isa<LoadInst>(Addr))
1919  return nullptr;
1920  if (LI->hasOneUse() && LI->isSimple())
1921  continue;
1922  // If a LoadInst has more than one use, changing the type of loaded
1923  // value may create another bitcast.
1924  return nullptr;
1925  }
1926 
1927  if (auto *PNode = dyn_cast<PHINode>(IncValue)) {
1928  if (OldPhiNodes.insert(PNode))
1929  PhiWorklist.push_back(PNode);
1930  continue;
1931  }
1932 
1933  auto *BCI = dyn_cast<BitCastInst>(IncValue);
1934  // We can't handle other instructions.
1935  if (!BCI)
1936  return nullptr;
1937 
1938  // Verify it's a A->B cast.
1939  Type *TyA = BCI->getOperand(0)->getType();
1940  Type *TyB = BCI->getType();
1941  if (TyA != DestTy || TyB != SrcTy)
1942  return nullptr;
1943  }
1944  }
1945 
1946  // For each old PHI node, create a corresponding new PHI node with a type A.
1948  for (auto *OldPN : OldPhiNodes) {
1949  Builder->SetInsertPoint(OldPN);
1950  PHINode *NewPN = Builder->CreatePHI(DestTy, OldPN->getNumOperands());
1951  NewPNodes[OldPN] = NewPN;
1952  }
1953 
1954  // Fill in the operands of new PHI nodes.
1955  for (auto *OldPN : OldPhiNodes) {
1956  PHINode *NewPN = NewPNodes[OldPN];
1957  for (unsigned j = 0, e = OldPN->getNumOperands(); j != e; ++j) {
1958  Value *V = OldPN->getOperand(j);
1959  Value *NewV = nullptr;
1960  if (auto *C = dyn_cast<Constant>(V)) {
1961  NewV = ConstantExpr::getBitCast(C, DestTy);
1962  } else if (auto *LI = dyn_cast<LoadInst>(V)) {
1963  Builder->SetInsertPoint(LI->getNextNode());
1964  NewV = Builder->CreateBitCast(LI, DestTy);
1965  Worklist.Add(LI);
1966  } else if (auto *BCI = dyn_cast<BitCastInst>(V)) {
1967  NewV = BCI->getOperand(0);
1968  } else if (auto *PrevPN = dyn_cast<PHINode>(V)) {
1969  NewV = NewPNodes[PrevPN];
1970  }
1971  assert(NewV);
1972  NewPN->addIncoming(NewV, OldPN->getIncomingBlock(j));
1973  }
1974  }
1975 
1976  // If there is a store with type B, change it to type A.
1977  for (User *U : PN->users()) {
1978  auto *SI = dyn_cast<StoreInst>(U);
1979  if (SI && SI->isSimple() && SI->getOperand(0) == PN) {
1980  Builder->SetInsertPoint(SI);
1981  auto *NewBC =
1982  cast<BitCastInst>(Builder->CreateBitCast(NewPNodes[PN], SrcTy));
1983  SI->setOperand(0, NewBC);
1984  Worklist.Add(SI);
1985  assert(hasStoreUsersOnly(*NewBC));
1986  }
1987  }
1988 
1989  return replaceInstUsesWith(CI, NewPNodes[PN]);
1990 }
1991 
1993  // If the operands are integer typed then apply the integer transforms,
1994  // otherwise just apply the common ones.
1995  Value *Src = CI.getOperand(0);
1996  Type *SrcTy = Src->getType();
1997  Type *DestTy = CI.getType();
1998 
1999  // Get rid of casts from one type to the same type. These are useless and can
2000  // be replaced by the operand.
2001  if (DestTy == Src->getType())
2002  return replaceInstUsesWith(CI, Src);
2003 
2004  if (PointerType *DstPTy = dyn_cast<PointerType>(DestTy)) {
2005  PointerType *SrcPTy = cast<PointerType>(SrcTy);
2006  Type *DstElTy = DstPTy->getElementType();
2007  Type *SrcElTy = SrcPTy->getElementType();
2008 
2009  // If we are casting a alloca to a pointer to a type of the same
2010  // size, rewrite the allocation instruction to allocate the "right" type.
2011  // There is no need to modify malloc calls because it is their bitcast that
2012  // needs to be cleaned up.
2013  if (AllocaInst *AI = dyn_cast<AllocaInst>(Src))
2014  if (Instruction *V = PromoteCastOfAllocation(CI, *AI))
2015  return V;
2016 
2017  // When the type pointed to is not sized the cast cannot be
2018  // turned into a gep.
2019  Type *PointeeType =
2020  cast<PointerType>(Src->getType()->getScalarType())->getElementType();
2021  if (!PointeeType->isSized())
2022  return nullptr;
2023 
2024  // If the source and destination are pointers, and this cast is equivalent
2025  // to a getelementptr X, 0, 0, 0... turn it into the appropriate gep.
2026  // This can enhance SROA and other transforms that want type-safe pointers.
2027  unsigned NumZeros = 0;
2028  while (SrcElTy != DstElTy &&
2029  isa<CompositeType>(SrcElTy) && !SrcElTy->isPointerTy() &&
2030  SrcElTy->getNumContainedTypes() /* not "{}" */) {
2031  SrcElTy = cast<CompositeType>(SrcElTy)->getTypeAtIndex(0U);
2032  ++NumZeros;
2033  }
2034 
2035  // If we found a path from the src to dest, create the getelementptr now.
2036  if (SrcElTy == DstElTy) {
2037  SmallVector<Value *, 8> Idxs(NumZeros + 1, Builder->getInt32(0));
2038  return GetElementPtrInst::CreateInBounds(Src, Idxs);
2039  }
2040  }
2041 
2042  if (VectorType *DestVTy = dyn_cast<VectorType>(DestTy)) {
2043  if (DestVTy->getNumElements() == 1 && !SrcTy->isVectorTy()) {
2044  Value *Elem = Builder->CreateBitCast(Src, DestVTy->getElementType());
2045  return InsertElementInst::Create(UndefValue::get(DestTy), Elem,
2047  // FIXME: Canonicalize bitcast(insertelement) -> insertelement(bitcast)
2048  }
2049 
2050  if (isa<IntegerType>(SrcTy)) {
2051  // If this is a cast from an integer to vector, check to see if the input
2052  // is a trunc or zext of a bitcast from vector. If so, we can replace all
2053  // the casts with a shuffle and (potentially) a bitcast.
2054  if (isa<TruncInst>(Src) || isa<ZExtInst>(Src)) {
2055  CastInst *SrcCast = cast<CastInst>(Src);
2056  if (BitCastInst *BCIn = dyn_cast<BitCastInst>(SrcCast->getOperand(0)))
2057  if (isa<VectorType>(BCIn->getOperand(0)->getType()))
2058  if (Instruction *I = optimizeVectorResize(BCIn->getOperand(0),
2059  cast<VectorType>(DestTy), *this))
2060  return I;
2061  }
2062 
2063  // If the input is an 'or' instruction, we may be doing shifts and ors to
2064  // assemble the elements of the vector manually. Try to rip the code out
2065  // and replace it with insertelements.
2066  if (Value *V = optimizeIntegerToVectorInsertions(CI, *this))
2067  return replaceInstUsesWith(CI, V);
2068  }
2069  }
2070 
2071  if (VectorType *SrcVTy = dyn_cast<VectorType>(SrcTy)) {
2072  if (SrcVTy->getNumElements() == 1) {
2073  // If our destination is not a vector, then make this a straight
2074  // scalar-scalar cast.
2075  if (!DestTy->isVectorTy()) {
2076  Value *Elem =
2077  Builder->CreateExtractElement(Src,
2079  return CastInst::Create(Instruction::BitCast, Elem, DestTy);
2080  }
2081 
2082  // Otherwise, see if our source is an insert. If so, then use the scalar
2083  // component directly.
2084  if (InsertElementInst *IEI =
2085  dyn_cast<InsertElementInst>(CI.getOperand(0)))
2086  return CastInst::Create(Instruction::BitCast, IEI->getOperand(1),
2087  DestTy);
2088  }
2089  }
2090 
2091  if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(Src)) {
2092  // Okay, we have (bitcast (shuffle ..)). Check to see if this is
2093  // a bitcast to a vector with the same # elts.
2094  if (SVI->hasOneUse() && DestTy->isVectorTy() &&
2095  DestTy->getVectorNumElements() == SVI->getType()->getNumElements() &&
2096  SVI->getType()->getNumElements() ==
2097  SVI->getOperand(0)->getType()->getVectorNumElements()) {
2098  BitCastInst *Tmp;
2099  // If either of the operands is a cast from CI.getType(), then
2100  // evaluating the shuffle in the casted destination's type will allow
2101  // us to eliminate at least one cast.
2102  if (((Tmp = dyn_cast<BitCastInst>(SVI->getOperand(0))) &&
2103  Tmp->getOperand(0)->getType() == DestTy) ||
2104  ((Tmp = dyn_cast<BitCastInst>(SVI->getOperand(1))) &&
2105  Tmp->getOperand(0)->getType() == DestTy)) {
2106  Value *LHS = Builder->CreateBitCast(SVI->getOperand(0), DestTy);
2107  Value *RHS = Builder->CreateBitCast(SVI->getOperand(1), DestTy);
2108  // Return a new shuffle vector. Use the same element ID's, as we
2109  // know the vector types match #elts.
2110  return new ShuffleVectorInst(LHS, RHS, SVI->getOperand(2));
2111  }
2112  }
2113  }
2114 
2115  // Handle the A->B->A cast, and there is an intervening PHI node.
2116  if (PHINode *PN = dyn_cast<PHINode>(Src))
2117  if (Instruction *I = optimizeBitCastFromPhi(CI, PN))
2118  return I;
2119 
2120  if (Instruction *I = canonicalizeBitCastExtElt(CI, *this, DL))
2121  return I;
2122 
2123  if (Instruction *I = foldBitCastBitwiseLogic(CI, *Builder))
2124  return I;
2125 
2126  if (Instruction *I = foldBitCastSelect(CI, *Builder))
2127  return I;
2128 
2129  if (SrcTy->isPointerTy())
2130  return commonPointerCastTransforms(CI);
2131  return commonCastTransforms(CI);
2132 }
2133 
2135  // If the destination pointer element type is not the same as the source's
2136  // first do a bitcast to the destination type, and then the addrspacecast.
2137  // This allows the cast to be exposed to other transforms.
2138  Value *Src = CI.getOperand(0);
2139  PointerType *SrcTy = cast<PointerType>(Src->getType()->getScalarType());
2140  PointerType *DestTy = cast<PointerType>(CI.getType()->getScalarType());
2141 
2142  Type *DestElemTy = DestTy->getElementType();
2143  if (SrcTy->getElementType() != DestElemTy) {
2144  Type *MidTy = PointerType::get(DestElemTy, SrcTy->getAddressSpace());
2145  if (VectorType *VT = dyn_cast<VectorType>(CI.getType())) {
2146  // Handle vectors of pointers.
2147  MidTy = VectorType::get(MidTy, VT->getNumElements());
2148  }
2149 
2150  Value *NewBitCast = Builder->CreateBitCast(Src, MidTy);
2151  return new AddrSpaceCastInst(NewBitCast, CI.getType());
2152  }
2153 
2154  return commonPointerCastTransforms(CI);
2155 }
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
Definition: PatternMatch.h:506
void computeKnownBits(const Value *V, APInt &KnownZero, APInt &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
void push_back(const T &Elt)
Definition: SmallVector.h:211
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
void copyFastMathFlags(FastMathFlags FMF)
Convenience function for transferring all fast-math flag values to this instruction, which must be an operator which supports these flags.
Instruction::CastOps getOpcode() const
Return the opcode of this CastInst.
Definition: InstrTypes.h:840
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:64
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:166
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
DiagnosticInfoOptimizationBase::Argument NV
size_t i
Instruction * visitBitCast(BitCastInst &CI)
void setAlignment(unsigned Align)
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
Definition: IntrinsicInst.h:51
This class represents zero extension of integer types.
Instruction * commonCastTransforms(CastInst &CI)
Implement the transforms common to all CastInst visitors.
bool hasNoSignedWrap() const
Test whether this operation is known to never undergo signed overflow, aka the nsw property...
Definition: Operator.h:104
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Get a value with low bits set.
Definition: APInt.h:536
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
Definition: PatternMatch.h:83
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space...
Definition: Type.cpp:655
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
Definition: PatternMatch.h:536
const DataLayout & getDataLayout() const
This instruction constructs a fixed permutation of two input vectors.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=nullptr, Instruction *MDFrom=nullptr)
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
Definition: Type.h:216
int getFPMantissaWidth() const
Return the width of the mantissa of this type.
Definition: Type.cpp:127
static bool isEquality(Predicate P)
Return true if this predicate is either EQ or NE.
static Value * lookThroughFPExtensions(Value *V)
If this is a floating-point extension instruction, look through it until we get the source value...
This class represents a sign extension of integer types.
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:471
Hexagon Common GEP
Type * getElementType() const
Definition: DerivedTypes.h:462
static Instruction * canonicalizeBitCastExtElt(BitCastInst &BitCast, InstCombiner &IC, const DataLayout &DL)
Canonicalize scalar bitcasts of extracted elements into a bitcast of the vector followed by extract e...
Instruction * visitUIToFP(CastInst &CI)
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:195
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
Instruction * visitFPExt(CastInst &CI)
Instruction * FoldItoFPtoI(Instruction &FI)
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:41
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Instruction * visitFPToUI(FPToUIInst &FI)
This class represents a conversion between pointers from one address space to another.
static Constant * getIntegerCast(Constant *C, Type *Ty, bool isSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
Definition: Constants.cpp:1535
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
Definition: PatternMatch.h:518
This class represents the LLVM 'select' instruction.
static bool hasStoreUsersOnly(CastInst &CI)
Check if all users of CI are StoreInsts.
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:578
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:143
BinOp2_match< LHS, RHS, Instruction::LShr, Instruction::AShr > m_Shr(const LHS &L, const RHS &R)
Matches LShr or AShr.
Definition: PatternMatch.h:658
static Constant * getLShr(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2210
static bool canEvaluateZExtd(Value *V, Type *Ty, unsigned &BitsToClear, InstCombiner &IC, Instruction *CxtI)
Determine if the specified value can be computed in the specified wider type and produce the same low...
CastClass_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
Definition: PatternMatch.h:801
The core instruction combiner logic.
static bool canEvaluateTruncated(Value *V, Type *Ty, InstCombiner &IC, Instruction *CxtI)
Return true if we can evaluate the specified expression tree as type Ty instead of its larger type...
Instruction * visitIntToPtr(IntToPtrInst &CI)
static Instruction * optimizeVectorResize(Value *InVal, VectorType *DestTy, InstCombiner &IC)
This input value (which is known to have vector type) is being zero extended or truncated to the spec...
Instruction * visitAddrSpaceCast(AddrSpaceCastInst &CI)
static Type * getPPC_FP128Ty(LLVMContext &C)
Definition: Type.cpp:163
static unsigned getTypeSizeIndex(unsigned Value, Type *Ty)
This class represents a cast from a pointer to an integer.
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:154
Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Attempt to fold the constant using the specified DataLayout.
static Constant * getZExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1587
static GetElementPtrInst * CreateInBounds(Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Create an "inbounds" getelementptr.
Definition: Instructions.h:891
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1362
static bool isMultipleOfTypeSize(unsigned Value, Type *Ty)
#define F(x, y, z)
Definition: MD5.cpp:51
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:136
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition: APFloat.cpp:4139
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
Definition: PatternMatch.h:117
CastClass_match< OpTy, Instruction::ZExt > m_ZExt(const OpTy &Op)
Matches ZExt.
Definition: PatternMatch.h:813
static bool isValidElementType(Type *ElemTy)
Return true if the specified type is valid as a element type.
Definition: Type.cpp:646
This class represents a no-op cast from one type to another.
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:75
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=None)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:949
An instruction for storing to memory.
Definition: Instructions.h:300
This class represents a cast from floating point to signed integer.
SelectClass_match< Cond, LHS, RHS > m_Select(const Cond &C, const LHS &L, const RHS &R)
Definition: PatternMatch.h:758
static Value * optimizeIntegerToVectorInsertions(BitCastInst &CI, InstCombiner &IC)
If the input is an 'or' instruction, we may be doing shifts and ors to assemble the elements of the v...
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:263
static Instruction * foldBitCastSelect(BitCastInst &BitCast, InstCombiner::BuilderTy &Builder)
Change the type of a select if we can eliminate a bitcast.
Type * getScalarType() const LLVM_READONLY
If this is a vector type, return the element type, otherwise return 'this'.
Definition: Type.cpp:44
Type * getElementType() const
Definition: DerivedTypes.h:336
This class represents a truncation of integer types.
Maximum length of the test input libFuzzer tries to guess a good value based on the corpus and reports it always prefer smaller inputs during the corpus shuffle When libFuzzer itself reports a bug this exit code will be used If indicates the maximal total time in seconds to run the fuzzer minimizes the provided crash input Use with etc Experimental Use value profile to guide fuzzing Number of simultaneous worker processes to run the jobs If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
Class to represent pointers.
Definition: DerivedTypes.h:443
bool ult(const APInt &RHS) const
Unsigned less than comparison.
Definition: APInt.cpp:501
unsigned getNumIncomingValues() const
Return the number of incoming edges.
SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr)
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out param...
static const fltSemantics & IEEEsingle()
Definition: APFloat.cpp:100
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
Definition: InstrTypes.h:1441
static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet)
Get a value with high bits set.
Definition: APInt.h:518
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1695
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:254
an instruction for type-safe pointer arithmetic to access elements of arrays and structs ...
Definition: Instructions.h:830
OneUse_match< T > m_OneUse(const T &SubPattern)
Definition: PatternMatch.h:55
#define P(N)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
Definition: PatternMatch.h:530
static Instruction * foldBitCastBitwiseLogic(BitCastInst &BitCast, InstCombiner::BuilderTy &Builder)
Change the type of a bitwise logic operation if we can eliminate a bitcast.
This instruction inserts a single (scalar) element into a VectorType value.
APInt trunc(unsigned width) const
Truncate to new width.
Definition: APInt.cpp:916
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:219
CastClass_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
Definition: PatternMatch.h:789
This is an important base class in LLVM.
Definition: Constant.h:42
PointerType * getType() const
Overload to return most specific pointer type.
Definition: Instructions.h:97
void setUsedWithInAlloca(bool V)
Specify whether this alloca is used to represent the arguments to a call.
Definition: Instructions.h:126
static Instruction * foldVecTruncToExtElt(TruncInst &Trunc, InstCombiner &IC, const DataLayout &DL)
Given a vector that is bitcast to an integer, optionally logically right-shifted, and truncated...
bool MaskedValueIsZero(const Value *V, const APInt &Mask, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Return true if 'V & Mask' is known to be zero.
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1947
unsigned getAlignment() const
Return the alignment of the memory that is being allocated by the instruction.
Definition: Instructions.h:109
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:269
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1952
static const fltSemantics & IEEEhalf()
Definition: APFloat.cpp:97
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
Definition: PatternMatch.h:322
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
Definition: PatternMatch.h:524
uint32_t Offset
bool isUsedWithInAlloca() const
Return true if this alloca is used as an inalloca argument to a call.
Definition: Instructions.h:121
static Value * decomposeSimpleLinearExpr(Value *Val, unsigned &Scale, uint64_t &Offset)
Analyze 'Val', seeing if it is a simple linear expression.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
This instruction compares its operands according to the predicate given to the constructor.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:880
Utility class for integer arithmetic operators which may exhibit overflow - Add, Sub, and Mul.
Definition: Operator.h:75
uint64_t getNumElements() const
Definition: DerivedTypes.h:335
Value * getOperand(unsigned i) const
Definition: User.h:145
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
Definition: PatternMatch.h:67
Class to represent integer types.
Definition: DerivedTypes.h:39
Type * getSrcTy() const
Return the source type, as a convenience.
Definition: InstrTypes.h:845
unsigned countPopulation() const
Count the number of bits set.
Definition: APInt.h:1397
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:960
This class represents a cast from an integer to a pointer.
static Constant * getAllOnesValue(Type *Ty)
Get the all ones value.
Definition: Constants.cpp:249
Instruction * visitFPToSI(FPToSIInst &FI)
unsigned getNumContainedTypes() const
Return the number of types in the derived type.
Definition: Type.h:322
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:213
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1337
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:654
const Value * getTrueValue() const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
signed greater than
Definition: InstrTypes.h:907
CastClass_match< OpTy, Instruction::SExt > m_SExt(const OpTy &Op)
Matches SExt.
Definition: PatternMatch.h:807
unsigned countTrailingZeros() const
Count the number of trailing zero bits.
Definition: APInt.cpp:703
BinaryOps getOpcode() const
Definition: InstrTypes.h:541
static BinaryOperator * CreateFNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:234
static CastInst * CreateIntegerCast(Value *S, Type *Ty, bool isSigned, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a ZExt, BitCast, or Trunc for int -> int casts.
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:292
This is the shared class of boolean and integer constants.
Definition: Constants.h:88
SelectPatternFlavor Flavor
unsigned ComputeNumSignBits(const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Return the number of times the sign bit of the register is replicated into the other bits...
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type...
Definition: Type.cpp:123
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:58
static CallInst * Create(Value *Func, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles=None, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:230
Instruction * user_back()
Specialize the methods defined in Value, as we know that an instruction can only be used by other ins...
Definition: Instruction.h:59
Value * CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx, const Twine &Name="")
Definition: IRBuilder.h:1642
Instruction * visitSExt(SExtInst &CI)
signed less than
Definition: InstrTypes.h:909
This class represents a cast from floating point to unsigned integer.
Type * getDestTy() const
Return the destination type, as a convenience.
Definition: InstrTypes.h:847
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:382
Instruction * visitZExt(ZExtInst &CI)
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Definition: IRBuilder.h:307
static CastInst * CreateFPCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create an FPExt, BitCast, or FPTrunc for fp -> fp casts.
static unsigned isEliminableCastPair(Instruction::CastOps firstOpcode, Instruction::CastOps secondOpcode, Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy, Type *DstIntPtrTy)
Determine how a pair of casts can be eliminated, if they can be at all.
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1559
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:558
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
Definition: Constants.cpp:623
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:90
unsigned getAddressSpace() const
Returns the address space of this instruction's pointer type.
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
void setOperand(unsigned i, Value *Val)
Definition: User.h:150
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th call argument.
Class to represent vector types.
Definition: DerivedTypes.h:369
Class for arbitrary precision integers.
Definition: APInt.h:77
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:195
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
iterator_range< user_iterator > users()
Definition: Value.h:370
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:438
static const fltSemantics & IEEEdouble()
Definition: APFloat.cpp:103
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1942
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
Instruction * visitTrunc(TruncInst &CI)
void ComputeSignBit(const Value *V, bool &KnownZero, bool &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Determine whether the sign bit is known to be zero or one.
static bool collectInsertionElements(Value *V, unsigned Shift, SmallVectorImpl< Value * > &Elements, Type *VecEltTy, bool isBigEndian)
V is a value which is inserted into a vector of VecEltTy.
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:169
Instruction * visitSIToFP(CastInst &CI)
static bool isFNeg(const Value *V, bool IgnoreZeroSign=false)
#define I(x, y, z)
Definition: MD5.cpp:54
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
bool hasOneUse() const
Return true if there is exactly one user of this value.
Definition: Value.h:383
static Constant * fitsInFPType(ConstantFP *CFP, const fltSemantics &Sem)
Return a Constant* for the specified floating-point constant if it fits in the specified FP type with...
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
This instruction extracts a single (scalar) element from a VectorType value.
static volatile int Zero
const APFloat & getValueAPF() const
Definition: Constants.h:300
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This class represents a truncation of floating point types.
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:108
LLVM Value Representation.
Definition: Value.h:71
This file provides internal interfaces used to implement the InstCombine.
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:111
static VectorType * get(Type *ElementType, unsigned NumElements)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:631
static bool canEvaluateSExtd(Value *V, Type *Ty)
Return true if we can take the specified value and return it as type Ty without inserting any new cas...
const Value * getArraySize() const
Get the number of elements allocated.
Definition: Instructions.h:93
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:81
Instruction * commonPointerCastTransforms(CastInst &CI)
Implement the transforms for cast of pointer (bitcast/ptrtoint)
#define DEBUG(X)
Definition: Debug.h:100
const Value * getFalseValue() const
static Constant * get(LLVMContext &Context, ArrayRef< uint8_t > Elts)
get() constructors - Return a constant with vector type with an element count and element type matchi...
Definition: Constants.cpp:2488
Instruction * visitPtrToInt(PtrToIntInst &CI)
static ExtractElementInst * Create(Value *Vec, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
bool isBitwiseLogicOp() const
Return true if this is and/or/xor.
Definition: Instruction.h:146
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
Definition: Instructions.h:102
op_range incoming_values()
bool isBigEndian() const
Definition: DataLayout.h:221
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
bool hasNoUnsignedWrap() const
Test whether this operation is known to never undergo unsigned overflow, aka the nuw property...
Definition: Operator.h:98
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:44
an instruction to allocate memory on the stack
Definition: Instructions.h:60
Instruction * visitFPTrunc(FPTruncInst &CI)