LLVM  14.0.0git
Constants.cpp
Go to the documentation of this file.
1 //===-- Constants.cpp - Implement Constant nodes --------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Constant* classes.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/IR/Constants.h"
14 #include "ConstantFold.h"
15 #include "LLVMContextImpl.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/ADT/SmallVector.h"
18 #include "llvm/ADT/StringMap.h"
19 #include "llvm/IR/DerivedTypes.h"
21 #include "llvm/IR/GlobalValue.h"
22 #include "llvm/IR/Instructions.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/IR/Operator.h"
25 #include "llvm/IR/PatternMatch.h"
26 #include "llvm/Support/Debug.h"
31 #include <algorithm>
32 
33 using namespace llvm;
34 using namespace PatternMatch;
35 
36 //===----------------------------------------------------------------------===//
37 // Constant Class
38 //===----------------------------------------------------------------------===//
39 
41  // Floating point values have an explicit -0.0 value.
42  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
43  return CFP->isZero() && CFP->isNegative();
44 
45  // Equivalent for a vector of -0.0's.
46  if (getType()->isVectorTy())
47  if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue()))
48  return SplatCFP->isNegativeZeroValue();
49 
50  // We've already handled true FP case; any other FP vectors can't represent -0.0.
51  if (getType()->isFPOrFPVectorTy())
52  return false;
53 
54  // Otherwise, just use +0.0.
55  return isNullValue();
56 }
57 
58 // Return true iff this constant is positive zero (floating point), negative
59 // zero (floating point), or a null value.
60 bool Constant::isZeroValue() const {
61  // Floating point values have an explicit -0.0 value.
62  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
63  return CFP->isZero();
64 
65  // Check for constant splat vectors of 1 values.
66  if (getType()->isVectorTy())
67  if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue()))
68  return SplatCFP->isZero();
69 
70  // Otherwise, just use +0.0.
71  return isNullValue();
72 }
73 
74 bool Constant::isNullValue() const {
75  // 0 is null.
76  if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
77  return CI->isZero();
78 
79  // +0.0 is null.
80  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
81  // ppc_fp128 determine isZero using high order double only
82  // Should check the bitwise value to make sure all bits are zero.
83  return CFP->isExactlyValue(+0.0);
84 
85  // constant zero is zero for aggregates, cpnull is null for pointers, none for
86  // tokens.
87  return isa<ConstantAggregateZero>(this) || isa<ConstantPointerNull>(this) ||
88  isa<ConstantTokenNone>(this);
89 }
90 
92  // Check for -1 integers
93  if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
94  return CI->isMinusOne();
95 
96  // Check for FP which are bitcasted from -1 integers
97  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
98  return CFP->getValueAPF().bitcastToAPInt().isAllOnes();
99 
100  // Check for constant splat vectors of 1 values.
101  if (getType()->isVectorTy())
102  if (const auto *SplatVal = getSplatValue())
103  return SplatVal->isAllOnesValue();
104 
105  return false;
106 }
107 
108 bool Constant::isOneValue() const {
109  // Check for 1 integers
110  if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
111  return CI->isOne();
112 
113  // Check for FP which are bitcasted from 1 integers
114  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
115  return CFP->getValueAPF().bitcastToAPInt().isOne();
116 
117  // Check for constant splat vectors of 1 values.
118  if (getType()->isVectorTy())
119  if (const auto *SplatVal = getSplatValue())
120  return SplatVal->isOneValue();
121 
122  return false;
123 }
124 
126  // Check for 1 integers
127  if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
128  return !CI->isOneValue();
129 
130  // Check for FP which are bitcasted from 1 integers
131  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
132  return !CFP->getValueAPF().bitcastToAPInt().isOne();
133 
134  // Check that vectors don't contain 1
135  if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
136  for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
137  Constant *Elt = getAggregateElement(I);
138  if (!Elt || !Elt->isNotOneValue())
139  return false;
140  }
141  return true;
142  }
143 
144  // Check for splats that don't contain 1
145  if (getType()->isVectorTy())
146  if (const auto *SplatVal = getSplatValue())
147  return SplatVal->isNotOneValue();
148 
149  // It *may* contain 1, we can't tell.
150  return false;
151 }
152 
154  // Check for INT_MIN integers
155  if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
156  return CI->isMinValue(/*isSigned=*/true);
157 
158  // Check for FP which are bitcasted from INT_MIN integers
159  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
160  return CFP->getValueAPF().bitcastToAPInt().isMinSignedValue();
161 
162  // Check for splats of INT_MIN values.
163  if (getType()->isVectorTy())
164  if (const auto *SplatVal = getSplatValue())
165  return SplatVal->isMinSignedValue();
166 
167  return false;
168 }
169 
171  // Check for INT_MIN integers
172  if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
173  return !CI->isMinValue(/*isSigned=*/true);
174 
175  // Check for FP which are bitcasted from INT_MIN integers
176  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
177  return !CFP->getValueAPF().bitcastToAPInt().isMinSignedValue();
178 
179  // Check that vectors don't contain INT_MIN
180  if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
181  for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
182  Constant *Elt = getAggregateElement(I);
183  if (!Elt || !Elt->isNotMinSignedValue())
184  return false;
185  }
186  return true;
187  }
188 
189  // Check for splats that aren't INT_MIN
190  if (getType()->isVectorTy())
191  if (const auto *SplatVal = getSplatValue())
192  return SplatVal->isNotMinSignedValue();
193 
194  // It *may* contain INT_MIN, we can't tell.
195  return false;
196 }
197 
199  if (auto *CFP = dyn_cast<ConstantFP>(this))
200  return CFP->getValueAPF().isFiniteNonZero();
201 
202  if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
203  for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
204  auto *CFP = dyn_cast_or_null<ConstantFP>(getAggregateElement(I));
205  if (!CFP || !CFP->getValueAPF().isFiniteNonZero())
206  return false;
207  }
208  return true;
209  }
210 
211  if (getType()->isVectorTy())
212  if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue()))
213  return SplatCFP->isFiniteNonZeroFP();
214 
215  // It *may* contain finite non-zero, we can't tell.
216  return false;
217 }
218 
219 bool Constant::isNormalFP() const {
220  if (auto *CFP = dyn_cast<ConstantFP>(this))
221  return CFP->getValueAPF().isNormal();
222 
223  if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
224  for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
225  auto *CFP = dyn_cast_or_null<ConstantFP>(getAggregateElement(I));
226  if (!CFP || !CFP->getValueAPF().isNormal())
227  return false;
228  }
229  return true;
230  }
231 
232  if (getType()->isVectorTy())
233  if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue()))
234  return SplatCFP->isNormalFP();
235 
236  // It *may* contain a normal fp value, we can't tell.
237  return false;
238 }
239 
241  if (auto *CFP = dyn_cast<ConstantFP>(this))
242  return CFP->getValueAPF().getExactInverse(nullptr);
243 
244  if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
245  for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
246  auto *CFP = dyn_cast_or_null<ConstantFP>(getAggregateElement(I));
247  if (!CFP || !CFP->getValueAPF().getExactInverse(nullptr))
248  return false;
249  }
250  return true;
251  }
252 
253  if (getType()->isVectorTy())
254  if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue()))
255  return SplatCFP->hasExactInverseFP();
256 
257  // It *may* have an exact inverse fp value, we can't tell.
258  return false;
259 }
260 
261 bool Constant::isNaN() const {
262  if (auto *CFP = dyn_cast<ConstantFP>(this))
263  return CFP->isNaN();
264 
265  if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
266  for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
267  auto *CFP = dyn_cast_or_null<ConstantFP>(getAggregateElement(I));
268  if (!CFP || !CFP->isNaN())
269  return false;
270  }
271  return true;
272  }
273 
274  if (getType()->isVectorTy())
275  if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue()))
276  return SplatCFP->isNaN();
277 
278  // It *may* be NaN, we can't tell.
279  return false;
280 }
281 
283  // Are they fully identical?
284  if (this == Y)
285  return true;
286 
287  // The input value must be a vector constant with the same type.
288  auto *VTy = dyn_cast<VectorType>(getType());
289  if (!isa<Constant>(Y) || !VTy || VTy != Y->getType())
290  return false;
291 
292  // TODO: Compare pointer constants?
293  if (!(VTy->getElementType()->isIntegerTy() ||
294  VTy->getElementType()->isFloatingPointTy()))
295  return false;
296 
297  // They may still be identical element-wise (if they have `undef`s).
298  // Bitcast to integer to allow exact bitwise comparison for all types.
299  Type *IntTy = VectorType::getInteger(VTy);
300  Constant *C0 = ConstantExpr::getBitCast(const_cast<Constant *>(this), IntTy);
301  Constant *C1 = ConstantExpr::getBitCast(cast<Constant>(Y), IntTy);
303  return isa<UndefValue>(CmpEq) || match(CmpEq, m_One());
304 }
305 
306 static bool
308  function_ref<bool(const Constant *)> HasFn) {
309  if (auto *VTy = dyn_cast<VectorType>(C->getType())) {
310  if (HasFn(C))
311  return true;
312  if (isa<ConstantAggregateZero>(C))
313  return false;
314  if (isa<ScalableVectorType>(C->getType()))
315  return false;
316 
317  for (unsigned i = 0, e = cast<FixedVectorType>(VTy)->getNumElements();
318  i != e; ++i) {
319  if (Constant *Elem = C->getAggregateElement(i))
320  if (HasFn(Elem))
321  return true;
322  }
323  }
324 
325  return false;
326 }
327 
330  this, [&](const auto *C) { return isa<UndefValue>(C); });
331 }
332 
335  this, [&](const auto *C) { return isa<PoisonValue>(C); });
336 }
337 
339  if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
340  for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i)
341  if (isa<ConstantExpr>(getAggregateElement(i)))
342  return true;
343  }
344  return false;
345 }
346 
347 /// Constructor to create a '0' constant of arbitrary type.
349  switch (Ty->getTypeID()) {
350  case Type::IntegerTyID:
351  return ConstantInt::get(Ty, 0);
352  case Type::HalfTyID:
353  return ConstantFP::get(Ty->getContext(),
355  case Type::BFloatTyID:
356  return ConstantFP::get(Ty->getContext(),
358  case Type::FloatTyID:
359  return ConstantFP::get(Ty->getContext(),
361  case Type::DoubleTyID:
362  return ConstantFP::get(Ty->getContext(),
364  case Type::X86_FP80TyID:
365  return ConstantFP::get(Ty->getContext(),
367  case Type::FP128TyID:
368  return ConstantFP::get(Ty->getContext(),
370  case Type::PPC_FP128TyID:
372  APInt::getZero(128)));
373  case Type::PointerTyID:
374  return ConstantPointerNull::get(cast<PointerType>(Ty));
375  case Type::StructTyID:
376  case Type::ArrayTyID:
379  return ConstantAggregateZero::get(Ty);
380  case Type::TokenTyID:
381  return ConstantTokenNone::get(Ty->getContext());
382  default:
383  // Function, Label, or Opaque type?
384  llvm_unreachable("Cannot create a null constant of that type!");
385  }
386 }
387 
389  Type *ScalarTy = Ty->getScalarType();
390 
391  // Create the base integer constant.
392  Constant *C = ConstantInt::get(Ty->getContext(), V);
393 
394  // Convert an integer to a pointer, if necessary.
395  if (PointerType *PTy = dyn_cast<PointerType>(ScalarTy))
396  C = ConstantExpr::getIntToPtr(C, PTy);
397 
398  // Broadcast a scalar to a vector, if necessary.
399  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
400  C = ConstantVector::getSplat(VTy->getElementCount(), C);
401 
402  return C;
403 }
404 
406  if (IntegerType *ITy = dyn_cast<IntegerType>(Ty))
407  return ConstantInt::get(Ty->getContext(),
408  APInt::getAllOnes(ITy->getBitWidth()));
409 
410  if (Ty->isFloatingPointTy()) {
412  return ConstantFP::get(Ty->getContext(), FL);
413  }
414 
415  VectorType *VTy = cast<VectorType>(Ty);
417  getAllOnesValue(VTy->getElementType()));
418 }
419 
421  assert((getType()->isAggregateType() || getType()->isVectorTy()) &&
422  "Must be an aggregate/vector constant");
423 
424  if (const auto *CC = dyn_cast<ConstantAggregate>(this))
425  return Elt < CC->getNumOperands() ? CC->getOperand(Elt) : nullptr;
426 
427  if (const auto *CAZ = dyn_cast<ConstantAggregateZero>(this))
428  return Elt < CAZ->getElementCount().getKnownMinValue()
429  ? CAZ->getElementValue(Elt)
430  : nullptr;
431 
432  // FIXME: getNumElements() will fail for non-fixed vector types.
433  if (isa<ScalableVectorType>(getType()))
434  return nullptr;
435 
436  if (const auto *PV = dyn_cast<PoisonValue>(this))
437  return Elt < PV->getNumElements() ? PV->getElementValue(Elt) : nullptr;
438 
439  if (const auto *UV = dyn_cast<UndefValue>(this))
440  return Elt < UV->getNumElements() ? UV->getElementValue(Elt) : nullptr;
441 
442  if (const auto *CDS = dyn_cast<ConstantDataSequential>(this))
443  return Elt < CDS->getNumElements() ? CDS->getElementAsConstant(Elt)
444  : nullptr;
445 
446  return nullptr;
447 }
448 
450  assert(isa<IntegerType>(Elt->getType()) && "Index must be an integer");
451  if (ConstantInt *CI = dyn_cast<ConstantInt>(Elt)) {
452  // Check if the constant fits into an uint64_t.
453  if (CI->getValue().getActiveBits() > 64)
454  return nullptr;
455  return getAggregateElement(CI->getZExtValue());
456  }
457  return nullptr;
458 }
459 
461  /// First call destroyConstantImpl on the subclass. This gives the subclass
462  /// a chance to remove the constant from any maps/pools it's contained in.
463  switch (getValueID()) {
464  default:
465  llvm_unreachable("Not a constant!");
466 #define HANDLE_CONSTANT(Name) \
467  case Value::Name##Val: \
468  cast<Name>(this)->destroyConstantImpl(); \
469  break;
470 #include "llvm/IR/Value.def"
471  }
472 
473  // When a Constant is destroyed, there may be lingering
474  // references to the constant by other constants in the constant pool. These
475  // constants are implicitly dependent on the module that is being deleted,
476  // but they don't know that. Because we only find out when the CPV is
477  // deleted, we must now notify all of our users (that should only be
478  // Constants) that they are, in fact, invalid now and should be deleted.
479  //
480  while (!use_empty()) {
481  Value *V = user_back();
482 #ifndef NDEBUG // Only in -g mode...
483  if (!isa<Constant>(V)) {
484  dbgs() << "While deleting: " << *this
485  << "\n\nUse still stuck around after Def is destroyed: " << *V
486  << "\n\n";
487  }
488 #endif
489  assert(isa<Constant>(V) && "References remain to Constant being destroyed");
490  cast<Constant>(V)->destroyConstant();
491 
492  // The constant should remove itself from our use list...
493  assert((use_empty() || user_back() != V) && "Constant not removed!");
494  }
495 
496  // Value has no outstanding references it is safe to delete it now...
497  deleteConstant(this);
498 }
499 
501  switch (C->getValueID()) {
502  case Constant::ConstantIntVal:
503  delete static_cast<ConstantInt *>(C);
504  break;
505  case Constant::ConstantFPVal:
506  delete static_cast<ConstantFP *>(C);
507  break;
508  case Constant::ConstantAggregateZeroVal:
509  delete static_cast<ConstantAggregateZero *>(C);
510  break;
511  case Constant::ConstantArrayVal:
512  delete static_cast<ConstantArray *>(C);
513  break;
514  case Constant::ConstantStructVal:
515  delete static_cast<ConstantStruct *>(C);
516  break;
517  case Constant::ConstantVectorVal:
518  delete static_cast<ConstantVector *>(C);
519  break;
520  case Constant::ConstantPointerNullVal:
521  delete static_cast<ConstantPointerNull *>(C);
522  break;
523  case Constant::ConstantDataArrayVal:
524  delete static_cast<ConstantDataArray *>(C);
525  break;
526  case Constant::ConstantDataVectorVal:
527  delete static_cast<ConstantDataVector *>(C);
528  break;
529  case Constant::ConstantTokenNoneVal:
530  delete static_cast<ConstantTokenNone *>(C);
531  break;
532  case Constant::BlockAddressVal:
533  delete static_cast<BlockAddress *>(C);
534  break;
535  case Constant::DSOLocalEquivalentVal:
536  delete static_cast<DSOLocalEquivalent *>(C);
537  break;
538  case Constant::NoCFIValueVal:
539  delete static_cast<NoCFIValue *>(C);
540  break;
541  case Constant::UndefValueVal:
542  delete static_cast<UndefValue *>(C);
543  break;
544  case Constant::PoisonValueVal:
545  delete static_cast<PoisonValue *>(C);
546  break;
547  case Constant::ConstantExprVal:
548  if (isa<UnaryConstantExpr>(C))
549  delete static_cast<UnaryConstantExpr *>(C);
550  else if (isa<BinaryConstantExpr>(C))
551  delete static_cast<BinaryConstantExpr *>(C);
552  else if (isa<SelectConstantExpr>(C))
553  delete static_cast<SelectConstantExpr *>(C);
554  else if (isa<ExtractElementConstantExpr>(C))
555  delete static_cast<ExtractElementConstantExpr *>(C);
556  else if (isa<InsertElementConstantExpr>(C))
557  delete static_cast<InsertElementConstantExpr *>(C);
558  else if (isa<ShuffleVectorConstantExpr>(C))
559  delete static_cast<ShuffleVectorConstantExpr *>(C);
560  else if (isa<ExtractValueConstantExpr>(C))
561  delete static_cast<ExtractValueConstantExpr *>(C);
562  else if (isa<InsertValueConstantExpr>(C))
563  delete static_cast<InsertValueConstantExpr *>(C);
564  else if (isa<GetElementPtrConstantExpr>(C))
565  delete static_cast<GetElementPtrConstantExpr *>(C);
566  else if (isa<CompareConstantExpr>(C))
567  delete static_cast<CompareConstantExpr *>(C);
568  else
569  llvm_unreachable("Unexpected constant expr");
570  break;
571  default:
572  llvm_unreachable("Unexpected constant");
573  }
574 }
575 
576 static bool canTrapImpl(const Constant *C,
577  SmallPtrSetImpl<const ConstantExpr *> &NonTrappingOps) {
578  assert(C->getType()->isFirstClassType() && "Cannot evaluate aggregate vals!");
579  // The only thing that could possibly trap are constant exprs.
580  const ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
581  if (!CE)
582  return false;
583 
584  // ConstantExpr traps if any operands can trap.
585  for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
586  if (ConstantExpr *Op = dyn_cast<ConstantExpr>(CE->getOperand(i))) {
587  if (NonTrappingOps.insert(Op).second && canTrapImpl(Op, NonTrappingOps))
588  return true;
589  }
590  }
591 
592  // Otherwise, only specific operations can trap.
593  switch (CE->getOpcode()) {
594  default:
595  return false;
596  case Instruction::UDiv:
597  case Instruction::SDiv:
598  case Instruction::URem:
599  case Instruction::SRem:
600  // Div and rem can trap if the RHS is not known to be non-zero.
601  if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue())
602  return true;
603  return false;
604  }
605 }
606 
607 bool Constant::canTrap() const {
609  return canTrapImpl(this, NonTrappingOps);
610 }
611 
612 /// Check if C contains a GlobalValue for which Predicate is true.
613 static bool
615  bool (*Predicate)(const GlobalValue *)) {
618  WorkList.push_back(C);
619  Visited.insert(C);
620 
621  while (!WorkList.empty()) {
622  const Constant *WorkItem = WorkList.pop_back_val();
623  if (const auto *GV = dyn_cast<GlobalValue>(WorkItem))
624  if (Predicate(GV))
625  return true;
626  for (const Value *Op : WorkItem->operands()) {
627  const Constant *ConstOp = dyn_cast<Constant>(Op);
628  if (!ConstOp)
629  continue;
630  if (Visited.insert(ConstOp).second)
631  WorkList.push_back(ConstOp);
632  }
633  }
634  return false;
635 }
636 
638  auto DLLImportPredicate = [](const GlobalValue *GV) {
639  return GV->isThreadLocal();
640  };
641  return ConstHasGlobalValuePredicate(this, DLLImportPredicate);
642 }
643 
645  auto DLLImportPredicate = [](const GlobalValue *GV) {
646  return GV->hasDLLImportStorageClass();
647  };
648  return ConstHasGlobalValuePredicate(this, DLLImportPredicate);
649 }
650 
652  for (const User *U : users()) {
653  const Constant *UC = dyn_cast<Constant>(U);
654  if (!UC || isa<GlobalValue>(UC))
655  return true;
656 
657  if (UC->isConstantUsed())
658  return true;
659  }
660  return false;
661 }
662 
664  return getRelocationInfo() == GlobalRelocation;
665 }
666 
668  return getRelocationInfo() != NoRelocation;
669 }
670 
671 Constant::PossibleRelocationsTy Constant::getRelocationInfo() const {
672  if (isa<GlobalValue>(this))
673  return GlobalRelocation; // Global reference.
674 
675  if (const BlockAddress *BA = dyn_cast<BlockAddress>(this))
676  return BA->getFunction()->getRelocationInfo();
677 
678  if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) {
679  if (CE->getOpcode() == Instruction::Sub) {
680  ConstantExpr *LHS = dyn_cast<ConstantExpr>(CE->getOperand(0));
681  ConstantExpr *RHS = dyn_cast<ConstantExpr>(CE->getOperand(1));
682  if (LHS && RHS && LHS->getOpcode() == Instruction::PtrToInt &&
683  RHS->getOpcode() == Instruction::PtrToInt) {
684  Constant *LHSOp0 = LHS->getOperand(0);
685  Constant *RHSOp0 = RHS->getOperand(0);
686 
687  // While raw uses of blockaddress need to be relocated, differences
688  // between two of them don't when they are for labels in the same
689  // function. This is a common idiom when creating a table for the
690  // indirect goto extension, so we handle it efficiently here.
691  if (isa<BlockAddress>(LHSOp0) && isa<BlockAddress>(RHSOp0) &&
692  cast<BlockAddress>(LHSOp0)->getFunction() ==
693  cast<BlockAddress>(RHSOp0)->getFunction())
694  return NoRelocation;
695 
696  // Relative pointers do not need to be dynamically relocated.
697  if (auto *RHSGV =
698  dyn_cast<GlobalValue>(RHSOp0->stripInBoundsConstantOffsets())) {
699  auto *LHS = LHSOp0->stripInBoundsConstantOffsets();
700  if (auto *LHSGV = dyn_cast<GlobalValue>(LHS)) {
701  if (LHSGV->isDSOLocal() && RHSGV->isDSOLocal())
702  return LocalRelocation;
703  } else if (isa<DSOLocalEquivalent>(LHS)) {
704  if (RHSGV->isDSOLocal())
705  return LocalRelocation;
706  }
707  }
708  }
709  }
710  }
711 
712  PossibleRelocationsTy Result = NoRelocation;
713  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
714  Result =
715  std::max(cast<Constant>(getOperand(i))->getRelocationInfo(), Result);
716 
717  return Result;
718 }
719 
720 /// Return true if the specified constantexpr is dead. This involves
721 /// recursively traversing users of the constantexpr.
722 /// If RemoveDeadUsers is true, also remove dead users at the same time.
723 static bool constantIsDead(const Constant *C, bool RemoveDeadUsers) {
724  if (isa<GlobalValue>(C)) return false; // Cannot remove this
725 
726  Value::const_user_iterator I = C->user_begin(), E = C->user_end();
727  while (I != E) {
728  const Constant *User = dyn_cast<Constant>(*I);
729  if (!User) return false; // Non-constant usage;
730  if (!constantIsDead(User, RemoveDeadUsers))
731  return false; // Constant wasn't dead
732 
733  // Just removed User, so the iterator was invalidated.
734  // Since we return immediately upon finding a live user, we can always
735  // restart from user_begin().
736  if (RemoveDeadUsers)
737  I = C->user_begin();
738  else
739  ++I;
740  }
741 
742  if (RemoveDeadUsers) {
743  // If C is only used by metadata, it should not be preserved but should
744  // have its uses replaced.
745  if (C->isUsedByMetadata()) {
746  const_cast<Constant *>(C)->replaceAllUsesWith(
747  UndefValue::get(C->getType()));
748  }
749  const_cast<Constant *>(C)->destroyConstant();
750  }
751 
752  return true;
753 }
754 
756  Value::const_user_iterator I = user_begin(), E = user_end();
757  Value::const_user_iterator LastNonDeadUser = E;
758  while (I != E) {
759  const Constant *User = dyn_cast<Constant>(*I);
760  if (!User) {
761  LastNonDeadUser = I;
762  ++I;
763  continue;
764  }
765 
766  if (!constantIsDead(User, /* RemoveDeadUsers= */ true)) {
767  // If the constant wasn't dead, remember that this was the last live use
768  // and move on to the next constant.
769  LastNonDeadUser = I;
770  ++I;
771  continue;
772  }
773 
774  // If the constant was dead, then the iterator is invalidated.
775  if (LastNonDeadUser == E)
776  I = user_begin();
777  else
778  I = std::next(LastNonDeadUser);
779  }
780 }
781 
782 bool Constant::hasOneLiveUse() const { return hasNLiveUses(1); }
783 
784 bool Constant::hasZeroLiveUses() const { return hasNLiveUses(0); }
785 
786 bool Constant::hasNLiveUses(unsigned N) const {
787  unsigned NumUses = 0;
788  for (const Use &U : uses()) {
789  const Constant *User = dyn_cast<Constant>(U.getUser());
790  if (!User || !constantIsDead(User, /* RemoveDeadUsers= */ false)) {
791  ++NumUses;
792 
793  if (NumUses > N)
794  return false;
795  }
796  }
797  return NumUses == N;
798 }
799 
801  assert(C && Replacement && "Expected non-nullptr constant arguments");
802  Type *Ty = C->getType();
803  if (match(C, m_Undef())) {
804  assert(Ty == Replacement->getType() && "Expected matching types");
805  return Replacement;
806  }
807 
808  // Don't know how to deal with this constant.
809  auto *VTy = dyn_cast<FixedVectorType>(Ty);
810  if (!VTy)
811  return C;
812 
813  unsigned NumElts = VTy->getNumElements();
814  SmallVector<Constant *, 32> NewC(NumElts);
815  for (unsigned i = 0; i != NumElts; ++i) {
816  Constant *EltC = C->getAggregateElement(i);
817  assert((!EltC || EltC->getType() == Replacement->getType()) &&
818  "Expected matching types");
819  NewC[i] = EltC && match(EltC, m_Undef()) ? Replacement : EltC;
820  }
821  return ConstantVector::get(NewC);
822 }
823 
825  assert(C && Other && "Expected non-nullptr constant arguments");
826  if (match(C, m_Undef()))
827  return C;
828 
829  Type *Ty = C->getType();
830  if (match(Other, m_Undef()))
831  return UndefValue::get(Ty);
832 
833  auto *VTy = dyn_cast<FixedVectorType>(Ty);
834  if (!VTy)
835  return C;
836 
837  Type *EltTy = VTy->getElementType();
838  unsigned NumElts = VTy->getNumElements();
839  assert(isa<FixedVectorType>(Other->getType()) &&
840  cast<FixedVectorType>(Other->getType())->getNumElements() == NumElts &&
841  "Type mismatch");
842 
843  bool FoundExtraUndef = false;
844  SmallVector<Constant *, 32> NewC(NumElts);
845  for (unsigned I = 0; I != NumElts; ++I) {
846  NewC[I] = C->getAggregateElement(I);
847  Constant *OtherEltC = Other->getAggregateElement(I);
848  assert(NewC[I] && OtherEltC && "Unknown vector element");
849  if (!match(NewC[I], m_Undef()) && match(OtherEltC, m_Undef())) {
850  NewC[I] = UndefValue::get(EltTy);
851  FoundExtraUndef = true;
852  }
853  }
854  if (FoundExtraUndef)
855  return ConstantVector::get(NewC);
856  return C;
857 }
858 
860  if (isa<ConstantData>(this))
861  return true;
862  if (isa<ConstantAggregate>(this) || isa<ConstantExpr>(this)) {
863  for (const Value *Op : operand_values())
864  if (!cast<Constant>(Op)->isManifestConstant())
865  return false;
866  return true;
867  }
868  return false;
869 }
870 
871 //===----------------------------------------------------------------------===//
872 // ConstantInt
873 //===----------------------------------------------------------------------===//
874 
875 ConstantInt::ConstantInt(IntegerType *Ty, const APInt &V)
876  : ConstantData(Ty, ConstantIntVal), Val(V) {
877  assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type");
878 }
879 
881  LLVMContextImpl *pImpl = Context.pImpl;
882  if (!pImpl->TheTrueVal)
884  return pImpl->TheTrueVal;
885 }
886 
888  LLVMContextImpl *pImpl = Context.pImpl;
889  if (!pImpl->TheFalseVal)
891  return pImpl->TheFalseVal;
892 }
893 
895  return V ? getTrue(Context) : getFalse(Context);
896 }
897 
899  assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
901  if (auto *VTy = dyn_cast<VectorType>(Ty))
902  return ConstantVector::getSplat(VTy->getElementCount(), TrueC);
903  return TrueC;
904 }
905 
907  assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
909  if (auto *VTy = dyn_cast<VectorType>(Ty))
910  return ConstantVector::getSplat(VTy->getElementCount(), FalseC);
911  return FalseC;
912 }
913 
915  return V ? getTrue(Ty) : getFalse(Ty);
916 }
917 
918 // Get a ConstantInt from an APInt.
920  // get an existing value or the insertion position
921  LLVMContextImpl *pImpl = Context.pImpl;
922  std::unique_ptr<ConstantInt> &Slot = pImpl->IntConstants[V];
923  if (!Slot) {
924  // Get the corresponding integer type for the bit width of the value.
926  Slot.reset(new ConstantInt(ITy, V));
927  }
928  assert(Slot->getType() == IntegerType::get(Context, V.getBitWidth()));
929  return Slot.get();
930 }
931 
932 Constant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) {
933  Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned);
934 
935  // For vectors, broadcast the value.
936  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
937  return ConstantVector::getSplat(VTy->getElementCount(), C);
938 
939  return C;
940 }
941 
943  return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned));
944 }
945 
947  return get(Ty, V, true);
948 }
949 
951  return get(Ty, V, true);
952 }
953 
955  ConstantInt *C = get(Ty->getContext(), V);
956  assert(C->getType() == Ty->getScalarType() &&
957  "ConstantInt type doesn't match the type implied by its value!");
958 
959  // For vectors, broadcast the value.
960  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
961  return ConstantVector::getSplat(VTy->getElementCount(), C);
962 
963  return C;
964 }
965 
967  return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix));
968 }
969 
970 /// Remove the constant from the constant table.
971 void ConstantInt::destroyConstantImpl() {
972  llvm_unreachable("You can't ConstantInt->destroyConstantImpl()!");
973 }
974 
975 //===----------------------------------------------------------------------===//
976 // ConstantFP
977 //===----------------------------------------------------------------------===//
978 
979 Constant *ConstantFP::get(Type *Ty, double V) {
980  LLVMContext &Context = Ty->getContext();
981 
982  APFloat FV(V);
983  bool ignored;
985  APFloat::rmNearestTiesToEven, &ignored);
986  Constant *C = get(Context, FV);
987 
988  // For vectors, broadcast the value.
989  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
990  return ConstantVector::getSplat(VTy->getElementCount(), C);
991 
992  return C;
993 }
994 
996  ConstantFP *C = get(Ty->getContext(), V);
997  assert(C->getType() == Ty->getScalarType() &&
998  "ConstantFP type doesn't match the type implied by its value!");
999 
1000  // For vectors, broadcast the value.
1001  if (auto *VTy = dyn_cast<VectorType>(Ty))
1002  return ConstantVector::getSplat(VTy->getElementCount(), C);
1003 
1004  return C;
1005 }
1006 
1008  LLVMContext &Context = Ty->getContext();
1009 
1010  APFloat FV(Ty->getScalarType()->getFltSemantics(), Str);
1011  Constant *C = get(Context, FV);
1012 
1013  // For vectors, broadcast the value.
1014  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1015  return ConstantVector::getSplat(VTy->getElementCount(), C);
1016 
1017  return C;
1018 }
1019 
1020 Constant *ConstantFP::getNaN(Type *Ty, bool Negative, uint64_t Payload) {
1021  const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1022  APFloat NaN = APFloat::getNaN(Semantics, Negative, Payload);
1023  Constant *C = get(Ty->getContext(), NaN);
1024 
1025  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1026  return ConstantVector::getSplat(VTy->getElementCount(), C);
1027 
1028  return C;
1029 }
1030 
1031 Constant *ConstantFP::getQNaN(Type *Ty, bool Negative, APInt *Payload) {
1032  const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1033  APFloat NaN = APFloat::getQNaN(Semantics, Negative, Payload);
1034  Constant *C = get(Ty->getContext(), NaN);
1035 
1036  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1037  return ConstantVector::getSplat(VTy->getElementCount(), C);
1038 
1039  return C;
1040 }
1041 
1042 Constant *ConstantFP::getSNaN(Type *Ty, bool Negative, APInt *Payload) {
1043  const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1044  APFloat NaN = APFloat::getSNaN(Semantics, Negative, Payload);
1045  Constant *C = get(Ty->getContext(), NaN);
1046 
1047  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1048  return ConstantVector::getSplat(VTy->getElementCount(), C);
1049 
1050  return C;
1051 }
1052 
1054  const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1055  APFloat NegZero = APFloat::getZero(Semantics, /*Negative=*/true);
1056  Constant *C = get(Ty->getContext(), NegZero);
1057 
1058  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1059  return ConstantVector::getSplat(VTy->getElementCount(), C);
1060 
1061  return C;
1062 }
1063 
1064 
1066  if (Ty->isFPOrFPVectorTy())
1067  return getNegativeZero(Ty);
1068 
1069  return Constant::getNullValue(Ty);
1070 }
1071 
1072 
1073 // ConstantFP accessors.
1075  LLVMContextImpl* pImpl = Context.pImpl;
1076 
1077  std::unique_ptr<ConstantFP> &Slot = pImpl->FPConstants[V];
1078 
1079  if (!Slot) {
1081  Slot.reset(new ConstantFP(Ty, V));
1082  }
1083 
1084  return Slot.get();
1085 }
1086 
1087 Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) {
1088  const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1089  Constant *C = get(Ty->getContext(), APFloat::getInf(Semantics, Negative));
1090 
1091  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1092  return ConstantVector::getSplat(VTy->getElementCount(), C);
1093 
1094  return C;
1095 }
1096 
1097 ConstantFP::ConstantFP(Type *Ty, const APFloat &V)
1098  : ConstantData(Ty, ConstantFPVal), Val(V) {
1099  assert(&V.getSemantics() == &Ty->getFltSemantics() &&
1100  "FP type Mismatch");
1101 }
1102 
1103 bool ConstantFP::isExactlyValue(const APFloat &V) const {
1104  return Val.bitwiseIsEqual(V);
1105 }
1106 
1107 /// Remove the constant from the constant table.
1108 void ConstantFP::destroyConstantImpl() {
1109  llvm_unreachable("You can't ConstantFP->destroyConstantImpl()!");
1110 }
1111 
1112 //===----------------------------------------------------------------------===//
1113 // ConstantAggregateZero Implementation
1114 //===----------------------------------------------------------------------===//
1115 
1117  if (auto *AT = dyn_cast<ArrayType>(getType()))
1118  return Constant::getNullValue(AT->getElementType());
1119  return Constant::getNullValue(cast<VectorType>(getType())->getElementType());
1120 }
1121 
1123  return Constant::getNullValue(getType()->getStructElementType(Elt));
1124 }
1125 
1127  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1128  return getSequentialElement();
1129  return getStructElement(cast<ConstantInt>(C)->getZExtValue());
1130 }
1131 
1133  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1134  return getSequentialElement();
1135  return getStructElement(Idx);
1136 }
1137 
1139  Type *Ty = getType();
1140  if (auto *AT = dyn_cast<ArrayType>(Ty))
1141  return ElementCount::getFixed(AT->getNumElements());
1142  if (auto *VT = dyn_cast<VectorType>(Ty))
1143  return VT->getElementCount();
1145 }
1146 
1147 //===----------------------------------------------------------------------===//
1148 // UndefValue Implementation
1149 //===----------------------------------------------------------------------===//
1150 
1152  if (ArrayType *ATy = dyn_cast<ArrayType>(getType()))
1153  return UndefValue::get(ATy->getElementType());
1154  return UndefValue::get(cast<VectorType>(getType())->getElementType());
1155 }
1156 
1158  return UndefValue::get(getType()->getStructElementType(Elt));
1159 }
1160 
1162  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1163  return getSequentialElement();
1164  return getStructElement(cast<ConstantInt>(C)->getZExtValue());
1165 }
1166 
1168  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1169  return getSequentialElement();
1170  return getStructElement(Idx);
1171 }
1172 
1173 unsigned UndefValue::getNumElements() const {
1174  Type *Ty = getType();
1175  if (auto *AT = dyn_cast<ArrayType>(Ty))
1176  return AT->getNumElements();
1177  if (auto *VT = dyn_cast<VectorType>(Ty))
1178  return cast<FixedVectorType>(VT)->getNumElements();
1179  return Ty->getStructNumElements();
1180 }
1181 
1182 //===----------------------------------------------------------------------===//
1183 // PoisonValue Implementation
1184 //===----------------------------------------------------------------------===//
1185 
1187  if (ArrayType *ATy = dyn_cast<ArrayType>(getType()))
1188  return PoisonValue::get(ATy->getElementType());
1189  return PoisonValue::get(cast<VectorType>(getType())->getElementType());
1190 }
1191 
1193  return PoisonValue::get(getType()->getStructElementType(Elt));
1194 }
1195 
1197  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1198  return getSequentialElement();
1199  return getStructElement(cast<ConstantInt>(C)->getZExtValue());
1200 }
1201 
1203  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1204  return getSequentialElement();
1205  return getStructElement(Idx);
1206 }
1207 
1208 //===----------------------------------------------------------------------===//
1209 // ConstantXXX Classes
1210 //===----------------------------------------------------------------------===//
1211 
1212 template <typename ItTy, typename EltTy>
1213 static bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt) {
1214  for (; Start != End; ++Start)
1215  if (*Start != Elt)
1216  return false;
1217  return true;
1218 }
1219 
1220 template <typename SequentialTy, typename ElementTy>
1222  assert(!V.empty() && "Cannot get empty int sequence.");
1223 
1225  for (Constant *C : V)
1226  if (auto *CI = dyn_cast<ConstantInt>(C))
1227  Elts.push_back(CI->getZExtValue());
1228  else
1229  return nullptr;
1230  return SequentialTy::get(V[0]->getContext(), Elts);
1231 }
1232 
1233 template <typename SequentialTy, typename ElementTy>
1235  assert(!V.empty() && "Cannot get empty FP sequence.");
1236 
1238  for (Constant *C : V)
1239  if (auto *CFP = dyn_cast<ConstantFP>(C))
1240  Elts.push_back(CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
1241  else
1242  return nullptr;
1243  return SequentialTy::getFP(V[0]->getType(), Elts);
1244 }
1245 
1246 template <typename SequenceTy>
1249  // We speculatively build the elements here even if it turns out that there is
1250  // a constantexpr or something else weird, since it is so uncommon for that to
1251  // happen.
1252  if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
1253  if (CI->getType()->isIntegerTy(8))
1254  return getIntSequenceIfElementsMatch<SequenceTy, uint8_t>(V);
1255  else if (CI->getType()->isIntegerTy(16))
1256  return getIntSequenceIfElementsMatch<SequenceTy, uint16_t>(V);
1257  else if (CI->getType()->isIntegerTy(32))
1258  return getIntSequenceIfElementsMatch<SequenceTy, uint32_t>(V);
1259  else if (CI->getType()->isIntegerTy(64))
1260  return getIntSequenceIfElementsMatch<SequenceTy, uint64_t>(V);
1261  } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
1262  if (CFP->getType()->isHalfTy() || CFP->getType()->isBFloatTy())
1263  return getFPSequenceIfElementsMatch<SequenceTy, uint16_t>(V);
1264  else if (CFP->getType()->isFloatTy())
1265  return getFPSequenceIfElementsMatch<SequenceTy, uint32_t>(V);
1266  else if (CFP->getType()->isDoubleTy())
1267  return getFPSequenceIfElementsMatch<SequenceTy, uint64_t>(V);
1268  }
1269 
1270  return nullptr;
1271 }
1272 
1275  : Constant(T, VT, OperandTraits<ConstantAggregate>::op_end(this) - V.size(),
1276  V.size()) {
1277  llvm::copy(V, op_begin());
1278 
1279  // Check that types match, unless this is an opaque struct.
1280  if (auto *ST = dyn_cast<StructType>(T)) {
1281  if (ST->isOpaque())
1282  return;
1283  for (unsigned I = 0, E = V.size(); I != E; ++I)
1284  assert(V[I]->getType() == ST->getTypeAtIndex(I) &&
1285  "Initializer for struct element doesn't match!");
1286  }
1287 }
1288 
1289 ConstantArray::ConstantArray(ArrayType *T, ArrayRef<Constant *> V)
1290  : ConstantAggregate(T, ConstantArrayVal, V) {
1291  assert(V.size() == T->getNumElements() &&
1292  "Invalid initializer for constant array");
1293 }
1294 
1296  if (Constant *C = getImpl(Ty, V))
1297  return C;
1298  return Ty->getContext().pImpl->ArrayConstants.getOrCreate(Ty, V);
1299 }
1300 
1302  // Empty arrays are canonicalized to ConstantAggregateZero.
1303  if (V.empty())
1304  return ConstantAggregateZero::get(Ty);
1305 
1306  for (Constant *C : V) {
1307  assert(C->getType() == Ty->getElementType() &&
1308  "Wrong type in array element initializer");
1309  (void)C;
1310  }
1311 
1312  // If this is an all-zero array, return a ConstantAggregateZero object. If
1313  // all undef, return an UndefValue, if "all simple", then return a
1314  // ConstantDataArray.
1315  Constant *C = V[0];
1316  if (isa<PoisonValue>(C) && rangeOnlyContains(V.begin(), V.end(), C))
1317  return PoisonValue::get(Ty);
1318 
1319  if (isa<UndefValue>(C) && rangeOnlyContains(V.begin(), V.end(), C))
1320  return UndefValue::get(Ty);
1321 
1322  if (C->isNullValue() && rangeOnlyContains(V.begin(), V.end(), C))
1323  return ConstantAggregateZero::get(Ty);
1324 
1325  // Check to see if all of the elements are ConstantFP or ConstantInt and if
1326  // the element type is compatible with ConstantDataVector. If so, use it.
1328  return getSequenceIfElementsMatch<ConstantDataArray>(C, V);
1329 
1330  // Otherwise, we really do want to create a ConstantArray.
1331  return nullptr;
1332 }
1333 
1336  bool Packed) {
1337  unsigned VecSize = V.size();
1338  SmallVector<Type*, 16> EltTypes(VecSize);
1339  for (unsigned i = 0; i != VecSize; ++i)
1340  EltTypes[i] = V[i]->getType();
1341 
1342  return StructType::get(Context, EltTypes, Packed);
1343 }
1344 
1345 
1347  bool Packed) {
1348  assert(!V.empty() &&
1349  "ConstantStruct::getTypeForElements cannot be called on empty list");
1350  return getTypeForElements(V[0]->getContext(), V, Packed);
1351 }
1352 
1353 ConstantStruct::ConstantStruct(StructType *T, ArrayRef<Constant *> V)
1354  : ConstantAggregate(T, ConstantStructVal, V) {
1355  assert((T->isOpaque() || V.size() == T->getNumElements()) &&
1356  "Invalid initializer for constant struct");
1357 }
1358 
1359 // ConstantStruct accessors.
1361  assert((ST->isOpaque() || ST->getNumElements() == V.size()) &&
1362  "Incorrect # elements specified to ConstantStruct::get");
1363 
1364  // Create a ConstantAggregateZero value if all elements are zeros.
1365  bool isZero = true;
1366  bool isUndef = false;
1367  bool isPoison = false;
1368 
1369  if (!V.empty()) {
1370  isUndef = isa<UndefValue>(V[0]);
1371  isPoison = isa<PoisonValue>(V[0]);
1372  isZero = V[0]->isNullValue();
1373  // PoisonValue inherits UndefValue, so its check is not necessary.
1374  if (isUndef || isZero) {
1375  for (Constant *C : V) {
1376  if (!C->isNullValue())
1377  isZero = false;
1378  if (!isa<PoisonValue>(C))
1379  isPoison = false;
1380  if (isa<PoisonValue>(C) || !isa<UndefValue>(C))
1381  isUndef = false;
1382  }
1383  }
1384  }
1385  if (isZero)
1387  if (isPoison)
1388  return PoisonValue::get(ST);
1389  if (isUndef)
1390  return UndefValue::get(ST);
1391 
1392  return ST->getContext().pImpl->StructConstants.getOrCreate(ST, V);
1393 }
1394 
1395 ConstantVector::ConstantVector(VectorType *T, ArrayRef<Constant *> V)
1396  : ConstantAggregate(T, ConstantVectorVal, V) {
1397  assert(V.size() == cast<FixedVectorType>(T)->getNumElements() &&
1398  "Invalid initializer for constant vector");
1399 }
1400 
1401 // ConstantVector accessors.
1403  if (Constant *C = getImpl(V))
1404  return C;
1405  auto *Ty = FixedVectorType::get(V.front()->getType(), V.size());
1406  return Ty->getContext().pImpl->VectorConstants.getOrCreate(Ty, V);
1407 }
1408 
1410  assert(!V.empty() && "Vectors can't be empty");
1411  auto *T = FixedVectorType::get(V.front()->getType(), V.size());
1412 
1413  // If this is an all-undef or all-zero vector, return a
1414  // ConstantAggregateZero or UndefValue.
1415  Constant *C = V[0];
1416  bool isZero = C->isNullValue();
1417  bool isUndef = isa<UndefValue>(C);
1418  bool isPoison = isa<PoisonValue>(C);
1419 
1420  if (isZero || isUndef) {
1421  for (unsigned i = 1, e = V.size(); i != e; ++i)
1422  if (V[i] != C) {
1423  isZero = isUndef = isPoison = false;
1424  break;
1425  }
1426  }
1427 
1428  if (isZero)
1429  return ConstantAggregateZero::get(T);
1430  if (isPoison)
1431  return PoisonValue::get(T);
1432  if (isUndef)
1433  return UndefValue::get(T);
1434 
1435  // Check to see if all of the elements are ConstantFP or ConstantInt and if
1436  // the element type is compatible with ConstantDataVector. If so, use it.
1438  return getSequenceIfElementsMatch<ConstantDataVector>(C, V);
1439 
1440  // Otherwise, the element type isn't compatible with ConstantDataVector, or
1441  // the operand list contains a ConstantExpr or something else strange.
1442  return nullptr;
1443 }
1444 
1446  if (!EC.isScalable()) {
1447  // If this splat is compatible with ConstantDataVector, use it instead of
1448  // ConstantVector.
1449  if ((isa<ConstantFP>(V) || isa<ConstantInt>(V)) &&
1451  return ConstantDataVector::getSplat(EC.getKnownMinValue(), V);
1452 
1453  SmallVector<Constant *, 32> Elts(EC.getKnownMinValue(), V);
1454  return get(Elts);
1455  }
1456 
1457  Type *VTy = VectorType::get(V->getType(), EC);
1458 
1459  if (V->isNullValue())
1460  return ConstantAggregateZero::get(VTy);
1461  else if (isa<UndefValue>(V))
1462  return UndefValue::get(VTy);
1463 
1464  Type *I32Ty = Type::getInt32Ty(VTy->getContext());
1465 
1466  // Move scalar into vector.
1467  Constant *PoisonV = PoisonValue::get(VTy);
1468  V = ConstantExpr::getInsertElement(PoisonV, V, ConstantInt::get(I32Ty, 0));
1469  // Build shuffle mask to perform the splat.
1470  SmallVector<int, 8> Zeros(EC.getKnownMinValue(), 0);
1471  // Splat.
1472  return ConstantExpr::getShuffleVector(V, PoisonV, Zeros);
1473 }
1474 
1476  LLVMContextImpl *pImpl = Context.pImpl;
1477  if (!pImpl->TheNoneToken)
1478  pImpl->TheNoneToken.reset(new ConstantTokenNone(Context));
1479  return pImpl->TheNoneToken.get();
1480 }
1481 
1482 /// Remove the constant from the constant table.
1483 void ConstantTokenNone::destroyConstantImpl() {
1484  llvm_unreachable("You can't ConstantTokenNone->destroyConstantImpl()!");
1485 }
1486 
1487 // Utility function for determining if a ConstantExpr is a CastOp or not. This
1488 // can't be inline because we don't want to #include Instruction.h into
1489 // Constant.h
1490 bool ConstantExpr::isCast() const {
1491  return Instruction::isCast(getOpcode());
1492 }
1493 
1495  return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp;
1496 }
1497 
1499  return getOpcode() == Instruction::ExtractValue ||
1500  getOpcode() == Instruction::InsertValue;
1501 }
1502 
1504  if (const ExtractValueConstantExpr *EVCE =
1505  dyn_cast<ExtractValueConstantExpr>(this))
1506  return EVCE->Indices;
1507 
1508  return cast<InsertValueConstantExpr>(this)->Indices;
1509 }
1510 
1511 unsigned ConstantExpr::getPredicate() const {
1512  return cast<CompareConstantExpr>(this)->predicate;
1513 }
1514 
1516  return cast<ShuffleVectorConstantExpr>(this)->ShuffleMask;
1517 }
1518 
1520  return cast<ShuffleVectorConstantExpr>(this)->ShuffleMaskForBitcode;
1521 }
1522 
1524  bool OnlyIfReduced, Type *SrcTy) const {
1525  assert(Ops.size() == getNumOperands() && "Operand count mismatch!");
1526 
1527  // If no operands changed return self.
1528  if (Ty == getType() && std::equal(Ops.begin(), Ops.end(), op_begin()))
1529  return const_cast<ConstantExpr*>(this);
1530 
1531  Type *OnlyIfReducedTy = OnlyIfReduced ? Ty : nullptr;
1532  switch (getOpcode()) {
1533  case Instruction::Trunc:
1534  case Instruction::ZExt:
1535  case Instruction::SExt:
1536  case Instruction::FPTrunc:
1537  case Instruction::FPExt:
1538  case Instruction::UIToFP:
1539  case Instruction::SIToFP:
1540  case Instruction::FPToUI:
1541  case Instruction::FPToSI:
1542  case Instruction::PtrToInt:
1543  case Instruction::IntToPtr:
1544  case Instruction::BitCast:
1545  case Instruction::AddrSpaceCast:
1546  return ConstantExpr::getCast(getOpcode(), Ops[0], Ty, OnlyIfReduced);
1547  case Instruction::Select:
1548  return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2], OnlyIfReducedTy);
1549  case Instruction::InsertElement:
1550  return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2],
1551  OnlyIfReducedTy);
1552  case Instruction::ExtractElement:
1553  return ConstantExpr::getExtractElement(Ops[0], Ops[1], OnlyIfReducedTy);
1554  case Instruction::InsertValue:
1555  return ConstantExpr::getInsertValue(Ops[0], Ops[1], getIndices(),
1556  OnlyIfReducedTy);
1557  case Instruction::ExtractValue:
1558  return ConstantExpr::getExtractValue(Ops[0], getIndices(), OnlyIfReducedTy);
1559  case Instruction::FNeg:
1560  return ConstantExpr::getFNeg(Ops[0]);
1561  case Instruction::ShuffleVector:
1562  return ConstantExpr::getShuffleVector(Ops[0], Ops[1], getShuffleMask(),
1563  OnlyIfReducedTy);
1564  case Instruction::GetElementPtr: {
1565  auto *GEPO = cast<GEPOperator>(this);
1566  assert(SrcTy || (Ops[0]->getType() == getOperand(0)->getType()));
1568  SrcTy ? SrcTy : GEPO->getSourceElementType(), Ops[0], Ops.slice(1),
1569  GEPO->isInBounds(), GEPO->getInRangeIndex(), OnlyIfReducedTy);
1570  }
1571  case Instruction::ICmp:
1572  case Instruction::FCmp:
1573  return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1],
1574  OnlyIfReducedTy);
1575  default:
1576  assert(getNumOperands() == 2 && "Must be binary operator?");
1577  return ConstantExpr::get(getOpcode(), Ops[0], Ops[1], SubclassOptionalData,
1578  OnlyIfReducedTy);
1579  }
1580 }
1581 
1582 
1583 //===----------------------------------------------------------------------===//
1584 // isValueValidForType implementations
1585 
1587  unsigned NumBits = Ty->getIntegerBitWidth(); // assert okay
1588  if (Ty->isIntegerTy(1))
1589  return Val == 0 || Val == 1;
1590  return isUIntN(NumBits, Val);
1591 }
1592 
1593 bool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) {
1594  unsigned NumBits = Ty->getIntegerBitWidth();
1595  if (Ty->isIntegerTy(1))
1596  return Val == 0 || Val == 1 || Val == -1;
1597  return isIntN(NumBits, Val);
1598 }
1599 
1601  // convert modifies in place, so make a copy.
1602  APFloat Val2 = APFloat(Val);
1603  bool losesInfo;
1604  switch (Ty->getTypeID()) {
1605  default:
1606  return false; // These can't be represented as floating point!
1607 
1608  // FIXME rounding mode needs to be more flexible
1609  case Type::HalfTyID: {
1610  if (&Val2.getSemantics() == &APFloat::IEEEhalf())
1611  return true;
1613  return !losesInfo;
1614  }
1615  case Type::BFloatTyID: {
1616  if (&Val2.getSemantics() == &APFloat::BFloat())
1617  return true;
1619  return !losesInfo;
1620  }
1621  case Type::FloatTyID: {
1622  if (&Val2.getSemantics() == &APFloat::IEEEsingle())
1623  return true;
1625  return !losesInfo;
1626  }
1627  case Type::DoubleTyID: {
1628  if (&Val2.getSemantics() == &APFloat::IEEEhalf() ||
1629  &Val2.getSemantics() == &APFloat::BFloat() ||
1630  &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1631  &Val2.getSemantics() == &APFloat::IEEEdouble())
1632  return true;
1634  return !losesInfo;
1635  }
1636  case Type::X86_FP80TyID:
1637  return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1638  &Val2.getSemantics() == &APFloat::BFloat() ||
1639  &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1640  &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1642  case Type::FP128TyID:
1643  return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1644  &Val2.getSemantics() == &APFloat::BFloat() ||
1645  &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1646  &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1647  &Val2.getSemantics() == &APFloat::IEEEquad();
1648  case Type::PPC_FP128TyID:
1649  return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1650  &Val2.getSemantics() == &APFloat::BFloat() ||
1651  &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1652  &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1653  &Val2.getSemantics() == &APFloat::PPCDoubleDouble();
1654  }
1655 }
1656 
1657 
1658 //===----------------------------------------------------------------------===//
1659 // Factory Function Implementation
1660 
1662  assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) &&
1663  "Cannot create an aggregate zero of non-aggregate type!");
1664 
1665  std::unique_ptr<ConstantAggregateZero> &Entry =
1666  Ty->getContext().pImpl->CAZConstants[Ty];
1667  if (!Entry)
1668  Entry.reset(new ConstantAggregateZero(Ty));
1669 
1670  return Entry.get();
1671 }
1672 
1673 /// Remove the constant from the constant table.
1674 void ConstantAggregateZero::destroyConstantImpl() {
1675  getContext().pImpl->CAZConstants.erase(getType());
1676 }
1677 
1678 /// Remove the constant from the constant table.
1679 void ConstantArray::destroyConstantImpl() {
1681 }
1682 
1683 
1684 //---- ConstantStruct::get() implementation...
1685 //
1686 
1687 /// Remove the constant from the constant table.
1688 void ConstantStruct::destroyConstantImpl() {
1690 }
1691 
1692 /// Remove the constant from the constant table.
1693 void ConstantVector::destroyConstantImpl() {
1695 }
1696 
1697 Constant *Constant::getSplatValue(bool AllowUndefs) const {
1698  assert(this->getType()->isVectorTy() && "Only valid for vectors!");
1699  if (isa<ConstantAggregateZero>(this))
1700  return getNullValue(cast<VectorType>(getType())->getElementType());
1701  if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
1702  return CV->getSplatValue();
1703  if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
1704  return CV->getSplatValue(AllowUndefs);
1705 
1706  // Check if this is a constant expression splat of the form returned by
1707  // ConstantVector::getSplat()
1708  const auto *Shuf = dyn_cast<ConstantExpr>(this);
1709  if (Shuf && Shuf->getOpcode() == Instruction::ShuffleVector &&
1710  isa<UndefValue>(Shuf->getOperand(1))) {
1711 
1712  const auto *IElt = dyn_cast<ConstantExpr>(Shuf->getOperand(0));
1713  if (IElt && IElt->getOpcode() == Instruction::InsertElement &&
1714  isa<UndefValue>(IElt->getOperand(0))) {
1715 
1716  ArrayRef<int> Mask = Shuf->getShuffleMask();
1717  Constant *SplatVal = IElt->getOperand(1);
1718  ConstantInt *Index = dyn_cast<ConstantInt>(IElt->getOperand(2));
1719 
1720  if (Index && Index->getValue() == 0 &&
1721  llvm::all_of(Mask, [](int I) { return I == 0; }))
1722  return SplatVal;
1723  }
1724  }
1725 
1726  return nullptr;
1727 }
1728 
1729 Constant *ConstantVector::getSplatValue(bool AllowUndefs) const {
1730  // Check out first element.
1731  Constant *Elt = getOperand(0);
1732  // Then make sure all remaining elements point to the same value.
1733  for (unsigned I = 1, E = getNumOperands(); I < E; ++I) {
1734  Constant *OpC = getOperand(I);
1735  if (OpC == Elt)
1736  continue;
1737 
1738  // Strict mode: any mismatch is not a splat.
1739  if (!AllowUndefs)
1740  return nullptr;
1741 
1742  // Allow undefs mode: ignore undefined elements.
1743  if (isa<UndefValue>(OpC))
1744  continue;
1745 
1746  // If we do not have a defined element yet, use the current operand.
1747  if (isa<UndefValue>(Elt))
1748  Elt = OpC;
1749 
1750  if (OpC != Elt)
1751  return nullptr;
1752  }
1753  return Elt;
1754 }
1755 
1757  if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
1758  return CI->getValue();
1759  assert(this->getSplatValue() && "Doesn't contain a unique integer!");
1760  const Constant *C = this->getAggregateElement(0U);
1761  assert(C && isa<ConstantInt>(C) && "Not a vector of numbers!");
1762  return cast<ConstantInt>(C)->getValue();
1763 }
1764 
1765 //---- ConstantPointerNull::get() implementation.
1766 //
1767 
1769  std::unique_ptr<ConstantPointerNull> &Entry =
1770  Ty->getContext().pImpl->CPNConstants[Ty];
1771  if (!Entry)
1772  Entry.reset(new ConstantPointerNull(Ty));
1773 
1774  return Entry.get();
1775 }
1776 
1777 /// Remove the constant from the constant table.
1778 void ConstantPointerNull::destroyConstantImpl() {
1779  getContext().pImpl->CPNConstants.erase(getType());
1780 }
1781 
1783  std::unique_ptr<UndefValue> &Entry = Ty->getContext().pImpl->UVConstants[Ty];
1784  if (!Entry)
1785  Entry.reset(new UndefValue(Ty));
1786 
1787  return Entry.get();
1788 }
1789 
1790 /// Remove the constant from the constant table.
1791 void UndefValue::destroyConstantImpl() {
1792  // Free the constant and any dangling references to it.
1793  if (getValueID() == UndefValueVal) {
1794  getContext().pImpl->UVConstants.erase(getType());
1795  } else if (getValueID() == PoisonValueVal) {
1796  getContext().pImpl->PVConstants.erase(getType());
1797  }
1798  llvm_unreachable("Not a undef or a poison!");
1799 }
1800 
1802  std::unique_ptr<PoisonValue> &Entry = Ty->getContext().pImpl->PVConstants[Ty];
1803  if (!Entry)
1804  Entry.reset(new PoisonValue(Ty));
1805 
1806  return Entry.get();
1807 }
1808 
1809 /// Remove the constant from the constant table.
1810 void PoisonValue::destroyConstantImpl() {
1811  // Free the constant and any dangling references to it.
1812  getContext().pImpl->PVConstants.erase(getType());
1813 }
1814 
1816  assert(BB->getParent() && "Block must have a parent");
1817  return get(BB->getParent(), BB);
1818 }
1819 
1821  BlockAddress *&BA =
1822  F->getContext().pImpl->BlockAddresses[std::make_pair(F, BB)];
1823  if (!BA)
1824  BA = new BlockAddress(F, BB);
1825 
1826  assert(BA->getFunction() == F && "Basic block moved between functions");
1827  return BA;
1828 }
1829 
1831  : Constant(Type::getInt8PtrTy(F->getContext(), F->getAddressSpace()),
1832  Value::BlockAddressVal, &Op<0>(), 2) {
1833  setOperand(0, F);
1834  setOperand(1, BB);
1835  BB->AdjustBlockAddressRefCount(1);
1836 }
1837 
1839  if (!BB->hasAddressTaken())
1840  return nullptr;
1841 
1842  const Function *F = BB->getParent();
1843  assert(F && "Block must have a parent");
1844  BlockAddress *BA =
1845  F->getContext().pImpl->BlockAddresses.lookup(std::make_pair(F, BB));
1846  assert(BA && "Refcount and block address map disagree!");
1847  return BA;
1848 }
1849 
1850 /// Remove the constant from the constant table.
1851 void BlockAddress::destroyConstantImpl() {
1853  ->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock()));
1854  getBasicBlock()->AdjustBlockAddressRefCount(-1);
1855 }
1856 
1857 Value *BlockAddress::handleOperandChangeImpl(Value *From, Value *To) {
1858  // This could be replacing either the Basic Block or the Function. In either
1859  // case, we have to remove the map entry.
1860  Function *NewF = getFunction();
1861  BasicBlock *NewBB = getBasicBlock();
1862 
1863  if (From == NewF)
1864  NewF = cast<Function>(To->stripPointerCasts());
1865  else {
1866  assert(From == NewBB && "From does not match any operand");
1867  NewBB = cast<BasicBlock>(To);
1868  }
1869 
1870  // See if the 'new' entry already exists, if not, just update this in place
1871  // and return early.
1872  BlockAddress *&NewBA =
1873  getContext().pImpl->BlockAddresses[std::make_pair(NewF, NewBB)];
1874  if (NewBA)
1875  return NewBA;
1876 
1877  getBasicBlock()->AdjustBlockAddressRefCount(-1);
1878 
1879  // Remove the old entry, this can't cause the map to rehash (just a
1880  // tombstone will get added).
1881  getContext().pImpl->BlockAddresses.erase(std::make_pair(getFunction(),
1882  getBasicBlock()));
1883  NewBA = this;
1884  setOperand(0, NewF);
1885  setOperand(1, NewBB);
1886  getBasicBlock()->AdjustBlockAddressRefCount(1);
1887 
1888  // If we just want to keep the existing value, then return null.
1889  // Callers know that this means we shouldn't delete this value.
1890  return nullptr;
1891 }
1892 
1895  if (!Equiv)
1896  Equiv = new DSOLocalEquivalent(GV);
1897 
1898  assert(Equiv->getGlobalValue() == GV &&
1899  "DSOLocalFunction does not match the expected global value");
1900  return Equiv;
1901 }
1902 
1903 DSOLocalEquivalent::DSOLocalEquivalent(GlobalValue *GV)
1904  : Constant(GV->getType(), Value::DSOLocalEquivalentVal, &Op<0>(), 1) {
1905  setOperand(0, GV);
1906 }
1907 
1908 /// Remove the constant from the constant table.
1909 void DSOLocalEquivalent::destroyConstantImpl() {
1910  const GlobalValue *GV = getGlobalValue();
1911  GV->getContext().pImpl->DSOLocalEquivalents.erase(GV);
1912 }
1913 
1914 Value *DSOLocalEquivalent::handleOperandChangeImpl(Value *From, Value *To) {
1915  assert(From == getGlobalValue() && "Changing value does not match operand.");
1916  assert(isa<Constant>(To) && "Can only replace the operands with a constant");
1917 
1918  // The replacement is with another global value.
1919  if (const auto *ToObj = dyn_cast<GlobalValue>(To)) {
1920  DSOLocalEquivalent *&NewEquiv =
1922  if (NewEquiv)
1923  return llvm::ConstantExpr::getBitCast(NewEquiv, getType());
1924  }
1925 
1926  // If the argument is replaced with a null value, just replace this constant
1927  // with a null value.
1928  if (cast<Constant>(To)->isNullValue())
1929  return To;
1930 
1931  // The replacement could be a bitcast or an alias to another function. We can
1932  // replace it with a bitcast to the dso_local_equivalent of that function.
1933  auto *Func = cast<Function>(To->stripPointerCastsAndAliases());
1935  if (NewEquiv)
1936  return llvm::ConstantExpr::getBitCast(NewEquiv, getType());
1937 
1938  // Replace this with the new one.
1940  NewEquiv = this;
1941  setOperand(0, Func);
1942 
1943  if (Func->getType() != getType()) {
1944  // It is ok to mutate the type here because this constant should always
1945  // reflect the type of the function it's holding.
1946  mutateType(Func->getType());
1947  }
1948  return nullptr;
1949 }
1950 
1952  NoCFIValue *&NC = GV->getContext().pImpl->NoCFIValues[GV];
1953  if (!NC)
1954  NC = new NoCFIValue(GV);
1955 
1956  assert(NC->getGlobalValue() == GV &&
1957  "NoCFIValue does not match the expected global value");
1958  return NC;
1959 }
1960 
1961 NoCFIValue::NoCFIValue(GlobalValue *GV)
1962  : Constant(GV->getType(), Value::NoCFIValueVal, &Op<0>(), 1) {
1963  setOperand(0, GV);
1964 }
1965 
1966 /// Remove the constant from the constant table.
1967 void NoCFIValue::destroyConstantImpl() {
1968  const GlobalValue *GV = getGlobalValue();
1969  GV->getContext().pImpl->NoCFIValues.erase(GV);
1970 }
1971 
1972 Value *NoCFIValue::handleOperandChangeImpl(Value *From, Value *To) {
1973  assert(From == getGlobalValue() && "Changing value does not match operand.");
1974 
1975  GlobalValue *GV = dyn_cast<GlobalValue>(To->stripPointerCasts());
1976  assert(GV && "Can only replace the operands with a global value");
1977 
1978  NoCFIValue *&NewNC = getContext().pImpl->NoCFIValues[GV];
1979  if (NewNC)
1980  return llvm::ConstantExpr::getBitCast(NewNC, getType());
1981 
1983  NewNC = this;
1984  setOperand(0, GV);
1985 
1986  if (GV->getType() != getType())
1987  mutateType(GV->getType());
1988 
1989  return nullptr;
1990 }
1991 
1992 //---- ConstantExpr::get() implementations.
1993 //
1994 
1995 /// This is a utility function to handle folding of casts and lookup of the
1996 /// cast in the ExprConstants map. It is used by the various get* methods below.
1998  bool OnlyIfReduced = false) {
1999  assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
2000  // Fold a few common cases
2001  if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
2002  return FC;
2003 
2004  if (OnlyIfReduced)
2005  return nullptr;
2006 
2007  LLVMContextImpl *pImpl = Ty->getContext().pImpl;
2008 
2009  // Look up the constant in the table first to ensure uniqueness.
2010  ConstantExprKeyType Key(opc, C);
2011 
2012  return pImpl->ExprConstants.getOrCreate(Ty, Key);
2013 }
2014 
2016  bool OnlyIfReduced) {
2018  assert(Instruction::isCast(opc) && "opcode out of range");
2019  assert(C && Ty && "Null arguments to getCast");
2020  assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!");
2021 
2022  switch (opc) {
2023  default:
2024  llvm_unreachable("Invalid cast opcode");
2025  case Instruction::Trunc:
2026  return getTrunc(C, Ty, OnlyIfReduced);
2027  case Instruction::ZExt:
2028  return getZExt(C, Ty, OnlyIfReduced);
2029  case Instruction::SExt:
2030  return getSExt(C, Ty, OnlyIfReduced);
2031  case Instruction::FPTrunc:
2032  return getFPTrunc(C, Ty, OnlyIfReduced);
2033  case Instruction::FPExt:
2034  return getFPExtend(C, Ty, OnlyIfReduced);
2035  case Instruction::UIToFP:
2036  return getUIToFP(C, Ty, OnlyIfReduced);
2037  case Instruction::SIToFP:
2038  return getSIToFP(C, Ty, OnlyIfReduced);
2039  case Instruction::FPToUI:
2040  return getFPToUI(C, Ty, OnlyIfReduced);
2041  case Instruction::FPToSI:
2042  return getFPToSI(C, Ty, OnlyIfReduced);
2043  case Instruction::PtrToInt:
2044  return getPtrToInt(C, Ty, OnlyIfReduced);
2045  case Instruction::IntToPtr:
2046  return getIntToPtr(C, Ty, OnlyIfReduced);
2047  case Instruction::BitCast:
2048  return getBitCast(C, Ty, OnlyIfReduced);
2049  case Instruction::AddrSpaceCast:
2050  return getAddrSpaceCast(C, Ty, OnlyIfReduced);
2051  }
2052 }
2053 
2055  if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2056  return getBitCast(C, Ty);
2057  return getZExt(C, Ty);
2058 }
2059 
2061  if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2062  return getBitCast(C, Ty);
2063  return getSExt(C, Ty);
2064 }
2065 
2067  if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2068  return getBitCast(C, Ty);
2069  return getTrunc(C, Ty);
2070 }
2071 
2073  assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
2074  assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
2075  "Invalid cast");
2076 
2077  if (Ty->isIntOrIntVectorTy())
2078  return getPtrToInt(S, Ty);
2079 
2080  unsigned SrcAS = S->getType()->getPointerAddressSpace();
2081  if (Ty->isPtrOrPtrVectorTy() && SrcAS != Ty->getPointerAddressSpace())
2082  return getAddrSpaceCast(S, Ty);
2083 
2084  return getBitCast(S, Ty);
2085 }
2086 
2088  Type *Ty) {
2089  assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
2090  assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
2091 
2092  if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace())
2093  return getAddrSpaceCast(S, Ty);
2094 
2095  return getBitCast(S, Ty);
2096 }
2097 
2099  assert(C->getType()->isIntOrIntVectorTy() &&
2100  Ty->isIntOrIntVectorTy() && "Invalid cast");
2101  unsigned SrcBits = C->getType()->getScalarSizeInBits();
2102  unsigned DstBits = Ty->getScalarSizeInBits();
2103  Instruction::CastOps opcode =
2104  (SrcBits == DstBits ? Instruction::BitCast :
2105  (SrcBits > DstBits ? Instruction::Trunc :
2106  (isSigned ? Instruction::SExt : Instruction::ZExt)));
2107  return getCast(opcode, C, Ty);
2108 }
2109 
2111  assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
2112  "Invalid cast");
2113  unsigned SrcBits = C->getType()->getScalarSizeInBits();
2114  unsigned DstBits = Ty->getScalarSizeInBits();
2115  if (SrcBits == DstBits)
2116  return C; // Avoid a useless cast
2117  Instruction::CastOps opcode =
2118  (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt);
2119  return getCast(opcode, C, Ty);
2120 }
2121 
2122 Constant *ConstantExpr::getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
2123 #ifndef NDEBUG
2124  bool fromVec = isa<VectorType>(C->getType());
2125  bool toVec = isa<VectorType>(Ty);
2126 #endif
2127  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2128  assert(C->getType()->isIntOrIntVectorTy() && "Trunc operand must be integer");
2129  assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral");
2130  assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
2131  "SrcTy must be larger than DestTy for Trunc!");
2132 
2133  return getFoldedCast(Instruction::Trunc, C, Ty, OnlyIfReduced);
2134 }
2135 
2136 Constant *ConstantExpr::getSExt(Constant *C, Type *Ty, bool OnlyIfReduced) {
2137 #ifndef NDEBUG
2138  bool fromVec = isa<VectorType>(C->getType());
2139  bool toVec = isa<VectorType>(Ty);
2140 #endif
2141  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2142  assert(C->getType()->isIntOrIntVectorTy() && "SExt operand must be integral");
2143  assert(Ty->isIntOrIntVectorTy() && "SExt produces only integer");
2144  assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
2145  "SrcTy must be smaller than DestTy for SExt!");
2146 
2147  return getFoldedCast(Instruction::SExt, C, Ty, OnlyIfReduced);
2148 }
2149 
2150 Constant *ConstantExpr::getZExt(Constant *C, Type *Ty, bool OnlyIfReduced) {
2151 #ifndef NDEBUG
2152  bool fromVec = isa<VectorType>(C->getType());
2153  bool toVec = isa<VectorType>(Ty);
2154 #endif
2155  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2156  assert(C->getType()->isIntOrIntVectorTy() && "ZEXt operand must be integral");
2157  assert(Ty->isIntOrIntVectorTy() && "ZExt produces only integer");
2158  assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
2159  "SrcTy must be smaller than DestTy for ZExt!");
2160 
2161  return getFoldedCast(Instruction::ZExt, C, Ty, OnlyIfReduced);
2162 }
2163 
2164 Constant *ConstantExpr::getFPTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
2165 #ifndef NDEBUG
2166  bool fromVec = isa<VectorType>(C->getType());
2167  bool toVec = isa<VectorType>(Ty);
2168 #endif
2169  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2170  assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
2171  C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
2172  "This is an illegal floating point truncation!");
2173  return getFoldedCast(Instruction::FPTrunc, C, Ty, OnlyIfReduced);
2174 }
2175 
2176 Constant *ConstantExpr::getFPExtend(Constant *C, Type *Ty, bool OnlyIfReduced) {
2177 #ifndef NDEBUG
2178  bool fromVec = isa<VectorType>(C->getType());
2179  bool toVec = isa<VectorType>(Ty);
2180 #endif
2181  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2182  assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
2183  C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
2184  "This is an illegal floating point extension!");
2185  return getFoldedCast(Instruction::FPExt, C, Ty, OnlyIfReduced);
2186 }
2187 
2188 Constant *ConstantExpr::getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced) {
2189 #ifndef NDEBUG
2190  bool fromVec = isa<VectorType>(C->getType());
2191  bool toVec = isa<VectorType>(Ty);
2192 #endif
2193  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2194  assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
2195  "This is an illegal uint to floating point cast!");
2196  return getFoldedCast(Instruction::UIToFP, C, Ty, OnlyIfReduced);
2197 }
2198 
2199 Constant *ConstantExpr::getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced) {
2200 #ifndef NDEBUG
2201  bool fromVec = isa<VectorType>(C->getType());
2202  bool toVec = isa<VectorType>(Ty);
2203 #endif
2204  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2205  assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
2206  "This is an illegal sint to floating point cast!");
2207  return getFoldedCast(Instruction::SIToFP, C, Ty, OnlyIfReduced);
2208 }
2209 
2210 Constant *ConstantExpr::getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced) {
2211 #ifndef NDEBUG
2212  bool fromVec = isa<VectorType>(C->getType());
2213  bool toVec = isa<VectorType>(Ty);
2214 #endif
2215  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2216  assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
2217  "This is an illegal floating point to uint cast!");
2218  return getFoldedCast(Instruction::FPToUI, C, Ty, OnlyIfReduced);
2219 }
2220 
2221 Constant *ConstantExpr::getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced) {
2222 #ifndef NDEBUG
2223  bool fromVec = isa<VectorType>(C->getType());
2224  bool toVec = isa<VectorType>(Ty);
2225 #endif
2226  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2227  assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
2228  "This is an illegal floating point to sint cast!");
2229  return getFoldedCast(Instruction::FPToSI, C, Ty, OnlyIfReduced);
2230 }
2231 
2233  bool OnlyIfReduced) {
2234  assert(C->getType()->isPtrOrPtrVectorTy() &&
2235  "PtrToInt source must be pointer or pointer vector");
2236  assert(DstTy->isIntOrIntVectorTy() &&
2237  "PtrToInt destination must be integer or integer vector");
2238  assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy));
2239  if (isa<VectorType>(C->getType()))
2240  assert(cast<FixedVectorType>(C->getType())->getNumElements() ==
2241  cast<FixedVectorType>(DstTy)->getNumElements() &&
2242  "Invalid cast between a different number of vector elements");
2243  return getFoldedCast(Instruction::PtrToInt, C, DstTy, OnlyIfReduced);
2244 }
2245 
2247  bool OnlyIfReduced) {
2248  assert(C->getType()->isIntOrIntVectorTy() &&
2249  "IntToPtr source must be integer or integer vector");
2250  assert(DstTy->isPtrOrPtrVectorTy() &&
2251  "IntToPtr destination must be a pointer or pointer vector");
2252  assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy));
2253  if (isa<VectorType>(C->getType()))
2254  assert(cast<VectorType>(C->getType())->getElementCount() ==
2255  cast<VectorType>(DstTy)->getElementCount() &&
2256  "Invalid cast between a different number of vector elements");
2257  return getFoldedCast(Instruction::IntToPtr, C, DstTy, OnlyIfReduced);
2258 }
2259 
2261  bool OnlyIfReduced) {
2262  assert(CastInst::castIsValid(Instruction::BitCast, C, DstTy) &&
2263  "Invalid constantexpr bitcast!");
2264 
2265  // It is common to ask for a bitcast of a value to its own type, handle this
2266  // speedily.
2267  if (C->getType() == DstTy) return C;
2268 
2269  return getFoldedCast(Instruction::BitCast, C, DstTy, OnlyIfReduced);
2270 }
2271 
2273  bool OnlyIfReduced) {
2274  assert(CastInst::castIsValid(Instruction::AddrSpaceCast, C, DstTy) &&
2275  "Invalid constantexpr addrspacecast!");
2276 
2277  // Canonicalize addrspacecasts between different pointer types by first
2278  // bitcasting the pointer type and then converting the address space.
2279  PointerType *SrcScalarTy = cast<PointerType>(C->getType()->getScalarType());
2280  PointerType *DstScalarTy = cast<PointerType>(DstTy->getScalarType());
2281  if (!SrcScalarTy->hasSameElementTypeAs(DstScalarTy)) {
2283  DstScalarTy, SrcScalarTy->getAddressSpace());
2284  if (VectorType *VT = dyn_cast<VectorType>(DstTy)) {
2285  // Handle vectors of pointers.
2286  MidTy = FixedVectorType::get(MidTy,
2287  cast<FixedVectorType>(VT)->getNumElements());
2288  }
2289  C = getBitCast(C, MidTy);
2290  }
2291  return getFoldedCast(Instruction::AddrSpaceCast, C, DstTy, OnlyIfReduced);
2292 }
2293 
2294 Constant *ConstantExpr::get(unsigned Opcode, Constant *C, unsigned Flags,
2295  Type *OnlyIfReducedTy) {
2296  // Check the operands for consistency first.
2297  assert(Instruction::isUnaryOp(Opcode) &&
2298  "Invalid opcode in unary constant expression");
2299 
2300 #ifndef NDEBUG
2301  switch (Opcode) {
2302  case Instruction::FNeg:
2303  assert(C->getType()->isFPOrFPVectorTy() &&
2304  "Tried to create a floating-point operation on a "
2305  "non-floating-point type!");
2306  break;
2307  default:
2308  break;
2309  }
2310 #endif
2311 
2312  if (Constant *FC = ConstantFoldUnaryInstruction(Opcode, C))
2313  return FC;
2314 
2315  if (OnlyIfReducedTy == C->getType())
2316  return nullptr;
2317 
2318  Constant *ArgVec[] = { C };
2319  ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
2320 
2321  LLVMContextImpl *pImpl = C->getContext().pImpl;
2322  return pImpl->ExprConstants.getOrCreate(C->getType(), Key);
2323 }
2324 
2326  unsigned Flags, Type *OnlyIfReducedTy) {
2327  // Check the operands for consistency first.
2328  assert(Instruction::isBinaryOp(Opcode) &&
2329  "Invalid opcode in binary constant expression");
2330  assert(C1->getType() == C2->getType() &&
2331  "Operand types in binary constant expression should match");
2332 
2333 #ifndef NDEBUG
2334  switch (Opcode) {
2335  case Instruction::Add:
2336  case Instruction::Sub:
2337  case Instruction::Mul:
2338  case Instruction::UDiv:
2339  case Instruction::SDiv:
2340  case Instruction::URem:
2341  case Instruction::SRem:
2342  assert(C1->getType()->isIntOrIntVectorTy() &&
2343  "Tried to create an integer operation on a non-integer type!");
2344  break;
2345  case Instruction::FAdd:
2346  case Instruction::FSub:
2347  case Instruction::FMul:
2348  case Instruction::FDiv:
2349  case Instruction::FRem:
2350  assert(C1->getType()->isFPOrFPVectorTy() &&
2351  "Tried to create a floating-point operation on a "
2352  "non-floating-point type!");
2353  break;
2354  case Instruction::And:
2355  case Instruction::Or:
2356  case Instruction::Xor:
2357  assert(C1->getType()->isIntOrIntVectorTy() &&
2358  "Tried to create a logical operation on a non-integral type!");
2359  break;
2360  case Instruction::Shl:
2361  case Instruction::LShr:
2362  case Instruction::AShr:
2363  assert(C1->getType()->isIntOrIntVectorTy() &&
2364  "Tried to create a shift operation on a non-integer type!");
2365  break;
2366  default:
2367  break;
2368  }
2369 #endif
2370 
2371  if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
2372  return FC;
2373 
2374  if (OnlyIfReducedTy == C1->getType())
2375  return nullptr;
2376 
2377  Constant *ArgVec[] = { C1, C2 };
2378  ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
2379 
2380  LLVMContextImpl *pImpl = C1->getContext().pImpl;
2381  return pImpl->ExprConstants.getOrCreate(C1->getType(), Key);
2382 }
2383 
2385  // sizeof is implemented as: (i64) gep (Ty*)null, 1
2386  // Note that a non-inbounds gep is used, as null isn't within any object.
2390  return getPtrToInt(GEP,
2391  Type::getInt64Ty(Ty->getContext()));
2392 }
2393 
2395  // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1
2396  // Note that a non-inbounds gep is used, as null isn't within any object.
2397  Type *AligningTy = StructType::get(Type::getInt1Ty(Ty->getContext()), Ty);
2398  Constant *NullPtr = Constant::getNullValue(AligningTy->getPointerTo(0));
2401  Constant *Indices[2] = { Zero, One };
2402  Constant *GEP = getGetElementPtr(AligningTy, NullPtr, Indices);
2403  return getPtrToInt(GEP,
2404  Type::getInt64Ty(Ty->getContext()));
2405 }
2406 
2409  FieldNo));
2410 }
2411 
2413  // offsetof is implemented as: (i64) gep (Ty*)null, 0, FieldNo
2414  // Note that a non-inbounds gep is used, as null isn't within any object.
2415  Constant *GEPIdx[] = {
2417  FieldNo
2418  };
2421  return getPtrToInt(GEP,
2422  Type::getInt64Ty(Ty->getContext()));
2423 }
2424 
2426  Constant *C2, bool OnlyIfReduced) {
2427  assert(C1->getType() == C2->getType() && "Op types should be identical!");
2428 
2429  switch (Predicate) {
2430  default: llvm_unreachable("Invalid CmpInst predicate");
2436  case CmpInst::FCMP_TRUE:
2437  return getFCmp(Predicate, C1, C2, OnlyIfReduced);
2438 
2442  case CmpInst::ICMP_SLE:
2443  return getICmp(Predicate, C1, C2, OnlyIfReduced);
2444  }
2445 }
2446 
2448  Type *OnlyIfReducedTy) {
2449  assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands");
2450 
2452  return SC; // Fold common cases
2453 
2454  if (OnlyIfReducedTy == V1->getType())
2455  return nullptr;
2456 
2457  Constant *ArgVec[] = { C, V1, V2 };
2459 
2460  LLVMContextImpl *pImpl = C->getContext().pImpl;
2461  return pImpl->ExprConstants.getOrCreate(V1->getType(), Key);
2462 }
2463 
2465  ArrayRef<Value *> Idxs, bool InBounds,
2466  Optional<unsigned> InRangeIndex,
2467  Type *OnlyIfReducedTy) {
2468  PointerType *OrigPtrTy = cast<PointerType>(C->getType()->getScalarType());
2469  assert(Ty && "Must specify element type");
2470  assert(OrigPtrTy->isOpaqueOrPointeeTypeMatches(Ty));
2471 
2472  if (Constant *FC =
2473  ConstantFoldGetElementPtr(Ty, C, InBounds, InRangeIndex, Idxs))
2474  return FC; // Fold a few common cases.
2475 
2476  // Get the result type of the getelementptr!
2477  Type *DestTy = GetElementPtrInst::getIndexedType(Ty, Idxs);
2478  assert(DestTy && "GEP indices invalid!");
2479  unsigned AS = OrigPtrTy->getAddressSpace();
2480  Type *ReqTy = OrigPtrTy->isOpaque()
2481  ? PointerType::get(OrigPtrTy->getContext(), AS)
2482  : DestTy->getPointerTo(AS);
2483 
2484  auto EltCount = ElementCount::getFixed(0);
2485  if (VectorType *VecTy = dyn_cast<VectorType>(C->getType()))
2486  EltCount = VecTy->getElementCount();
2487  else
2488  for (auto Idx : Idxs)
2489  if (VectorType *VecTy = dyn_cast<VectorType>(Idx->getType()))
2490  EltCount = VecTy->getElementCount();
2491 
2492  if (EltCount.isNonZero())
2493  ReqTy = VectorType::get(ReqTy, EltCount);
2494 
2495  if (OnlyIfReducedTy == ReqTy)
2496  return nullptr;
2497 
2498  // Look up the constant in the table first to ensure uniqueness
2499  std::vector<Constant*> ArgVec;
2500  ArgVec.reserve(1 + Idxs.size());
2501  ArgVec.push_back(C);
2502  auto GTI = gep_type_begin(Ty, Idxs), GTE = gep_type_end(Ty, Idxs);
2503  for (; GTI != GTE; ++GTI) {
2504  auto *Idx = cast<Constant>(GTI.getOperand());
2505  assert(
2506  (!isa<VectorType>(Idx->getType()) ||
2507  cast<VectorType>(Idx->getType())->getElementCount() == EltCount) &&
2508  "getelementptr index type missmatch");
2509 
2510  if (GTI.isStruct() && Idx->getType()->isVectorTy()) {
2511  Idx = Idx->getSplatValue();
2512  } else if (GTI.isSequential() && EltCount.isNonZero() &&
2513  !Idx->getType()->isVectorTy()) {
2514  Idx = ConstantVector::getSplat(EltCount, Idx);
2515  }
2516  ArgVec.push_back(Idx);
2517  }
2518 
2519  unsigned SubClassOptionalData = InBounds ? GEPOperator::IsInBounds : 0;
2520  if (InRangeIndex && *InRangeIndex < 63)
2521  SubClassOptionalData |= (*InRangeIndex + 1) << 1;
2522  const ConstantExprKeyType Key(Instruction::GetElementPtr, ArgVec, 0,
2523  SubClassOptionalData, None, None, Ty);
2524 
2525  LLVMContextImpl *pImpl = C->getContext().pImpl;
2526  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2527 }
2528 
2530  Constant *RHS, bool OnlyIfReduced) {
2531  auto Predicate = static_cast<CmpInst::Predicate>(pred);
2532  assert(LHS->getType() == RHS->getType());
2533  assert(CmpInst::isIntPredicate(Predicate) && "Invalid ICmp Predicate");
2534 
2536  return FC; // Fold a few common cases...
2537 
2538  if (OnlyIfReduced)
2539  return nullptr;
2540 
2541  // Look up the constant in the table first to ensure uniqueness
2542  Constant *ArgVec[] = { LHS, RHS };
2543  // Get the key type with both the opcode and predicate
2544  const ConstantExprKeyType Key(Instruction::ICmp, ArgVec, Predicate);
2545 
2546  Type *ResultTy = Type::getInt1Ty(LHS->getContext());
2547  if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
2548  ResultTy = VectorType::get(ResultTy, VT->getElementCount());
2549 
2550  LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
2551  return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
2552 }
2553 
2555  Constant *RHS, bool OnlyIfReduced) {
2556  auto Predicate = static_cast<CmpInst::Predicate>(pred);
2557  assert(LHS->getType() == RHS->getType());
2558  assert(CmpInst::isFPPredicate(Predicate) && "Invalid FCmp Predicate");
2559 
2561  return FC; // Fold a few common cases...
2562 
2563  if (OnlyIfReduced)
2564  return nullptr;
2565 
2566  // Look up the constant in the table first to ensure uniqueness
2567  Constant *ArgVec[] = { LHS, RHS };
2568  // Get the key type with both the opcode and predicate
2569  const ConstantExprKeyType Key(Instruction::FCmp, ArgVec, Predicate);
2570 
2571  Type *ResultTy = Type::getInt1Ty(LHS->getContext());
2572  if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
2573  ResultTy = VectorType::get(ResultTy, VT->getElementCount());
2574 
2575  LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
2576  return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
2577 }
2578 
2580  Type *OnlyIfReducedTy) {
2581  assert(Val->getType()->isVectorTy() &&
2582  "Tried to create extractelement operation on non-vector type!");
2583  assert(Idx->getType()->isIntegerTy() &&
2584  "Extractelement index must be an integer type!");
2585 
2587  return FC; // Fold a few common cases.
2588 
2589  Type *ReqTy = cast<VectorType>(Val->getType())->getElementType();
2590  if (OnlyIfReducedTy == ReqTy)
2591  return nullptr;
2592 
2593  // Look up the constant in the table first to ensure uniqueness
2594  Constant *ArgVec[] = { Val, Idx };
2595  const ConstantExprKeyType Key(Instruction::ExtractElement, ArgVec);
2596 
2597  LLVMContextImpl *pImpl = Val->getContext().pImpl;
2598  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2599 }
2600 
2602  Constant *Idx, Type *OnlyIfReducedTy) {
2603  assert(Val->getType()->isVectorTy() &&
2604  "Tried to create insertelement operation on non-vector type!");
2605  assert(Elt->getType() == cast<VectorType>(Val->getType())->getElementType() &&
2606  "Insertelement types must match!");
2607  assert(Idx->getType()->isIntegerTy() &&
2608  "Insertelement index must be i32 type!");
2609 
2610  if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx))
2611  return FC; // Fold a few common cases.
2612 
2613  if (OnlyIfReducedTy == Val->getType())
2614  return nullptr;
2615 
2616  // Look up the constant in the table first to ensure uniqueness
2617  Constant *ArgVec[] = { Val, Elt, Idx };
2618  const ConstantExprKeyType Key(Instruction::InsertElement, ArgVec);
2619 
2620  LLVMContextImpl *pImpl = Val->getContext().pImpl;
2621  return pImpl->ExprConstants.getOrCreate(Val->getType(), Key);
2622 }
2623 
2626  Type *OnlyIfReducedTy) {
2628  "Invalid shuffle vector constant expr operands!");
2629 
2631  return FC; // Fold a few common cases.
2632 
2633  unsigned NElts = Mask.size();
2634  auto V1VTy = cast<VectorType>(V1->getType());
2635  Type *EltTy = V1VTy->getElementType();
2636  bool TypeIsScalable = isa<ScalableVectorType>(V1VTy);
2637  Type *ShufTy = VectorType::get(EltTy, NElts, TypeIsScalable);
2638 
2639  if (OnlyIfReducedTy == ShufTy)
2640  return nullptr;
2641 
2642  // Look up the constant in the table first to ensure uniqueness
2643  Constant *ArgVec[] = {V1, V2};
2644  ConstantExprKeyType Key(Instruction::ShuffleVector, ArgVec, 0, 0, None, Mask);
2645 
2646  LLVMContextImpl *pImpl = ShufTy->getContext().pImpl;
2647  return pImpl->ExprConstants.getOrCreate(ShufTy, Key);
2648 }
2649 
2651  ArrayRef<unsigned> Idxs,
2652  Type *OnlyIfReducedTy) {
2653  assert(Agg->getType()->isFirstClassType() &&
2654  "Non-first-class type for constant insertvalue expression");
2655 
2657  Idxs) == Val->getType() &&
2658  "insertvalue indices invalid!");
2659  Type *ReqTy = Val->getType();
2660 
2661  if (Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs))
2662  return FC;
2663 
2664  if (OnlyIfReducedTy == ReqTy)
2665  return nullptr;
2666 
2667  Constant *ArgVec[] = { Agg, Val };
2668  const ConstantExprKeyType Key(Instruction::InsertValue, ArgVec, 0, 0, Idxs);
2669 
2670  LLVMContextImpl *pImpl = Agg->getContext().pImpl;
2671  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2672 }
2673 
2675  Type *OnlyIfReducedTy) {
2676  assert(Agg->getType()->isFirstClassType() &&
2677  "Tried to create extractelement operation on non-first-class type!");
2678 
2679  Type *ReqTy = ExtractValueInst::getIndexedType(Agg->getType(), Idxs);
2680  (void)ReqTy;
2681  assert(ReqTy && "extractvalue indices invalid!");
2682 
2683  assert(Agg->getType()->isFirstClassType() &&
2684  "Non-first-class type for constant extractvalue expression");
2686  return FC;
2687 
2688  if (OnlyIfReducedTy == ReqTy)
2689  return nullptr;
2690 
2691  Constant *ArgVec[] = { Agg };
2692  const ConstantExprKeyType Key(Instruction::ExtractValue, ArgVec, 0, 0, Idxs);
2693 
2694  LLVMContextImpl *pImpl = Agg->getContext().pImpl;
2695  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2696 }
2697 
2698 Constant *ConstantExpr::getNeg(Constant *C, bool HasNUW, bool HasNSW) {
2699  assert(C->getType()->isIntOrIntVectorTy() &&
2700  "Cannot NEG a nonintegral value!");
2701  return getSub(ConstantFP::getZeroValueForNegation(C->getType()),
2702  C, HasNUW, HasNSW);
2703 }
2704 
2706  assert(C->getType()->isFPOrFPVectorTy() &&
2707  "Cannot FNEG a non-floating-point value!");
2708  return get(Instruction::FNeg, C);
2709 }
2710 
2712  assert(C->getType()->isIntOrIntVectorTy() &&
2713  "Cannot NOT a nonintegral value!");
2714  return get(Instruction::Xor, C, Constant::getAllOnesValue(C->getType()));
2715 }
2716 
2718  bool HasNUW, bool HasNSW) {
2719  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2721  return get(Instruction::Add, C1, C2, Flags);
2722 }
2723 
2725  return get(Instruction::FAdd, C1, C2);
2726 }
2727 
2729  bool HasNUW, bool HasNSW) {
2730  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2732  return get(Instruction::Sub, C1, C2, Flags);
2733 }
2734 
2736  return get(Instruction::FSub, C1, C2);
2737 }
2738 
2740  bool HasNUW, bool HasNSW) {
2741  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2743  return get(Instruction::Mul, C1, C2, Flags);
2744 }
2745 
2747  return get(Instruction::FMul, C1, C2);
2748 }
2749 
2751  return get(Instruction::UDiv, C1, C2,
2752  isExact ? PossiblyExactOperator::IsExact : 0);
2753 }
2754 
2756  return get(Instruction::SDiv, C1, C2,
2757  isExact ? PossiblyExactOperator::IsExact : 0);
2758 }
2759 
2761  return get(Instruction::FDiv, C1, C2);
2762 }
2763 
2765  return get(Instruction::URem, C1, C2);
2766 }
2767 
2769  return get(Instruction::SRem, C1, C2);
2770 }
2771 
2773  return get(Instruction::FRem, C1, C2);
2774 }
2775 
2777  return get(Instruction::And, C1, C2);
2778 }
2779 
2781  return get(Instruction::Or, C1, C2);
2782 }
2783 
2785  return get(Instruction::Xor, C1, C2);
2786 }
2787 
2790  return getSelect(Cmp, C1, C2);
2791 }
2792 
2794  bool HasNUW, bool HasNSW) {
2795  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2797  return get(Instruction::Shl, C1, C2, Flags);
2798 }
2799 
2801  return get(Instruction::LShr, C1, C2,
2802  isExact ? PossiblyExactOperator::IsExact : 0);
2803 }
2804 
2806  return get(Instruction::AShr, C1, C2,
2807  isExact ? PossiblyExactOperator::IsExact : 0);
2808 }
2809 
2811  Type *Ty = C->getType();
2812  const APInt *IVal;
2813  if (match(C, m_APInt(IVal)) && IVal->isPowerOf2())
2814  return ConstantInt::get(Ty, IVal->logBase2());
2815 
2816  // FIXME: We can extract pow of 2 of splat constant for scalable vectors.
2817  auto *VecTy = dyn_cast<FixedVectorType>(Ty);
2818  if (!VecTy)
2819  return nullptr;
2820 
2822  for (unsigned I = 0, E = VecTy->getNumElements(); I != E; ++I) {
2823  Constant *Elt = C->getAggregateElement(I);
2824  if (!Elt)
2825  return nullptr;
2826  // Note that log2(iN undef) is *NOT* iN undef, because log2(iN undef) u< N.
2827  if (isa<UndefValue>(Elt)) {
2828  Elts.push_back(Constant::getNullValue(Ty->getScalarType()));
2829  continue;
2830  }
2831  if (!match(Elt, m_APInt(IVal)) || !IVal->isPowerOf2())
2832  return nullptr;
2833  Elts.push_back(ConstantInt::get(Ty->getScalarType(), IVal->logBase2()));
2834  }
2835 
2836  return ConstantVector::get(Elts);
2837 }
2838 
2840  bool AllowRHSConstant) {
2841  assert(Instruction::isBinaryOp(Opcode) && "Only binops allowed");
2842 
2843  // Commutative opcodes: it does not matter if AllowRHSConstant is set.
2844  if (Instruction::isCommutative(Opcode)) {
2845  switch (Opcode) {
2846  case Instruction::Add: // X + 0 = X
2847  case Instruction::Or: // X | 0 = X
2848  case Instruction::Xor: // X ^ 0 = X
2849  return Constant::getNullValue(Ty);
2850  case Instruction::Mul: // X * 1 = X
2851  return ConstantInt::get(Ty, 1);
2852  case Instruction::And: // X & -1 = X
2853  return Constant::getAllOnesValue(Ty);
2854  case Instruction::FAdd: // X + -0.0 = X
2855  // TODO: If the fadd has 'nsz', should we return +0.0?
2856  return ConstantFP::getNegativeZero(Ty);
2857  case Instruction::FMul: // X * 1.0 = X
2858  return ConstantFP::get(Ty, 1.0);
2859  default:
2860  llvm_unreachable("Every commutative binop has an identity constant");
2861  }
2862  }
2863 
2864  // Non-commutative opcodes: AllowRHSConstant must be set.
2865  if (!AllowRHSConstant)
2866  return nullptr;
2867 
2868  switch (Opcode) {
2869  case Instruction::Sub: // X - 0 = X
2870  case Instruction::Shl: // X << 0 = X
2871  case Instruction::LShr: // X >>u 0 = X
2872  case Instruction::AShr: // X >> 0 = X
2873  case Instruction::FSub: // X - 0.0 = X
2874  return Constant::getNullValue(Ty);
2875  case Instruction::SDiv: // X / 1 = X
2876  case Instruction::UDiv: // X /u 1 = X
2877  return ConstantInt::get(Ty, 1);
2878  case Instruction::FDiv: // X / 1.0 = X
2879  return ConstantFP::get(Ty, 1.0);
2880  default:
2881  return nullptr;
2882  }
2883 }
2884 
2886  switch (Opcode) {
2887  default:
2888  // Doesn't have an absorber.
2889  return nullptr;
2890 
2891  case Instruction::Or:
2892  return Constant::getAllOnesValue(Ty);
2893 
2894  case Instruction::And:
2895  case Instruction::Mul:
2896  return Constant::getNullValue(Ty);
2897  }
2898 }
2899 
2900 /// Remove the constant from the constant table.
2901 void ConstantExpr::destroyConstantImpl() {
2902  getType()->getContext().pImpl->ExprConstants.remove(this);
2903 }
2904 
2905 const char *ConstantExpr::getOpcodeName() const {
2907 }
2908 
2909 GetElementPtrConstantExpr::GetElementPtrConstantExpr(
2910  Type *SrcElementTy, Constant *C, ArrayRef<Constant *> IdxList, Type *DestTy)
2911  : ConstantExpr(DestTy, Instruction::GetElementPtr,
2913  (IdxList.size() + 1),
2914  IdxList.size() + 1),
2915  SrcElementTy(SrcElementTy),
2916  ResElementTy(GetElementPtrInst::getIndexedType(SrcElementTy, IdxList)) {
2917  Op<0>() = C;
2918  Use *OperandList = getOperandList();
2919  for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
2920  OperandList[i+1] = IdxList[i];
2921 }
2922 
2924  return SrcElementTy;
2925 }
2926 
2928  return ResElementTy;
2929 }
2930 
2931 //===----------------------------------------------------------------------===//
2932 // ConstantData* implementations
2933 
2935  if (ArrayType *ATy = dyn_cast<ArrayType>(getType()))
2936  return ATy->getElementType();
2937  return cast<VectorType>(getType())->getElementType();
2938 }
2939 
2941  return StringRef(DataElements, getNumElements()*getElementByteSize());
2942 }
2943 
2945  if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() || Ty->isDoubleTy())
2946  return true;
2947  if (auto *IT = dyn_cast<IntegerType>(Ty)) {
2948  switch (IT->getBitWidth()) {
2949  case 8:
2950  case 16:
2951  case 32:
2952  case 64:
2953  return true;
2954  default: break;
2955  }
2956  }
2957  return false;
2958 }
2959 
2961  if (ArrayType *AT = dyn_cast<ArrayType>(getType()))
2962  return AT->getNumElements();
2963  return cast<FixedVectorType>(getType())->getNumElements();
2964 }
2965 
2966 
2968  return getElementType()->getPrimitiveSizeInBits()/8;
2969 }
2970 
2971 /// Return the start of the specified element.
2972 const char *ConstantDataSequential::getElementPointer(unsigned Elt) const {
2973  assert(Elt < getNumElements() && "Invalid Elt");
2974  return DataElements+Elt*getElementByteSize();
2975 }
2976 
2977 
2978 /// Return true if the array is empty or all zeros.
2979 static bool isAllZeros(StringRef Arr) {
2980  for (char I : Arr)
2981  if (I != 0)
2982  return false;
2983  return true;
2984 }
2985 
2986 /// This is the underlying implementation of all of the
2987 /// ConstantDataSequential::get methods. They all thunk down to here, providing
2988 /// the correct element type. We take the bytes in as a StringRef because
2989 /// we *want* an underlying "char*" to avoid TBAA type punning violations.
2991 #ifndef NDEBUG
2992  if (ArrayType *ATy = dyn_cast<ArrayType>(Ty))
2993  assert(isElementTypeCompatible(ATy->getElementType()));
2994  else
2995  assert(isElementTypeCompatible(cast<VectorType>(Ty)->getElementType()));
2996 #endif
2997  // If the elements are all zero or there are no elements, return a CAZ, which
2998  // is more dense and canonical.
2999  if (isAllZeros(Elements))
3000  return ConstantAggregateZero::get(Ty);
3001 
3002  // Do a lookup to see if we have already formed one of these.
3003  auto &Slot =
3004  *Ty->getContext()
3005  .pImpl->CDSConstants.insert(std::make_pair(Elements, nullptr))
3006  .first;
3007 
3008  // The bucket can point to a linked list of different CDS's that have the same
3009  // body but different types. For example, 0,0,0,1 could be a 4 element array
3010  // of i8, or a 1-element array of i32. They'll both end up in the same
3011  /// StringMap bucket, linked up by their Next pointers. Walk the list.
3012  std::unique_ptr<ConstantDataSequential> *Entry = &Slot.second;
3013  for (; *Entry; Entry = &(*Entry)->Next)
3014  if ((*Entry)->getType() == Ty)
3015  return Entry->get();
3016 
3017  // Okay, we didn't get a hit. Create a node of the right class, link it in,
3018  // and return it.
3019  if (isa<ArrayType>(Ty)) {
3020  // Use reset because std::make_unique can't access the constructor.
3021  Entry->reset(new ConstantDataArray(Ty, Slot.first().data()));
3022  return Entry->get();
3023  }
3024 
3025  assert(isa<VectorType>(Ty));
3026  // Use reset because std::make_unique can't access the constructor.
3027  Entry->reset(new ConstantDataVector(Ty, Slot.first().data()));
3028  return Entry->get();
3029 }
3030 
3031 void ConstantDataSequential::destroyConstantImpl() {
3032  // Remove the constant from the StringMap.
3035 
3036  auto Slot = CDSConstants.find(getRawDataValues());
3037 
3038  assert(Slot != CDSConstants.end() && "CDS not found in uniquing table");
3039 
3040  std::unique_ptr<ConstantDataSequential> *Entry = &Slot->getValue();
3041 
3042  // Remove the entry from the hash table.
3043  if (!(*Entry)->Next) {
3044  // If there is only one value in the bucket (common case) it must be this
3045  // entry, and removing the entry should remove the bucket completely.
3046  assert(Entry->get() == this && "Hash mismatch in ConstantDataSequential");
3047  getContext().pImpl->CDSConstants.erase(Slot);
3048  return;
3049  }
3050 
3051  // Otherwise, there are multiple entries linked off the bucket, unlink the
3052  // node we care about but keep the bucket around.
3053  while (true) {
3054  std::unique_ptr<ConstantDataSequential> &Node = *Entry;
3055  assert(Node && "Didn't find entry in its uniquing hash table!");
3056  // If we found our entry, unlink it from the list and we're done.
3057  if (Node.get() == this) {
3058  Node = std::move(Node->Next);
3059  return;
3060  }
3061 
3062  Entry = &Node->Next;
3063  }
3064 }
3065 
3066 /// getFP() constructors - Return a constant of array type with a float
3067 /// element type taken from argument `ElementType', and count taken from
3068 /// argument `Elts'. The amount of bits of the contained type must match the
3069 /// number of bits of the type contained in the passed in ArrayRef.
3070 /// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
3071 /// that this can return a ConstantAggregateZero object.
3073  assert((ElementType->isHalfTy() || ElementType->isBFloatTy()) &&
3074  "Element type is not a 16-bit float type");
3075  Type *Ty = ArrayType::get(ElementType, Elts.size());
3076  const char *Data = reinterpret_cast<const char *>(Elts.data());
3077  return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3078 }
3080  assert(ElementType->isFloatTy() && "Element type is not a 32-bit float type");
3081  Type *Ty = ArrayType::get(ElementType, Elts.size());
3082  const char *Data = reinterpret_cast<const char *>(Elts.data());
3083  return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3084 }
3086  assert(ElementType->isDoubleTy() &&
3087  "Element type is not a 64-bit float type");
3088  Type *Ty = ArrayType::get(ElementType, Elts.size());
3089  const char *Data = reinterpret_cast<const char *>(Elts.data());
3090  return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3091 }
3092 
3094  StringRef Str, bool AddNull) {
3095  if (!AddNull) {
3096  const uint8_t *Data = Str.bytes_begin();
3097  return get(Context, makeArrayRef(Data, Str.size()));
3098  }
3099 
3100  SmallVector<uint8_t, 64> ElementVals;
3101  ElementVals.append(Str.begin(), Str.end());
3102  ElementVals.push_back(0);
3103  return get(Context, ElementVals);
3104 }
3105 
3106 /// get() constructors - Return a constant with vector type with an element
3107 /// count and element type matching the ArrayRef passed in. Note that this
3108 /// can return a ConstantAggregateZero object.
3110  auto *Ty = FixedVectorType::get(Type::getInt8Ty(Context), Elts.size());
3111  const char *Data = reinterpret_cast<const char *>(Elts.data());
3112  return getImpl(StringRef(Data, Elts.size() * 1), Ty);
3113 }
3115  auto *Ty = FixedVectorType::get(Type::getInt16Ty(Context), Elts.size());
3116  const char *Data = reinterpret_cast<const char *>(Elts.data());
3117  return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3118 }
3120  auto *Ty = FixedVectorType::get(Type::getInt32Ty(Context), Elts.size());
3121  const char *Data = reinterpret_cast<const char *>(Elts.data());
3122  return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3123 }
3125  auto *Ty = FixedVectorType::get(Type::getInt64Ty(Context), Elts.size());
3126  const char *Data = reinterpret_cast<const char *>(Elts.data());
3127  return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3128 }
3130  auto *Ty = FixedVectorType::get(Type::getFloatTy(Context), Elts.size());
3131  const char *Data = reinterpret_cast<const char *>(Elts.data());
3132  return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3133 }
3135  auto *Ty = FixedVectorType::get(Type::getDoubleTy(Context), Elts.size());
3136  const char *Data = reinterpret_cast<const char *>(Elts.data());
3137  return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3138 }
3139 
3140 /// getFP() constructors - Return a constant of vector type with a float
3141 /// element type taken from argument `ElementType', and count taken from
3142 /// argument `Elts'. The amount of bits of the contained type must match the
3143 /// number of bits of the type contained in the passed in ArrayRef.
3144 /// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
3145 /// that this can return a ConstantAggregateZero object.
3147  ArrayRef<uint16_t> Elts) {
3148  assert((ElementType->isHalfTy() || ElementType->isBFloatTy()) &&
3149  "Element type is not a 16-bit float type");
3150  auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3151  const char *Data = reinterpret_cast<const char *>(Elts.data());
3152  return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3153 }
3155  ArrayRef<uint32_t> Elts) {
3156  assert(ElementType->isFloatTy() && "Element type is not a 32-bit float type");
3157  auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3158  const char *Data = reinterpret_cast<const char *>(Elts.data());
3159  return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3160 }
3162  ArrayRef<uint64_t> Elts) {
3163  assert(ElementType->isDoubleTy() &&
3164  "Element type is not a 64-bit float type");
3165  auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3166  const char *Data = reinterpret_cast<const char *>(Elts.data());
3167  return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3168 }
3169 
3172  "Element type not compatible with ConstantData");
3173  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
3174  if (CI->getType()->isIntegerTy(8)) {
3175  SmallVector<uint8_t, 16> Elts(NumElts, CI->getZExtValue());
3176  return get(V->getContext(), Elts);
3177  }
3178  if (CI->getType()->isIntegerTy(16)) {
3179  SmallVector<uint16_t, 16> Elts(NumElts, CI->getZExtValue());
3180  return get(V->getContext(), Elts);
3181  }
3182  if (CI->getType()->isIntegerTy(32)) {
3183  SmallVector<uint32_t, 16> Elts(NumElts, CI->getZExtValue());
3184  return get(V->getContext(), Elts);
3185  }
3186  assert(CI->getType()->isIntegerTy(64) && "Unsupported ConstantData type");
3187  SmallVector<uint64_t, 16> Elts(NumElts, CI->getZExtValue());
3188  return get(V->getContext(), Elts);
3189  }
3190 
3191  if (ConstantFP *CFP = dyn_cast<ConstantFP>(V)) {
3192  if (CFP->getType()->isHalfTy()) {
3194  NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3195  return getFP(V->getType(), Elts);
3196  }
3197  if (CFP->getType()->isBFloatTy()) {
3199  NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3200  return getFP(V->getType(), Elts);
3201  }
3202  if (CFP->getType()->isFloatTy()) {
3204  NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3205  return getFP(V->getType(), Elts);
3206  }
3207  if (CFP->getType()->isDoubleTy()) {
3209  NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3210  return getFP(V->getType(), Elts);
3211  }
3212  }
3214 }
3215 
3216 
3218  assert(isa<IntegerType>(getElementType()) &&
3219  "Accessor can only be used when element is an integer");
3220  const char *EltPtr = getElementPointer(Elt);
3221 
3222  // The data is stored in host byte order, make sure to cast back to the right
3223  // type to load with the right endianness.
3224  switch (getElementType()->getIntegerBitWidth()) {
3225  default: llvm_unreachable("Invalid bitwidth for CDS");
3226  case 8:
3227  return *reinterpret_cast<const uint8_t *>(EltPtr);
3228  case 16:
3229  return *reinterpret_cast<const uint16_t *>(EltPtr);
3230  case 32:
3231  return *reinterpret_cast<const uint32_t *>(EltPtr);
3232  case 64:
3233  return *reinterpret_cast<const uint64_t *>(EltPtr);
3234  }
3235 }
3236 
3238  assert(isa<IntegerType>(getElementType()) &&
3239  "Accessor can only be used when element is an integer");
3240  const char *EltPtr = getElementPointer(Elt);
3241 
3242  // The data is stored in host byte order, make sure to cast back to the right
3243  // type to load with the right endianness.
3244  switch (getElementType()->getIntegerBitWidth()) {
3245  default: llvm_unreachable("Invalid bitwidth for CDS");
3246  case 8: {
3247  auto EltVal = *reinterpret_cast<const uint8_t *>(EltPtr);
3248  return APInt(8, EltVal);
3249  }
3250  case 16: {
3251  auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
3252  return APInt(16, EltVal);
3253  }
3254  case 32: {
3255  auto EltVal = *reinterpret_cast<const uint32_t *>(EltPtr);
3256  return APInt(32, EltVal);
3257  }
3258  case 64: {
3259  auto EltVal = *reinterpret_cast<const uint64_t *>(EltPtr);
3260  return APInt(64, EltVal);
3261  }
3262  }
3263 }
3264 
3266  const char *EltPtr = getElementPointer(Elt);
3267 
3268  switch (getElementType()->getTypeID()) {
3269  default:
3270  llvm_unreachable("Accessor can only be used when element is float/double!");
3271  case Type::HalfTyID: {
3272  auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
3273  return APFloat(APFloat::IEEEhalf(), APInt(16, EltVal));
3274  }
3275  case Type::BFloatTyID: {
3276  auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
3277  return APFloat(APFloat::BFloat(), APInt(16, EltVal));
3278  }
3279  case Type::FloatTyID: {
3280  auto EltVal = *reinterpret_cast<const uint32_t *>(EltPtr);
3281  return APFloat(APFloat::IEEEsingle(), APInt(32, EltVal));
3282  }
3283  case Type::DoubleTyID: {
3284  auto EltVal = *reinterpret_cast<const uint64_t *>(EltPtr);
3285  return APFloat(APFloat::IEEEdouble(), APInt(64, EltVal));
3286  }
3287  }
3288 }
3289 
3291  assert(getElementType()->isFloatTy() &&
3292  "Accessor can only be used when element is a 'float'");
3293  return *reinterpret_cast<const float *>(getElementPointer(Elt));
3294 }
3295 
3297  assert(getElementType()->isDoubleTy() &&
3298  "Accessor can only be used when element is a 'float'");
3299  return *reinterpret_cast<const double *>(getElementPointer(Elt));
3300 }
3301 
3303  if (getElementType()->isHalfTy() || getElementType()->isBFloatTy() ||
3304  getElementType()->isFloatTy() || getElementType()->isDoubleTy())
3306 
3308 }
3309 
3310 bool ConstantDataSequential::isString(unsigned CharSize) const {
3311  return isa<ArrayType>(getType()) && getElementType()->isIntegerTy(CharSize);
3312 }
3313 
3315  if (!isString())
3316  return false;
3317 
3318  StringRef Str = getAsString();
3319 
3320  // The last value must be nul.
3321  if (Str.back() != 0) return false;
3322 
3323  // Other elements must be non-nul.
3324  return !Str.drop_back().contains(0);
3325 }
3326 
3327 bool ConstantDataVector::isSplatData() const {
3328  const char *Base = getRawDataValues().data();
3329 
3330  // Compare elements 1+ to the 0'th element.
3331  unsigned EltSize = getElementByteSize();
3332  for (unsigned i = 1, e = getNumElements(); i != e; ++i)
3333  if (memcmp(Base, Base+i*EltSize, EltSize))
3334  return false;
3335 
3336  return true;
3337 }
3338 
3340  if (!IsSplatSet) {
3341  IsSplatSet = true;
3342  IsSplat = isSplatData();
3343  }
3344  return IsSplat;
3345 }
3346 
3348  // If they're all the same, return the 0th one as a representative.
3349  return isSplat() ? getElementAsConstant(0) : nullptr;
3350 }
3351 
3352 //===----------------------------------------------------------------------===//
3353 // handleOperandChange implementations
3354 
3355 /// Update this constant array to change uses of
3356 /// 'From' to be uses of 'To'. This must update the uniquing data structures
3357 /// etc.
3358 ///
3359 /// Note that we intentionally replace all uses of From with To here. Consider
3360 /// a large array that uses 'From' 1000 times. By handling this case all here,
3361 /// ConstantArray::handleOperandChange is only invoked once, and that
3362 /// single invocation handles all 1000 uses. Handling them one at a time would
3363 /// work, but would be really slow because it would have to unique each updated
3364 /// array instance.
3365 ///
3367  Value *Replacement = nullptr;
3368  switch (getValueID()) {
3369  default:
3370  llvm_unreachable("Not a constant!");
3371 #define HANDLE_CONSTANT(Name) \
3372  case Value::Name##Val: \
3373  Replacement = cast<Name>(this)->handleOperandChangeImpl(From, To); \
3374  break;
3375 #include "llvm/IR/Value.def"
3376  }
3377 
3378  // If handleOperandChangeImpl returned nullptr, then it handled
3379  // replacing itself and we don't want to delete or replace anything else here.
3380  if (!Replacement)
3381  return;
3382 
3383  // I do need to replace this with an existing value.
3384  assert(Replacement != this && "I didn't contain From!");
3385 
3386  // Everyone using this now uses the replacement.
3387  replaceAllUsesWith(Replacement);
3388 
3389  // Delete the old constant!
3390  destroyConstant();
3391 }
3392 
3393 Value *ConstantArray::handleOperandChangeImpl(Value *From, Value *To) {
3394  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
3395  Constant *ToC = cast<Constant>(To);
3396 
3398  Values.reserve(getNumOperands()); // Build replacement array.
3399 
3400  // Fill values with the modified operands of the constant array. Also,
3401  // compute whether this turns into an all-zeros array.
3402  unsigned NumUpdated = 0;
3403 
3404  // Keep track of whether all the values in the array are "ToC".
3405  bool AllSame = true;
3406  Use *OperandList = getOperandList();
3407  unsigned OperandNo = 0;
3408  for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
3409  Constant *Val = cast<Constant>(O->get());
3410  if (Val == From) {
3411  OperandNo = (O - OperandList);
3412  Val = ToC;
3413  ++NumUpdated;
3414  }
3415  Values.push_back(Val);
3416  AllSame &= Val == ToC;
3417  }
3418 
3419  if (AllSame && ToC->isNullValue())
3421 
3422  if (AllSame && isa<UndefValue>(ToC))
3423  return UndefValue::get(getType());
3424 
3425  // Check for any other type of constant-folding.
3426  if (Constant *C = getImpl(getType(), Values))
3427  return C;
3428 
3429  // Update to the new value.
3431  Values, this, From, ToC, NumUpdated, OperandNo);
3432 }
3433 
3434 Value *ConstantStruct::handleOperandChangeImpl(Value *From, Value *To) {
3435  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
3436  Constant *ToC = cast<Constant>(To);
3437 
3438  Use *OperandList = getOperandList();
3439 
3441  Values.reserve(getNumOperands()); // Build replacement struct.
3442 
3443  // Fill values with the modified operands of the constant struct. Also,
3444  // compute whether this turns into an all-zeros struct.
3445  unsigned NumUpdated = 0;
3446  bool AllSame = true;
3447  unsigned OperandNo = 0;
3448  for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O) {
3449  Constant *Val = cast<Constant>(O->get());
3450  if (Val == From) {
3451  OperandNo = (O - OperandList);
3452  Val = ToC;
3453  ++NumUpdated;
3454  }
3455  Values.push_back(Val);
3456  AllSame &= Val == ToC;
3457  }
3458 
3459  if (AllSame && ToC->isNullValue())
3461 
3462  if (AllSame && isa<UndefValue>(ToC))
3463  return UndefValue::get(getType());
3464 
3465  // Update to the new value.
3467  Values, this, From, ToC, NumUpdated, OperandNo);
3468 }
3469 
3470 Value *ConstantVector::handleOperandChangeImpl(Value *From, Value *To) {
3471  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
3472  Constant *ToC = cast<Constant>(To);
3473 
3475  Values.reserve(getNumOperands()); // Build replacement array...
3476  unsigned NumUpdated = 0;
3477  unsigned OperandNo = 0;
3478  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
3479  Constant *Val = getOperand(i);
3480  if (Val == From) {
3481  OperandNo = i;
3482  ++NumUpdated;
3483  Val = ToC;
3484  }
3485  Values.push_back(Val);
3486  }
3487 
3488  if (Constant *C = getImpl(Values))
3489  return C;
3490 
3491  // Update to the new value.
3493  Values, this, From, ToC, NumUpdated, OperandNo);
3494 }
3495 
3496 Value *ConstantExpr::handleOperandChangeImpl(Value *From, Value *ToV) {
3497  assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!");
3498  Constant *To = cast<Constant>(ToV);
3499 
3501  unsigned NumUpdated = 0;
3502  unsigned OperandNo = 0;
3503  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
3504  Constant *Op = getOperand(i);
3505  if (Op == From) {
3506  OperandNo = i;
3507  ++NumUpdated;
3508  Op = To;
3509  }
3510  NewOps.push_back(Op);
3511  }
3512  assert(NumUpdated && "I didn't contain From!");
3513 
3514  if (Constant *C = getWithOperands(NewOps, getType(), true))
3515  return C;
3516 
3517  // Update to the new value.
3518  return getContext().pImpl->ExprConstants.replaceOperandsInPlace(
3519  NewOps, this, From, To, NumUpdated, OperandNo);
3520 }
3521 
3523  SmallVector<Value *, 4> ValueOperands(operands());
3524  ArrayRef<Value*> Ops(ValueOperands);
3525 
3526  switch (getOpcode()) {
3527  case Instruction::Trunc:
3528  case Instruction::ZExt:
3529  case Instruction::SExt:
3530  case Instruction::FPTrunc:
3531  case Instruction::FPExt:
3532  case Instruction::UIToFP:
3533  case Instruction::SIToFP:
3534  case Instruction::FPToUI:
3535  case Instruction::FPToSI:
3536  case Instruction::PtrToInt:
3537  case Instruction::IntToPtr:
3538  case Instruction::BitCast:
3539  case Instruction::AddrSpaceCast:
3541  getType(), "", InsertBefore);
3542  case Instruction::Select:
3543  return SelectInst::Create(Ops[0], Ops[1], Ops[2], "", InsertBefore);
3544  case Instruction::InsertElement:
3545  return InsertElementInst::Create(Ops[0], Ops[1], Ops[2], "", InsertBefore);
3546  case Instruction::ExtractElement:
3547  return ExtractElementInst::Create(Ops[0], Ops[1], "", InsertBefore);
3548  case Instruction::InsertValue:
3549  return InsertValueInst::Create(Ops[0], Ops[1], getIndices(), "",
3550  InsertBefore);
3551  case Instruction::ExtractValue:
3552  return ExtractValueInst::Create(Ops[0], getIndices(), "", InsertBefore);
3553  case Instruction::ShuffleVector:
3554  return new ShuffleVectorInst(Ops[0], Ops[1], getShuffleMask(), "",
3555  InsertBefore);
3556 
3557  case Instruction::GetElementPtr: {
3558  const auto *GO = cast<GEPOperator>(this);
3559  if (GO->isInBounds())
3561  GO->getSourceElementType(), Ops[0], Ops.slice(1), "", InsertBefore);
3562  return GetElementPtrInst::Create(GO->getSourceElementType(), Ops[0],
3563  Ops.slice(1), "", InsertBefore);
3564  }
3565  case Instruction::ICmp:
3566  case Instruction::FCmp:
3568  (CmpInst::Predicate)getPredicate(), Ops[0], Ops[1],
3569  "", InsertBefore);
3570  case Instruction::FNeg:
3572  InsertBefore);
3573  default:
3574  assert(getNumOperands() == 2 && "Must be binary operator?");
3576  (Instruction::BinaryOps)getOpcode(), Ops[0], Ops[1], "", InsertBefore);
3577  if (isa<OverflowingBinaryOperator>(BO)) {
3582  }
3583  if (isa<PossiblyExactOperator>(BO))
3585  return BO;
3586  }
3587 }
i
i
Definition: README.txt:29
llvm::lltok::APFloat
@ APFloat
Definition: LLToken.h:497
llvm::CmpInst::FCMP_ULE
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:736
llvm::Type::ArrayTyID
@ ArrayTyID
Arrays.
Definition: Type.h:75
llvm::ARMII::VecSize
@ VecSize
Definition: ARMBaseInfo.h:421
llvm::LLVMContext::pImpl
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:69
llvm::Type::FloatTyID
@ FloatTyID
32-bit floating point type
Definition: Type.h:58
llvm::Constant::isAllOnesValue
bool isAllOnesValue() const
Return true if this is the value that would be returned by getAllOnesValue.
Definition: Constants.cpp:91
llvm::Value::const_user_iterator
user_iterator_impl< const User > const_user_iterator
Definition: Value.h:391
llvm::Value::stripPointerCastsAndAliases
const Value * stripPointerCastsAndAliases() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
Definition: Value.cpp:689
MathExtras.h
llvm::Type::DoubleTyID
@ DoubleTyID
64-bit floating point type
Definition: Type.h:59
llvm::Constant::isFiniteNonZeroFP
bool isFiniteNonZeroFP() const
Return true if this is a finite and non-zero floating-point scalar constant or a fixed width vector c...
Definition: Constants.cpp:198
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
llvm::ConstantDataSequential::getElementByteSize
uint64_t getElementByteSize() const
Return the size (in bytes) of each element in the array/vector.
Definition: Constants.cpp:2967
llvm::Constant::isNormalFP
bool isNormalFP() const
Return true if this is a normal (as opposed to denormal, infinity, nan, or zero) floating-point scala...
Definition: Constants.cpp:219
llvm::Constant::isNaN
bool isNaN() const
Return true if this is a floating-point NaN constant or a vector floating-point constant with all NaN...
Definition: Constants.cpp:261
llvm::ConstantExpr::getFDiv
static Constant * getFDiv(Constant *C1, Constant *C2)
Definition: Constants.cpp:2760
llvm::Type::getInt1Ty
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:238
llvm::ConstantExpr::getExtractElement
static Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2579
llvm::deleteConstant
void deleteConstant(Constant *C)
Definition: Constants.cpp:500
llvm::CmpInst::ICMP_EQ
@ ICMP_EQ
equal
Definition: InstrTypes.h:742
llvm::LLVMContextImpl::BlockAddresses
DenseMap< std::pair< const Function *, const BasicBlock * >, BlockAddress * > BlockAddresses
Definition: LLVMContextImpl.h:1424
llvm::ConstantExpr::getNot
static Constant * getNot(Constant *C)
Definition: Constants.cpp:2711
llvm::StructType::get
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Definition: Type.cpp:408
llvm::ConstantFP::isValueValidForType
static bool isValueValidForType(Type *Ty, const APFloat &V)
Return true if Ty is big enough to represent V.
Definition: Constants.cpp:1600
llvm::ConstantExpr::getZExtOrBitCast
static Constant * getZExtOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:2054
llvm::Instruction::UnaryOps
UnaryOps
Definition: Instruction.h:782
llvm::ConstantExpr::getSIToFP
static Constant * getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2199
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:721
llvm::User::operands
op_range operands()
Definition: User.h:242
llvm::Value::SubclassOptionalData
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
Definition: Value.h:90
llvm::Constant::containsPoisonElement
bool containsPoisonElement() const
Return true if this is a vector constant that includes any poison elements.
Definition: Constants.cpp:333
llvm::ConstantExpr::getOpcodeName
const char * getOpcodeName() const
Return a string representation for an opcode.
Definition: Constants.cpp:2905
llvm::ConstantAggregateZero::getSequentialElement
Constant * getSequentialElement() const
If this CAZ has array or vector type, return a zero with the right element type.
Definition: Constants.cpp:1116
isAllZeros
static bool isAllZeros(StringRef Arr)
Return true if the array is empty or all zeros.
Definition: Constants.cpp:2979
llvm::ElementCount
Definition: TypeSize.h:385
llvm::APFloatBase::IEEEsingle
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:170
llvm::ConstantUniqueMap::replaceOperandsInPlace
ConstantClass * replaceOperandsInPlace(ArrayRef< Constant * > Operands, ConstantClass *CP, Value *From, Constant *To, unsigned NumUpdated=0, unsigned OperandNo=~0u)
Definition: ConstantsContext.h:745
llvm::LLVMContextImpl::FPConstants
FPMapTy FPConstants
Definition: LLVMContextImpl.h:1379
llvm::ConstantExpr::getZExt
static Constant * getZExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2150
T
llvm::Function
Definition: Function.h:62
getFunction
static Function * getFunction(Constant *C)
Definition: Evaluator.cpp:235
llvm::ISD::ConstantFP
@ ConstantFP
Definition: ISDOpcodes.h:77
llvm::Instruction::isCast
bool isCast() const
Definition: Instruction.h:168
llvm::ConstantStruct::get
static Constant * get(StructType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:1360
llvm::LLVMContextImpl::UVConstants
DenseMap< Type *, std::unique_ptr< UndefValue > > UVConstants
Definition: LLVMContextImpl.h:1417
llvm::ConstantExpr::getAsInstruction
Instruction * getAsInstruction(Instruction *InsertBefore=nullptr) const
Returns an Instruction which implements the same operation as this ConstantExpr.
Definition: Constants.cpp:3522
rangeOnlyContains
static bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt)
Definition: Constants.cpp:1213
llvm::ConstantExpr::getFRem
static Constant * getFRem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2772
llvm::APInt::isPowerOf2
bool isPowerOf2() const
Check if this APInt's value is a power of two greater than zero.
Definition: APInt.h:425
llvm::PointerType::get
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space.
Definition: Type.cpp:729
llvm::ConstantExpr::getFPCast
static Constant * getFPCast(Constant *C, Type *Ty)
Create a FPExt, Bitcast or FPTrunc for fp -> fp casts.
Definition: Constants.cpp:2110
C1
instcombine should handle this C2 when C1
Definition: README.txt:263
llvm::ConstantFoldSelectInstruction
Constant * ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2)
Attempt to constant fold a select instruction with the specified operands.
Definition: ConstantFold.cpp:529
GetElementPtrTypeIterator.h
llvm::Type::getScalarType
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
Definition: Type.h:308
llvm::ConstantExpr::getOpcode
unsigned getOpcode() const
Return the opcode at the root of this constant expression.
Definition: Constants.h:1295
llvm::PoisonValue::getSequentialElement
PoisonValue * getSequentialElement() const
If this poison has array or vector type, return a poison with the right element type.
Definition: Constants.cpp:1186
llvm::ConstantExpr::getSExt
static Constant * getSExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2136
uses
This might compile to this xmm1 xorps xmm0 movss xmm0 ret Now consider if the code caused xmm1 to get spilled This might produce this xmm1 movaps xmm0 movaps xmm1 movss xmm0 ret since the reload is only used by these we could fold it into the uses
Definition: README-SSE.txt:258
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1177
getImpl
static LazyValueInfoImpl & getImpl(void *&PImpl, AssumptionCache *AC, const Module *M)
This lazily constructs the LazyValueInfoImpl.
Definition: LazyValueInfo.cpp:1522
llvm::ConstantExpr::getICmp
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
Definition: Constants.cpp:2529
llvm::PoisonValue::getElementValue
PoisonValue * getElementValue(Constant *C) const
Return an poison of the right value for the specified GEP index if we can, otherwise return null (e....
Definition: Constants.cpp:1196
llvm::CmpInst::FCMP_ONE
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:729
llvm::Type::getFltSemantics
const fltSemantics & getFltSemantics() const
Definition: Type.cpp:69
llvm::ConstantDataSequential::getElementAsInteger
uint64_t getElementAsInteger(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element in the low ...
Definition: Constants.cpp:3217
llvm::getSplatValue
Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
Definition: VectorUtils.cpp:366
ErrorHandling.h
llvm::ConstantExpr::getPredicate
unsigned getPredicate() const
Return the ICMP or FCMP predicate value.
Definition: Constants.cpp:1511
llvm::Type::getPointerAddressSpace
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:734
ManagedStatic.h
llvm::CastInst::castIsValid
static bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy)
This method can be used to determine if a cast from SrcTy to DstTy using Opcode op is valid or not.
Definition: Instructions.cpp:3537
llvm::InsertValueInst::Create
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:2554
llvm::CastInst::Create
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 ...
Definition: Instructions.cpp:3152
llvm::PointerType::getAddressSpace
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:687
llvm::ConstantAggregate
Base class for aggregate constants (with operands).
Definition: Constants.h:385
llvm::CmpInst::ICMP_NE
@ ICMP_NE
not equal
Definition: InstrTypes.h:743
llvm::ConstantExpr::getBitCast
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2260
R600_InstFlag::FC
@ FC
Definition: R600Defines.h:32
llvm::ExtractValueInst::getIndexedType
static Type * getIndexedType(Type *Agg, ArrayRef< unsigned > Idxs)
Returns the type of the element that would be extracted with an extractvalue instruction with the spe...
Definition: Instructions.cpp:2574
llvm::LLVMContextImpl::ExprConstants
ConstantUniqueMap< ConstantExpr > ExprConstants
Definition: LLVMContextImpl.h:1430
llvm::BlockAddress::getBasicBlock
BasicBlock * getBasicBlock() const
Definition: Constants.h:877
memcmp
Merge contiguous icmps into a memcmp
Definition: MergeICmps.cpp:888
llvm::ConstantFP::getInfinity
static Constant * getInfinity(Type *Ty, bool Negative=false)
Definition: Constants.cpp:1087
llvm::ConstantExpr::getSelect
static Constant * getSelect(Constant *C, Constant *V1, Constant *V2, Type *OnlyIfReducedTy=nullptr)
Select constant expr.
Definition: Constants.cpp:2447
llvm::Type::getTypeID
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:135
llvm::ConstantExpr::getInsertValue
static Constant * getInsertValue(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2650
llvm::APFloatBase::x87DoubleExtended
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition: APFloat.cpp:179
llvm::Type::isFPOrFPVectorTy
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
Definition: Type.h:178
llvm::ConstantDataVector::get
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:3109
llvm::ConstantDataSequential::getElementAsFloat
float getElementAsFloat(unsigned i) const
If this is an sequential container of floats, return the specified element as a float.
Definition: Constants.cpp:3290
llvm::InsertElementInst::Create
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:1954
llvm::ConstantAggregateZero::getElementCount
ElementCount getElementCount() const
Return the number of elements in the array, vector, or struct.
Definition: Constants.cpp:1138
llvm::ConstantExpr::getOffsetOf
static Constant * getOffsetOf(StructType *STy, unsigned FieldNo)
getOffsetOf constant expr - computes the offset of a struct field in a target independent way (Note: ...
Definition: Constants.cpp:2407
llvm::CmpInst::ICMP_SGT
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:748
llvm::StringMap::end
iterator end()
Definition: StringMap.h:203
llvm::ExtractElementInst::Create
static ExtractElementInst * Create(Value *Vec, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:1889
llvm::GetElementPtrConstantExpr
GetElementPtrConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to ...
Definition: ConstantsContext.h:275
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::NoCFIValue
Wrapper for a value that won't be replaced with a CFI jump table pointer in LowerTypeTestsModule.
Definition: Constants.h:931
llvm::APInt::getBitWidth
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1412
Module.h
llvm::APFloatBase::BFloat
static const fltSemantics & BFloat() LLVM_READNONE
Definition: APFloat.cpp:167
llvm::Constant::isNotOneValue
bool isNotOneValue() const
Return true if the value is not the one value, or, for vectors, does not contain one value elements.
Definition: Constants.cpp:125
llvm::ConstantExpr::hasIndices
bool hasIndices() const
Return true if this is an insertvalue or extractvalue expression, and the getIndices() method may be ...
Definition: Constants.cpp:1498
llvm::ConstantDataSequential::isElementTypeCompatible
static bool isElementTypeCompatible(Type *Ty)
Return true if a ConstantDataSequential can be formed with a vector or array of the specified element...
Definition: Constants.cpp:2944
llvm::ConstantExpr::getFPToSI
static Constant * getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2221
llvm::ConstantAggregateZero
All zero aggregate value.
Definition: Constants.h:336
llvm::Constant::needsDynamicRelocation
bool needsDynamicRelocation() const
Definition: Constants.cpp:663
llvm::copy
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1700
llvm::Constant::needsRelocation
bool needsRelocation() const
This method classifies the entry according to whether or not it may generate a relocation entry (eith...
Definition: Constants.cpp:667
llvm::Instruction::setHasNoUnsignedWrap
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag.
Definition: Instruction.cpp:124
llvm::Optional< unsigned >
llvm::SmallPtrSet
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:449
Operator.h
llvm::VectorType::getElementType
Type * getElementType() const
Definition: DerivedTypes.h:422
llvm::ShuffleVectorInst::isValidOperands
static bool isValidOperands(const Value *V1, const Value *V2, const Value *Mask)
Return true if a shufflevector instruction can be formed with the specified operands.
Definition: Instructions.cpp:2051
llvm::CmpInst::ICMP_SLE
@ ICMP_SLE
signed less or equal
Definition: InstrTypes.h:751
llvm::ConstantExpr::getExactLogBase2
static Constant * getExactLogBase2(Constant *C)
If C is a scalar/fixed width vector of known powers of 2, then this function returns a new scalar/fix...
Definition: Constants.cpp:2810
llvm::APFloat::getSNaN
static APFloat getSNaN(const fltSemantics &Sem, bool Negative=false, const APInt *payload=nullptr)
Factory for SNaN values.
Definition: APFloat.h:924
STLExtras.h
llvm::SmallVectorImpl::pop_back_val
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:644
RHS
Value * RHS
Definition: X86PartialReduction.cpp:74
llvm::ArrayType
Class to represent array types.
Definition: DerivedTypes.h:357
llvm::StringMap::find
iterator find(StringRef Key)
Definition: StringMap.h:216
llvm::ConstantFP::getNegativeZero
static Constant * getNegativeZero(Type *Ty)
Definition: Constants.cpp:1053
llvm::gep_type_begin
gep_type_iterator gep_type_begin(const User *GEP)
Definition: GetElementPtrTypeIterator.h:123
llvm::Type::isFloatingPointTy
bool isFloatingPointTy() const
Return true if this is one of the six floating-point types.
Definition: Type.h:162
llvm::Constant::isOneValue
bool isOneValue() const
Returns true if the value is one.
Definition: Constants.cpp:108
llvm::Instruction::setIsExact
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag.
Definition: Instruction.cpp:132
llvm::CmpInst::FCMP_OGT
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:725
llvm::ConstantDataSequential::isString
bool isString(unsigned CharSize=8) const
This method returns true if this is an array of CharSize integers.
Definition: Constants.cpp:3310
llvm::BitmaskEnumDetail::Mask
std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
llvm::APFloat::getSemantics
const fltSemantics & getSemantics() const
Definition: APFloat.h:1223
llvm::LLVMContextImpl::DSOLocalEquivalents
DenseMap< const GlobalValue *, DSOLocalEquivalent * > DSOLocalEquivalents
Definition: LLVMContextImpl.h:1426
llvm::Type::getInt8Ty
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:239
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::APInt::getZero
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
Definition: APInt.h:177
llvm::Type::getInt32Ty
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:241
llvm::Constant::isThreadDependent
bool isThreadDependent() const
Return true if the value can vary between threads.
Definition: Constants.cpp:637
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:158
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:160
llvm::SelectInst::areInvalidOperands
static const char * areInvalidOperands(Value *Cond, Value *True, Value *False)
Return a string if the specified operands are invalid for a select operation, otherwise return null.
Definition: Instructions.cpp:75
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::ConstantFoldExtractValueInstruction
Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)
Attempt to constant fold an extractvalue instruction with the specified operands and indices.
Definition: ConstantFold.cpp:778
llvm::ConstantExpr::getWithOperands
Constant * getWithOperands(ArrayRef< Constant * > Ops) const
This returns the current constant expression with the operands replaced with the specified values.
Definition: Constants.h:1321
getFPSequenceIfElementsMatch
static Constant * getFPSequenceIfElementsMatch(ArrayRef< Constant * > V)
Definition: Constants.cpp:1234
llvm::ConstantExpr::getPointerCast
static Constant * getPointerCast(Constant *C, Type *Ty)
Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant expression.
Definition: Constants.cpp:2072
llvm::LLVMContextImpl::TheNoneToken
std::unique_ptr< ConstantTokenNone > TheNoneToken
Definition: LLVMContextImpl.h:1437
Context
ManagedStatic< detail::RecordContext > Context
Definition: Record.cpp:96
llvm::APFloatBase::IEEEquad
static const fltSemantics & IEEEquad() LLVM_READNONE
Definition: APFloat.cpp:176
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::lltok::equal
@ equal
Definition: LLToken.h:25
llvm::LLVMContextImpl::ArrayConstants
ArrayConstantsTy ArrayConstants
Definition: LLVMContextImpl.h:1407
llvm::gep_type_end
gep_type_iterator gep_type_end(const User *GEP)
Definition: GetElementPtrTypeIterator.h:130
isUndef
static bool isUndef(ArrayRef< int > Mask)
Definition: HexagonISelDAGToDAGHVX.cpp:909
llvm::CmpInst::FCMP_ULT
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:735
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::ConstantExpr::getSub
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2728
llvm::PossiblyExactOperator::IsExact
@ IsExact
Definition: Operator.h:128
llvm::ConstantDataSequential::getElementAsAPFloat
APFloat getElementAsAPFloat(unsigned i) const
If this is a sequential container of floating point type, return the specified element as an APFloat.
Definition: Constants.cpp:3265
llvm::ConstantData
Base class for constants with no operands.
Definition: Constants.h:51
llvm::ConstantPointerNull
A constant pointer value that points to null.
Definition: Constants.h:534
llvm::PatternMatch::m_APInt
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
Definition: PatternMatch.h:270
LHS
Value * LHS
Definition: X86PartialReduction.cpp:73
llvm::APFloat::getZero
static APFloat getZero(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Zero.
Definition: APFloat.h:885
llvm::PointerType::isOpaqueOrPointeeTypeMatches
bool isOpaqueOrPointeeTypeMatches(Type *Ty)
Return true if either this is an opaque pointer type or if this pointee type matches Ty.
Definition: DerivedTypes.h:693
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::Type::isArrayTy
bool isArrayTy() const
True if this is an instance of ArrayType.
Definition: Type.h:214
llvm::Intrinsic::getType
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:1355
llvm::all_of
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1649
llvm::SelectInst::Create
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=nullptr, Instruction *MDFrom=nullptr)
Definition: Instructions.h:1772
llvm::ConstantExpr::getShuffleMask
ArrayRef< int > getShuffleMask() const
Assert that this is a shufflevector and return the mask.
Definition: Constants.cpp:1515
GlobalValue.h
llvm::OperandTraits
Compile-time customization of User operands.
Definition: User.h:42
llvm::PPCISD::SC
@ SC
CHAIN = SC CHAIN, Imm128 - System call.
Definition: PPCISelLowering.h:418
llvm::Constant::containsConstantExpression
bool containsConstantExpression() const
Return true if this is a fixed width vector constant that includes any constant expressions.
Definition: Constants.cpp:338
llvm::CmpInst::isFPPredicate
bool isFPPredicate() const
Definition: InstrTypes.h:828
Constants.h
llvm::PatternMatch::match
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
isZero
static bool isZero(Value *V, const DataLayout &DL, DominatorTree *DT, AssumptionCache *AC)
Definition: Lint.cpp:519
llvm::Constant::isNullValue
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:74
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::SmallVectorImpl::append
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:657
llvm::APFloatBase::IEEEhalf
static const fltSemantics & IEEEhalf() LLVM_READNONE
Definition: APFloat.cpp:164
llvm::Instruction::setHasNoSignedWrap
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag.
Definition: Instruction.cpp:128
llvm::User
Definition: User.h:44
llvm::UndefValue::getElementValue
UndefValue * getElementValue(Constant *C) const
Return an undef of the right value for the specified GEP index if we can, otherwise return null (e....
Definition: Constants.cpp:1161
llvm::Type::getDoubleTy
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:229
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
ItTy
llvm::CmpInst::ICMP_ULE
@ ICMP_ULE
unsigned less or equal
Definition: InstrTypes.h:747
llvm::LLVMContextImpl
Definition: LLVMContextImpl.h:1333
llvm::ConstantExpr::getIntToPtr
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2246
llvm::LLVMContextImpl::CAZConstants
DenseMap< Type *, std::unique_ptr< ConstantAggregateZero > > CAZConstants
Definition: LLVMContextImpl.h:1404
llvm::UnaryConstantExpr
UnaryConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implemen...
Definition: ConstantsContext.h:46
llvm::VectorType::getInteger
static VectorType * getInteger(VectorType *VTy)
This static method gets a VectorType with the same number of elements as the input type,...
Definition: DerivedTypes.h:440
Y
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
llvm::ConstantExpr::getUDiv
static Constant * getUDiv(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2750
llvm::CmpInst::FCMP_UGE
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:734
llvm::ConstantExpr::getPtrToInt
static Constant * getPtrToInt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2232
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
llvm::Instruction::OtherOps
OtherOps
Definition: Instruction.h:817
llvm::APInt::getAllOnes
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
Definition: APInt.h:214
llvm::AMDGPU::PALMD::Key
Key
PAL metadata keys.
Definition: AMDGPUMetadata.h:481
llvm::Type::isVectorTy
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:226
llvm::VectorType::getElementCount
ElementCount getElementCount() const
Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...
Definition: DerivedTypes.h:627
llvm::ConstantExpr::getBinOpAbsorber
static Constant * getBinOpAbsorber(unsigned Opcode, Type *Ty)
Return the absorbing element for the given binary operation, i.e.
Definition: Constants.cpp:2885
llvm::Value::getValueID
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:532
llvm::isUIntN
bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
Definition: MathExtras.h:455
llvm::IntegerType
Class to represent integer types.
Definition: DerivedTypes.h:40
llvm::Instruction::getOpcodeName
const char * getOpcodeName() const
Definition: Instruction.h:162
llvm::Instruction::CastOps
CastOps
Definition: Instruction.h:803
llvm::ConstantArray
ConstantArray - Constant Array Declarations.
Definition: Constants.h:409
llvm::Constant::getAllOnesValue
static Constant * getAllOnesValue(Type *Ty)
Definition: Constants.cpp:405
llvm::CmpInst::FCMP_UNO
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:731
llvm::Instruction
Definition: Instruction.h:45
containsUndefinedElement
static bool containsUndefinedElement(const Constant *C, function_ref< bool(const Constant *)> HasFn)
Definition: Constants.cpp:307
llvm::ConstantDataVector::getSplatValue
Constant * getSplatValue() const
If this is a splat constant, meaning that all of the elements have the same value,...
Definition: Constants.cpp:3347
llvm::Type::getScalarSizeInBits
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
Definition: Type.cpp:191
LLVMContextImpl.h
llvm::APFloat::bitwiseIsEqual
bool bitwiseIsEqual(const APFloat &RHS) const
Definition: APFloat.h:1180
llvm::InsertValueConstantExpr
InsertValueConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to im...
Definition: ConstantsContext.h:245
llvm::ConstantFoldGetElementPtr
Constant * ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool InBounds, Optional< unsigned > InRangeIndex, ArrayRef< Value * > Idxs)
Definition: ConstantFold.cpp:2025
llvm::ConstantFP
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:257
llvm::ConstantVector::getSplat
static Constant * getSplat(ElementCount EC, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
Definition: Constants.cpp:1445
llvm::ConstantFP::isExactlyValue
bool isExactlyValue(const APFloat &V) const
We don't rely on operator== working on double values, as it returns true for things that are clearly ...
Definition: Constants.cpp:1103
llvm::ShuffleVectorConstantExpr
ShuffleVectorConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to ...
Definition: ConstantsContext.h:179
llvm::UndefValue::get
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1782
llvm::ConstantExpr::getXor
static Constant * getXor(Constant *C1, Constant *C2)
Definition: Constants.cpp:2784
llvm::ConstantExpr::getURem
static Constant * getURem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2764
llvm::ConstantInt::get
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:932
llvm::CmpInst::FCMP_OEQ
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:724
llvm::ConstantDataSequential::getImpl
static Constant * getImpl(StringRef Bytes, Type *Ty)
This is the underlying implementation of all of the ConstantDataSequential::get methods.
Definition: Constants.cpp:2990
llvm::CmpInst::FCMP_OLT
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:727
llvm::PoisonValue::getStructElement
PoisonValue * getStructElement(unsigned Elt) const
If this poison has struct type, return a poison with the right element type for the specified element...
Definition: Constants.cpp:1192
StringMap.h
llvm::Type::PointerTyID
@ PointerTyID
Pointers.
Definition: Type.h:73
PatternMatch.h
llvm::ConstantStruct::getType
StructType * getType() const
Specialization - reduce amount of casting.
Definition: Constants.h:480
llvm::ConstantAggregate::ConstantAggregate
ConstantAggregate(Type *T, ValueTy VT, ArrayRef< Constant * > V)
Definition: Constants.cpp:1273
llvm::FixedVectorType::get
static FixedVectorType * get(Type *ElementType, unsigned NumElts)
Definition: Type.cpp:686
getSequenceIfElementsMatch
static Constant * getSequenceIfElementsMatch(Constant *C, ArrayRef< Constant * > V)
Definition: Constants.cpp:1247
llvm::PointerType::isOpaque
bool isOpaque() const
Definition: DerivedTypes.h:678
llvm::Type::BFloatTyID
@ BFloatTyID
16-bit floating point type (7-bit significand)
Definition: Type.h:57
llvm::Constant::isMinSignedValue
bool isMinSignedValue() const
Return true if the value is the smallest signed value.
Definition: Constants.cpp:153
llvm::LLVMContextImpl::CDSConstants
StringMap< std::unique_ptr< ConstantDataSequential > > CDSConstants
Definition: LLVMContextImpl.h:1421
llvm::isIntN
bool isIntN(unsigned N, int64_t x)
Checks if an signed integer fits into the given (dynamic) bit width.
Definition: MathExtras.h:460
llvm::SelectConstantExpr
SelectConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to impleme...
Definition: ConstantsContext.h:97
llvm::ArrayRef::slice
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Definition: ArrayRef.h:193
llvm::UndefValue::getNumElements
unsigned getNumElements() const
Return the number of elements in the array, vector, or struct.
Definition: Constants.cpp:1173
llvm::ConstantFP::getSNaN
static Constant * getSNaN(Type *Ty, bool Negative=false, APInt *Payload=nullptr)
Definition: Constants.cpp:1042
llvm::None
const NoneType None
Definition: None.h:23
llvm::LinearPolySize< ElementCount >::getFixed
static ElementCount getFixed(ScalarTy MinVal)
Definition: TypeSize.h:283
llvm::Type::getIntegerBitWidth
unsigned getIntegerBitWidth() const
Definition: DerivedTypes.h:97
llvm::ConstantExpr::getFNeg
static Constant * getFNeg(Constant *C)
Definition: Constants.cpp:2705
llvm::ConstantExpr::isCompare
bool isCompare() const
Return true if this is a compare constant expression.
Definition: Constants.cpp:1494
llvm::ConstantExpr::getShuffleMaskForBitcode
Constant * getShuffleMaskForBitcode() const
Assert that this is a shufflevector and return the mask.
Definition: Constants.cpp:1519
llvm::ConstantFoldBinaryInstruction
Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
Definition: ConstantFold.cpp:875
llvm::ConstantFoldExtractElementInstruction
Constant * ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx)
Attempt to constant fold an extractelement instruction with the specified operands and indices.
Definition: ConstantFold.cpp:618
llvm::PatternMatch::m_One
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:513
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:108
llvm::Instruction::isCommutative
bool isCommutative() const LLVM_READONLY
Return true if the instruction is commutative:
Definition: Instruction.cpp:768
llvm::CmpInst::FCMP_FALSE
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:723
llvm::ConstantExpr::getAShr
static Constant * getAShr(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2805
llvm::Type::getStructNumElements
unsigned getStructNumElements() const
Definition: DerivedTypes.h:348
llvm::ConstantDataSequential::isCString
bool isCString() const
This method returns true if the array "isString", ends with a null byte, and does not contains any ot...
Definition: Constants.cpp:3314
llvm::ConstantFoldCastInstruction
Constant * ConstantFoldCastInstruction(unsigned opcode, Constant *V, Type *DestTy)
Definition: ConstantFold.cpp:352
llvm::Type::isIntegerTy
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:190
llvm::APFloat::getQNaN
static APFloat getQNaN(const fltSemantics &Sem, bool Negative=false, const APInt *payload=nullptr)
Factory for QNaN values.
Definition: APFloat.h:916
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:223
llvm::ConstantExpr::isCast
bool isCast() const
Return true if this is a convert constant expression.
Definition: Constants.cpp:1490
llvm::ISD::BlockAddress
@ BlockAddress
Definition: ISDOpcodes.h:84
llvm::ConstantExpr::getShuffleVector
static Constant * getShuffleVector(Constant *V1, Constant *V2, ArrayRef< int > Mask, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2624
llvm::ConstantArray::getType
ArrayType * getType() const
Specialize the getType() method to always return an ArrayType, which reduces the amount of casting ne...
Definition: Constants.h:428
llvm::VectorType
Base class of all SIMD vector types.
Definition: DerivedTypes.h:389
llvm::ConstantExpr::getTrunc
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2122
llvm::ConstantDataSequential::getRawDataValues
StringRef getRawDataValues() const
Return the raw, underlying, bytes of this data.
Definition: Constants.cpp:2940
llvm::APFloat
Definition: APFloat.h:701
llvm::ConstantVector::getType
FixedVectorType * getType() const
Specialize the getType() method to always return a FixedVectorType, which reduces the amount of casti...
Definition: Constants.h:516
llvm::Constant::isDLLImportDependent
bool isDLLImportDependent() const
Return true if the value is dependent on a dllimport variable.
Definition: Constants.cpp:644
llvm::ConstantExpr::getCompare
static Constant * getCompare(unsigned short pred, Constant *C1, Constant *C2, bool OnlyIfReduced=false)
Return an ICmp or FCmp comparison operator constant expression.
Definition: Constants.cpp:2425
llvm::Constant::hasZeroLiveUses
bool hasZeroLiveUses() const
Return true if the constant has no live uses.
Definition: Constants.cpp:784
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:206
llvm::ConstantFP::getQNaN
static Constant * getQNaN(Type *Ty, bool Negative=false, APInt *Payload=nullptr)
Definition: Constants.cpp:1031
llvm::PPC::Predicate
Predicate
Predicate - These are "(BI << 5) | BO" for various predicates.
Definition: PPCPredicates.h:26
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::ConstantFoldCompareInstruction
Constant * ConstantFoldCompareInstruction(CmpInst::Predicate Predicate, Constant *C1, Constant *C2)
Definition: ConstantFold.cpp:1575
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::Value::mutateType
void mutateType(Type *Ty)
Mutate the type of this Value to be of the specified type.
Definition: Value.h:801
llvm::PointerType::getUnqual
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Definition: DerivedTypes.h:651
llvm::LLVMContextImpl::CPNConstants
DenseMap< PointerType *, std::unique_ptr< ConstantPointerNull > > CPNConstants
Definition: LLVMContextImpl.h:1415
llvm::Constant::isElementWiseEqual
bool isElementWiseEqual(Value *Y) const
Return true if this constant and a constant 'Y' are element-wise equal.
Definition: Constants.cpp:282
getFoldedCast
static Constant * getFoldedCast(Instruction::CastOps opc, Constant *C, Type *Ty, bool OnlyIfReduced=false)
This is a utility function to handle folding of casts and lookup of the cast in the ExprConstants map...
Definition: Constants.cpp:1997
llvm::ConstantExpr::getBinOpIdentity
static Constant * getBinOpIdentity(unsigned Opcode, Type *Ty, bool AllowRHSConstant=false)
Return the identity constant for a binary opcode.
Definition: Constants.cpp:2839
Index
uint32_t Index
Definition: ELFObjHandler.cpp:83
llvm::Constant::replaceUndefsWith
static Constant * replaceUndefsWith(Constant *C, Constant *Replacement)
Try to replace undefined constant C or undefined elements in C with Replacement.
Definition: Constants.cpp:800
llvm::ConstantDataVector::getFP
static Constant * getFP(Type *ElementType, ArrayRef< uint16_t > Elts)
getFP() constructors - Return a constant of vector type with a float element type taken from argument...
Definition: Constants.cpp:3146
llvm::ExtractValueInst::Create
static ExtractValueInst * Create(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:2430
uint64_t
llvm::ConstantFoldInsertValueInstruction
Constant * ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs)
ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue instruction with the spe...
Definition: ConstantFold.cpp:790
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
llvm::ConstantExpr::getIndices
ArrayRef< unsigned > getIndices() const
Assert that this is an insertvalue or exactvalue expression and return the list of indices.
Definition: Constants.cpp:1503
llvm::LLVMContextImpl::TheFalseVal
ConstantInt * TheFalseVal
Definition: LLVMContextImpl.h:1435
llvm::ConstantExpr::getAddrSpaceCast
static Constant * getAddrSpaceCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2272
llvm::APInt::logBase2
unsigned logBase2() const
Definition: APInt.h:1648
llvm::ConstantPointerNull::get
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1768
llvm::ConstantDataArray
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
Definition: Constants.h:678
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
llvm::DSOLocalEquivalent::getGlobalValue
GlobalValue * getGlobalValue() const
Definition: Constants.h:913
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::ConstantDataVector::isSplat
bool isSplat() const
Returns true if this is a splat constant, meaning that all elements have the same value.
Definition: Constants.cpp:3339
llvm::GetElementPtrConstantExpr::getSourceElementType
Type * getSourceElementType() const
Definition: Constants.cpp:2923
llvm::ConstantExpr::get
static Constant * get(unsigned Opcode, Constant *C1, unsigned Flags=0, Type *OnlyIfReducedTy=nullptr)
get - Return a unary operator constant expression, folding if possible.
Definition: Constants.cpp:2294
llvm::ConstantExpr::getAlignOf
static Constant * getAlignOf(Type *Ty)
getAlignOf constant expr - computes the alignment of a type in a target independent way (Note: the re...
Definition: Constants.cpp:2394
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::ConstantDataVector
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
Definition: Constants.h:752
llvm::ExtractValueConstantExpr
ExtractValueConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to i...
Definition: ConstantsContext.h:215
llvm::UndefValue
'undef' values are things that do not have specified contents.
Definition: Constants.h:1377
llvm::GetElementPtrInst
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
Definition: Instructions.h:933
llvm::OverflowingBinaryOperator::NoUnsignedWrap
@ NoUnsignedWrap
Definition: Operator.h:75
llvm::ConstantExpr::getShl
static Constant * getShl(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2793
llvm::ConstantExpr::getFSub
static Constant * getFSub(Constant *C1, Constant *C2)
Definition: Constants.cpp:2735
llvm::ConstantExpr::getOr
static Constant * getOr(Constant *C1, Constant *C2)
Definition: Constants.cpp:2780
getIntSequenceIfElementsMatch
static Constant * getIntSequenceIfElementsMatch(ArrayRef< Constant * > V)
Definition: Constants.cpp:1221
llvm::PointerType
Class to represent pointers.
Definition: DerivedTypes.h:632
llvm::ConstantDataSequential::getElementType
Type * getElementType() const
Return the element type of the array/vector.
Definition: Constants.cpp:2934
llvm::ConstantUniqueMap::getOrCreate
ConstantClass * getOrCreate(TypeClass *Ty, ValType V)
Return the specified constant from the map, creating it if necessary.
Definition: ConstantsContext.h:720
llvm::Type::isHalfTy
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
Definition: Type.h:141
llvm::GetElementPtrInst::CreateInBounds
static GetElementPtrInst * CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Create an "inbounds" getelementptr.
Definition: Instructions.h:986
llvm::Constant::hasOneLiveUse
bool hasOneLiveUse() const
Return true if the constant has exactly one live use.
Definition: Constants.cpp:782
llvm::CompareConstantExpr
Definition: ConstantsContext.h:309
llvm::ConstantVector
Constant Vector Declarations.
Definition: Constants.h:493
llvm::APFloatBase::PPCDoubleDouble
static const fltSemantics & PPCDoubleDouble() LLVM_READNONE
Definition: APFloat.cpp:185
llvm::ConstantFoldInsertElementInstruction
Constant * ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt, Constant *Idx)
Attempt to constant fold an insertelement instruction with the specified operands and indices.
Definition: ConstantFold.cpp:682
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::ConstantDataSequential::getElementAsConstant
Constant * getElementAsConstant(unsigned i) const
Return a Constant for a specified index's element.
Definition: Constants.cpp:3302
llvm::Constant::isNegativeZeroValue
bool isNegativeZeroValue() const
Return true if the value is what would be returned by getZeroValueForNegation.
Definition: Constants.cpp:40
llvm::Constant::isManifestConstant
bool isManifestConstant() const
Return true if a constant is ConstantData or a ConstantAggregate or ConstantExpr that contain only Co...
Definition: Constants.cpp:859
llvm::CmpInst::FCMP_OGE
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:726
llvm::ConstantExpr::getCast
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:2015
llvm::LLVMContextImpl::TheTrueVal
ConstantInt * TheTrueVal
Definition: LLVMContextImpl.h:1434
llvm::CmpInst::ICMP_UGE
@ ICMP_UGE
unsigned greater or equal
Definition: InstrTypes.h:745
llvm::ConstantFP::getZeroValueForNegation
static Constant * getZeroValueForNegation(Type *Ty)
Floating point negation must be implemented with f(x) = -0.0 - x.
Definition: Constants.cpp:1065
llvm::ConstantAggregateZero::getElementValue
Constant * getElementValue(Constant *C) const
Return a zero of the right value for the specified GEP index if we can, otherwise return null (e....
Definition: Constants.cpp:1126
llvm::Instruction::isBinaryOp
bool isBinaryOp() const
Definition: Instruction.h:165
llvm::ConstantVector::getSplatValue
Constant * getSplatValue(bool AllowUndefs=false) const
If all elements of the vector constant have the same value, return that value.
Definition: Constants.cpp:1729
llvm::ArrayType::get
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
Definition: Type.cpp:640
llvm::ConstantFP::getNaN
static Constant * getNaN(Type *Ty, bool Negative=false, uint64_t Payload=0)
Definition: Constants.cpp:1020
llvm::Constant::handleOperandChange
void handleOperandChange(Value *, Value *)
This method is a special form of User::replaceUsesOfWith (which does not work on constants) that does...
Definition: Constants.cpp:3366
llvm::ConstantExpr::getTruncOrBitCast
static Constant * getTruncOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:2066
llvm::ConstantStruct
Definition: Constants.h:441
llvm::ConstantExpr::getSizeOf
static Constant * getSizeOf(Type *Ty)
getSizeOf constant expr - computes the (alloc) size of a type (in address-units, not bits) in a targe...
Definition: Constants.cpp:2384
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::User::setOperand
void setOperand(unsigned i, Value *Val)
Definition: User.h:174
llvm::CmpInst::ICMP_SLT
@ ICMP_SLT
signed less than
Definition: InstrTypes.h:750
llvm::CmpInst::isIntPredicate
bool isIntPredicate() const
Definition: InstrTypes.h:829
llvm::Type::FP128TyID
@ FP128TyID
128-bit floating point type (112-bit significand)
Definition: Type.h:61
llvm::size
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1630
llvm::LLVMContextImpl::IntConstants
IntMapTy IntConstants
Definition: LLVMContextImpl.h:1375
llvm::GetElementPtrInst::Create
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:959
llvm::Value::ValueTy
ValueTy
Concrete subclass of this.
Definition: Value.h:513
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:848
llvm::OverflowingBinaryOperator::NoSignedWrap
@ NoSignedWrap
Definition: Operator.h:76
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
IT
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::ZeroOrMore, cl::values(clEnumValN(DefaultIT, "arm-default-it", "Generate IT block based on arch"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow deprecated IT based on ARMv8"), clEnumValN(NoRestrictedIT, "arm-no-restrict-it", "Allow IT blocks based on ARMv7")))
llvm::Constant::removeDeadConstantUsers
void removeDeadConstantUsers() const
If there are any dead constant users dangling off of this constant, remove them.
Definition: Constants.cpp:755
llvm::BinaryOperator
Definition: InstrTypes.h:190
Mul
BinaryOperator * Mul
Definition: X86PartialReduction.cpp:68
llvm::StructType
Class to represent struct types.
Definition: DerivedTypes.h:213
llvm::APFloatBase::IEEEdouble
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:173
llvm::Type::PPC_FP128TyID
@ PPC_FP128TyID
128-bit floating point type (two 64-bits, PowerPC)
Definition: Type.h:62
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
this
Analysis the ScalarEvolution expression for r is this
Definition: README.txt:8
llvm::User::getOperandList
const Use * getOperandList() const
Definition: User.h:162
llvm::PatternMatch::m_Undef
auto m_Undef()
Match an arbitrary undef constant.
Definition: PatternMatch.h:136
llvm::ConstantExpr::getSExtOrBitCast
static Constant * getSExtOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:2060
llvm::ConstantExpr::getUMin
static Constant * getUMin(Constant *C1, Constant *C2)
Definition: Constants.cpp:2788
llvm::CmpInst::ICMP_ULT
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:746
llvm::ConstantDataSequential::getElementAsAPInt
APInt getElementAsAPInt(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element as an APInt...
Definition: Constants.cpp:3237
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
llvm::Constant::getAggregateElement
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:420
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
llvm::ConstantDataArray::get
static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)
get() constructor - Return a constant with array type with an element count and element type matching...
Definition: Constants.h:691
llvm::Value::replaceAllUsesWith
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:532
uint32_t
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:991
llvm::LLVMContextImpl::StructConstants
StructConstantsTy StructConstants
Definition: LLVMContextImpl.h:1410
llvm::ConstantExpr::getInsertElement
static Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2601
llvm::ConstantDataArray::getString
static Constant * getString(LLVMContext &Context, StringRef Initializer, bool AddNull=true)
This method constructs a CDS and initializes it with a text string.
Definition: Constants.cpp:3093
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::LLVMContextImpl::PVConstants
DenseMap< Type *, std::unique_ptr< PoisonValue > > PVConstants
Definition: LLVMContextImpl.h:1419
llvm::ConstantExpr::getIntegerCast
static Constant * getIntegerCast(Constant *C, Type *Ty, bool IsSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
Definition: Constants.cpp:2098
llvm::ConstantExprKeyType
Definition: ConstantsContext.h:504
llvm::ConstantVector::get
static Constant * get(ArrayRef< Constant * > V)
Definition: Constants.cpp:1402
llvm::Type::isPtrOrPtrVectorTy
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
Definition: Type.h:223
llvm::ConstantExpr::getFMul
static Constant * getFMul(Constant *C1, Constant *C2)
Definition: Constants.cpp:2746
llvm::ifs::IFSSymbolType::Func
@ Func
llvm::Type::getContext
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:127
llvm::ArrayRef::front
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:166
users
iv users
Definition: IVUsers.cpp:52
llvm::Value::stripPointerCasts
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:685
llvm::ConstantInt::getFalse
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:887
llvm::ConstantExpr::getFCmp
static Constant * getFCmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
Definition: Constants.cpp:2554
ConstantFold.h
llvm::Type::IntegerTyID
@ IntegerTyID
Arbitrary bit width integers.
Definition: Type.h:71
llvm::ConstantDataArray::getFP
static Constant * getFP(Type *ElementType, ArrayRef< uint16_t > Elts)
getFP() constructors - Return a constant of array type with a float element type taken from argument ...
Definition: Constants.cpp:3072
llvm::ConstantAggregateZero::getStructElement
Constant * getStructElement(unsigned Elt) const
If this CAZ has struct type, return a zero with the right element type for the specified element.
Definition: Constants.cpp:1122
llvm::MCID::Select
@ Select
Definition: MCInstrDesc.h:162
llvm::NoCFIValue::get
static NoCFIValue * get(GlobalValue *GV)
Return a NoCFIValue for the specified function.
Definition: Constants.cpp:1951
llvm::CmpInst::FCMP_UGT
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:733
llvm::BlockAddress::getFunction
Function * getFunction() const
Definition: Constants.h:876
canTrapImpl
static bool canTrapImpl(const Constant *C, SmallPtrSetImpl< const ConstantExpr * > &NonTrappingOps)
Definition: Constants.cpp:576
llvm::NVPTX::PTXLdStInstCode::V2
@ V2
Definition: NVPTX.h:123
llvm::UndefValue::getSequentialElement
UndefValue * getSequentialElement() const
If this Undef has array or vector type, return a undef with the right element type.
Definition: Constants.cpp:1151
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:242
llvm::ConstantExpr
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:971
constantIsDead
static bool constantIsDead(const Constant *C, bool RemoveDeadUsers)
Return true if the specified constantexpr is dead.
Definition: Constants.cpp:723
llvm::ConstantExpr::getSDiv
static Constant * getSDiv(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2755
llvm::ConstantInt::getTrue
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:880
llvm::Constant::getNullValue
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:348
llvm::PointerType::hasSameElementTypeAs
bool hasSameElementTypeAs(PointerType *Other)
Return true if both pointer types have the same element type.
Definition: DerivedTypes.h:701
llvm::Type::isFloatTy
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:147
uint16_t
llvm::ConstantExpr::getNeg
static Constant * getNeg(Constant *C, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2698
get
Should compile to something r4 addze r3 instead we get
Definition: README.txt:24
NC
#define NC
Definition: regutils.h:42
llvm::ConstantDataSequential::getElementAsDouble
double getElementAsDouble(unsigned i) const
If this is an sequential container of doubles, return the specified element as a double.
Definition: Constants.cpp:3296
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:325
llvm::ArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:151
llvm::ConstantInt::getBool
static ConstantInt * getBool(LLVMContext &Context, bool V)
Definition: Constants.cpp:894
llvm::Type::FixedVectorTyID
@ FixedVectorTyID
Fixed width SIMD vector type.
Definition: Type.h:76
llvm::Constant::isZeroValue
bool isZeroValue() const
Return true if the value is negative zero or null value.
Definition: Constants.cpp:60
llvm::ConstantExpr::getAdd
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2717
llvm::Type::isIntOrIntVectorTy
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:196
llvm::ConstantFP::get
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
Definition: Constants.cpp:979
llvm::ConstantTokenNone::get
static ConstantTokenNone * get(LLVMContext &Context)
Return the ConstantTokenNone.
Definition: Constants.cpp:1475
llvm::ConstantInt::getSigned
static ConstantInt * getSigned(IntegerType *Ty, int64_t V)
Return a ConstantInt with the specified value for the specified type.
Definition: Constants.cpp:946
llvm::fltSemantics
Definition: APFloat.cpp:54
getTypeID
static char getTypeID(Type *Ty)
Definition: ExternalFunctions.cpp:73
llvm::ConstantExpr::getAnd
static Constant * getAnd(Constant *C1, Constant *C2)
Definition: Constants.cpp:2776
llvm::ConstantFoldShuffleVectorInstruction
Constant * ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, ArrayRef< int > Mask)
Attempt to constant fold a shufflevector instruction with the specified operands and mask.
Definition: ConstantFold.cpp:719
llvm::UndefValue::getStructElement
UndefValue * getStructElement(unsigned Elt) const
If this undef has struct type, return a undef with the right element type for the specified element.
Definition: Constants.cpp:1157
llvm::Type::getPointerTo
PointerType * getPointerTo(unsigned AddrSpace=0) const
Return a pointer to the current type.
Definition: Type.cpp:776
llvm::Type::TokenTyID
@ TokenTyID
Tokens.
Definition: Type.h:68
llvm::Type::isDoubleTy
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:150
ConstHasGlobalValuePredicate
static bool ConstHasGlobalValuePredicate(const Constant *C, bool(*Predicate)(const GlobalValue *))
Check if C contains a GlobalValue for which Predicate is true.
Definition: Constants.cpp:614
llvm::ConstantArray::get
static Constant * get(ArrayType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:1295
llvm::ConstantExpr::getGetElementPtr
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, bool InBounds=false, Optional< unsigned > InRangeIndex=None, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
Definition: Constants.h:1238
llvm::GetElementPtrInst::getIndexedType
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the result type of a getelementptr with the given source element type and indexes.
Definition: Instructions.cpp:1768
llvm::ConstantExpr::getLShr
static Constant * getLShr(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2800
llvm::ConstantUniqueMap::remove
void remove(ConstantClass *CP)
Remove this constant from the map.
Definition: ConstantsContext.h:738
llvm::ConstantExpr::getFPTrunc
static Constant * getFPTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2164
llvm::CmpInst::ICMP_SGE
@ ICMP_SGE
signed greater or equal
Definition: InstrTypes.h:749
llvm::ConstantExpr::getFPToUI
static Constant * getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2210
llvm::MCID::Add
@ Add
Definition: MCInstrDesc.h:183
llvm::CmpInst::Create
static CmpInst * Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, const Twine &Name="", Instruction *InsertBefore=nullptr)
Construct a compare instruction, given the opcode, the predicate and the two operands.
Definition: Instructions.cpp:3823
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:474
llvm::Constant::mergeUndefsWith
static Constant * mergeUndefsWith(Constant *C, Constant *Other)
Merges undefs of a Constant with another Constant, along with the undefs already present.
Definition: Constants.cpp:824
llvm::APFloat::getAllOnesValue
static APFloat getAllOnesValue(const fltSemantics &Semantics)
Returns a float which is bitcasted from an all one value int.
Definition: APFloat.cpp:4861
Predicate
llvm::Instruction::BinaryOps
BinaryOps
Definition: Instruction.h:789
llvm::Type::StructTyID
@ StructTyID
Structures.
Definition: Type.h:74
llvm::GetElementPtrConstantExpr::getResultElementType
Type * getResultElementType() const
Definition: Constants.cpp:2927
llvm::ShuffleVectorInst
This instruction constructs a fixed permutation of two input vectors.
Definition: Instructions.h:2012
llvm::APFloatBase::rmNearestTiesToEven
static constexpr roundingMode rmNearestTiesToEven
Definition: APFloat.h:190
llvm::UnaryOperator::Create
static UnaryOperator * Create(UnaryOps Op, Value *S, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a unary instruction, given the opcode and an operand.
Definition: Instructions.cpp:2621
Instructions.h
llvm::APFloat::convert
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition: APFloat.cpp:4836
llvm::Constant::getIntegerValue
static Constant * getIntegerValue(Type *Ty, const APInt &V)
Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value...
Definition: Constants.cpp:388
llvm::Constant::hasExactInverseFP
bool hasExactInverseFP() const
Return true if this scalar has an exact multiplicative inverse or this vector has an exact multiplica...
Definition: Constants.cpp:240
llvm::User::getNumOperands
unsigned getNumOperands() const
Definition: User.h:191
llvm::Type::isStructTy
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:211
llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast
static Constant * getPointerBitCastOrAddrSpaceCast(Constant *C, Type *Ty)
Create a BitCast or AddrSpaceCast for a pointer type depending on the address space.
Definition: Constants.cpp:2087
llvm::ConstantExpr::getSRem
static Constant * getSRem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2768
llvm::InsertElementConstantExpr
InsertElementConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to ...
Definition: ConstantsContext.h:151
SmallVector.h
llvm::Type::isBFloatTy
bool isBFloatTy() const
Return true if this is 'bfloat', a 16-bit bfloat type.
Definition: Type.h:144
llvm::Constant::getUniqueInteger
const APInt & getUniqueInteger() const
If C is a constant integer then return its value, otherwise C must be a vector of constant integers,...
Definition: Constants.cpp:1756
llvm::ConstantExpr::getFPExtend
static Constant * getFPExtend(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2176
llvm::Value::stripInBoundsConstantOffsets
const Value * stripInBoundsConstantOffsets() const
Strip off pointer casts and all-constant inbounds GEPs.
Definition: Value.cpp:697
llvm::CmpInst::ICMP_UGT
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:744
llvm::User::op_begin
op_iterator op_begin()
Definition: User.h:234
llvm::PointerType::getWithSamePointeeType
static PointerType * getWithSamePointeeType(PointerType *PT, unsigned AddressSpace)
This constructs a pointer type with the same pointee type as input PointerType (or opaque pointer is ...
Definition: DerivedTypes.h:666
llvm::CmpInst::FCMP_UNE
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:737
llvm::Constant::containsUndefOrPoisonElement
bool containsUndefOrPoisonElement() const
Return true if this is a vector constant that includes any undef or poison elements.
Definition: Constants.cpp:328
llvm::ConstantDataVector::getSplat
static Constant * getSplat(unsigned NumElts, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
Definition: Constants.cpp:3170
N
#define N
llvm::BinaryConstantExpr
BinaryConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to impleme...
Definition: ConstantsContext.h:70
llvm::Constant::canTrap
bool canTrap() const
Return true if evaluation of this constant could trap.
Definition: Constants.cpp:607
llvm::BlockAddress::get
static BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
Definition: Constants.cpp:1820
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
llvm::IntegerType::getBitWidth
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:72
llvm::ConstantInt::isValueValidForType
static bool isValueValidForType(Type *Ty, uint64_t V)
This static method returns true if the type Ty is big enough to represent the value V.
Definition: Constants.cpp:1586
llvm::ConstantExpr::getMul
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2739
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::Instruction::isUnaryOp
bool isUnaryOp() const
Definition: Instruction.h:164
llvm::APFloat::getNaN
static APFloat getNaN(const fltSemantics &Sem, bool Negative=false, uint64_t payload=0)
Factory for NaN values.
Definition: APFloat.h:905
llvm::Constant::getSplatValue
Constant * getSplatValue(bool AllowUndefs=false) const
If all elements of the vector constant have the same value, return that value.
Definition: Constants.cpp:1697
llvm::StringRef::data
const LLVM_NODISCARD char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:148
llvm::CmpInst::FCMP_OLE
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:728
llvm::LLVMContextImpl::VectorConstants
VectorConstantsTy VectorConstants
Definition: LLVMContextImpl.h:1413
llvm::ConstantStruct::getTypeForElements
static StructType * getTypeForElements(ArrayRef< Constant * > V, bool Packed=false)
Return an anonymous struct type to use for a constant with the specified set of elements.
Definition: Constants.cpp:1346
llvm::NoCFIValue::getGlobalValue
GlobalValue * getGlobalValue() const
Definition: Constants.h:948
llvm::Type::getInt16Ty
static IntegerType * getInt16Ty(LLVMContext &C)
Definition: Type.cpp:240
llvm::Type::ScalableVectorTyID
@ ScalableVectorTyID
Scalable SIMD vector type.
Definition: Type.h:77
llvm::GlobalValue::getType
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:271
DerivedTypes.h
llvm::SmallPtrSetImpl
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:343
pred
hexagon gen pred
Definition: HexagonGenPredicate.cpp:134
llvm::Constant::isNotMinSignedValue
bool isNotMinSignedValue() const
Return true if the value is not the smallest signed value, or, for vectors, does not contain smallest...
Definition: Constants.cpp:170
llvm::IntegerType::get
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:313
llvm::APFloat::getInf
static APFloat getInf(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Infinity.
Definition: APFloat.h:894
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
GEP
Hexagon Common GEP
Definition: HexagonCommonGEP.cpp:172
llvm::User::Op
Use & Op()
Definition: User.h:133
llvm::BlockAddress::lookup
static BlockAddress * lookup(const BasicBlock *BB)
Lookup an existing BlockAddress constant for the given BasicBlock.
Definition: Constants.cpp:1838
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::ConstantPointerNull::getType
PointerType * getType() const
Specialize the getType() method to always return an PointerType, which reduces the amount of casting ...
Definition: Constants.h:550
llvm::Constant::isConstantUsed
bool isConstantUsed() const
Return true if the constant has users other than constant expressions and other dangling things.
Definition: Constants.cpp:651
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::ConstantDataSequential::getAsString
StringRef getAsString() const
If this array is isString(), then this method returns the array as a StringRef.
Definition: Constants.h:644
raw_ostream.h
llvm::ConstantFoldUnaryInstruction
Constant * ConstantFoldUnaryInstruction(unsigned Opcode, Constant *V)