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::UndefValueVal:
539  delete static_cast<UndefValue *>(C);
540  break;
541  case Constant::PoisonValueVal:
542  delete static_cast<PoisonValue *>(C);
543  break;
544  case Constant::ConstantExprVal:
545  if (isa<UnaryConstantExpr>(C))
546  delete static_cast<UnaryConstantExpr *>(C);
547  else if (isa<BinaryConstantExpr>(C))
548  delete static_cast<BinaryConstantExpr *>(C);
549  else if (isa<SelectConstantExpr>(C))
550  delete static_cast<SelectConstantExpr *>(C);
551  else if (isa<ExtractElementConstantExpr>(C))
552  delete static_cast<ExtractElementConstantExpr *>(C);
553  else if (isa<InsertElementConstantExpr>(C))
554  delete static_cast<InsertElementConstantExpr *>(C);
555  else if (isa<ShuffleVectorConstantExpr>(C))
556  delete static_cast<ShuffleVectorConstantExpr *>(C);
557  else if (isa<ExtractValueConstantExpr>(C))
558  delete static_cast<ExtractValueConstantExpr *>(C);
559  else if (isa<InsertValueConstantExpr>(C))
560  delete static_cast<InsertValueConstantExpr *>(C);
561  else if (isa<GetElementPtrConstantExpr>(C))
562  delete static_cast<GetElementPtrConstantExpr *>(C);
563  else if (isa<CompareConstantExpr>(C))
564  delete static_cast<CompareConstantExpr *>(C);
565  else
566  llvm_unreachable("Unexpected constant expr");
567  break;
568  default:
569  llvm_unreachable("Unexpected constant");
570  }
571 }
572 
573 static bool canTrapImpl(const Constant *C,
574  SmallPtrSetImpl<const ConstantExpr *> &NonTrappingOps) {
575  assert(C->getType()->isFirstClassType() && "Cannot evaluate aggregate vals!");
576  // The only thing that could possibly trap are constant exprs.
577  const ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
578  if (!CE)
579  return false;
580 
581  // ConstantExpr traps if any operands can trap.
582  for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
583  if (ConstantExpr *Op = dyn_cast<ConstantExpr>(CE->getOperand(i))) {
584  if (NonTrappingOps.insert(Op).second && canTrapImpl(Op, NonTrappingOps))
585  return true;
586  }
587  }
588 
589  // Otherwise, only specific operations can trap.
590  switch (CE->getOpcode()) {
591  default:
592  return false;
593  case Instruction::UDiv:
594  case Instruction::SDiv:
595  case Instruction::URem:
596  case Instruction::SRem:
597  // Div and rem can trap if the RHS is not known to be non-zero.
598  if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue())
599  return true;
600  return false;
601  }
602 }
603 
604 bool Constant::canTrap() const {
606  return canTrapImpl(this, NonTrappingOps);
607 }
608 
609 /// Check if C contains a GlobalValue for which Predicate is true.
610 static bool
612  bool (*Predicate)(const GlobalValue *)) {
615  WorkList.push_back(C);
616  Visited.insert(C);
617 
618  while (!WorkList.empty()) {
619  const Constant *WorkItem = WorkList.pop_back_val();
620  if (const auto *GV = dyn_cast<GlobalValue>(WorkItem))
621  if (Predicate(GV))
622  return true;
623  for (const Value *Op : WorkItem->operands()) {
624  const Constant *ConstOp = dyn_cast<Constant>(Op);
625  if (!ConstOp)
626  continue;
627  if (Visited.insert(ConstOp).second)
628  WorkList.push_back(ConstOp);
629  }
630  }
631  return false;
632 }
633 
635  auto DLLImportPredicate = [](const GlobalValue *GV) {
636  return GV->isThreadLocal();
637  };
638  return ConstHasGlobalValuePredicate(this, DLLImportPredicate);
639 }
640 
642  auto DLLImportPredicate = [](const GlobalValue *GV) {
643  return GV->hasDLLImportStorageClass();
644  };
645  return ConstHasGlobalValuePredicate(this, DLLImportPredicate);
646 }
647 
649  for (const User *U : users()) {
650  const Constant *UC = dyn_cast<Constant>(U);
651  if (!UC || isa<GlobalValue>(UC))
652  return true;
653 
654  if (UC->isConstantUsed())
655  return true;
656  }
657  return false;
658 }
659 
661  return getRelocationInfo() == GlobalRelocation;
662 }
663 
665  return getRelocationInfo() != NoRelocation;
666 }
667 
668 Constant::PossibleRelocationsTy Constant::getRelocationInfo() const {
669  if (isa<GlobalValue>(this))
670  return GlobalRelocation; // Global reference.
671 
672  if (const BlockAddress *BA = dyn_cast<BlockAddress>(this))
673  return BA->getFunction()->getRelocationInfo();
674 
675  if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) {
676  if (CE->getOpcode() == Instruction::Sub) {
677  ConstantExpr *LHS = dyn_cast<ConstantExpr>(CE->getOperand(0));
678  ConstantExpr *RHS = dyn_cast<ConstantExpr>(CE->getOperand(1));
679  if (LHS && RHS && LHS->getOpcode() == Instruction::PtrToInt &&
680  RHS->getOpcode() == Instruction::PtrToInt) {
681  Constant *LHSOp0 = LHS->getOperand(0);
682  Constant *RHSOp0 = RHS->getOperand(0);
683 
684  // While raw uses of blockaddress need to be relocated, differences
685  // between two of them don't when they are for labels in the same
686  // function. This is a common idiom when creating a table for the
687  // indirect goto extension, so we handle it efficiently here.
688  if (isa<BlockAddress>(LHSOp0) && isa<BlockAddress>(RHSOp0) &&
689  cast<BlockAddress>(LHSOp0)->getFunction() ==
690  cast<BlockAddress>(RHSOp0)->getFunction())
691  return NoRelocation;
692 
693  // Relative pointers do not need to be dynamically relocated.
694  if (auto *RHSGV =
695  dyn_cast<GlobalValue>(RHSOp0->stripInBoundsConstantOffsets())) {
696  auto *LHS = LHSOp0->stripInBoundsConstantOffsets();
697  if (auto *LHSGV = dyn_cast<GlobalValue>(LHS)) {
698  if (LHSGV->isDSOLocal() && RHSGV->isDSOLocal())
699  return LocalRelocation;
700  } else if (isa<DSOLocalEquivalent>(LHS)) {
701  if (RHSGV->isDSOLocal())
702  return LocalRelocation;
703  }
704  }
705  }
706  }
707  }
708 
709  PossibleRelocationsTy Result = NoRelocation;
710  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
711  Result =
712  std::max(cast<Constant>(getOperand(i))->getRelocationInfo(), Result);
713 
714  return Result;
715 }
716 
717 /// Return true if the specified constantexpr is dead. This involves
718 /// recursively traversing users of the constantexpr.
719 /// If RemoveDeadUsers is true, also remove dead users at the same time.
720 static bool constantIsDead(const Constant *C, bool RemoveDeadUsers) {
721  if (isa<GlobalValue>(C)) return false; // Cannot remove this
722 
723  Value::const_user_iterator I = C->user_begin(), E = C->user_end();
724  while (I != E) {
725  const Constant *User = dyn_cast<Constant>(*I);
726  if (!User) return false; // Non-constant usage;
727  if (!constantIsDead(User, RemoveDeadUsers))
728  return false; // Constant wasn't dead
729 
730  // Just removed User, so the iterator was invalidated.
731  // Since we return immediately upon finding a live user, we can always
732  // restart from user_begin().
733  if (RemoveDeadUsers)
734  I = C->user_begin();
735  else
736  ++I;
737  }
738 
739  if (RemoveDeadUsers) {
740  // If C is only used by metadata, it should not be preserved but should
741  // have its uses replaced.
742  if (C->isUsedByMetadata()) {
743  const_cast<Constant *>(C)->replaceAllUsesWith(
744  UndefValue::get(C->getType()));
745  }
746  const_cast<Constant *>(C)->destroyConstant();
747  }
748 
749  return true;
750 }
751 
753  Value::const_user_iterator I = user_begin(), E = user_end();
754  Value::const_user_iterator LastNonDeadUser = E;
755  while (I != E) {
756  const Constant *User = dyn_cast<Constant>(*I);
757  if (!User) {
758  LastNonDeadUser = I;
759  ++I;
760  continue;
761  }
762 
763  if (!constantIsDead(User, /* RemoveDeadUsers= */ true)) {
764  // If the constant wasn't dead, remember that this was the last live use
765  // and move on to the next constant.
766  LastNonDeadUser = I;
767  ++I;
768  continue;
769  }
770 
771  // If the constant was dead, then the iterator is invalidated.
772  if (LastNonDeadUser == E)
773  I = user_begin();
774  else
775  I = std::next(LastNonDeadUser);
776  }
777 }
778 
780  unsigned NumUses = 0;
781  for (const Use &use : uses()) {
782  const Constant *User = dyn_cast<Constant>(use.getUser());
783  if (!User || !constantIsDead(User, /* RemoveDeadUsers= */ false)) {
784  ++NumUses;
785 
786  if (NumUses > 1)
787  return false;
788  }
789  }
790  return NumUses == 1;
791 }
792 
794  assert(C && Replacement && "Expected non-nullptr constant arguments");
795  Type *Ty = C->getType();
796  if (match(C, m_Undef())) {
797  assert(Ty == Replacement->getType() && "Expected matching types");
798  return Replacement;
799  }
800 
801  // Don't know how to deal with this constant.
802  auto *VTy = dyn_cast<FixedVectorType>(Ty);
803  if (!VTy)
804  return C;
805 
806  unsigned NumElts = VTy->getNumElements();
807  SmallVector<Constant *, 32> NewC(NumElts);
808  for (unsigned i = 0; i != NumElts; ++i) {
809  Constant *EltC = C->getAggregateElement(i);
810  assert((!EltC || EltC->getType() == Replacement->getType()) &&
811  "Expected matching types");
812  NewC[i] = EltC && match(EltC, m_Undef()) ? Replacement : EltC;
813  }
814  return ConstantVector::get(NewC);
815 }
816 
818  assert(C && Other && "Expected non-nullptr constant arguments");
819  if (match(C, m_Undef()))
820  return C;
821 
822  Type *Ty = C->getType();
823  if (match(Other, m_Undef()))
824  return UndefValue::get(Ty);
825 
826  auto *VTy = dyn_cast<FixedVectorType>(Ty);
827  if (!VTy)
828  return C;
829 
830  Type *EltTy = VTy->getElementType();
831  unsigned NumElts = VTy->getNumElements();
832  assert(isa<FixedVectorType>(Other->getType()) &&
833  cast<FixedVectorType>(Other->getType())->getNumElements() == NumElts &&
834  "Type mismatch");
835 
836  bool FoundExtraUndef = false;
837  SmallVector<Constant *, 32> NewC(NumElts);
838  for (unsigned I = 0; I != NumElts; ++I) {
839  NewC[I] = C->getAggregateElement(I);
840  Constant *OtherEltC = Other->getAggregateElement(I);
841  assert(NewC[I] && OtherEltC && "Unknown vector element");
842  if (!match(NewC[I], m_Undef()) && match(OtherEltC, m_Undef())) {
843  NewC[I] = UndefValue::get(EltTy);
844  FoundExtraUndef = true;
845  }
846  }
847  if (FoundExtraUndef)
848  return ConstantVector::get(NewC);
849  return C;
850 }
851 
853  if (isa<ConstantData>(this))
854  return true;
855  if (isa<ConstantAggregate>(this) || isa<ConstantExpr>(this)) {
856  for (const Value *Op : operand_values())
857  if (!cast<Constant>(Op)->isManifestConstant())
858  return false;
859  return true;
860  }
861  return false;
862 }
863 
864 //===----------------------------------------------------------------------===//
865 // ConstantInt
866 //===----------------------------------------------------------------------===//
867 
868 ConstantInt::ConstantInt(IntegerType *Ty, const APInt &V)
869  : ConstantData(Ty, ConstantIntVal), Val(V) {
870  assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type");
871 }
872 
874  LLVMContextImpl *pImpl = Context.pImpl;
875  if (!pImpl->TheTrueVal)
877  return pImpl->TheTrueVal;
878 }
879 
881  LLVMContextImpl *pImpl = Context.pImpl;
882  if (!pImpl->TheFalseVal)
884  return pImpl->TheFalseVal;
885 }
886 
888  return V ? getTrue(Context) : getFalse(Context);
889 }
890 
892  assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
894  if (auto *VTy = dyn_cast<VectorType>(Ty))
895  return ConstantVector::getSplat(VTy->getElementCount(), TrueC);
896  return TrueC;
897 }
898 
900  assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
902  if (auto *VTy = dyn_cast<VectorType>(Ty))
903  return ConstantVector::getSplat(VTy->getElementCount(), FalseC);
904  return FalseC;
905 }
906 
908  return V ? getTrue(Ty) : getFalse(Ty);
909 }
910 
911 // Get a ConstantInt from an APInt.
913  // get an existing value or the insertion position
914  LLVMContextImpl *pImpl = Context.pImpl;
915  std::unique_ptr<ConstantInt> &Slot = pImpl->IntConstants[V];
916  if (!Slot) {
917  // Get the corresponding integer type for the bit width of the value.
919  Slot.reset(new ConstantInt(ITy, V));
920  }
921  assert(Slot->getType() == IntegerType::get(Context, V.getBitWidth()));
922  return Slot.get();
923 }
924 
925 Constant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) {
926  Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned);
927 
928  // For vectors, broadcast the value.
929  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
930  return ConstantVector::getSplat(VTy->getElementCount(), C);
931 
932  return C;
933 }
934 
936  return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned));
937 }
938 
940  return get(Ty, V, true);
941 }
942 
944  return get(Ty, V, true);
945 }
946 
948  ConstantInt *C = get(Ty->getContext(), V);
949  assert(C->getType() == Ty->getScalarType() &&
950  "ConstantInt type doesn't match the type implied by its value!");
951 
952  // For vectors, broadcast the value.
953  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
954  return ConstantVector::getSplat(VTy->getElementCount(), C);
955 
956  return C;
957 }
958 
960  return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix));
961 }
962 
963 /// Remove the constant from the constant table.
964 void ConstantInt::destroyConstantImpl() {
965  llvm_unreachable("You can't ConstantInt->destroyConstantImpl()!");
966 }
967 
968 //===----------------------------------------------------------------------===//
969 // ConstantFP
970 //===----------------------------------------------------------------------===//
971 
972 Constant *ConstantFP::get(Type *Ty, double V) {
973  LLVMContext &Context = Ty->getContext();
974 
975  APFloat FV(V);
976  bool ignored;
978  APFloat::rmNearestTiesToEven, &ignored);
979  Constant *C = get(Context, FV);
980 
981  // For vectors, broadcast the value.
982  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
983  return ConstantVector::getSplat(VTy->getElementCount(), C);
984 
985  return C;
986 }
987 
989  ConstantFP *C = get(Ty->getContext(), V);
990  assert(C->getType() == Ty->getScalarType() &&
991  "ConstantFP type doesn't match the type implied by its value!");
992 
993  // For vectors, broadcast the value.
994  if (auto *VTy = dyn_cast<VectorType>(Ty))
995  return ConstantVector::getSplat(VTy->getElementCount(), C);
996 
997  return C;
998 }
999 
1001  LLVMContext &Context = Ty->getContext();
1002 
1003  APFloat FV(Ty->getScalarType()->getFltSemantics(), Str);
1004  Constant *C = get(Context, FV);
1005 
1006  // For vectors, broadcast the value.
1007  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1008  return ConstantVector::getSplat(VTy->getElementCount(), C);
1009 
1010  return C;
1011 }
1012 
1013 Constant *ConstantFP::getNaN(Type *Ty, bool Negative, uint64_t Payload) {
1014  const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1015  APFloat NaN = APFloat::getNaN(Semantics, Negative, Payload);
1016  Constant *C = get(Ty->getContext(), NaN);
1017 
1018  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1019  return ConstantVector::getSplat(VTy->getElementCount(), C);
1020 
1021  return C;
1022 }
1023 
1024 Constant *ConstantFP::getQNaN(Type *Ty, bool Negative, APInt *Payload) {
1025  const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1026  APFloat NaN = APFloat::getQNaN(Semantics, Negative, Payload);
1027  Constant *C = get(Ty->getContext(), NaN);
1028 
1029  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1030  return ConstantVector::getSplat(VTy->getElementCount(), C);
1031 
1032  return C;
1033 }
1034 
1035 Constant *ConstantFP::getSNaN(Type *Ty, bool Negative, APInt *Payload) {
1036  const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1037  APFloat NaN = APFloat::getSNaN(Semantics, Negative, Payload);
1038  Constant *C = get(Ty->getContext(), NaN);
1039 
1040  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1041  return ConstantVector::getSplat(VTy->getElementCount(), C);
1042 
1043  return C;
1044 }
1045 
1047  const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1048  APFloat NegZero = APFloat::getZero(Semantics, /*Negative=*/true);
1049  Constant *C = get(Ty->getContext(), NegZero);
1050 
1051  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1052  return ConstantVector::getSplat(VTy->getElementCount(), C);
1053 
1054  return C;
1055 }
1056 
1057 
1059  if (Ty->isFPOrFPVectorTy())
1060  return getNegativeZero(Ty);
1061 
1062  return Constant::getNullValue(Ty);
1063 }
1064 
1065 
1066 // ConstantFP accessors.
1068  LLVMContextImpl* pImpl = Context.pImpl;
1069 
1070  std::unique_ptr<ConstantFP> &Slot = pImpl->FPConstants[V];
1071 
1072  if (!Slot) {
1074  Slot.reset(new ConstantFP(Ty, V));
1075  }
1076 
1077  return Slot.get();
1078 }
1079 
1080 Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) {
1081  const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1082  Constant *C = get(Ty->getContext(), APFloat::getInf(Semantics, Negative));
1083 
1084  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1085  return ConstantVector::getSplat(VTy->getElementCount(), C);
1086 
1087  return C;
1088 }
1089 
1090 ConstantFP::ConstantFP(Type *Ty, const APFloat &V)
1091  : ConstantData(Ty, ConstantFPVal), Val(V) {
1092  assert(&V.getSemantics() == &Ty->getFltSemantics() &&
1093  "FP type Mismatch");
1094 }
1095 
1096 bool ConstantFP::isExactlyValue(const APFloat &V) const {
1097  return Val.bitwiseIsEqual(V);
1098 }
1099 
1100 /// Remove the constant from the constant table.
1101 void ConstantFP::destroyConstantImpl() {
1102  llvm_unreachable("You can't ConstantFP->destroyConstantImpl()!");
1103 }
1104 
1105 //===----------------------------------------------------------------------===//
1106 // ConstantAggregateZero Implementation
1107 //===----------------------------------------------------------------------===//
1108 
1110  if (auto *AT = dyn_cast<ArrayType>(getType()))
1111  return Constant::getNullValue(AT->getElementType());
1112  return Constant::getNullValue(cast<VectorType>(getType())->getElementType());
1113 }
1114 
1116  return Constant::getNullValue(getType()->getStructElementType(Elt));
1117 }
1118 
1120  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1121  return getSequentialElement();
1122  return getStructElement(cast<ConstantInt>(C)->getZExtValue());
1123 }
1124 
1126  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1127  return getSequentialElement();
1128  return getStructElement(Idx);
1129 }
1130 
1132  Type *Ty = getType();
1133  if (auto *AT = dyn_cast<ArrayType>(Ty))
1134  return ElementCount::getFixed(AT->getNumElements());
1135  if (auto *VT = dyn_cast<VectorType>(Ty))
1136  return VT->getElementCount();
1138 }
1139 
1140 //===----------------------------------------------------------------------===//
1141 // UndefValue Implementation
1142 //===----------------------------------------------------------------------===//
1143 
1145  if (ArrayType *ATy = dyn_cast<ArrayType>(getType()))
1146  return UndefValue::get(ATy->getElementType());
1147  return UndefValue::get(cast<VectorType>(getType())->getElementType());
1148 }
1149 
1151  return UndefValue::get(getType()->getStructElementType(Elt));
1152 }
1153 
1155  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1156  return getSequentialElement();
1157  return getStructElement(cast<ConstantInt>(C)->getZExtValue());
1158 }
1159 
1161  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1162  return getSequentialElement();
1163  return getStructElement(Idx);
1164 }
1165 
1166 unsigned UndefValue::getNumElements() const {
1167  Type *Ty = getType();
1168  if (auto *AT = dyn_cast<ArrayType>(Ty))
1169  return AT->getNumElements();
1170  if (auto *VT = dyn_cast<VectorType>(Ty))
1171  return cast<FixedVectorType>(VT)->getNumElements();
1172  return Ty->getStructNumElements();
1173 }
1174 
1175 //===----------------------------------------------------------------------===//
1176 // PoisonValue Implementation
1177 //===----------------------------------------------------------------------===//
1178 
1180  if (ArrayType *ATy = dyn_cast<ArrayType>(getType()))
1181  return PoisonValue::get(ATy->getElementType());
1182  return PoisonValue::get(cast<VectorType>(getType())->getElementType());
1183 }
1184 
1186  return PoisonValue::get(getType()->getStructElementType(Elt));
1187 }
1188 
1190  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1191  return getSequentialElement();
1192  return getStructElement(cast<ConstantInt>(C)->getZExtValue());
1193 }
1194 
1196  if (isa<ArrayType>(getType()) || isa<VectorType>(getType()))
1197  return getSequentialElement();
1198  return getStructElement(Idx);
1199 }
1200 
1201 //===----------------------------------------------------------------------===//
1202 // ConstantXXX Classes
1203 //===----------------------------------------------------------------------===//
1204 
1205 template <typename ItTy, typename EltTy>
1206 static bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt) {
1207  for (; Start != End; ++Start)
1208  if (*Start != Elt)
1209  return false;
1210  return true;
1211 }
1212 
1213 template <typename SequentialTy, typename ElementTy>
1215  assert(!V.empty() && "Cannot get empty int sequence.");
1216 
1218  for (Constant *C : V)
1219  if (auto *CI = dyn_cast<ConstantInt>(C))
1220  Elts.push_back(CI->getZExtValue());
1221  else
1222  return nullptr;
1223  return SequentialTy::get(V[0]->getContext(), Elts);
1224 }
1225 
1226 template <typename SequentialTy, typename ElementTy>
1228  assert(!V.empty() && "Cannot get empty FP sequence.");
1229 
1231  for (Constant *C : V)
1232  if (auto *CFP = dyn_cast<ConstantFP>(C))
1233  Elts.push_back(CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
1234  else
1235  return nullptr;
1236  return SequentialTy::getFP(V[0]->getType(), Elts);
1237 }
1238 
1239 template <typename SequenceTy>
1242  // We speculatively build the elements here even if it turns out that there is
1243  // a constantexpr or something else weird, since it is so uncommon for that to
1244  // happen.
1245  if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
1246  if (CI->getType()->isIntegerTy(8))
1247  return getIntSequenceIfElementsMatch<SequenceTy, uint8_t>(V);
1248  else if (CI->getType()->isIntegerTy(16))
1249  return getIntSequenceIfElementsMatch<SequenceTy, uint16_t>(V);
1250  else if (CI->getType()->isIntegerTy(32))
1251  return getIntSequenceIfElementsMatch<SequenceTy, uint32_t>(V);
1252  else if (CI->getType()->isIntegerTy(64))
1253  return getIntSequenceIfElementsMatch<SequenceTy, uint64_t>(V);
1254  } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
1255  if (CFP->getType()->isHalfTy() || CFP->getType()->isBFloatTy())
1256  return getFPSequenceIfElementsMatch<SequenceTy, uint16_t>(V);
1257  else if (CFP->getType()->isFloatTy())
1258  return getFPSequenceIfElementsMatch<SequenceTy, uint32_t>(V);
1259  else if (CFP->getType()->isDoubleTy())
1260  return getFPSequenceIfElementsMatch<SequenceTy, uint64_t>(V);
1261  }
1262 
1263  return nullptr;
1264 }
1265 
1268  : Constant(T, VT, OperandTraits<ConstantAggregate>::op_end(this) - V.size(),
1269  V.size()) {
1270  llvm::copy(V, op_begin());
1271 
1272  // Check that types match, unless this is an opaque struct.
1273  if (auto *ST = dyn_cast<StructType>(T)) {
1274  if (ST->isOpaque())
1275  return;
1276  for (unsigned I = 0, E = V.size(); I != E; ++I)
1277  assert(V[I]->getType() == ST->getTypeAtIndex(I) &&
1278  "Initializer for struct element doesn't match!");
1279  }
1280 }
1281 
1282 ConstantArray::ConstantArray(ArrayType *T, ArrayRef<Constant *> V)
1283  : ConstantAggregate(T, ConstantArrayVal, V) {
1284  assert(V.size() == T->getNumElements() &&
1285  "Invalid initializer for constant array");
1286 }
1287 
1289  if (Constant *C = getImpl(Ty, V))
1290  return C;
1291  return Ty->getContext().pImpl->ArrayConstants.getOrCreate(Ty, V);
1292 }
1293 
1295  // Empty arrays are canonicalized to ConstantAggregateZero.
1296  if (V.empty())
1297  return ConstantAggregateZero::get(Ty);
1298 
1299  for (unsigned i = 0, e = V.size(); i != e; ++i) {
1300  assert(V[i]->getType() == Ty->getElementType() &&
1301  "Wrong type in array element initializer");
1302  }
1303 
1304  // If this is an all-zero array, return a ConstantAggregateZero object. If
1305  // all undef, return an UndefValue, if "all simple", then return a
1306  // ConstantDataArray.
1307  Constant *C = V[0];
1308  if (isa<PoisonValue>(C) && rangeOnlyContains(V.begin(), V.end(), C))
1309  return PoisonValue::get(Ty);
1310 
1311  if (isa<UndefValue>(C) && rangeOnlyContains(V.begin(), V.end(), C))
1312  return UndefValue::get(Ty);
1313 
1314  if (C->isNullValue() && rangeOnlyContains(V.begin(), V.end(), C))
1315  return ConstantAggregateZero::get(Ty);
1316 
1317  // Check to see if all of the elements are ConstantFP or ConstantInt and if
1318  // the element type is compatible with ConstantDataVector. If so, use it.
1320  return getSequenceIfElementsMatch<ConstantDataArray>(C, V);
1321 
1322  // Otherwise, we really do want to create a ConstantArray.
1323  return nullptr;
1324 }
1325 
1328  bool Packed) {
1329  unsigned VecSize = V.size();
1330  SmallVector<Type*, 16> EltTypes(VecSize);
1331  for (unsigned i = 0; i != VecSize; ++i)
1332  EltTypes[i] = V[i]->getType();
1333 
1334  return StructType::get(Context, EltTypes, Packed);
1335 }
1336 
1337 
1339  bool Packed) {
1340  assert(!V.empty() &&
1341  "ConstantStruct::getTypeForElements cannot be called on empty list");
1342  return getTypeForElements(V[0]->getContext(), V, Packed);
1343 }
1344 
1345 ConstantStruct::ConstantStruct(StructType *T, ArrayRef<Constant *> V)
1346  : ConstantAggregate(T, ConstantStructVal, V) {
1347  assert((T->isOpaque() || V.size() == T->getNumElements()) &&
1348  "Invalid initializer for constant struct");
1349 }
1350 
1351 // ConstantStruct accessors.
1353  assert((ST->isOpaque() || ST->getNumElements() == V.size()) &&
1354  "Incorrect # elements specified to ConstantStruct::get");
1355 
1356  // Create a ConstantAggregateZero value if all elements are zeros.
1357  bool isZero = true;
1358  bool isUndef = false;
1359  bool isPoison = false;
1360 
1361  if (!V.empty()) {
1362  isUndef = isa<UndefValue>(V[0]);
1363  isPoison = isa<PoisonValue>(V[0]);
1364  isZero = V[0]->isNullValue();
1365  // PoisonValue inherits UndefValue, so its check is not necessary.
1366  if (isUndef || isZero) {
1367  for (unsigned i = 0, e = V.size(); i != e; ++i) {
1368  if (!V[i]->isNullValue())
1369  isZero = false;
1370  if (!isa<PoisonValue>(V[i]))
1371  isPoison = false;
1372  if (isa<PoisonValue>(V[i]) || !isa<UndefValue>(V[i]))
1373  isUndef = false;
1374  }
1375  }
1376  }
1377  if (isZero)
1379  if (isPoison)
1380  return PoisonValue::get(ST);
1381  if (isUndef)
1382  return UndefValue::get(ST);
1383 
1384  return ST->getContext().pImpl->StructConstants.getOrCreate(ST, V);
1385 }
1386 
1387 ConstantVector::ConstantVector(VectorType *T, ArrayRef<Constant *> V)
1388  : ConstantAggregate(T, ConstantVectorVal, V) {
1389  assert(V.size() == cast<FixedVectorType>(T)->getNumElements() &&
1390  "Invalid initializer for constant vector");
1391 }
1392 
1393 // ConstantVector accessors.
1395  if (Constant *C = getImpl(V))
1396  return C;
1397  auto *Ty = FixedVectorType::get(V.front()->getType(), V.size());
1398  return Ty->getContext().pImpl->VectorConstants.getOrCreate(Ty, V);
1399 }
1400 
1402  assert(!V.empty() && "Vectors can't be empty");
1403  auto *T = FixedVectorType::get(V.front()->getType(), V.size());
1404 
1405  // If this is an all-undef or all-zero vector, return a
1406  // ConstantAggregateZero or UndefValue.
1407  Constant *C = V[0];
1408  bool isZero = C->isNullValue();
1409  bool isUndef = isa<UndefValue>(C);
1410  bool isPoison = isa<PoisonValue>(C);
1411 
1412  if (isZero || isUndef) {
1413  for (unsigned i = 1, e = V.size(); i != e; ++i)
1414  if (V[i] != C) {
1415  isZero = isUndef = isPoison = false;
1416  break;
1417  }
1418  }
1419 
1420  if (isZero)
1421  return ConstantAggregateZero::get(T);
1422  if (isPoison)
1423  return PoisonValue::get(T);
1424  if (isUndef)
1425  return UndefValue::get(T);
1426 
1427  // Check to see if all of the elements are ConstantFP or ConstantInt and if
1428  // the element type is compatible with ConstantDataVector. If so, use it.
1430  return getSequenceIfElementsMatch<ConstantDataVector>(C, V);
1431 
1432  // Otherwise, the element type isn't compatible with ConstantDataVector, or
1433  // the operand list contains a ConstantExpr or something else strange.
1434  return nullptr;
1435 }
1436 
1438  if (!EC.isScalable()) {
1439  // If this splat is compatible with ConstantDataVector, use it instead of
1440  // ConstantVector.
1441  if ((isa<ConstantFP>(V) || isa<ConstantInt>(V)) &&
1443  return ConstantDataVector::getSplat(EC.getKnownMinValue(), V);
1444 
1445  SmallVector<Constant *, 32> Elts(EC.getKnownMinValue(), V);
1446  return get(Elts);
1447  }
1448 
1449  Type *VTy = VectorType::get(V->getType(), EC);
1450 
1451  if (V->isNullValue())
1452  return ConstantAggregateZero::get(VTy);
1453  else if (isa<UndefValue>(V))
1454  return UndefValue::get(VTy);
1455 
1456  Type *I32Ty = Type::getInt32Ty(VTy->getContext());
1457 
1458  // Move scalar into vector.
1459  Constant *PoisonV = PoisonValue::get(VTy);
1460  V = ConstantExpr::getInsertElement(PoisonV, V, ConstantInt::get(I32Ty, 0));
1461  // Build shuffle mask to perform the splat.
1462  SmallVector<int, 8> Zeros(EC.getKnownMinValue(), 0);
1463  // Splat.
1464  return ConstantExpr::getShuffleVector(V, PoisonV, Zeros);
1465 }
1466 
1468  LLVMContextImpl *pImpl = Context.pImpl;
1469  if (!pImpl->TheNoneToken)
1470  pImpl->TheNoneToken.reset(new ConstantTokenNone(Context));
1471  return pImpl->TheNoneToken.get();
1472 }
1473 
1474 /// Remove the constant from the constant table.
1475 void ConstantTokenNone::destroyConstantImpl() {
1476  llvm_unreachable("You can't ConstantTokenNone->destroyConstantImpl()!");
1477 }
1478 
1479 // Utility function for determining if a ConstantExpr is a CastOp or not. This
1480 // can't be inline because we don't want to #include Instruction.h into
1481 // Constant.h
1482 bool ConstantExpr::isCast() const {
1483  return Instruction::isCast(getOpcode());
1484 }
1485 
1487  return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp;
1488 }
1489 
1491  if (getOpcode() != Instruction::GetElementPtr) return false;
1492 
1493  gep_type_iterator GEPI = gep_type_begin(this), E = gep_type_end(this);
1494  User::const_op_iterator OI = std::next(this->op_begin());
1495 
1496  // The remaining indices may be compile-time known integers within the bounds
1497  // of the corresponding notional static array types.
1498  for (; GEPI != E; ++GEPI, ++OI) {
1499  if (isa<UndefValue>(*OI))
1500  continue;
1501  auto *CI = dyn_cast<ConstantInt>(*OI);
1502  if (!CI || (GEPI.isBoundedSequential() &&
1503  (CI->getValue().getActiveBits() > 64 ||
1504  CI->getZExtValue() >= GEPI.getSequentialNumElements())))
1505  return false;
1506  }
1507 
1508  // All the indices checked out.
1509  return true;
1510 }
1511 
1513  return getOpcode() == Instruction::ExtractValue ||
1514  getOpcode() == Instruction::InsertValue;
1515 }
1516 
1518  if (const ExtractValueConstantExpr *EVCE =
1519  dyn_cast<ExtractValueConstantExpr>(this))
1520  return EVCE->Indices;
1521 
1522  return cast<InsertValueConstantExpr>(this)->Indices;
1523 }
1524 
1525 unsigned ConstantExpr::getPredicate() const {
1526  return cast<CompareConstantExpr>(this)->predicate;
1527 }
1528 
1530  return cast<ShuffleVectorConstantExpr>(this)->ShuffleMask;
1531 }
1532 
1534  return cast<ShuffleVectorConstantExpr>(this)->ShuffleMaskForBitcode;
1535 }
1536 
1538  bool OnlyIfReduced, Type *SrcTy) const {
1539  assert(Ops.size() == getNumOperands() && "Operand count mismatch!");
1540 
1541  // If no operands changed return self.
1542  if (Ty == getType() && std::equal(Ops.begin(), Ops.end(), op_begin()))
1543  return const_cast<ConstantExpr*>(this);
1544 
1545  Type *OnlyIfReducedTy = OnlyIfReduced ? Ty : nullptr;
1546  switch (getOpcode()) {
1547  case Instruction::Trunc:
1548  case Instruction::ZExt:
1549  case Instruction::SExt:
1550  case Instruction::FPTrunc:
1551  case Instruction::FPExt:
1552  case Instruction::UIToFP:
1553  case Instruction::SIToFP:
1554  case Instruction::FPToUI:
1555  case Instruction::FPToSI:
1556  case Instruction::PtrToInt:
1557  case Instruction::IntToPtr:
1558  case Instruction::BitCast:
1559  case Instruction::AddrSpaceCast:
1560  return ConstantExpr::getCast(getOpcode(), Ops[0], Ty, OnlyIfReduced);
1561  case Instruction::Select:
1562  return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2], OnlyIfReducedTy);
1563  case Instruction::InsertElement:
1564  return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2],
1565  OnlyIfReducedTy);
1566  case Instruction::ExtractElement:
1567  return ConstantExpr::getExtractElement(Ops[0], Ops[1], OnlyIfReducedTy);
1568  case Instruction::InsertValue:
1569  return ConstantExpr::getInsertValue(Ops[0], Ops[1], getIndices(),
1570  OnlyIfReducedTy);
1571  case Instruction::ExtractValue:
1572  return ConstantExpr::getExtractValue(Ops[0], getIndices(), OnlyIfReducedTy);
1573  case Instruction::FNeg:
1574  return ConstantExpr::getFNeg(Ops[0]);
1575  case Instruction::ShuffleVector:
1576  return ConstantExpr::getShuffleVector(Ops[0], Ops[1], getShuffleMask(),
1577  OnlyIfReducedTy);
1578  case Instruction::GetElementPtr: {
1579  auto *GEPO = cast<GEPOperator>(this);
1580  assert(SrcTy || (Ops[0]->getType() == getOperand(0)->getType()));
1582  SrcTy ? SrcTy : GEPO->getSourceElementType(), Ops[0], Ops.slice(1),
1583  GEPO->isInBounds(), GEPO->getInRangeIndex(), OnlyIfReducedTy);
1584  }
1585  case Instruction::ICmp:
1586  case Instruction::FCmp:
1587  return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1],
1588  OnlyIfReducedTy);
1589  default:
1590  assert(getNumOperands() == 2 && "Must be binary operator?");
1591  return ConstantExpr::get(getOpcode(), Ops[0], Ops[1], SubclassOptionalData,
1592  OnlyIfReducedTy);
1593  }
1594 }
1595 
1596 
1597 //===----------------------------------------------------------------------===//
1598 // isValueValidForType implementations
1599 
1601  unsigned NumBits = Ty->getIntegerBitWidth(); // assert okay
1602  if (Ty->isIntegerTy(1))
1603  return Val == 0 || Val == 1;
1604  return isUIntN(NumBits, Val);
1605 }
1606 
1607 bool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) {
1608  unsigned NumBits = Ty->getIntegerBitWidth();
1609  if (Ty->isIntegerTy(1))
1610  return Val == 0 || Val == 1 || Val == -1;
1611  return isIntN(NumBits, Val);
1612 }
1613 
1615  // convert modifies in place, so make a copy.
1616  APFloat Val2 = APFloat(Val);
1617  bool losesInfo;
1618  switch (Ty->getTypeID()) {
1619  default:
1620  return false; // These can't be represented as floating point!
1621 
1622  // FIXME rounding mode needs to be more flexible
1623  case Type::HalfTyID: {
1624  if (&Val2.getSemantics() == &APFloat::IEEEhalf())
1625  return true;
1627  return !losesInfo;
1628  }
1629  case Type::BFloatTyID: {
1630  if (&Val2.getSemantics() == &APFloat::BFloat())
1631  return true;
1633  return !losesInfo;
1634  }
1635  case Type::FloatTyID: {
1636  if (&Val2.getSemantics() == &APFloat::IEEEsingle())
1637  return true;
1639  return !losesInfo;
1640  }
1641  case Type::DoubleTyID: {
1642  if (&Val2.getSemantics() == &APFloat::IEEEhalf() ||
1643  &Val2.getSemantics() == &APFloat::BFloat() ||
1644  &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1645  &Val2.getSemantics() == &APFloat::IEEEdouble())
1646  return true;
1648  return !losesInfo;
1649  }
1650  case Type::X86_FP80TyID:
1651  return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1652  &Val2.getSemantics() == &APFloat::BFloat() ||
1653  &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1654  &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1656  case Type::FP128TyID:
1657  return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1658  &Val2.getSemantics() == &APFloat::BFloat() ||
1659  &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1660  &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1661  &Val2.getSemantics() == &APFloat::IEEEquad();
1662  case Type::PPC_FP128TyID:
1663  return &Val2.getSemantics() == &APFloat::IEEEhalf() ||
1664  &Val2.getSemantics() == &APFloat::BFloat() ||
1665  &Val2.getSemantics() == &APFloat::IEEEsingle() ||
1666  &Val2.getSemantics() == &APFloat::IEEEdouble() ||
1667  &Val2.getSemantics() == &APFloat::PPCDoubleDouble();
1668  }
1669 }
1670 
1671 
1672 //===----------------------------------------------------------------------===//
1673 // Factory Function Implementation
1674 
1676  assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) &&
1677  "Cannot create an aggregate zero of non-aggregate type!");
1678 
1679  std::unique_ptr<ConstantAggregateZero> &Entry =
1680  Ty->getContext().pImpl->CAZConstants[Ty];
1681  if (!Entry)
1682  Entry.reset(new ConstantAggregateZero(Ty));
1683 
1684  return Entry.get();
1685 }
1686 
1687 /// Remove the constant from the constant table.
1688 void ConstantAggregateZero::destroyConstantImpl() {
1689  getContext().pImpl->CAZConstants.erase(getType());
1690 }
1691 
1692 /// Remove the constant from the constant table.
1693 void ConstantArray::destroyConstantImpl() {
1695 }
1696 
1697 
1698 //---- ConstantStruct::get() implementation...
1699 //
1700 
1701 /// Remove the constant from the constant table.
1702 void ConstantStruct::destroyConstantImpl() {
1704 }
1705 
1706 /// Remove the constant from the constant table.
1707 void ConstantVector::destroyConstantImpl() {
1709 }
1710 
1711 Constant *Constant::getSplatValue(bool AllowUndefs) const {
1712  assert(this->getType()->isVectorTy() && "Only valid for vectors!");
1713  if (isa<ConstantAggregateZero>(this))
1714  return getNullValue(cast<VectorType>(getType())->getElementType());
1715  if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
1716  return CV->getSplatValue();
1717  if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
1718  return CV->getSplatValue(AllowUndefs);
1719 
1720  // Check if this is a constant expression splat of the form returned by
1721  // ConstantVector::getSplat()
1722  const auto *Shuf = dyn_cast<ConstantExpr>(this);
1723  if (Shuf && Shuf->getOpcode() == Instruction::ShuffleVector &&
1724  isa<UndefValue>(Shuf->getOperand(1))) {
1725 
1726  const auto *IElt = dyn_cast<ConstantExpr>(Shuf->getOperand(0));
1727  if (IElt && IElt->getOpcode() == Instruction::InsertElement &&
1728  isa<UndefValue>(IElt->getOperand(0))) {
1729 
1730  ArrayRef<int> Mask = Shuf->getShuffleMask();
1731  Constant *SplatVal = IElt->getOperand(1);
1732  ConstantInt *Index = dyn_cast<ConstantInt>(IElt->getOperand(2));
1733 
1734  if (Index && Index->getValue() == 0 &&
1735  llvm::all_of(Mask, [](int I) { return I == 0; }))
1736  return SplatVal;
1737  }
1738  }
1739 
1740  return nullptr;
1741 }
1742 
1743 Constant *ConstantVector::getSplatValue(bool AllowUndefs) const {
1744  // Check out first element.
1745  Constant *Elt = getOperand(0);
1746  // Then make sure all remaining elements point to the same value.
1747  for (unsigned I = 1, E = getNumOperands(); I < E; ++I) {
1748  Constant *OpC = getOperand(I);
1749  if (OpC == Elt)
1750  continue;
1751 
1752  // Strict mode: any mismatch is not a splat.
1753  if (!AllowUndefs)
1754  return nullptr;
1755 
1756  // Allow undefs mode: ignore undefined elements.
1757  if (isa<UndefValue>(OpC))
1758  continue;
1759 
1760  // If we do not have a defined element yet, use the current operand.
1761  if (isa<UndefValue>(Elt))
1762  Elt = OpC;
1763 
1764  if (OpC != Elt)
1765  return nullptr;
1766  }
1767  return Elt;
1768 }
1769 
1771  if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
1772  return CI->getValue();
1773  assert(this->getSplatValue() && "Doesn't contain a unique integer!");
1774  const Constant *C = this->getAggregateElement(0U);
1775  assert(C && isa<ConstantInt>(C) && "Not a vector of numbers!");
1776  return cast<ConstantInt>(C)->getValue();
1777 }
1778 
1779 //---- ConstantPointerNull::get() implementation.
1780 //
1781 
1783  std::unique_ptr<ConstantPointerNull> &Entry =
1784  Ty->getContext().pImpl->CPNConstants[Ty];
1785  if (!Entry)
1786  Entry.reset(new ConstantPointerNull(Ty));
1787 
1788  return Entry.get();
1789 }
1790 
1791 /// Remove the constant from the constant table.
1792 void ConstantPointerNull::destroyConstantImpl() {
1793  getContext().pImpl->CPNConstants.erase(getType());
1794 }
1795 
1797  std::unique_ptr<UndefValue> &Entry = Ty->getContext().pImpl->UVConstants[Ty];
1798  if (!Entry)
1799  Entry.reset(new UndefValue(Ty));
1800 
1801  return Entry.get();
1802 }
1803 
1804 /// Remove the constant from the constant table.
1805 void UndefValue::destroyConstantImpl() {
1806  // Free the constant and any dangling references to it.
1807  if (getValueID() == UndefValueVal) {
1808  getContext().pImpl->UVConstants.erase(getType());
1809  } else if (getValueID() == PoisonValueVal) {
1810  getContext().pImpl->PVConstants.erase(getType());
1811  }
1812  llvm_unreachable("Not a undef or a poison!");
1813 }
1814 
1816  std::unique_ptr<PoisonValue> &Entry = Ty->getContext().pImpl->PVConstants[Ty];
1817  if (!Entry)
1818  Entry.reset(new PoisonValue(Ty));
1819 
1820  return Entry.get();
1821 }
1822 
1823 /// Remove the constant from the constant table.
1824 void PoisonValue::destroyConstantImpl() {
1825  // Free the constant and any dangling references to it.
1826  getContext().pImpl->PVConstants.erase(getType());
1827 }
1828 
1830  assert(BB->getParent() && "Block must have a parent");
1831  return get(BB->getParent(), BB);
1832 }
1833 
1835  BlockAddress *&BA =
1836  F->getContext().pImpl->BlockAddresses[std::make_pair(F, BB)];
1837  if (!BA)
1838  BA = new BlockAddress(F, BB);
1839 
1840  assert(BA->getFunction() == F && "Basic block moved between functions");
1841  return BA;
1842 }
1843 
1845  : Constant(Type::getInt8PtrTy(F->getContext(), F->getAddressSpace()),
1846  Value::BlockAddressVal, &Op<0>(), 2) {
1847  setOperand(0, F);
1848  setOperand(1, BB);
1849  BB->AdjustBlockAddressRefCount(1);
1850 }
1851 
1853  if (!BB->hasAddressTaken())
1854  return nullptr;
1855 
1856  const Function *F = BB->getParent();
1857  assert(F && "Block must have a parent");
1858  BlockAddress *BA =
1859  F->getContext().pImpl->BlockAddresses.lookup(std::make_pair(F, BB));
1860  assert(BA && "Refcount and block address map disagree!");
1861  return BA;
1862 }
1863 
1864 /// Remove the constant from the constant table.
1865 void BlockAddress::destroyConstantImpl() {
1867  ->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock()));
1868  getBasicBlock()->AdjustBlockAddressRefCount(-1);
1869 }
1870 
1871 Value *BlockAddress::handleOperandChangeImpl(Value *From, Value *To) {
1872  // This could be replacing either the Basic Block or the Function. In either
1873  // case, we have to remove the map entry.
1874  Function *NewF = getFunction();
1875  BasicBlock *NewBB = getBasicBlock();
1876 
1877  if (From == NewF)
1878  NewF = cast<Function>(To->stripPointerCasts());
1879  else {
1880  assert(From == NewBB && "From does not match any operand");
1881  NewBB = cast<BasicBlock>(To);
1882  }
1883 
1884  // See if the 'new' entry already exists, if not, just update this in place
1885  // and return early.
1886  BlockAddress *&NewBA =
1887  getContext().pImpl->BlockAddresses[std::make_pair(NewF, NewBB)];
1888  if (NewBA)
1889  return NewBA;
1890 
1891  getBasicBlock()->AdjustBlockAddressRefCount(-1);
1892 
1893  // Remove the old entry, this can't cause the map to rehash (just a
1894  // tombstone will get added).
1895  getContext().pImpl->BlockAddresses.erase(std::make_pair(getFunction(),
1896  getBasicBlock()));
1897  NewBA = this;
1898  setOperand(0, NewF);
1899  setOperand(1, NewBB);
1900  getBasicBlock()->AdjustBlockAddressRefCount(1);
1901 
1902  // If we just want to keep the existing value, then return null.
1903  // Callers know that this means we shouldn't delete this value.
1904  return nullptr;
1905 }
1906 
1909  if (!Equiv)
1910  Equiv = new DSOLocalEquivalent(GV);
1911 
1912  assert(Equiv->getGlobalValue() == GV &&
1913  "DSOLocalFunction does not match the expected global value");
1914  return Equiv;
1915 }
1916 
1917 DSOLocalEquivalent::DSOLocalEquivalent(GlobalValue *GV)
1918  : Constant(GV->getType(), Value::DSOLocalEquivalentVal, &Op<0>(), 1) {
1919  setOperand(0, GV);
1920 }
1921 
1922 /// Remove the constant from the constant table.
1923 void DSOLocalEquivalent::destroyConstantImpl() {
1924  const GlobalValue *GV = getGlobalValue();
1925  GV->getContext().pImpl->DSOLocalEquivalents.erase(GV);
1926 }
1927 
1928 Value *DSOLocalEquivalent::handleOperandChangeImpl(Value *From, Value *To) {
1929  assert(From == getGlobalValue() && "Changing value does not match operand.");
1930  assert(isa<Constant>(To) && "Can only replace the operands with a constant");
1931 
1932  // The replacement is with another global value.
1933  if (const auto *ToObj = dyn_cast<GlobalValue>(To)) {
1934  DSOLocalEquivalent *&NewEquiv =
1936  if (NewEquiv)
1937  return llvm::ConstantExpr::getBitCast(NewEquiv, getType());
1938  }
1939 
1940  // If the argument is replaced with a null value, just replace this constant
1941  // with a null value.
1942  if (cast<Constant>(To)->isNullValue())
1943  return To;
1944 
1945  // The replacement could be a bitcast or an alias to another function. We can
1946  // replace it with a bitcast to the dso_local_equivalent of that function.
1947  auto *Func = cast<Function>(To->stripPointerCastsAndAliases());
1949  if (NewEquiv)
1950  return llvm::ConstantExpr::getBitCast(NewEquiv, getType());
1951 
1952  // Replace this with the new one.
1954  NewEquiv = this;
1955  setOperand(0, Func);
1956 
1957  if (Func->getType() != getType()) {
1958  // It is ok to mutate the type here because this constant should always
1959  // reflect the type of the function it's holding.
1960  mutateType(Func->getType());
1961  }
1962  return nullptr;
1963 }
1964 
1965 //---- ConstantExpr::get() implementations.
1966 //
1967 
1968 /// This is a utility function to handle folding of casts and lookup of the
1969 /// cast in the ExprConstants map. It is used by the various get* methods below.
1971  bool OnlyIfReduced = false) {
1972  assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
1973  // Fold a few common cases
1974  if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
1975  return FC;
1976 
1977  if (OnlyIfReduced)
1978  return nullptr;
1979 
1980  LLVMContextImpl *pImpl = Ty->getContext().pImpl;
1981 
1982  // Look up the constant in the table first to ensure uniqueness.
1983  ConstantExprKeyType Key(opc, C);
1984 
1985  return pImpl->ExprConstants.getOrCreate(Ty, Key);
1986 }
1987 
1989  bool OnlyIfReduced) {
1991  assert(Instruction::isCast(opc) && "opcode out of range");
1992  assert(C && Ty && "Null arguments to getCast");
1993  assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!");
1994 
1995  switch (opc) {
1996  default:
1997  llvm_unreachable("Invalid cast opcode");
1998  case Instruction::Trunc:
1999  return getTrunc(C, Ty, OnlyIfReduced);
2000  case Instruction::ZExt:
2001  return getZExt(C, Ty, OnlyIfReduced);
2002  case Instruction::SExt:
2003  return getSExt(C, Ty, OnlyIfReduced);
2004  case Instruction::FPTrunc:
2005  return getFPTrunc(C, Ty, OnlyIfReduced);
2006  case Instruction::FPExt:
2007  return getFPExtend(C, Ty, OnlyIfReduced);
2008  case Instruction::UIToFP:
2009  return getUIToFP(C, Ty, OnlyIfReduced);
2010  case Instruction::SIToFP:
2011  return getSIToFP(C, Ty, OnlyIfReduced);
2012  case Instruction::FPToUI:
2013  return getFPToUI(C, Ty, OnlyIfReduced);
2014  case Instruction::FPToSI:
2015  return getFPToSI(C, Ty, OnlyIfReduced);
2016  case Instruction::PtrToInt:
2017  return getPtrToInt(C, Ty, OnlyIfReduced);
2018  case Instruction::IntToPtr:
2019  return getIntToPtr(C, Ty, OnlyIfReduced);
2020  case Instruction::BitCast:
2021  return getBitCast(C, Ty, OnlyIfReduced);
2022  case Instruction::AddrSpaceCast:
2023  return getAddrSpaceCast(C, Ty, OnlyIfReduced);
2024  }
2025 }
2026 
2028  if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2029  return getBitCast(C, Ty);
2030  return getZExt(C, Ty);
2031 }
2032 
2034  if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2035  return getBitCast(C, Ty);
2036  return getSExt(C, Ty);
2037 }
2038 
2040  if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2041  return getBitCast(C, Ty);
2042  return getTrunc(C, Ty);
2043 }
2044 
2046  assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
2047  assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
2048  "Invalid cast");
2049 
2050  if (Ty->isIntOrIntVectorTy())
2051  return getPtrToInt(S, Ty);
2052 
2053  unsigned SrcAS = S->getType()->getPointerAddressSpace();
2054  if (Ty->isPtrOrPtrVectorTy() && SrcAS != Ty->getPointerAddressSpace())
2055  return getAddrSpaceCast(S, Ty);
2056 
2057  return getBitCast(S, Ty);
2058 }
2059 
2061  Type *Ty) {
2062  assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
2063  assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
2064 
2065  if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace())
2066  return getAddrSpaceCast(S, Ty);
2067 
2068  return getBitCast(S, Ty);
2069 }
2070 
2072  assert(C->getType()->isIntOrIntVectorTy() &&
2073  Ty->isIntOrIntVectorTy() && "Invalid cast");
2074  unsigned SrcBits = C->getType()->getScalarSizeInBits();
2075  unsigned DstBits = Ty->getScalarSizeInBits();
2076  Instruction::CastOps opcode =
2077  (SrcBits == DstBits ? Instruction::BitCast :
2078  (SrcBits > DstBits ? Instruction::Trunc :
2079  (isSigned ? Instruction::SExt : Instruction::ZExt)));
2080  return getCast(opcode, C, Ty);
2081 }
2082 
2084  assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
2085  "Invalid cast");
2086  unsigned SrcBits = C->getType()->getScalarSizeInBits();
2087  unsigned DstBits = Ty->getScalarSizeInBits();
2088  if (SrcBits == DstBits)
2089  return C; // Avoid a useless cast
2090  Instruction::CastOps opcode =
2091  (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt);
2092  return getCast(opcode, C, Ty);
2093 }
2094 
2095 Constant *ConstantExpr::getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
2096 #ifndef NDEBUG
2097  bool fromVec = isa<VectorType>(C->getType());
2098  bool toVec = isa<VectorType>(Ty);
2099 #endif
2100  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2101  assert(C->getType()->isIntOrIntVectorTy() && "Trunc operand must be integer");
2102  assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral");
2103  assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
2104  "SrcTy must be larger than DestTy for Trunc!");
2105 
2106  return getFoldedCast(Instruction::Trunc, C, Ty, OnlyIfReduced);
2107 }
2108 
2109 Constant *ConstantExpr::getSExt(Constant *C, Type *Ty, bool OnlyIfReduced) {
2110 #ifndef NDEBUG
2111  bool fromVec = isa<VectorType>(C->getType());
2112  bool toVec = isa<VectorType>(Ty);
2113 #endif
2114  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2115  assert(C->getType()->isIntOrIntVectorTy() && "SExt operand must be integral");
2116  assert(Ty->isIntOrIntVectorTy() && "SExt produces only integer");
2117  assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
2118  "SrcTy must be smaller than DestTy for SExt!");
2119 
2120  return getFoldedCast(Instruction::SExt, C, Ty, OnlyIfReduced);
2121 }
2122 
2123 Constant *ConstantExpr::getZExt(Constant *C, Type *Ty, bool OnlyIfReduced) {
2124 #ifndef NDEBUG
2125  bool fromVec = isa<VectorType>(C->getType());
2126  bool toVec = isa<VectorType>(Ty);
2127 #endif
2128  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2129  assert(C->getType()->isIntOrIntVectorTy() && "ZEXt operand must be integral");
2130  assert(Ty->isIntOrIntVectorTy() && "ZExt produces only integer");
2131  assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
2132  "SrcTy must be smaller than DestTy for ZExt!");
2133 
2134  return getFoldedCast(Instruction::ZExt, C, Ty, OnlyIfReduced);
2135 }
2136 
2137 Constant *ConstantExpr::getFPTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
2138 #ifndef NDEBUG
2139  bool fromVec = isa<VectorType>(C->getType());
2140  bool toVec = isa<VectorType>(Ty);
2141 #endif
2142  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2143  assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
2144  C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
2145  "This is an illegal floating point truncation!");
2146  return getFoldedCast(Instruction::FPTrunc, C, Ty, OnlyIfReduced);
2147 }
2148 
2149 Constant *ConstantExpr::getFPExtend(Constant *C, Type *Ty, bool OnlyIfReduced) {
2150 #ifndef NDEBUG
2151  bool fromVec = isa<VectorType>(C->getType());
2152  bool toVec = isa<VectorType>(Ty);
2153 #endif
2154  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2155  assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
2156  C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
2157  "This is an illegal floating point extension!");
2158  return getFoldedCast(Instruction::FPExt, C, Ty, OnlyIfReduced);
2159 }
2160 
2161 Constant *ConstantExpr::getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced) {
2162 #ifndef NDEBUG
2163  bool fromVec = isa<VectorType>(C->getType());
2164  bool toVec = isa<VectorType>(Ty);
2165 #endif
2166  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2167  assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
2168  "This is an illegal uint to floating point cast!");
2169  return getFoldedCast(Instruction::UIToFP, C, Ty, OnlyIfReduced);
2170 }
2171 
2172 Constant *ConstantExpr::getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced) {
2173 #ifndef NDEBUG
2174  bool fromVec = isa<VectorType>(C->getType());
2175  bool toVec = isa<VectorType>(Ty);
2176 #endif
2177  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2178  assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
2179  "This is an illegal sint to floating point cast!");
2180  return getFoldedCast(Instruction::SIToFP, C, Ty, OnlyIfReduced);
2181 }
2182 
2183 Constant *ConstantExpr::getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced) {
2184 #ifndef NDEBUG
2185  bool fromVec = isa<VectorType>(C->getType());
2186  bool toVec = isa<VectorType>(Ty);
2187 #endif
2188  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2189  assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
2190  "This is an illegal floating point to uint cast!");
2191  return getFoldedCast(Instruction::FPToUI, C, Ty, OnlyIfReduced);
2192 }
2193 
2194 Constant *ConstantExpr::getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced) {
2195 #ifndef NDEBUG
2196  bool fromVec = isa<VectorType>(C->getType());
2197  bool toVec = isa<VectorType>(Ty);
2198 #endif
2199  assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
2200  assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
2201  "This is an illegal floating point to sint cast!");
2202  return getFoldedCast(Instruction::FPToSI, C, Ty, OnlyIfReduced);
2203 }
2204 
2206  bool OnlyIfReduced) {
2207  assert(C->getType()->isPtrOrPtrVectorTy() &&
2208  "PtrToInt source must be pointer or pointer vector");
2209  assert(DstTy->isIntOrIntVectorTy() &&
2210  "PtrToInt destination must be integer or integer vector");
2211  assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy));
2212  if (isa<VectorType>(C->getType()))
2213  assert(cast<FixedVectorType>(C->getType())->getNumElements() ==
2214  cast<FixedVectorType>(DstTy)->getNumElements() &&
2215  "Invalid cast between a different number of vector elements");
2216  return getFoldedCast(Instruction::PtrToInt, C, DstTy, OnlyIfReduced);
2217 }
2218 
2220  bool OnlyIfReduced) {
2221  assert(C->getType()->isIntOrIntVectorTy() &&
2222  "IntToPtr source must be integer or integer vector");
2223  assert(DstTy->isPtrOrPtrVectorTy() &&
2224  "IntToPtr destination must be a pointer or pointer vector");
2225  assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy));
2226  if (isa<VectorType>(C->getType()))
2227  assert(cast<VectorType>(C->getType())->getElementCount() ==
2228  cast<VectorType>(DstTy)->getElementCount() &&
2229  "Invalid cast between a different number of vector elements");
2230  return getFoldedCast(Instruction::IntToPtr, C, DstTy, OnlyIfReduced);
2231 }
2232 
2234  bool OnlyIfReduced) {
2235  assert(CastInst::castIsValid(Instruction::BitCast, C, DstTy) &&
2236  "Invalid constantexpr bitcast!");
2237 
2238  // It is common to ask for a bitcast of a value to its own type, handle this
2239  // speedily.
2240  if (C->getType() == DstTy) return C;
2241 
2242  return getFoldedCast(Instruction::BitCast, C, DstTy, OnlyIfReduced);
2243 }
2244 
2246  bool OnlyIfReduced) {
2247  assert(CastInst::castIsValid(Instruction::AddrSpaceCast, C, DstTy) &&
2248  "Invalid constantexpr addrspacecast!");
2249 
2250  // Canonicalize addrspacecasts between different pointer types by first
2251  // bitcasting the pointer type and then converting the address space.
2252  PointerType *SrcScalarTy = cast<PointerType>(C->getType()->getScalarType());
2253  PointerType *DstScalarTy = cast<PointerType>(DstTy->getScalarType());
2254  if (!SrcScalarTy->hasSameElementTypeAs(DstScalarTy)) {
2256  DstScalarTy, SrcScalarTy->getAddressSpace());
2257  if (VectorType *VT = dyn_cast<VectorType>(DstTy)) {
2258  // Handle vectors of pointers.
2259  MidTy = FixedVectorType::get(MidTy,
2260  cast<FixedVectorType>(VT)->getNumElements());
2261  }
2262  C = getBitCast(C, MidTy);
2263  }
2264  return getFoldedCast(Instruction::AddrSpaceCast, C, DstTy, OnlyIfReduced);
2265 }
2266 
2267 Constant *ConstantExpr::get(unsigned Opcode, Constant *C, unsigned Flags,
2268  Type *OnlyIfReducedTy) {
2269  // Check the operands for consistency first.
2270  assert(Instruction::isUnaryOp(Opcode) &&
2271  "Invalid opcode in unary constant expression");
2272 
2273 #ifndef NDEBUG
2274  switch (Opcode) {
2275  case Instruction::FNeg:
2276  assert(C->getType()->isFPOrFPVectorTy() &&
2277  "Tried to create a floating-point operation on a "
2278  "non-floating-point type!");
2279  break;
2280  default:
2281  break;
2282  }
2283 #endif
2284 
2285  if (Constant *FC = ConstantFoldUnaryInstruction(Opcode, C))
2286  return FC;
2287 
2288  if (OnlyIfReducedTy == C->getType())
2289  return nullptr;
2290 
2291  Constant *ArgVec[] = { C };
2292  ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
2293 
2294  LLVMContextImpl *pImpl = C->getContext().pImpl;
2295  return pImpl->ExprConstants.getOrCreate(C->getType(), Key);
2296 }
2297 
2299  unsigned Flags, Type *OnlyIfReducedTy) {
2300  // Check the operands for consistency first.
2301  assert(Instruction::isBinaryOp(Opcode) &&
2302  "Invalid opcode in binary constant expression");
2303  assert(C1->getType() == C2->getType() &&
2304  "Operand types in binary constant expression should match");
2305 
2306 #ifndef NDEBUG
2307  switch (Opcode) {
2308  case Instruction::Add:
2309  case Instruction::Sub:
2310  case Instruction::Mul:
2311  case Instruction::UDiv:
2312  case Instruction::SDiv:
2313  case Instruction::URem:
2314  case Instruction::SRem:
2315  assert(C1->getType()->isIntOrIntVectorTy() &&
2316  "Tried to create an integer operation on a non-integer type!");
2317  break;
2318  case Instruction::FAdd:
2319  case Instruction::FSub:
2320  case Instruction::FMul:
2321  case Instruction::FDiv:
2322  case Instruction::FRem:
2323  assert(C1->getType()->isFPOrFPVectorTy() &&
2324  "Tried to create a floating-point operation on a "
2325  "non-floating-point type!");
2326  break;
2327  case Instruction::And:
2328  case Instruction::Or:
2329  case Instruction::Xor:
2330  assert(C1->getType()->isIntOrIntVectorTy() &&
2331  "Tried to create a logical operation on a non-integral type!");
2332  break;
2333  case Instruction::Shl:
2334  case Instruction::LShr:
2335  case Instruction::AShr:
2336  assert(C1->getType()->isIntOrIntVectorTy() &&
2337  "Tried to create a shift operation on a non-integer type!");
2338  break;
2339  default:
2340  break;
2341  }
2342 #endif
2343 
2344  if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
2345  return FC;
2346 
2347  if (OnlyIfReducedTy == C1->getType())
2348  return nullptr;
2349 
2350  Constant *ArgVec[] = { C1, C2 };
2351  ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
2352 
2353  LLVMContextImpl *pImpl = C1->getContext().pImpl;
2354  return pImpl->ExprConstants.getOrCreate(C1->getType(), Key);
2355 }
2356 
2358  // sizeof is implemented as: (i64) gep (Ty*)null, 1
2359  // Note that a non-inbounds gep is used, as null isn't within any object.
2363  return getPtrToInt(GEP,
2364  Type::getInt64Ty(Ty->getContext()));
2365 }
2366 
2368  // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1
2369  // Note that a non-inbounds gep is used, as null isn't within any object.
2370  Type *AligningTy = StructType::get(Type::getInt1Ty(Ty->getContext()), Ty);
2371  Constant *NullPtr = Constant::getNullValue(AligningTy->getPointerTo(0));
2374  Constant *Indices[2] = { Zero, One };
2375  Constant *GEP = getGetElementPtr(AligningTy, NullPtr, Indices);
2376  return getPtrToInt(GEP,
2377  Type::getInt64Ty(Ty->getContext()));
2378 }
2379 
2382  FieldNo));
2383 }
2384 
2386  // offsetof is implemented as: (i64) gep (Ty*)null, 0, FieldNo
2387  // Note that a non-inbounds gep is used, as null isn't within any object.
2388  Constant *GEPIdx[] = {
2390  FieldNo
2391  };
2394  return getPtrToInt(GEP,
2395  Type::getInt64Ty(Ty->getContext()));
2396 }
2397 
2399  Constant *C2, bool OnlyIfReduced) {
2400  assert(C1->getType() == C2->getType() && "Op types should be identical!");
2401 
2402  switch (Predicate) {
2403  default: llvm_unreachable("Invalid CmpInst predicate");
2409  case CmpInst::FCMP_TRUE:
2410  return getFCmp(Predicate, C1, C2, OnlyIfReduced);
2411 
2415  case CmpInst::ICMP_SLE:
2416  return getICmp(Predicate, C1, C2, OnlyIfReduced);
2417  }
2418 }
2419 
2421  Type *OnlyIfReducedTy) {
2422  assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands");
2423 
2425  return SC; // Fold common cases
2426 
2427  if (OnlyIfReducedTy == V1->getType())
2428  return nullptr;
2429 
2430  Constant *ArgVec[] = { C, V1, V2 };
2432 
2433  LLVMContextImpl *pImpl = C->getContext().pImpl;
2434  return pImpl->ExprConstants.getOrCreate(V1->getType(), Key);
2435 }
2436 
2438  ArrayRef<Value *> Idxs, bool InBounds,
2439  Optional<unsigned> InRangeIndex,
2440  Type *OnlyIfReducedTy) {
2441  PointerType *OrigPtrTy = cast<PointerType>(C->getType()->getScalarType());
2442  assert(Ty && "Must specify element type");
2443  assert(OrigPtrTy->isOpaqueOrPointeeTypeMatches(Ty));
2444 
2445  if (Constant *FC =
2446  ConstantFoldGetElementPtr(Ty, C, InBounds, InRangeIndex, Idxs))
2447  return FC; // Fold a few common cases.
2448 
2449  // Get the result type of the getelementptr!
2450  Type *DestTy = GetElementPtrInst::getIndexedType(Ty, Idxs);
2451  assert(DestTy && "GEP indices invalid!");
2452  unsigned AS = OrigPtrTy->getAddressSpace();
2453  Type *ReqTy = OrigPtrTy->isOpaque()
2454  ? PointerType::get(OrigPtrTy->getContext(), AS)
2455  : DestTy->getPointerTo(AS);
2456 
2457  auto EltCount = ElementCount::getFixed(0);
2458  if (VectorType *VecTy = dyn_cast<VectorType>(C->getType()))
2459  EltCount = VecTy->getElementCount();
2460  else
2461  for (auto Idx : Idxs)
2462  if (VectorType *VecTy = dyn_cast<VectorType>(Idx->getType()))
2463  EltCount = VecTy->getElementCount();
2464 
2465  if (EltCount.isNonZero())
2466  ReqTy = VectorType::get(ReqTy, EltCount);
2467 
2468  if (OnlyIfReducedTy == ReqTy)
2469  return nullptr;
2470 
2471  // Look up the constant in the table first to ensure uniqueness
2472  std::vector<Constant*> ArgVec;
2473  ArgVec.reserve(1 + Idxs.size());
2474  ArgVec.push_back(C);
2475  auto GTI = gep_type_begin(Ty, Idxs), GTE = gep_type_end(Ty, Idxs);
2476  for (; GTI != GTE; ++GTI) {
2477  auto *Idx = cast<Constant>(GTI.getOperand());
2478  assert(
2479  (!isa<VectorType>(Idx->getType()) ||
2480  cast<VectorType>(Idx->getType())->getElementCount() == EltCount) &&
2481  "getelementptr index type missmatch");
2482 
2483  if (GTI.isStruct() && Idx->getType()->isVectorTy()) {
2484  Idx = Idx->getSplatValue();
2485  } else if (GTI.isSequential() && EltCount.isNonZero() &&
2486  !Idx->getType()->isVectorTy()) {
2487  Idx = ConstantVector::getSplat(EltCount, Idx);
2488  }
2489  ArgVec.push_back(Idx);
2490  }
2491 
2492  unsigned SubClassOptionalData = InBounds ? GEPOperator::IsInBounds : 0;
2493  if (InRangeIndex && *InRangeIndex < 63)
2494  SubClassOptionalData |= (*InRangeIndex + 1) << 1;
2495  const ConstantExprKeyType Key(Instruction::GetElementPtr, ArgVec, 0,
2496  SubClassOptionalData, None, None, Ty);
2497 
2498  LLVMContextImpl *pImpl = C->getContext().pImpl;
2499  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2500 }
2501 
2503  Constant *RHS, bool OnlyIfReduced) {
2504  assert(LHS->getType() == RHS->getType());
2506  "Invalid ICmp Predicate");
2507 
2508  if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
2509  return FC; // Fold a few common cases...
2510 
2511  if (OnlyIfReduced)
2512  return nullptr;
2513 
2514  // Look up the constant in the table first to ensure uniqueness
2515  Constant *ArgVec[] = { LHS, RHS };
2516  // Get the key type with both the opcode and predicate
2517  const ConstantExprKeyType Key(Instruction::ICmp, ArgVec, pred);
2518 
2519  Type *ResultTy = Type::getInt1Ty(LHS->getContext());
2520  if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
2521  ResultTy = VectorType::get(ResultTy, VT->getElementCount());
2522 
2523  LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
2524  return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
2525 }
2526 
2528  Constant *RHS, bool OnlyIfReduced) {
2529  assert(LHS->getType() == RHS->getType());
2531  "Invalid FCmp Predicate");
2532 
2533  if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
2534  return FC; // Fold a few common cases...
2535 
2536  if (OnlyIfReduced)
2537  return nullptr;
2538 
2539  // Look up the constant in the table first to ensure uniqueness
2540  Constant *ArgVec[] = { LHS, RHS };
2541  // Get the key type with both the opcode and predicate
2542  const ConstantExprKeyType Key(Instruction::FCmp, ArgVec, pred);
2543 
2544  Type *ResultTy = Type::getInt1Ty(LHS->getContext());
2545  if (VectorType *VT = dyn_cast<VectorType>(LHS->getType()))
2546  ResultTy = VectorType::get(ResultTy, VT->getElementCount());
2547 
2548  LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl;
2549  return pImpl->ExprConstants.getOrCreate(ResultTy, Key);
2550 }
2551 
2553  Type *OnlyIfReducedTy) {
2554  assert(Val->getType()->isVectorTy() &&
2555  "Tried to create extractelement operation on non-vector type!");
2556  assert(Idx->getType()->isIntegerTy() &&
2557  "Extractelement index must be an integer type!");
2558 
2560  return FC; // Fold a few common cases.
2561 
2562  Type *ReqTy = cast<VectorType>(Val->getType())->getElementType();
2563  if (OnlyIfReducedTy == ReqTy)
2564  return nullptr;
2565 
2566  // Look up the constant in the table first to ensure uniqueness
2567  Constant *ArgVec[] = { Val, Idx };
2568  const ConstantExprKeyType Key(Instruction::ExtractElement, ArgVec);
2569 
2570  LLVMContextImpl *pImpl = Val->getContext().pImpl;
2571  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2572 }
2573 
2575  Constant *Idx, Type *OnlyIfReducedTy) {
2576  assert(Val->getType()->isVectorTy() &&
2577  "Tried to create insertelement operation on non-vector type!");
2578  assert(Elt->getType() == cast<VectorType>(Val->getType())->getElementType() &&
2579  "Insertelement types must match!");
2580  assert(Idx->getType()->isIntegerTy() &&
2581  "Insertelement index must be i32 type!");
2582 
2583  if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx))
2584  return FC; // Fold a few common cases.
2585 
2586  if (OnlyIfReducedTy == Val->getType())
2587  return nullptr;
2588 
2589  // Look up the constant in the table first to ensure uniqueness
2590  Constant *ArgVec[] = { Val, Elt, Idx };
2591  const ConstantExprKeyType Key(Instruction::InsertElement, ArgVec);
2592 
2593  LLVMContextImpl *pImpl = Val->getContext().pImpl;
2594  return pImpl->ExprConstants.getOrCreate(Val->getType(), Key);
2595 }
2596 
2599  Type *OnlyIfReducedTy) {
2601  "Invalid shuffle vector constant expr operands!");
2602 
2604  return FC; // Fold a few common cases.
2605 
2606  unsigned NElts = Mask.size();
2607  auto V1VTy = cast<VectorType>(V1->getType());
2608  Type *EltTy = V1VTy->getElementType();
2609  bool TypeIsScalable = isa<ScalableVectorType>(V1VTy);
2610  Type *ShufTy = VectorType::get(EltTy, NElts, TypeIsScalable);
2611 
2612  if (OnlyIfReducedTy == ShufTy)
2613  return nullptr;
2614 
2615  // Look up the constant in the table first to ensure uniqueness
2616  Constant *ArgVec[] = {V1, V2};
2617  ConstantExprKeyType Key(Instruction::ShuffleVector, ArgVec, 0, 0, None, Mask);
2618 
2619  LLVMContextImpl *pImpl = ShufTy->getContext().pImpl;
2620  return pImpl->ExprConstants.getOrCreate(ShufTy, Key);
2621 }
2622 
2624  ArrayRef<unsigned> Idxs,
2625  Type *OnlyIfReducedTy) {
2626  assert(Agg->getType()->isFirstClassType() &&
2627  "Non-first-class type for constant insertvalue expression");
2628 
2630  Idxs) == Val->getType() &&
2631  "insertvalue indices invalid!");
2632  Type *ReqTy = Val->getType();
2633 
2634  if (Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs))
2635  return FC;
2636 
2637  if (OnlyIfReducedTy == ReqTy)
2638  return nullptr;
2639 
2640  Constant *ArgVec[] = { Agg, Val };
2641  const ConstantExprKeyType Key(Instruction::InsertValue, ArgVec, 0, 0, Idxs);
2642 
2643  LLVMContextImpl *pImpl = Agg->getContext().pImpl;
2644  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2645 }
2646 
2648  Type *OnlyIfReducedTy) {
2649  assert(Agg->getType()->isFirstClassType() &&
2650  "Tried to create extractelement operation on non-first-class type!");
2651 
2652  Type *ReqTy = ExtractValueInst::getIndexedType(Agg->getType(), Idxs);
2653  (void)ReqTy;
2654  assert(ReqTy && "extractvalue indices invalid!");
2655 
2656  assert(Agg->getType()->isFirstClassType() &&
2657  "Non-first-class type for constant extractvalue expression");
2659  return FC;
2660 
2661  if (OnlyIfReducedTy == ReqTy)
2662  return nullptr;
2663 
2664  Constant *ArgVec[] = { Agg };
2665  const ConstantExprKeyType Key(Instruction::ExtractValue, ArgVec, 0, 0, Idxs);
2666 
2667  LLVMContextImpl *pImpl = Agg->getContext().pImpl;
2668  return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
2669 }
2670 
2671 Constant *ConstantExpr::getNeg(Constant *C, bool HasNUW, bool HasNSW) {
2672  assert(C->getType()->isIntOrIntVectorTy() &&
2673  "Cannot NEG a nonintegral value!");
2674  return getSub(ConstantFP::getZeroValueForNegation(C->getType()),
2675  C, HasNUW, HasNSW);
2676 }
2677 
2679  assert(C->getType()->isFPOrFPVectorTy() &&
2680  "Cannot FNEG a non-floating-point value!");
2681  return get(Instruction::FNeg, C);
2682 }
2683 
2685  assert(C->getType()->isIntOrIntVectorTy() &&
2686  "Cannot NOT a nonintegral value!");
2687  return get(Instruction::Xor, C, Constant::getAllOnesValue(C->getType()));
2688 }
2689 
2691  bool HasNUW, bool HasNSW) {
2692  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2694  return get(Instruction::Add, C1, C2, Flags);
2695 }
2696 
2698  return get(Instruction::FAdd, C1, C2);
2699 }
2700 
2702  bool HasNUW, bool HasNSW) {
2703  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2705  return get(Instruction::Sub, C1, C2, Flags);
2706 }
2707 
2709  return get(Instruction::FSub, C1, C2);
2710 }
2711 
2713  bool HasNUW, bool HasNSW) {
2714  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2716  return get(Instruction::Mul, C1, C2, Flags);
2717 }
2718 
2720  return get(Instruction::FMul, C1, C2);
2721 }
2722 
2724  return get(Instruction::UDiv, C1, C2,
2725  isExact ? PossiblyExactOperator::IsExact : 0);
2726 }
2727 
2729  return get(Instruction::SDiv, C1, C2,
2730  isExact ? PossiblyExactOperator::IsExact : 0);
2731 }
2732 
2734  return get(Instruction::FDiv, C1, C2);
2735 }
2736 
2738  return get(Instruction::URem, C1, C2);
2739 }
2740 
2742  return get(Instruction::SRem, C1, C2);
2743 }
2744 
2746  return get(Instruction::FRem, C1, C2);
2747 }
2748 
2750  return get(Instruction::And, C1, C2);
2751 }
2752 
2754  return get(Instruction::Or, C1, C2);
2755 }
2756 
2758  return get(Instruction::Xor, C1, C2);
2759 }
2760 
2763  return getSelect(Cmp, C1, C2);
2764 }
2765 
2767  bool HasNUW, bool HasNSW) {
2768  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
2770  return get(Instruction::Shl, C1, C2, Flags);
2771 }
2772 
2774  return get(Instruction::LShr, C1, C2,
2775  isExact ? PossiblyExactOperator::IsExact : 0);
2776 }
2777 
2779  return get(Instruction::AShr, C1, C2,
2780  isExact ? PossiblyExactOperator::IsExact : 0);
2781 }
2782 
2784  Type *Ty = C->getType();
2785  const APInt *IVal;
2786  if (match(C, m_APInt(IVal)) && IVal->isPowerOf2())
2787  return ConstantInt::get(Ty, IVal->logBase2());
2788 
2789  // FIXME: We can extract pow of 2 of splat constant for scalable vectors.
2790  auto *VecTy = dyn_cast<FixedVectorType>(Ty);
2791  if (!VecTy)
2792  return nullptr;
2793 
2795  for (unsigned I = 0, E = VecTy->getNumElements(); I != E; ++I) {
2796  Constant *Elt = C->getAggregateElement(I);
2797  if (!Elt)
2798  return nullptr;
2799  // Note that log2(iN undef) is *NOT* iN undef, because log2(iN undef) u< N.
2800  if (isa<UndefValue>(Elt)) {
2801  Elts.push_back(Constant::getNullValue(Ty->getScalarType()));
2802  continue;
2803  }
2804  if (!match(Elt, m_APInt(IVal)) || !IVal->isPowerOf2())
2805  return nullptr;
2806  Elts.push_back(ConstantInt::get(Ty->getScalarType(), IVal->logBase2()));
2807  }
2808 
2809  return ConstantVector::get(Elts);
2810 }
2811 
2813  bool AllowRHSConstant) {
2814  assert(Instruction::isBinaryOp(Opcode) && "Only binops allowed");
2815 
2816  // Commutative opcodes: it does not matter if AllowRHSConstant is set.
2817  if (Instruction::isCommutative(Opcode)) {
2818  switch (Opcode) {
2819  case Instruction::Add: // X + 0 = X
2820  case Instruction::Or: // X | 0 = X
2821  case Instruction::Xor: // X ^ 0 = X
2822  return Constant::getNullValue(Ty);
2823  case Instruction::Mul: // X * 1 = X
2824  return ConstantInt::get(Ty, 1);
2825  case Instruction::And: // X & -1 = X
2826  return Constant::getAllOnesValue(Ty);
2827  case Instruction::FAdd: // X + -0.0 = X
2828  // TODO: If the fadd has 'nsz', should we return +0.0?
2829  return ConstantFP::getNegativeZero(Ty);
2830  case Instruction::FMul: // X * 1.0 = X
2831  return ConstantFP::get(Ty, 1.0);
2832  default:
2833  llvm_unreachable("Every commutative binop has an identity constant");
2834  }
2835  }
2836 
2837  // Non-commutative opcodes: AllowRHSConstant must be set.
2838  if (!AllowRHSConstant)
2839  return nullptr;
2840 
2841  switch (Opcode) {
2842  case Instruction::Sub: // X - 0 = X
2843  case Instruction::Shl: // X << 0 = X
2844  case Instruction::LShr: // X >>u 0 = X
2845  case Instruction::AShr: // X >> 0 = X
2846  case Instruction::FSub: // X - 0.0 = X
2847  return Constant::getNullValue(Ty);
2848  case Instruction::SDiv: // X / 1 = X
2849  case Instruction::UDiv: // X /u 1 = X
2850  return ConstantInt::get(Ty, 1);
2851  case Instruction::FDiv: // X / 1.0 = X
2852  return ConstantFP::get(Ty, 1.0);
2853  default:
2854  return nullptr;
2855  }
2856 }
2857 
2859  switch (Opcode) {
2860  default:
2861  // Doesn't have an absorber.
2862  return nullptr;
2863 
2864  case Instruction::Or:
2865  return Constant::getAllOnesValue(Ty);
2866 
2867  case Instruction::And:
2868  case Instruction::Mul:
2869  return Constant::getNullValue(Ty);
2870  }
2871 }
2872 
2873 /// Remove the constant from the constant table.
2874 void ConstantExpr::destroyConstantImpl() {
2875  getType()->getContext().pImpl->ExprConstants.remove(this);
2876 }
2877 
2878 const char *ConstantExpr::getOpcodeName() const {
2880 }
2881 
2882 GetElementPtrConstantExpr::GetElementPtrConstantExpr(
2883  Type *SrcElementTy, Constant *C, ArrayRef<Constant *> IdxList, Type *DestTy)
2884  : ConstantExpr(DestTy, Instruction::GetElementPtr,
2886  (IdxList.size() + 1),
2887  IdxList.size() + 1),
2888  SrcElementTy(SrcElementTy),
2889  ResElementTy(GetElementPtrInst::getIndexedType(SrcElementTy, IdxList)) {
2890  Op<0>() = C;
2891  Use *OperandList = getOperandList();
2892  for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
2893  OperandList[i+1] = IdxList[i];
2894 }
2895 
2897  return SrcElementTy;
2898 }
2899 
2901  return ResElementTy;
2902 }
2903 
2904 //===----------------------------------------------------------------------===//
2905 // ConstantData* implementations
2906 
2908  if (ArrayType *ATy = dyn_cast<ArrayType>(getType()))
2909  return ATy->getElementType();
2910  return cast<VectorType>(getType())->getElementType();
2911 }
2912 
2914  return StringRef(DataElements, getNumElements()*getElementByteSize());
2915 }
2916 
2918  if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() || Ty->isDoubleTy())
2919  return true;
2920  if (auto *IT = dyn_cast<IntegerType>(Ty)) {
2921  switch (IT->getBitWidth()) {
2922  case 8:
2923  case 16:
2924  case 32:
2925  case 64:
2926  return true;
2927  default: break;
2928  }
2929  }
2930  return false;
2931 }
2932 
2934  if (ArrayType *AT = dyn_cast<ArrayType>(getType()))
2935  return AT->getNumElements();
2936  return cast<FixedVectorType>(getType())->getNumElements();
2937 }
2938 
2939 
2941  return getElementType()->getPrimitiveSizeInBits()/8;
2942 }
2943 
2944 /// Return the start of the specified element.
2945 const char *ConstantDataSequential::getElementPointer(unsigned Elt) const {
2946  assert(Elt < getNumElements() && "Invalid Elt");
2947  return DataElements+Elt*getElementByteSize();
2948 }
2949 
2950 
2951 /// Return true if the array is empty or all zeros.
2952 static bool isAllZeros(StringRef Arr) {
2953  for (char I : Arr)
2954  if (I != 0)
2955  return false;
2956  return true;
2957 }
2958 
2959 /// This is the underlying implementation of all of the
2960 /// ConstantDataSequential::get methods. They all thunk down to here, providing
2961 /// the correct element type. We take the bytes in as a StringRef because
2962 /// we *want* an underlying "char*" to avoid TBAA type punning violations.
2964 #ifndef NDEBUG
2965  if (ArrayType *ATy = dyn_cast<ArrayType>(Ty))
2966  assert(isElementTypeCompatible(ATy->getElementType()));
2967  else
2968  assert(isElementTypeCompatible(cast<VectorType>(Ty)->getElementType()));
2969 #endif
2970  // If the elements are all zero or there are no elements, return a CAZ, which
2971  // is more dense and canonical.
2972  if (isAllZeros(Elements))
2973  return ConstantAggregateZero::get(Ty);
2974 
2975  // Do a lookup to see if we have already formed one of these.
2976  auto &Slot =
2977  *Ty->getContext()
2978  .pImpl->CDSConstants.insert(std::make_pair(Elements, nullptr))
2979  .first;
2980 
2981  // The bucket can point to a linked list of different CDS's that have the same
2982  // body but different types. For example, 0,0,0,1 could be a 4 element array
2983  // of i8, or a 1-element array of i32. They'll both end up in the same
2984  /// StringMap bucket, linked up by their Next pointers. Walk the list.
2985  std::unique_ptr<ConstantDataSequential> *Entry = &Slot.second;
2986  for (; *Entry; Entry = &(*Entry)->Next)
2987  if ((*Entry)->getType() == Ty)
2988  return Entry->get();
2989 
2990  // Okay, we didn't get a hit. Create a node of the right class, link it in,
2991  // and return it.
2992  if (isa<ArrayType>(Ty)) {
2993  // Use reset because std::make_unique can't access the constructor.
2994  Entry->reset(new ConstantDataArray(Ty, Slot.first().data()));
2995  return Entry->get();
2996  }
2997 
2998  assert(isa<VectorType>(Ty));
2999  // Use reset because std::make_unique can't access the constructor.
3000  Entry->reset(new ConstantDataVector(Ty, Slot.first().data()));
3001  return Entry->get();
3002 }
3003 
3004 void ConstantDataSequential::destroyConstantImpl() {
3005  // Remove the constant from the StringMap.
3008 
3009  auto Slot = CDSConstants.find(getRawDataValues());
3010 
3011  assert(Slot != CDSConstants.end() && "CDS not found in uniquing table");
3012 
3013  std::unique_ptr<ConstantDataSequential> *Entry = &Slot->getValue();
3014 
3015  // Remove the entry from the hash table.
3016  if (!(*Entry)->Next) {
3017  // If there is only one value in the bucket (common case) it must be this
3018  // entry, and removing the entry should remove the bucket completely.
3019  assert(Entry->get() == this && "Hash mismatch in ConstantDataSequential");
3020  getContext().pImpl->CDSConstants.erase(Slot);
3021  return;
3022  }
3023 
3024  // Otherwise, there are multiple entries linked off the bucket, unlink the
3025  // node we care about but keep the bucket around.
3026  while (true) {
3027  std::unique_ptr<ConstantDataSequential> &Node = *Entry;
3028  assert(Node && "Didn't find entry in its uniquing hash table!");
3029  // If we found our entry, unlink it from the list and we're done.
3030  if (Node.get() == this) {
3031  Node = std::move(Node->Next);
3032  return;
3033  }
3034 
3035  Entry = &Node->Next;
3036  }
3037 }
3038 
3039 /// getFP() constructors - Return a constant of array type with a float
3040 /// element type taken from argument `ElementType', and count taken from
3041 /// argument `Elts'. The amount of bits of the contained type must match the
3042 /// number of bits of the type contained in the passed in ArrayRef.
3043 /// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
3044 /// that this can return a ConstantAggregateZero object.
3046  assert((ElementType->isHalfTy() || ElementType->isBFloatTy()) &&
3047  "Element type is not a 16-bit float type");
3048  Type *Ty = ArrayType::get(ElementType, Elts.size());
3049  const char *Data = reinterpret_cast<const char *>(Elts.data());
3050  return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3051 }
3053  assert(ElementType->isFloatTy() && "Element type is not a 32-bit float type");
3054  Type *Ty = ArrayType::get(ElementType, Elts.size());
3055  const char *Data = reinterpret_cast<const char *>(Elts.data());
3056  return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3057 }
3059  assert(ElementType->isDoubleTy() &&
3060  "Element type is not a 64-bit float type");
3061  Type *Ty = ArrayType::get(ElementType, Elts.size());
3062  const char *Data = reinterpret_cast<const char *>(Elts.data());
3063  return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3064 }
3065 
3067  StringRef Str, bool AddNull) {
3068  if (!AddNull) {
3069  const uint8_t *Data = Str.bytes_begin();
3070  return get(Context, makeArrayRef(Data, Str.size()));
3071  }
3072 
3073  SmallVector<uint8_t, 64> ElementVals;
3074  ElementVals.append(Str.begin(), Str.end());
3075  ElementVals.push_back(0);
3076  return get(Context, ElementVals);
3077 }
3078 
3079 /// get() constructors - Return a constant with vector type with an element
3080 /// count and element type matching the ArrayRef passed in. Note that this
3081 /// can return a ConstantAggregateZero object.
3083  auto *Ty = FixedVectorType::get(Type::getInt8Ty(Context), Elts.size());
3084  const char *Data = reinterpret_cast<const char *>(Elts.data());
3085  return getImpl(StringRef(Data, Elts.size() * 1), Ty);
3086 }
3088  auto *Ty = FixedVectorType::get(Type::getInt16Ty(Context), Elts.size());
3089  const char *Data = reinterpret_cast<const char *>(Elts.data());
3090  return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3091 }
3093  auto *Ty = FixedVectorType::get(Type::getInt32Ty(Context), Elts.size());
3094  const char *Data = reinterpret_cast<const char *>(Elts.data());
3095  return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3096 }
3098  auto *Ty = FixedVectorType::get(Type::getInt64Ty(Context), Elts.size());
3099  const char *Data = reinterpret_cast<const char *>(Elts.data());
3100  return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3101 }
3103  auto *Ty = FixedVectorType::get(Type::getFloatTy(Context), Elts.size());
3104  const char *Data = reinterpret_cast<const char *>(Elts.data());
3105  return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3106 }
3108  auto *Ty = FixedVectorType::get(Type::getDoubleTy(Context), Elts.size());
3109  const char *Data = reinterpret_cast<const char *>(Elts.data());
3110  return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3111 }
3112 
3113 /// getFP() constructors - Return a constant of vector type with a float
3114 /// element type taken from argument `ElementType', and count taken from
3115 /// argument `Elts'. The amount of bits of the contained type must match the
3116 /// number of bits of the type contained in the passed in ArrayRef.
3117 /// (i.e. half or bfloat for 16bits, float for 32bits, double for 64bits) Note
3118 /// that this can return a ConstantAggregateZero object.
3120  ArrayRef<uint16_t> Elts) {
3121  assert((ElementType->isHalfTy() || ElementType->isBFloatTy()) &&
3122  "Element type is not a 16-bit float type");
3123  auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3124  const char *Data = reinterpret_cast<const char *>(Elts.data());
3125  return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3126 }
3128  ArrayRef<uint32_t> Elts) {
3129  assert(ElementType->isFloatTy() && "Element type is not a 32-bit float type");
3130  auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3131  const char *Data = reinterpret_cast<const char *>(Elts.data());
3132  return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3133 }
3135  ArrayRef<uint64_t> Elts) {
3136  assert(ElementType->isDoubleTy() &&
3137  "Element type is not a 64-bit float type");
3138  auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3139  const char *Data = reinterpret_cast<const char *>(Elts.data());
3140  return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3141 }
3142 
3145  "Element type not compatible with ConstantData");
3146  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
3147  if (CI->getType()->isIntegerTy(8)) {
3148  SmallVector<uint8_t, 16> Elts(NumElts, CI->getZExtValue());
3149  return get(V->getContext(), Elts);
3150  }
3151  if (CI->getType()->isIntegerTy(16)) {
3152  SmallVector<uint16_t, 16> Elts(NumElts, CI->getZExtValue());
3153  return get(V->getContext(), Elts);
3154  }
3155  if (CI->getType()->isIntegerTy(32)) {
3156  SmallVector<uint32_t, 16> Elts(NumElts, CI->getZExtValue());
3157  return get(V->getContext(), Elts);
3158  }
3159  assert(CI->getType()->isIntegerTy(64) && "Unsupported ConstantData type");
3160  SmallVector<uint64_t, 16> Elts(NumElts, CI->getZExtValue());
3161  return get(V->getContext(), Elts);
3162  }
3163 
3164  if (ConstantFP *CFP = dyn_cast<ConstantFP>(V)) {
3165  if (CFP->getType()->isHalfTy()) {
3167  NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3168  return getFP(V->getType(), Elts);
3169  }
3170  if (CFP->getType()->isBFloatTy()) {
3172  NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3173  return getFP(V->getType(), Elts);
3174  }
3175  if (CFP->getType()->isFloatTy()) {
3177  NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3178  return getFP(V->getType(), Elts);
3179  }
3180  if (CFP->getType()->isDoubleTy()) {
3182  NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
3183  return getFP(V->getType(), Elts);
3184  }
3185  }
3187 }
3188 
3189 
3191  assert(isa<IntegerType>(getElementType()) &&
3192  "Accessor can only be used when element is an integer");
3193  const char *EltPtr = getElementPointer(Elt);
3194 
3195  // The data is stored in host byte order, make sure to cast back to the right
3196  // type to load with the right endianness.
3197  switch (getElementType()->getIntegerBitWidth()) {
3198  default: llvm_unreachable("Invalid bitwidth for CDS");
3199  case 8:
3200  return *reinterpret_cast<const uint8_t *>(EltPtr);
3201  case 16:
3202  return *reinterpret_cast<const uint16_t *>(EltPtr);
3203  case 32:
3204  return *reinterpret_cast<const uint32_t *>(EltPtr);
3205  case 64:
3206  return *reinterpret_cast<const uint64_t *>(EltPtr);
3207  }
3208 }
3209 
3211  assert(isa<IntegerType>(getElementType()) &&
3212  "Accessor can only be used when element is an integer");
3213  const char *EltPtr = getElementPointer(Elt);
3214 
3215  // The data is stored in host byte order, make sure to cast back to the right
3216  // type to load with the right endianness.
3217  switch (getElementType()->getIntegerBitWidth()) {
3218  default: llvm_unreachable("Invalid bitwidth for CDS");
3219  case 8: {
3220  auto EltVal = *reinterpret_cast<const uint8_t *>(EltPtr);
3221  return APInt(8, EltVal);
3222  }
3223  case 16: {
3224  auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
3225  return APInt(16, EltVal);
3226  }
3227  case 32: {
3228  auto EltVal = *reinterpret_cast<const uint32_t *>(EltPtr);
3229  return APInt(32, EltVal);
3230  }
3231  case 64: {
3232  auto EltVal = *reinterpret_cast<const uint64_t *>(EltPtr);
3233  return APInt(64, EltVal);
3234  }
3235  }
3236 }
3237 
3239  const char *EltPtr = getElementPointer(Elt);
3240 
3241  switch (getElementType()->getTypeID()) {
3242  default:
3243  llvm_unreachable("Accessor can only be used when element is float/double!");
3244  case Type::HalfTyID: {
3245  auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
3246  return APFloat(APFloat::IEEEhalf(), APInt(16, EltVal));
3247  }
3248  case Type::BFloatTyID: {
3249  auto EltVal = *reinterpret_cast<const uint16_t *>(EltPtr);
3250  return APFloat(APFloat::BFloat(), APInt(16, EltVal));
3251  }
3252  case Type::FloatTyID: {
3253  auto EltVal = *reinterpret_cast<const uint32_t *>(EltPtr);
3254  return APFloat(APFloat::IEEEsingle(), APInt(32, EltVal));
3255  }
3256  case Type::DoubleTyID: {
3257  auto EltVal = *reinterpret_cast<const uint64_t *>(EltPtr);
3258  return APFloat(APFloat::IEEEdouble(), APInt(64, EltVal));
3259  }
3260  }
3261 }
3262 
3264  assert(getElementType()->isFloatTy() &&
3265  "Accessor can only be used when element is a 'float'");
3266  return *reinterpret_cast<const float *>(getElementPointer(Elt));
3267 }
3268 
3270  assert(getElementType()->isDoubleTy() &&
3271  "Accessor can only be used when element is a 'float'");
3272  return *reinterpret_cast<const double *>(getElementPointer(Elt));
3273 }
3274 
3276  if (getElementType()->isHalfTy() || getElementType()->isBFloatTy() ||
3277  getElementType()->isFloatTy() || getElementType()->isDoubleTy())
3279 
3281 }
3282 
3283 bool ConstantDataSequential::isString(unsigned CharSize) const {
3284  return isa<ArrayType>(getType()) && getElementType()->isIntegerTy(CharSize);
3285 }
3286 
3288  if (!isString())
3289  return false;
3290 
3291  StringRef Str = getAsString();
3292 
3293  // The last value must be nul.
3294  if (Str.back() != 0) return false;
3295 
3296  // Other elements must be non-nul.
3297  return Str.drop_back().find(0) == StringRef::npos;
3298 }
3299 
3300 bool ConstantDataVector::isSplatData() const {
3301  const char *Base = getRawDataValues().data();
3302 
3303  // Compare elements 1+ to the 0'th element.
3304  unsigned EltSize = getElementByteSize();
3305  for (unsigned i = 1, e = getNumElements(); i != e; ++i)
3306  if (memcmp(Base, Base+i*EltSize, EltSize))
3307  return false;
3308 
3309  return true;
3310 }
3311 
3313  if (!IsSplatSet) {
3314  IsSplatSet = true;
3315  IsSplat = isSplatData();
3316  }
3317  return IsSplat;
3318 }
3319 
3321  // If they're all the same, return the 0th one as a representative.
3322  return isSplat() ? getElementAsConstant(0) : nullptr;
3323 }
3324 
3325 //===----------------------------------------------------------------------===//
3326 // handleOperandChange implementations
3327 
3328 /// Update this constant array to change uses of
3329 /// 'From' to be uses of 'To'. This must update the uniquing data structures
3330 /// etc.
3331 ///
3332 /// Note that we intentionally replace all uses of From with To here. Consider
3333 /// a large array that uses 'From' 1000 times. By handling this case all here,
3334 /// ConstantArray::handleOperandChange is only invoked once, and that
3335 /// single invocation handles all 1000 uses. Handling them one at a time would
3336 /// work, but would be really slow because it would have to unique each updated
3337 /// array instance.
3338 ///
3340  Value *Replacement = nullptr;
3341  switch (getValueID()) {
3342  default:
3343  llvm_unreachable("Not a constant!");
3344 #define HANDLE_CONSTANT(Name) \
3345  case Value::Name##Val: \
3346  Replacement = cast<Name>(this)->handleOperandChangeImpl(From, To); \
3347  break;
3348 #include "llvm/IR/Value.def"
3349  }
3350 
3351  // If handleOperandChangeImpl returned nullptr, then it handled
3352  // replacing itself and we don't want to delete or replace anything else here.
3353  if (!Replacement)
3354  return;
3355 
3356  // I do need to replace this with an existing value.
3357  assert(Replacement != this && "I didn't contain From!");
3358 
3359  // Everyone using this now uses the replacement.
3360  replaceAllUsesWith(Replacement);
3361 
3362  // Delete the old constant!
3363  destroyConstant();
3364 }
3365 
3366 Value *ConstantArray::handleOperandChangeImpl(Value *From, Value *To) {
3367  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
3368  Constant *ToC = cast<Constant>(To);
3369 
3371  Values.reserve(getNumOperands()); // Build replacement array.
3372 
3373  // Fill values with the modified operands of the constant array. Also,
3374  // compute whether this turns into an all-zeros array.
3375  unsigned NumUpdated = 0;
3376 
3377  // Keep track of whether all the values in the array are "ToC".
3378  bool AllSame = true;
3379  Use *OperandList = getOperandList();
3380  unsigned OperandNo = 0;
3381  for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
3382  Constant *Val = cast<Constant>(O->get());
3383  if (Val == From) {
3384  OperandNo = (O - OperandList);
3385  Val = ToC;
3386  ++NumUpdated;
3387  }
3388  Values.push_back(Val);
3389  AllSame &= Val == ToC;
3390  }
3391 
3392  if (AllSame && ToC->isNullValue())
3394 
3395  if (AllSame && isa<UndefValue>(ToC))
3396  return UndefValue::get(getType());
3397 
3398  // Check for any other type of constant-folding.
3399  if (Constant *C = getImpl(getType(), Values))
3400  return C;
3401 
3402  // Update to the new value.
3404  Values, this, From, ToC, NumUpdated, OperandNo);
3405 }
3406 
3407 Value *ConstantStruct::handleOperandChangeImpl(Value *From, Value *To) {
3408  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
3409  Constant *ToC = cast<Constant>(To);
3410 
3411  Use *OperandList = getOperandList();
3412 
3414  Values.reserve(getNumOperands()); // Build replacement struct.
3415 
3416  // Fill values with the modified operands of the constant struct. Also,
3417  // compute whether this turns into an all-zeros struct.
3418  unsigned NumUpdated = 0;
3419  bool AllSame = true;
3420  unsigned OperandNo = 0;
3421  for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O) {
3422  Constant *Val = cast<Constant>(O->get());
3423  if (Val == From) {
3424  OperandNo = (O - OperandList);
3425  Val = ToC;
3426  ++NumUpdated;
3427  }
3428  Values.push_back(Val);
3429  AllSame &= Val == ToC;
3430  }
3431 
3432  if (AllSame && ToC->isNullValue())
3434 
3435  if (AllSame && isa<UndefValue>(ToC))
3436  return UndefValue::get(getType());
3437 
3438  // Update to the new value.
3440  Values, this, From, ToC, NumUpdated, OperandNo);
3441 }
3442 
3443 Value *ConstantVector::handleOperandChangeImpl(Value *From, Value *To) {
3444  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
3445  Constant *ToC = cast<Constant>(To);
3446 
3448  Values.reserve(getNumOperands()); // Build replacement array...
3449  unsigned NumUpdated = 0;
3450  unsigned OperandNo = 0;
3451  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
3452  Constant *Val = getOperand(i);
3453  if (Val == From) {
3454  OperandNo = i;
3455  ++NumUpdated;
3456  Val = ToC;
3457  }
3458  Values.push_back(Val);
3459  }
3460 
3461  if (Constant *C = getImpl(Values))
3462  return C;
3463 
3464  // Update to the new value.
3466  Values, this, From, ToC, NumUpdated, OperandNo);
3467 }
3468 
3469 Value *ConstantExpr::handleOperandChangeImpl(Value *From, Value *ToV) {
3470  assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!");
3471  Constant *To = cast<Constant>(ToV);
3472 
3474  unsigned NumUpdated = 0;
3475  unsigned OperandNo = 0;
3476  for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
3477  Constant *Op = getOperand(i);
3478  if (Op == From) {
3479  OperandNo = i;
3480  ++NumUpdated;
3481  Op = To;
3482  }
3483  NewOps.push_back(Op);
3484  }
3485  assert(NumUpdated && "I didn't contain From!");
3486 
3487  if (Constant *C = getWithOperands(NewOps, getType(), true))
3488  return C;
3489 
3490  // Update to the new value.
3491  return getContext().pImpl->ExprConstants.replaceOperandsInPlace(
3492  NewOps, this, From, To, NumUpdated, OperandNo);
3493 }
3494 
3496  SmallVector<Value *, 4> ValueOperands(operands());
3497  ArrayRef<Value*> Ops(ValueOperands);
3498 
3499  switch (getOpcode()) {
3500  case Instruction::Trunc:
3501  case Instruction::ZExt:
3502  case Instruction::SExt:
3503  case Instruction::FPTrunc:
3504  case Instruction::FPExt:
3505  case Instruction::UIToFP:
3506  case Instruction::SIToFP:
3507  case Instruction::FPToUI:
3508  case Instruction::FPToSI:
3509  case Instruction::PtrToInt:
3510  case Instruction::IntToPtr:
3511  case Instruction::BitCast:
3512  case Instruction::AddrSpaceCast:
3514  Ops[0], getType());
3515  case Instruction::Select:
3516  return SelectInst::Create(Ops[0], Ops[1], Ops[2]);
3517  case Instruction::InsertElement:
3518  return InsertElementInst::Create(Ops[0], Ops[1], Ops[2]);
3519  case Instruction::ExtractElement:
3520  return ExtractElementInst::Create(Ops[0], Ops[1]);
3521  case Instruction::InsertValue:
3522  return InsertValueInst::Create(Ops[0], Ops[1], getIndices());
3523  case Instruction::ExtractValue:
3524  return ExtractValueInst::Create(Ops[0], getIndices());
3525  case Instruction::ShuffleVector:
3526  return new ShuffleVectorInst(Ops[0], Ops[1], getShuffleMask());
3527 
3528  case Instruction::GetElementPtr: {
3529  const auto *GO = cast<GEPOperator>(this);
3530  if (GO->isInBounds())
3531  return GetElementPtrInst::CreateInBounds(GO->getSourceElementType(),
3532  Ops[0], Ops.slice(1));
3533  return GetElementPtrInst::Create(GO->getSourceElementType(), Ops[0],
3534  Ops.slice(1));
3535  }
3536  case Instruction::ICmp:
3537  case Instruction::FCmp:
3539  (CmpInst::Predicate)getPredicate(), Ops[0], Ops[1]);
3540  case Instruction::FNeg:
3542  default:
3543  assert(getNumOperands() == 2 && "Must be binary operator?");
3544  BinaryOperator *BO =
3546  Ops[0], Ops[1]);
3547  if (isa<OverflowingBinaryOperator>(BO)) {
3552  }
3553  if (isa<PossiblyExactOperator>(BO))
3555  return BO;
3556  }
3557 }
i
i
Definition: README.txt:29
use
Move duplicate certain instructions close to their use
Definition: Localizer.cpp:31
llvm::lltok::APFloat
@ APFloat
Definition: LLToken.h:495
llvm::CmpInst::FCMP_ULE
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:735
llvm::Type::ArrayTyID
@ ArrayTyID
Arrays.
Definition: Type.h:75
llvm::LLVMContext::pImpl
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:70
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:392
llvm::Value::stripPointerCastsAndAliases
const Value * stripPointerCastsAndAliases() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
Definition: Value.cpp:691
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 file implements support for optimizing divisions by a constant.
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:2940
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:2733
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:2552
llvm::deleteConstant
void deleteConstant(Constant *C)
Definition: Constants.cpp:500
llvm::CmpInst::ICMP_EQ
@ ICMP_EQ
equal
Definition: InstrTypes.h:741
llvm::LLVMContextImpl::BlockAddresses
DenseMap< std::pair< const Function *, const BasicBlock * >, BlockAddress * > BlockAddresses
Definition: LLVMContextImpl.h:1432
llvm::ConstantExpr::getNot
static Constant * getNot(Constant *C)
Definition: Constants.cpp:2684
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:1614
llvm::ConstantExpr::getZExtOrBitCast
static Constant * getZExtOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:2027
llvm::Instruction::UnaryOps
UnaryOps
Definition: Instruction.h:778
llvm::ConstantExpr::getSIToFP
static Constant * getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2172
llvm::generic_gep_type_iterator
Definition: GetElementPtrTypeIterator.h:31
llvm::ARMII::VecSize
@ VecSize
Definition: ARMBaseInfo.h:417
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:720
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:91
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:2878
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:1109
isAllZeros
static bool isAllZeros(StringRef Arr)
Return true if the array is empty or all zeros.
Definition: Constants.cpp:2952
llvm::ElementCount
Definition: TypeSize.h:386
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:1387
llvm::ConstantExpr::getZExt
static Constant * getZExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2123
T
llvm::Function
Definition: Function.h:62
getFunction
static Function * getFunction(Constant *C)
Definition: Evaluator.cpp:255
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:1352
llvm::LLVMContextImpl::UVConstants
DenseMap< Type *, std::unique_ptr< UndefValue > > UVConstants
Definition: LLVMContextImpl.h:1425
rangeOnlyContains
static bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt)
Definition: Constants.cpp:1206
llvm::ConstantExpr::getFRem
static Constant * getFRem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2745
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:2083
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:1267
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:1179
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:60
llvm::ConstantExpr::getSExt
static Constant * getSExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2109
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:1168
getImpl
static LazyValueInfoImpl & getImpl(void *&PImpl, AssumptionCache *AC, const Module *M)
This lazily constructs the LazyValueInfoImpl.
Definition: LazyValueInfo.cpp:1506
llvm::ConstantExpr::getICmp
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
Definition: Constants.cpp:2502
llvm::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:1189
llvm::generic_gep_type_iterator::getSequentialNumElements
uint64_t getSequentialNumElements() const
Definition: GetElementPtrTypeIterator.h:131
llvm::CmpInst::FCMP_ONE
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:728
llvm::Type::getFltSemantics
const fltSemantics & getFltSemantics() const
Definition: Type.cpp:69
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:3190
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:1525
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:3461
llvm::InsertValueInst::Create
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:2530
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:3076
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:742
llvm::ConstantExpr::getBitCast
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2233
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:2498
llvm::LLVMContextImpl::ExprConstants
ConstantUniqueMap< ConstantExpr > ExprConstants
Definition: LLVMContextImpl.h:1436
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:1080
llvm::ConstantExpr::getSelect
static Constant * getSelect(Constant *C, Constant *V1, Constant *V2, Type *OnlyIfReducedTy=nullptr)
Select constant expr.
Definition: Constants.cpp:2420
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:2623
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:3082
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:3263
llvm::InsertElementInst::Create
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:1951
llvm::ConstantAggregateZero::getElementCount
ElementCount getElementCount() const
Return the number of elements in the array, vector, or struct.
Definition: Constants.cpp:1131
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:2380
llvm::CmpInst::ICMP_SGT
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:747
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:1886
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::APInt::getBitWidth
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1399
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:1512
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:2917
llvm::ConstantExpr::getFPToSI
static Constant * getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2194
llvm::ConstantAggregateZero
All zero aggregate value.
Definition: Constants.h:336
llvm::Constant::needsDynamicRelocation
bool needsDynamicRelocation() const
Definition: Constants.cpp:660
llvm::copy
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1602
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:664
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:2055
llvm::CmpInst::ICMP_SLE
@ ICMP_SLE
signed less or equal
Definition: InstrTypes.h:750
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:2783
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:635
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:1046
llvm::gep_type_begin
gep_type_iterator gep_type_begin(const User *GEP)
Definition: GetElementPtrTypeIterator.h:139
llvm::Type::isFloatingPointTy
bool isFloatingPointTy() const
Return true if this is one of the six floating-point types.
Definition: Type.h:162
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:724
llvm::ConstantDataSequential::isString
bool isString(unsigned CharSize=8) const
This method returns true if this is an array of CharSize integers.
Definition: Constants.cpp:3283
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:1434
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:634
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:162
llvm::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:56
llvm::ConstantFoldExtractValueInstruction
Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)
Attempt to constant fold an extractvalue instruction with the specified operands and indices.
Definition: ConstantFold.cpp:774
llvm::ConstantExpr::getWithOperands
Constant * getWithOperands(ArrayRef< Constant * > Ops) const
This returns the current constant expression with the operands replaced with the specified values.
Definition: Constants.h:1293
getFPSequenceIfElementsMatch
static Constant * getFPSequenceIfElementsMatch(ArrayRef< Constant * > V)
Definition: Constants.cpp:1227
llvm::ConstantExpr::getPointerCast
static Constant * getPointerCast(Constant *C, Type *Ty)
Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant expression.
Definition: Constants.cpp:2045
llvm::LLVMContextImpl::TheNoneToken
std::unique_ptr< ConstantTokenNone > TheNoneToken
Definition: LLVMContextImpl.h:1443
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:1415
llvm::gep_type_end
gep_type_iterator gep_type_end(const User *GEP)
Definition: GetElementPtrTypeIterator.h:146
isUndef
static bool isUndef(ArrayRef< int > Mask)
Definition: HexagonISelDAGToDAGHVX.cpp:912
llvm::CmpInst::FCMP_ULT
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:734
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
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:2701
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:3238
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
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:1335
llvm::all_of
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1551
llvm::SelectInst::Create
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=nullptr, Instruction *MDFrom=nullptr)
Definition: Instructions.h:1769
llvm::ConstantExpr::getShuffleMask
ArrayRef< int > getShuffleMask() const
Assert that this is a shufflevector and return the mask.
Definition: Constants.cpp:1529
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:410
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:813
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:648
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:1154
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:746
llvm::LLVMContextImpl
Definition: LLVMContextImpl.h:1341
llvm::ConstantExpr::getIntToPtr
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2219
llvm::LLVMContextImpl::CAZConstants
DenseMap< Type *, std::unique_ptr< ConstantAggregateZero > > CAZConstants
Definition: LLVMContextImpl.h:1412
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:2723
llvm::CmpInst::FCMP_UGE
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:733
llvm::ConstantExpr::getPtrToInt
static Constant * getPtrToInt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2205
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
llvm::Instruction::OtherOps
OtherOps
Definition: Instruction.h:813
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:2858
llvm::Value::getValueID
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:533
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:799
llvm::ConstantArray
ConstantArray - Constant Array Declarations.
Definition: Constants.h:409
llvm::Constant::getAllOnesValue
static Constant * getAllOnesValue(Type *Ty)
Definition: Constants.cpp:405
llvm::generic_gep_type_iterator::isBoundedSequential
bool isBoundedSequential() const
Definition: GetElementPtrTypeIterator.h:127
llvm::CmpInst::FCMP_UNO
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:730
llvm::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:3320
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:2200
llvm::ConstantFP
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:257
llvm::ConstantVector::getSplat
static Constant * getSplat(ElementCount EC, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
Definition: Constants.cpp:1437
llvm::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:1096
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:1796
llvm::ConstantExpr::getXor
static Constant * getXor(Constant *C1, Constant *C2)
Definition: Constants.cpp:2757
llvm::ConstantExpr::getURem
static Constant * getURem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2737
llvm::ConstantInt::get
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:925
llvm::CmpInst::FCMP_OEQ
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:723
llvm::ConstantExpr::getAsInstruction
Instruction * getAsInstruction() const
Returns an Instruction which implements the same operation as this ConstantExpr.
Definition: Constants.cpp:3495
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:2963
llvm::CmpInst::FCMP_OLT
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:726
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:1185
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:1266
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:1240
llvm::ConstantFoldCompareInstruction
Constant * ConstantFoldCompareInstruction(unsigned short predicate, Constant *C1, Constant *C2)
Definition: ConstantFold.cpp:1703
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:1429
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:195
llvm::UndefValue::getNumElements
unsigned getNumElements() const
Return the number of elements in the array, vector, or struct.
Definition: Constants.cpp:1166
llvm::ConstantFP::getSNaN
static Constant * getSNaN(Type *Ty, bool Negative=false, APInt *Payload=nullptr)
Definition: Constants.cpp:1035
llvm::None
const NoneType None
Definition: None.h:23
llvm::LinearPolySize< ElementCount >::getFixed
static ElementCount getFixed(ScalarTy MinVal)
Definition: TypeSize.h:284
llvm::Type::getIntegerBitWidth
unsigned getIntegerBitWidth() const
Definition: DerivedTypes.h:97
llvm::ConstantExpr::getFNeg
static Constant * getFNeg(Constant *C)
Definition: Constants.cpp:2678
llvm::ConstantExpr::isCompare
bool isCompare() const
Return true if this is a compare constant expression.
Definition: Constants.cpp:1486
llvm::ConstantExpr::getShuffleMaskForBitcode
Constant * getShuffleMaskForBitcode() const
Assert that this is a shufflevector and return the mask.
Definition: Constants.cpp:1533
llvm::ConstantFoldBinaryInstruction
Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
Definition: ConstantFold.cpp:871
llvm::ConstantFoldExtractElementInstruction
Constant * ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx)
Attempt to constant fold an extractelement instruction with the specified operands and indices.
Definition: ConstantFold.cpp:618
llvm::PatternMatch::m_One
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:513
llvm::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:758
llvm::CmpInst::FCMP_FALSE
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:722
llvm::ConstantExpr::getAShr
static Constant * getAShr(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2778
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:3287
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:168
llvm::ConstantExpr::isCast
bool isCast() const
Return true if this is a convert constant expression.
Definition: Constants.cpp:1482
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:2597
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:2095
llvm::ConstantDataSequential::getRawDataValues
StringRef getRawDataValues() const
Return the raw, underlying, bytes of this data.
Definition: Constants.cpp:2913
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:641
llvm::ConstantExpr::getCompare
static Constant * getCompare(unsigned short pred, Constant *C1, Constant *C2, bool OnlyIfReduced=false)
Return an ICmp or FCmp comparison operator constant expression.
Definition: Constants.cpp:2398
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:197
llvm::ConstantFP::getQNaN
static Constant * getQNaN(Type *Ty, bool Negative=false, APInt *Payload=nullptr)
Definition: Constants.cpp:1024
llvm::PPC::Predicate
Predicate
Predicate - These are "(BI << 5) | BO" for various predicates.
Definition: PPCPredicates.h:26
llvm::GlobalValue
Definition: GlobalValue.h:44
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:797
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:1423
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:1970
llvm::ConstantExpr::getBinOpIdentity
static Constant * getBinOpIdentity(unsigned Opcode, Type *Ty, bool AllowRHSConstant=false)
Return the identity constant for a binary opcode.
Definition: Constants.cpp:2812
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
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:793
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:3119
llvm::ExtractValueInst::Create
static ExtractValueInst * Create(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:2406
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:786
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:1517
llvm::LLVMContextImpl::TheFalseVal
ConstantInt * TheFalseVal
Definition: LLVMContextImpl.h:1441
llvm::ConstantExpr::getAddrSpaceCast
static Constant * getAddrSpaceCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2245
llvm::APInt::logBase2
unsigned logBase2() const
Definition: APInt.h:1632
llvm::ConstantPointerNull::get
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1782
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:68
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:3312
llvm::GetElementPtrConstantExpr::getSourceElementType
Type * getSourceElementType() const
Definition: Constants.cpp:2896
llvm::ConstantExpr::get
static Constant * get(unsigned Opcode, Constant *C1, unsigned Flags=0, Type *OnlyIfReducedTy=nullptr)
get - Return a unary operator constant expression, folding if possible.
Definition: Constants.cpp:2267
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:2367
I
#define I(x, y, z)
Definition: MD5.cpp:59
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:1348
llvm::GetElementPtrInst
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
Definition: Instructions.h:928
llvm::ConstantExpr::getShl
static Constant * getShl(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2766
llvm::ConstantExpr::getFSub
static Constant * getFSub(Constant *C1, Constant *C2)
Definition: Constants.cpp:2708
llvm::ConstantExpr::getOr
static Constant * getOr(Constant *C1, Constant *C2)
Definition: Constants.cpp:2753
getIntSequenceIfElementsMatch
static Constant * getIntSequenceIfElementsMatch(ArrayRef< Constant * > V)
Definition: Constants.cpp:1214
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:2907
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:990
llvm::Constant::hasOneLiveUse
bool hasOneLiveUse() const
Return true if the constant has exactly one live use.
Definition: Constants.cpp:779
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:3275
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:852
llvm::CmpInst::FCMP_OGE
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:725
llvm::ConstantExpr::getCast
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:1988
llvm::LLVMContextImpl::TheTrueVal
ConstantInt * TheTrueVal
Definition: LLVMContextImpl.h:1440
llvm::CmpInst::ICMP_UGE
@ ICMP_UGE
unsigned greater or equal
Definition: InstrTypes.h:744
llvm::ConstantFP::getZeroValueForNegation
static Constant * getZeroValueForNegation(Type *Ty)
Floating point negation must be implemented with f(x) = -0.0 - x.
Definition: Constants.cpp:1058
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:1119
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:1743
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:1013
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:3339
llvm::ConstantExpr::getTruncOrBitCast
static Constant * getTruncOrBitCast(Constant *C, Type *Ty)
Definition: Constants.cpp:2039
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:2357
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:749
llvm::CmpInst::isIntPredicate
bool isIntPredicate() const
Definition: InstrTypes.h:814
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:1532
llvm::LLVMContextImpl::IntConstants
IntMapTy IntConstants
Definition: LLVMContextImpl.h:1383
llvm::PossiblyExactOperator::IsExact
@ IsExact
Definition: Operator.h:124
llvm::GetElementPtrInst::Create
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:954
llvm::Value::ValueTy
ValueTy
Concrete subclass of this.
Definition: Value.h:514
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:848
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:752
llvm::BinaryOperator
Definition: InstrTypes.h:189
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:58
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:2033
llvm::ConstantExpr::getUMin
static Constant * getUMin(Constant *C1, Constant *C2)
Definition: Constants.cpp:2761
llvm::CmpInst::ICMP_ULT
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:745
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:3210
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:256
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:990
llvm::LLVMContextImpl::StructConstants
StructConstantsTy StructConstants
Definition: LLVMContextImpl.h:1418
llvm::ConstantExpr::getInsertElement
static Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2574
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:3066
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:1427
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:2071
llvm::ConstantExprKeyType
Definition: ConstantsContext.h:504
llvm::ConstantVector::get
static Constant * get(ArrayRef< Constant * > V)
Definition: Constants.cpp:1394
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:2719
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:168
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:687
llvm::ConstantInt::getFalse
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:880
llvm::ConstantExpr::getFCmp
static Constant * getFCmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
Definition: Constants.cpp:2527
ConstantFold.h
llvm::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:3045
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:1115
llvm::MCID::Select
@ Select
Definition: MCInstrDesc.h:162
llvm::CmpInst::FCMP_UGT
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:732
llvm::BlockAddress::getFunction
Function * getFunction() const
Definition: Constants.h:876
canTrapImpl
static bool canTrapImpl(const Constant *C, SmallPtrSetImpl< const ConstantExpr * > &NonTrappingOps)
Definition: Constants.cpp:573
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:1144
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:242
llvm::ConstantExpr
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:936
constantIsDead
static bool constantIsDead(const Constant *C, bool RemoveDeadUsers)
Return true if the specified constantexpr is dead.
Definition: Constants.cpp:720
llvm::ConstantExpr::getSDiv
static Constant * getSDiv(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2728
llvm::ConstantInt::getTrue
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:873
llvm::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:2671
get
Should compile to something r4 addze r3 instead we get
Definition: README.txt:24
llvm::OverflowingBinaryOperator::NoSignedWrap
@ NoSignedWrap
Definition: Operator.h:72
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:3269
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:324
llvm::ArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:153
llvm::ConstantInt::getBool
static ConstantInt * getBool(LLVMContext &Context, bool V)
Definition: Constants.cpp:887
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:2690
llvm::Type::isIntOrIntVectorTy
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:196
llvm::ConstantFP::get
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
Definition: Constants.cpp:972
llvm::ConstantTokenNone::get
static ConstantTokenNone * get(LLVMContext &Context)
Return the ConstantTokenNone.
Definition: Constants.cpp:1467
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:939
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:2749
llvm::ConstantFoldShuffleVectorInstruction
Constant * ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, ArrayRef< int > Mask)
Attempt to constant fold a shufflevector instruction with the specified operands and mask.
Definition: ConstantFold.cpp:719
llvm::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:1150
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:611
llvm::ConstantArray::get
static Constant * get(ArrayType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:1288
llvm::ConstantExpr::getGetElementPtr
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, bool InBounds=false, Optional< unsigned > InRangeIndex=None, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
Definition: Constants.h:1210
llvm::GetElementPtrInst::getIndexedType
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the result type of a getelementptr with the given source element type and indexes.
Definition: Instructions.cpp:1772
llvm::ConstantExpr::getLShr
static Constant * getLShr(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2773
llvm::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:2137
llvm::CmpInst::ICMP_SGE
@ ICMP_SGE
signed greater or equal
Definition: InstrTypes.h:748
llvm::ConstantExpr::getFPToUI
static Constant * getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2183
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:3747
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:476
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:817
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
llvm::Instruction::BinaryOps
BinaryOps
Definition: Instruction.h:785
llvm::Type::StructTyID
@ StructTyID
Structures.
Definition: Type.h:74
llvm::GetElementPtrConstantExpr::getResultElementType
Type * getResultElementType() const
Definition: Constants.cpp:2900
llvm::ShuffleVectorInst
This instruction constructs a fixed permutation of two input vectors.
Definition: Instructions.h:2009
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:2545
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:2060
llvm::ConstantExpr::getSRem
static Constant * getSRem(Constant *C1, Constant *C2)
Definition: Constants.cpp:2741
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:1770
llvm::ConstantExpr::getFPExtend
static Constant * getFPExtend(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2149
llvm::Value::stripInBoundsConstantOffsets
const Value * stripInBoundsConstantOffsets() const
Strip off pointer casts and all-constant inbounds GEPs.
Definition: Value.cpp:699
llvm::CmpInst::ICMP_UGT
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:743
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:736
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:3143
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:604
llvm::BlockAddress::get
static BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
Definition: Constants.cpp:1834
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
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:1600
llvm::ConstantExpr::getMul
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2712
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:1711
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:149
llvm::CmpInst::FCMP_OLE
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:727
llvm::LLVMContextImpl::VectorConstants
VectorConstantsTy VectorConstants
Definition: LLVMContextImpl.h:1421
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:1338
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:1852
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:648
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)
Definition: ConstantFold.cpp:815
llvm::ConstantExpr::getFAdd
static Constant * getFAdd(Constant *C1, Constant *C2)
Definition: Constants.cpp:2697
llvm::ConstantAggregateZero::get
static ConstantAggregateZero * get(Type *Ty)
Definition: Constants.cpp:1675
llvm::SmallVectorImpl::reserve
void reserve(size_type N)
Definition: SmallVector.h:624
llvm::BinaryOperator::Create
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
Definition: Instructions.cpp:2674
llvm::CmpInst::FCMP_TRUE
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:737
llvm::OverflowingBinaryOperator::NoUnsignedWrap
@ NoUnsignedWrap
Definition: Operator.h:71
llvm::ConstantTokenNone
A constant token which is empty.
Definition: Constants.h:826
llvm::DSOLocalEquivalent::get
static DSOLocalEquivalent * get(GlobalValue *GV)
Return a DSOLocalEquivalent for the specified global value.
Definition: Constants.cpp:1907
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::DSOLocalEquivalent
Wrapper for a function that represents a value that functionally represents the original function.
Definition: Constants.h:894
Debug.h
llvm::VectorType::get
static VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:670
llvm::Type::HalfTyID
@ HalfTyID
16-bit floating point type
Definition: Type.h:56
llvm::Type::X86_FP80TyID
@ X86_FP80TyID
80-bit floating point type (X87)
Definition: Type.h:60
llvm::Type::getFloatTy
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:228
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:154
llvm::Type::getFloatingPointTy
static Type * getFloatingPointTy(LLVMContext &C, const fltSemantics &S)
Definition: Type.cpp:86
llvm::ArrayType::getElementType
Type * getElementType() const
Definition: DerivedTypes.h:370
llvm::ConstantExpr::getExtractValue
static Constant * getExtractValue(Constant *Agg, ArrayRef< unsigned > Idxs, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2647
llvm::Constant::destroyConstant
void destroyConstant()
Called if some element of this constant is no longer valid.
Definition: Constants.cpp:460
llvm::CmpInst::FCMP_ORD
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:729
llvm::ExtractElementConstantExpr
ExtractElementConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to...
Definition: ConstantsContext.h:124
llvm::Type::isFirstClassType
bool isFirstClassType() const
Return true if the type is "first class", meaning it is a valid type for a Value.
Definition: Type.h:242
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
Other
Optional< std::vector< StOtherPiece > >