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