LLVM 19.0.0git
ConstantFold.cpp
Go to the documentation of this file.
1//===- ConstantFold.cpp - LLVM constant folder ----------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements folding of constants for LLVM. This implements the
10// (internal) ConstantFold.h interface, which is used by the
11// ConstantExpr::get* methods to automatically fold constants when possible.
12//
13// The current constant folding implementation is implemented in two pieces: the
14// pieces that don't need DataLayout, and the pieces that do. This is to avoid
15// a dependence in IR on Target.
16//
17//===----------------------------------------------------------------------===//
18
20#include "llvm/ADT/APSInt.h"
22#include "llvm/IR/Constants.h"
24#include "llvm/IR/Function.h"
26#include "llvm/IR/GlobalAlias.h"
29#include "llvm/IR/Module.h"
30#include "llvm/IR/Operator.h"
33using namespace llvm;
34using namespace llvm::PatternMatch;
35
36//===----------------------------------------------------------------------===//
37// ConstantFold*Instruction Implementations
38//===----------------------------------------------------------------------===//
39
40/// This function determines which opcode to use to fold two constant cast
41/// expressions together. It uses CastInst::isEliminableCastPair to determine
42/// the opcode. Consequently its just a wrapper around that function.
43/// Determine if it is valid to fold a cast of a cast
44static unsigned
46 unsigned opc, ///< opcode of the second cast constant expression
47 ConstantExpr *Op, ///< the first cast constant expression
48 Type *DstTy ///< destination type of the first cast
49) {
50 assert(Op && Op->isCast() && "Can't fold cast of cast without a cast!");
51 assert(DstTy && DstTy->isFirstClassType() && "Invalid cast destination type");
52 assert(CastInst::isCast(opc) && "Invalid cast opcode");
53
54 // The types and opcodes for the two Cast constant expressions
55 Type *SrcTy = Op->getOperand(0)->getType();
56 Type *MidTy = Op->getType();
57 Instruction::CastOps firstOp = Instruction::CastOps(Op->getOpcode());
59
60 // Assume that pointers are never more than 64 bits wide, and only use this
61 // for the middle type. Otherwise we could end up folding away illegal
62 // bitcasts between address spaces with different sizes.
63 IntegerType *FakeIntPtrTy = Type::getInt64Ty(DstTy->getContext());
64
65 // Let CastInst::isEliminableCastPair do the heavy lifting.
66 return CastInst::isEliminableCastPair(firstOp, secondOp, SrcTy, MidTy, DstTy,
67 nullptr, FakeIntPtrTy, nullptr);
68}
69
70static Constant *FoldBitCast(Constant *V, Type *DestTy) {
71 Type *SrcTy = V->getType();
72 if (SrcTy == DestTy)
73 return V; // no-op cast
74
75 // Handle casts from one vector constant to another. We know that the src
76 // and dest type have the same size (otherwise its an illegal cast).
77 if (VectorType *DestPTy = dyn_cast<VectorType>(DestTy)) {
78 if (V->isAllOnesValue())
79 return Constant::getAllOnesValue(DestTy);
80
81 // Canonicalize scalar-to-vector bitcasts into vector-to-vector bitcasts
82 // This allows for other simplifications (although some of them
83 // can only be handled by Analysis/ConstantFolding.cpp).
84 if (isa<ConstantInt>(V) || isa<ConstantFP>(V))
86 return nullptr;
87 }
88
89 // Handle integral constant input.
90 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
91 // See note below regarding the PPC_FP128 restriction.
92 if (DestTy->isFloatingPointTy() && !DestTy->isPPC_FP128Ty())
93 return ConstantFP::get(DestTy->getContext(),
94 APFloat(DestTy->getFltSemantics(),
95 CI->getValue()));
96
97 // Otherwise, can't fold this (vector?)
98 return nullptr;
99 }
100
101 // Handle ConstantFP input: FP -> Integral.
102 if (ConstantFP *FP = dyn_cast<ConstantFP>(V)) {
103 // PPC_FP128 is really the sum of two consecutive doubles, where the first
104 // double is always stored first in memory, regardless of the target
105 // endianness. The memory layout of i128, however, depends on the target
106 // endianness, and so we can't fold this without target endianness
107 // information. This should instead be handled by
108 // Analysis/ConstantFolding.cpp
109 if (FP->getType()->isPPC_FP128Ty())
110 return nullptr;
111
112 // Make sure dest type is compatible with the folded integer constant.
113 if (!DestTy->isIntegerTy())
114 return nullptr;
115
116 return ConstantInt::get(FP->getContext(),
117 FP->getValueAPF().bitcastToAPInt());
118 }
119
120 return nullptr;
121}
122
123
124/// V is an integer constant which only has a subset of its bytes used.
125/// The bytes used are indicated by ByteStart (which is the first byte used,
126/// counting from the least significant byte) and ByteSize, which is the number
127/// of bytes used.
128///
129/// This function analyzes the specified constant to see if the specified byte
130/// range can be returned as a simplified constant. If so, the constant is
131/// returned, otherwise null is returned.
132static Constant *ExtractConstantBytes(Constant *C, unsigned ByteStart,
133 unsigned ByteSize) {
134 assert(C->getType()->isIntegerTy() &&
135 (cast<IntegerType>(C->getType())->getBitWidth() & 7) == 0 &&
136 "Non-byte sized integer input");
137 [[maybe_unused]] unsigned CSize = cast<IntegerType>(C->getType())->getBitWidth()/8;
138 assert(ByteSize && "Must be accessing some piece");
139 assert(ByteStart+ByteSize <= CSize && "Extracting invalid piece from input");
140 assert(ByteSize != CSize && "Should not extract everything");
141
142 // Constant Integers are simple.
143 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
144 APInt V = CI->getValue();
145 if (ByteStart)
146 V.lshrInPlace(ByteStart*8);
147 V = V.trunc(ByteSize*8);
148 return ConstantInt::get(CI->getContext(), V);
149 }
150
151 // In the input is a constant expr, we might be able to recursively simplify.
152 // If not, we definitely can't do anything.
153 ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
154 if (!CE) return nullptr;
155
156 switch (CE->getOpcode()) {
157 default: return nullptr;
158 case Instruction::Shl: {
159 ConstantInt *Amt = dyn_cast<ConstantInt>(CE->getOperand(1));
160 if (!Amt)
161 return nullptr;
162 APInt ShAmt = Amt->getValue();
163 // Cannot analyze non-byte shifts.
164 if ((ShAmt & 7) != 0)
165 return nullptr;
166 ShAmt.lshrInPlace(3);
167
168 // If the extract is known to be all zeros, return zero.
169 if (ShAmt.uge(ByteStart + ByteSize))
171 IntegerType::get(CE->getContext(), ByteSize * 8));
172 // If the extract is known to be fully in the input, extract it.
173 if (ShAmt.ule(ByteStart))
174 return ExtractConstantBytes(CE->getOperand(0),
175 ByteStart - ShAmt.getZExtValue(), ByteSize);
176
177 // TODO: Handle the 'partially zero' case.
178 return nullptr;
179 }
180 }
181}
182
184 Type *DestTy) {
186 ? ConstantExpr::getCast(opc, V, DestTy)
187 : ConstantFoldCastInstruction(opc, V, DestTy);
188}
189
191 Type *DestTy) {
192 if (isa<PoisonValue>(V))
193 return PoisonValue::get(DestTy);
194
195 if (isa<UndefValue>(V)) {
196 // zext(undef) = 0, because the top bits will be zero.
197 // sext(undef) = 0, because the top bits will all be the same.
198 // [us]itofp(undef) = 0, because the result value is bounded.
199 if (opc == Instruction::ZExt || opc == Instruction::SExt ||
200 opc == Instruction::UIToFP || opc == Instruction::SIToFP)
201 return Constant::getNullValue(DestTy);
202 return UndefValue::get(DestTy);
203 }
204
205 if (V->isNullValue() && !DestTy->isX86_MMXTy() && !DestTy->isX86_AMXTy() &&
206 opc != Instruction::AddrSpaceCast)
207 return Constant::getNullValue(DestTy);
208
209 // If the cast operand is a constant expression, there's a few things we can
210 // do to try to simplify it.
211 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
212 if (CE->isCast()) {
213 // Try hard to fold cast of cast because they are often eliminable.
214 if (unsigned newOpc = foldConstantCastPair(opc, CE, DestTy))
215 return foldMaybeUndesirableCast(newOpc, CE->getOperand(0), DestTy);
216 }
217 }
218
219 // If the cast operand is a constant vector, perform the cast by
220 // operating on each element. In the cast of bitcasts, the element
221 // count may be mismatched; don't attempt to handle that here.
222 if ((isa<ConstantVector>(V) || isa<ConstantDataVector>(V)) &&
223 DestTy->isVectorTy() &&
224 cast<FixedVectorType>(DestTy)->getNumElements() ==
225 cast<FixedVectorType>(V->getType())->getNumElements()) {
226 VectorType *DestVecTy = cast<VectorType>(DestTy);
227 Type *DstEltTy = DestVecTy->getElementType();
228 // Fast path for splatted constants.
229 if (Constant *Splat = V->getSplatValue()) {
230 Constant *Res = foldMaybeUndesirableCast(opc, Splat, DstEltTy);
231 if (!Res)
232 return nullptr;
234 cast<VectorType>(DestTy)->getElementCount(), Res);
235 }
237 Type *Ty = IntegerType::get(V->getContext(), 32);
238 for (unsigned i = 0,
239 e = cast<FixedVectorType>(V->getType())->getNumElements();
240 i != e; ++i) {
241 Constant *C = ConstantExpr::getExtractElement(V, ConstantInt::get(Ty, i));
242 Constant *Casted = foldMaybeUndesirableCast(opc, C, DstEltTy);
243 if (!Casted)
244 return nullptr;
245 res.push_back(Casted);
246 }
247 return ConstantVector::get(res);
248 }
249
250 // We actually have to do a cast now. Perform the cast according to the
251 // opcode specified.
252 switch (opc) {
253 default:
254 llvm_unreachable("Failed to cast constant expression");
255 case Instruction::FPTrunc:
256 case Instruction::FPExt:
257 if (ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
258 bool ignored;
259 APFloat Val = FPC->getValueAPF();
260 Val.convert(DestTy->getFltSemantics(), APFloat::rmNearestTiesToEven,
261 &ignored);
262 return ConstantFP::get(V->getContext(), Val);
263 }
264 return nullptr; // Can't fold.
265 case Instruction::FPToUI:
266 case Instruction::FPToSI:
267 if (ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
268 const APFloat &V = FPC->getValueAPF();
269 bool ignored;
270 uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
271 APSInt IntVal(DestBitWidth, opc == Instruction::FPToUI);
272 if (APFloat::opInvalidOp ==
273 V.convertToInteger(IntVal, APFloat::rmTowardZero, &ignored)) {
274 // Undefined behavior invoked - the destination type can't represent
275 // the input constant.
276 return PoisonValue::get(DestTy);
277 }
278 return ConstantInt::get(FPC->getContext(), IntVal);
279 }
280 return nullptr; // Can't fold.
281 case Instruction::UIToFP:
282 case Instruction::SIToFP:
283 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
284 const APInt &api = CI->getValue();
285 APFloat apf(DestTy->getFltSemantics(),
287 apf.convertFromAPInt(api, opc==Instruction::SIToFP,
288 APFloat::rmNearestTiesToEven);
289 return ConstantFP::get(V->getContext(), apf);
290 }
291 return nullptr;
292 case Instruction::ZExt:
293 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
294 uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
295 return ConstantInt::get(V->getContext(),
296 CI->getValue().zext(BitWidth));
297 }
298 return nullptr;
299 case Instruction::SExt:
300 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
301 uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
302 return ConstantInt::get(V->getContext(),
303 CI->getValue().sext(BitWidth));
304 }
305 return nullptr;
306 case Instruction::Trunc: {
307 if (V->getType()->isVectorTy())
308 return nullptr;
309
310 uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
311 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
312 return ConstantInt::get(V->getContext(),
313 CI->getValue().trunc(DestBitWidth));
314 }
315
316 // The input must be a constantexpr. See if we can simplify this based on
317 // the bytes we are demanding. Only do this if the source and dest are an
318 // even multiple of a byte.
319 if ((DestBitWidth & 7) == 0 &&
320 (cast<IntegerType>(V->getType())->getBitWidth() & 7) == 0)
321 if (Constant *Res = ExtractConstantBytes(V, 0, DestBitWidth / 8))
322 return Res;
323
324 return nullptr;
325 }
326 case Instruction::BitCast:
327 return FoldBitCast(V, DestTy);
328 case Instruction::AddrSpaceCast:
329 case Instruction::IntToPtr:
330 case Instruction::PtrToInt:
331 return nullptr;
332 }
333}
334
336 Constant *V1, Constant *V2) {
337 // Check for i1 and vector true/false conditions.
338 if (Cond->isNullValue()) return V2;
339 if (Cond->isAllOnesValue()) return V1;
340
341 // If the condition is a vector constant, fold the result elementwise.
342 if (ConstantVector *CondV = dyn_cast<ConstantVector>(Cond)) {
343 auto *V1VTy = CondV->getType();
345 Type *Ty = IntegerType::get(CondV->getContext(), 32);
346 for (unsigned i = 0, e = V1VTy->getNumElements(); i != e; ++i) {
347 Constant *V;
349 ConstantInt::get(Ty, i));
351 ConstantInt::get(Ty, i));
352 auto *Cond = cast<Constant>(CondV->getOperand(i));
353 if (isa<PoisonValue>(Cond)) {
354 V = PoisonValue::get(V1Element->getType());
355 } else if (V1Element == V2Element) {
356 V = V1Element;
357 } else if (isa<UndefValue>(Cond)) {
358 V = isa<UndefValue>(V1Element) ? V1Element : V2Element;
359 } else {
360 if (!isa<ConstantInt>(Cond)) break;
361 V = Cond->isNullValue() ? V2Element : V1Element;
362 }
363 Result.push_back(V);
364 }
365
366 // If we were able to build the vector, return it.
367 if (Result.size() == V1VTy->getNumElements())
368 return ConstantVector::get(Result);
369 }
370
371 if (isa<PoisonValue>(Cond))
372 return PoisonValue::get(V1->getType());
373
374 if (isa<UndefValue>(Cond)) {
375 if (isa<UndefValue>(V1)) return V1;
376 return V2;
377 }
378
379 if (V1 == V2) return V1;
380
381 if (isa<PoisonValue>(V1))
382 return V2;
383 if (isa<PoisonValue>(V2))
384 return V1;
385
386 // If the true or false value is undef, we can fold to the other value as
387 // long as the other value isn't poison.
388 auto NotPoison = [](Constant *C) {
389 if (isa<PoisonValue>(C))
390 return false;
391
392 // TODO: We can analyze ConstExpr by opcode to determine if there is any
393 // possibility of poison.
394 if (isa<ConstantExpr>(C))
395 return false;
396
397 if (isa<ConstantInt>(C) || isa<GlobalVariable>(C) || isa<ConstantFP>(C) ||
398 isa<ConstantPointerNull>(C) || isa<Function>(C))
399 return true;
400
401 if (C->getType()->isVectorTy())
402 return !C->containsPoisonElement() && !C->containsConstantExpression();
403
404 // TODO: Recursively analyze aggregates or other constants.
405 return false;
406 };
407 if (isa<UndefValue>(V1) && NotPoison(V2)) return V2;
408 if (isa<UndefValue>(V2) && NotPoison(V1)) return V1;
409
410 return nullptr;
411}
412
414 Constant *Idx) {
415 auto *ValVTy = cast<VectorType>(Val->getType());
416
417 // extractelt poison, C -> poison
418 // extractelt C, undef -> poison
419 if (isa<PoisonValue>(Val) || isa<UndefValue>(Idx))
420 return PoisonValue::get(ValVTy->getElementType());
421
422 // extractelt undef, C -> undef
423 if (isa<UndefValue>(Val))
424 return UndefValue::get(ValVTy->getElementType());
425
426 auto *CIdx = dyn_cast<ConstantInt>(Idx);
427 if (!CIdx)
428 return nullptr;
429
430 if (auto *ValFVTy = dyn_cast<FixedVectorType>(Val->getType())) {
431 // ee({w,x,y,z}, wrong_value) -> poison
432 if (CIdx->uge(ValFVTy->getNumElements()))
433 return PoisonValue::get(ValFVTy->getElementType());
434 }
435
436 // ee (gep (ptr, idx0, ...), idx) -> gep (ee (ptr, idx), ee (idx0, idx), ...)
437 if (auto *CE = dyn_cast<ConstantExpr>(Val)) {
438 if (auto *GEP = dyn_cast<GEPOperator>(CE)) {
440 Ops.reserve(CE->getNumOperands());
441 for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) {
442 Constant *Op = CE->getOperand(i);
443 if (Op->getType()->isVectorTy()) {
445 if (!ScalarOp)
446 return nullptr;
447 Ops.push_back(ScalarOp);
448 } else
449 Ops.push_back(Op);
450 }
451 return CE->getWithOperands(Ops, ValVTy->getElementType(), false,
452 GEP->getSourceElementType());
453 } else if (CE->getOpcode() == Instruction::InsertElement) {
454 if (const auto *IEIdx = dyn_cast<ConstantInt>(CE->getOperand(2))) {
455 if (APSInt::isSameValue(APSInt(IEIdx->getValue()),
456 APSInt(CIdx->getValue()))) {
457 return CE->getOperand(1);
458 } else {
459 return ConstantExpr::getExtractElement(CE->getOperand(0), CIdx);
460 }
461 }
462 }
463 }
464
465 if (Constant *C = Val->getAggregateElement(CIdx))
466 return C;
467
468 // Lane < Splat minimum vector width => extractelt Splat(x), Lane -> x
469 if (CIdx->getValue().ult(ValVTy->getElementCount().getKnownMinValue())) {
470 if (Constant *SplatVal = Val->getSplatValue())
471 return SplatVal;
472 }
473
474 return nullptr;
475}
476
478 Constant *Elt,
479 Constant *Idx) {
480 if (isa<UndefValue>(Idx))
481 return PoisonValue::get(Val->getType());
482
483 // Inserting null into all zeros is still all zeros.
484 // TODO: This is true for undef and poison splats too.
485 if (isa<ConstantAggregateZero>(Val) && Elt->isNullValue())
486 return Val;
487
488 ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx);
489 if (!CIdx) return nullptr;
490
491 // Do not iterate on scalable vector. The num of elements is unknown at
492 // compile-time.
493 if (isa<ScalableVectorType>(Val->getType()))
494 return nullptr;
495
496 auto *ValTy = cast<FixedVectorType>(Val->getType());
497
498 unsigned NumElts = ValTy->getNumElements();
499 if (CIdx->uge(NumElts))
500 return PoisonValue::get(Val->getType());
501
503 Result.reserve(NumElts);
504 auto *Ty = Type::getInt32Ty(Val->getContext());
505 uint64_t IdxVal = CIdx->getZExtValue();
506 for (unsigned i = 0; i != NumElts; ++i) {
507 if (i == IdxVal) {
508 Result.push_back(Elt);
509 continue;
510 }
511
512 Constant *C = ConstantExpr::getExtractElement(Val, ConstantInt::get(Ty, i));
513 Result.push_back(C);
514 }
515
516 return ConstantVector::get(Result);
517}
518
520 ArrayRef<int> Mask) {
521 auto *V1VTy = cast<VectorType>(V1->getType());
522 unsigned MaskNumElts = Mask.size();
523 auto MaskEltCount =
524 ElementCount::get(MaskNumElts, isa<ScalableVectorType>(V1VTy));
525 Type *EltTy = V1VTy->getElementType();
526
527 // Poison shuffle mask -> poison value.
528 if (all_of(Mask, [](int Elt) { return Elt == PoisonMaskElem; })) {
529 return PoisonValue::get(VectorType::get(EltTy, MaskEltCount));
530 }
531
532 // If the mask is all zeros this is a splat, no need to go through all
533 // elements.
534 if (all_of(Mask, [](int Elt) { return Elt == 0; })) {
535 Type *Ty = IntegerType::get(V1->getContext(), 32);
536 Constant *Elt =
537 ConstantExpr::getExtractElement(V1, ConstantInt::get(Ty, 0));
538
539 if (Elt->isNullValue()) {
540 auto *VTy = VectorType::get(EltTy, MaskEltCount);
541 return ConstantAggregateZero::get(VTy);
542 } else if (!MaskEltCount.isScalable())
543 return ConstantVector::getSplat(MaskEltCount, Elt);
544 }
545
546 // Do not iterate on scalable vector. The num of elements is unknown at
547 // compile-time.
548 if (isa<ScalableVectorType>(V1VTy))
549 return nullptr;
550
551 unsigned SrcNumElts = V1VTy->getElementCount().getKnownMinValue();
552
553 // Loop over the shuffle mask, evaluating each element.
555 for (unsigned i = 0; i != MaskNumElts; ++i) {
556 int Elt = Mask[i];
557 if (Elt == -1) {
558 Result.push_back(UndefValue::get(EltTy));
559 continue;
560 }
561 Constant *InElt;
562 if (unsigned(Elt) >= SrcNumElts*2)
563 InElt = UndefValue::get(EltTy);
564 else if (unsigned(Elt) >= SrcNumElts) {
565 Type *Ty = IntegerType::get(V2->getContext(), 32);
566 InElt =
568 ConstantInt::get(Ty, Elt - SrcNumElts));
569 } else {
570 Type *Ty = IntegerType::get(V1->getContext(), 32);
571 InElt = ConstantExpr::getExtractElement(V1, ConstantInt::get(Ty, Elt));
572 }
573 Result.push_back(InElt);
574 }
575
576 return ConstantVector::get(Result);
577}
578
580 ArrayRef<unsigned> Idxs) {
581 // Base case: no indices, so return the entire value.
582 if (Idxs.empty())
583 return Agg;
584
585 if (Constant *C = Agg->getAggregateElement(Idxs[0]))
587
588 return nullptr;
589}
590
592 Constant *Val,
593 ArrayRef<unsigned> Idxs) {
594 // Base case: no indices, so replace the entire value.
595 if (Idxs.empty())
596 return Val;
597
598 unsigned NumElts;
599 if (StructType *ST = dyn_cast<StructType>(Agg->getType()))
600 NumElts = ST->getNumElements();
601 else
602 NumElts = cast<ArrayType>(Agg->getType())->getNumElements();
603
605 for (unsigned i = 0; i != NumElts; ++i) {
606 Constant *C = Agg->getAggregateElement(i);
607 if (!C) return nullptr;
608
609 if (Idxs[0] == i)
611
612 Result.push_back(C);
613 }
614
615 if (StructType *ST = dyn_cast<StructType>(Agg->getType()))
616 return ConstantStruct::get(ST, Result);
617 return ConstantArray::get(cast<ArrayType>(Agg->getType()), Result);
618}
619
621 assert(Instruction::isUnaryOp(Opcode) && "Non-unary instruction detected");
622
623 // Handle scalar UndefValue and scalable vector UndefValue. Fixed-length
624 // vectors are always evaluated per element.
625 bool IsScalableVector = isa<ScalableVectorType>(C->getType());
626 bool HasScalarUndefOrScalableVectorUndef =
627 (!C->getType()->isVectorTy() || IsScalableVector) && isa<UndefValue>(C);
628
629 if (HasScalarUndefOrScalableVectorUndef) {
630 switch (static_cast<Instruction::UnaryOps>(Opcode)) {
631 case Instruction::FNeg:
632 return C; // -undef -> undef
633 case Instruction::UnaryOpsEnd:
634 llvm_unreachable("Invalid UnaryOp");
635 }
636 }
637
638 // Constant should not be UndefValue, unless these are vector constants.
639 assert(!HasScalarUndefOrScalableVectorUndef && "Unexpected UndefValue");
640 // We only have FP UnaryOps right now.
641 assert(!isa<ConstantInt>(C) && "Unexpected Integer UnaryOp");
642
643 if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
644 const APFloat &CV = CFP->getValueAPF();
645 switch (Opcode) {
646 default:
647 break;
648 case Instruction::FNeg:
649 return ConstantFP::get(C->getContext(), neg(CV));
650 }
651 } else if (auto *VTy = dyn_cast<FixedVectorType>(C->getType())) {
652
653 Type *Ty = IntegerType::get(VTy->getContext(), 32);
654 // Fast path for splatted constants.
655 if (Constant *Splat = C->getSplatValue())
656 if (Constant *Elt = ConstantFoldUnaryInstruction(Opcode, Splat))
657 return ConstantVector::getSplat(VTy->getElementCount(), Elt);
658
659 // Fold each element and create a vector constant from those constants.
661 for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
662 Constant *ExtractIdx = ConstantInt::get(Ty, i);
663 Constant *Elt = ConstantExpr::getExtractElement(C, ExtractIdx);
664 Constant *Res = ConstantFoldUnaryInstruction(Opcode, Elt);
665 if (!Res)
666 return nullptr;
667 Result.push_back(Res);
668 }
669
670 return ConstantVector::get(Result);
671 }
672
673 // We don't know how to fold this.
674 return nullptr;
675}
676
678 Constant *C2) {
679 assert(Instruction::isBinaryOp(Opcode) && "Non-binary instruction detected");
680
681 // Simplify BinOps with their identity values first. They are no-ops and we
682 // can always return the other value, including undef or poison values.
684 Opcode, C1->getType(), /*AllowRHSIdentity*/ false)) {
685 if (C1 == Identity)
686 return C2;
687 if (C2 == Identity)
688 return C1;
689 } else if (Constant *Identity = ConstantExpr::getBinOpIdentity(
690 Opcode, C1->getType(), /*AllowRHSIdentity*/ true)) {
691 if (C2 == Identity)
692 return C1;
693 }
694
695 // Binary operations propagate poison.
696 if (isa<PoisonValue>(C1) || isa<PoisonValue>(C2))
697 return PoisonValue::get(C1->getType());
698
699 // Handle scalar UndefValue and scalable vector UndefValue. Fixed-length
700 // vectors are always evaluated per element.
701 bool IsScalableVector = isa<ScalableVectorType>(C1->getType());
702 bool HasScalarUndefOrScalableVectorUndef =
703 (!C1->getType()->isVectorTy() || IsScalableVector) &&
704 (isa<UndefValue>(C1) || isa<UndefValue>(C2));
705 if (HasScalarUndefOrScalableVectorUndef) {
706 switch (static_cast<Instruction::BinaryOps>(Opcode)) {
707 case Instruction::Xor:
708 if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
709 // Handle undef ^ undef -> 0 special case. This is a common
710 // idiom (misuse).
711 return Constant::getNullValue(C1->getType());
712 [[fallthrough]];
713 case Instruction::Add:
714 case Instruction::Sub:
715 return UndefValue::get(C1->getType());
716 case Instruction::And:
717 if (isa<UndefValue>(C1) && isa<UndefValue>(C2)) // undef & undef -> undef
718 return C1;
719 return Constant::getNullValue(C1->getType()); // undef & X -> 0
720 case Instruction::Mul: {
721 // undef * undef -> undef
722 if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
723 return C1;
724 const APInt *CV;
725 // X * undef -> undef if X is odd
726 if (match(C1, m_APInt(CV)) || match(C2, m_APInt(CV)))
727 if ((*CV)[0])
728 return UndefValue::get(C1->getType());
729
730 // X * undef -> 0 otherwise
731 return Constant::getNullValue(C1->getType());
732 }
733 case Instruction::SDiv:
734 case Instruction::UDiv:
735 // X / undef -> poison
736 // X / 0 -> poison
737 if (match(C2, m_CombineOr(m_Undef(), m_Zero())))
738 return PoisonValue::get(C2->getType());
739 // undef / X -> 0 otherwise
740 return Constant::getNullValue(C1->getType());
741 case Instruction::URem:
742 case Instruction::SRem:
743 // X % undef -> poison
744 // X % 0 -> poison
745 if (match(C2, m_CombineOr(m_Undef(), m_Zero())))
746 return PoisonValue::get(C2->getType());
747 // undef % X -> 0 otherwise
748 return Constant::getNullValue(C1->getType());
749 case Instruction::Or: // X | undef -> -1
750 if (isa<UndefValue>(C1) && isa<UndefValue>(C2)) // undef | undef -> undef
751 return C1;
752 return Constant::getAllOnesValue(C1->getType()); // undef | X -> ~0
753 case Instruction::LShr:
754 // X >>l undef -> poison
755 if (isa<UndefValue>(C2))
756 return PoisonValue::get(C2->getType());
757 // undef >>l X -> 0
758 return Constant::getNullValue(C1->getType());
759 case Instruction::AShr:
760 // X >>a undef -> poison
761 if (isa<UndefValue>(C2))
762 return PoisonValue::get(C2->getType());
763 // TODO: undef >>a X -> poison if the shift is exact
764 // undef >>a X -> 0
765 return Constant::getNullValue(C1->getType());
766 case Instruction::Shl:
767 // X << undef -> undef
768 if (isa<UndefValue>(C2))
769 return PoisonValue::get(C2->getType());
770 // undef << X -> 0
771 return Constant::getNullValue(C1->getType());
772 case Instruction::FSub:
773 // -0.0 - undef --> undef (consistent with "fneg undef")
774 if (match(C1, m_NegZeroFP()) && isa<UndefValue>(C2))
775 return C2;
776 [[fallthrough]];
777 case Instruction::FAdd:
778 case Instruction::FMul:
779 case Instruction::FDiv:
780 case Instruction::FRem:
781 // [any flop] undef, undef -> undef
782 if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
783 return C1;
784 // [any flop] C, undef -> NaN
785 // [any flop] undef, C -> NaN
786 // We could potentially specialize NaN/Inf constants vs. 'normal'
787 // constants (possibly differently depending on opcode and operand). This
788 // would allow returning undef sometimes. But it is always safe to fold to
789 // NaN because we can choose the undef operand as NaN, and any FP opcode
790 // with a NaN operand will propagate NaN.
791 return ConstantFP::getNaN(C1->getType());
792 case Instruction::BinaryOpsEnd:
793 llvm_unreachable("Invalid BinaryOp");
794 }
795 }
796
797 // Neither constant should be UndefValue, unless these are vector constants.
798 assert((!HasScalarUndefOrScalableVectorUndef) && "Unexpected UndefValue");
799
800 // Handle simplifications when the RHS is a constant int.
801 if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
802 switch (Opcode) {
803 case Instruction::Mul:
804 if (CI2->isZero())
805 return C2; // X * 0 == 0
806 break;
807 case Instruction::UDiv:
808 case Instruction::SDiv:
809 if (CI2->isZero())
810 return PoisonValue::get(CI2->getType()); // X / 0 == poison
811 break;
812 case Instruction::URem:
813 case Instruction::SRem:
814 if (CI2->isOne())
815 return Constant::getNullValue(CI2->getType()); // X % 1 == 0
816 if (CI2->isZero())
817 return PoisonValue::get(CI2->getType()); // X % 0 == poison
818 break;
819 case Instruction::And:
820 if (CI2->isZero())
821 return C2; // X & 0 == 0
822
823 if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
824 // If and'ing the address of a global with a constant, fold it.
825 if (CE1->getOpcode() == Instruction::PtrToInt &&
826 isa<GlobalValue>(CE1->getOperand(0))) {
827 GlobalValue *GV = cast<GlobalValue>(CE1->getOperand(0));
828
829 Align GVAlign; // defaults to 1
830
831 if (Module *TheModule = GV->getParent()) {
832 const DataLayout &DL = TheModule->getDataLayout();
833 GVAlign = GV->getPointerAlignment(DL);
834
835 // If the function alignment is not specified then assume that it
836 // is 4.
837 // This is dangerous; on x86, the alignment of the pointer
838 // corresponds to the alignment of the function, but might be less
839 // than 4 if it isn't explicitly specified.
840 // However, a fix for this behaviour was reverted because it
841 // increased code size (see https://reviews.llvm.org/D55115)
842 // FIXME: This code should be deleted once existing targets have
843 // appropriate defaults
844 if (isa<Function>(GV) && !DL.getFunctionPtrAlign())
845 GVAlign = Align(4);
846 } else if (isa<GlobalVariable>(GV)) {
847 GVAlign = cast<GlobalVariable>(GV)->getAlign().valueOrOne();
848 }
849
850 if (GVAlign > 1) {
851 unsigned DstWidth = CI2->getBitWidth();
852 unsigned SrcWidth = std::min(DstWidth, Log2(GVAlign));
853 APInt BitsNotSet(APInt::getLowBitsSet(DstWidth, SrcWidth));
854
855 // If checking bits we know are clear, return zero.
856 if ((CI2->getValue() & BitsNotSet) == CI2->getValue())
857 return Constant::getNullValue(CI2->getType());
858 }
859 }
860 }
861 break;
862 case Instruction::Or:
863 if (CI2->isMinusOne())
864 return C2; // X | -1 == -1
865 break;
866 case Instruction::Xor:
867 if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
868 switch (CE1->getOpcode()) {
869 default:
870 break;
871 case Instruction::ICmp:
872 case Instruction::FCmp:
873 // cmp pred ^ true -> cmp !pred
874 assert(CI2->isOne());
875 CmpInst::Predicate pred = (CmpInst::Predicate)CE1->getPredicate();
877 return ConstantExpr::getCompare(pred, CE1->getOperand(0),
878 CE1->getOperand(1));
879 }
880 }
881 break;
882 }
883 } else if (isa<ConstantInt>(C1)) {
884 // If C1 is a ConstantInt and C2 is not, swap the operands.
885 if (Instruction::isCommutative(Opcode))
886 return ConstantExpr::isDesirableBinOp(Opcode)
887 ? ConstantExpr::get(Opcode, C2, C1)
888 : ConstantFoldBinaryInstruction(Opcode, C2, C1);
889 }
890
891 if (ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
892 if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
893 const APInt &C1V = CI1->getValue();
894 const APInt &C2V = CI2->getValue();
895 switch (Opcode) {
896 default:
897 break;
898 case Instruction::Add:
899 return ConstantInt::get(CI1->getContext(), C1V + C2V);
900 case Instruction::Sub:
901 return ConstantInt::get(CI1->getContext(), C1V - C2V);
902 case Instruction::Mul:
903 return ConstantInt::get(CI1->getContext(), C1V * C2V);
904 case Instruction::UDiv:
905 assert(!CI2->isZero() && "Div by zero handled above");
906 return ConstantInt::get(CI1->getContext(), C1V.udiv(C2V));
907 case Instruction::SDiv:
908 assert(!CI2->isZero() && "Div by zero handled above");
909 if (C2V.isAllOnes() && C1V.isMinSignedValue())
910 return PoisonValue::get(CI1->getType()); // MIN_INT / -1 -> poison
911 return ConstantInt::get(CI1->getContext(), C1V.sdiv(C2V));
912 case Instruction::URem:
913 assert(!CI2->isZero() && "Div by zero handled above");
914 return ConstantInt::get(CI1->getContext(), C1V.urem(C2V));
915 case Instruction::SRem:
916 assert(!CI2->isZero() && "Div by zero handled above");
917 if (C2V.isAllOnes() && C1V.isMinSignedValue())
918 return PoisonValue::get(CI1->getType()); // MIN_INT % -1 -> poison
919 return ConstantInt::get(CI1->getContext(), C1V.srem(C2V));
920 case Instruction::And:
921 return ConstantInt::get(CI1->getContext(), C1V & C2V);
922 case Instruction::Or:
923 return ConstantInt::get(CI1->getContext(), C1V | C2V);
924 case Instruction::Xor:
925 return ConstantInt::get(CI1->getContext(), C1V ^ C2V);
926 case Instruction::Shl:
927 if (C2V.ult(C1V.getBitWidth()))
928 return ConstantInt::get(CI1->getContext(), C1V.shl(C2V));
929 return PoisonValue::get(C1->getType()); // too big shift is poison
930 case Instruction::LShr:
931 if (C2V.ult(C1V.getBitWidth()))
932 return ConstantInt::get(CI1->getContext(), C1V.lshr(C2V));
933 return PoisonValue::get(C1->getType()); // too big shift is poison
934 case Instruction::AShr:
935 if (C2V.ult(C1V.getBitWidth()))
936 return ConstantInt::get(CI1->getContext(), C1V.ashr(C2V));
937 return PoisonValue::get(C1->getType()); // too big shift is poison
938 }
939 }
940
941 switch (Opcode) {
942 case Instruction::SDiv:
943 case Instruction::UDiv:
944 case Instruction::URem:
945 case Instruction::SRem:
946 case Instruction::LShr:
947 case Instruction::AShr:
948 case Instruction::Shl:
949 if (CI1->isZero()) return C1;
950 break;
951 default:
952 break;
953 }
954 } else if (ConstantFP *CFP1 = dyn_cast<ConstantFP>(C1)) {
955 if (ConstantFP *CFP2 = dyn_cast<ConstantFP>(C2)) {
956 const APFloat &C1V = CFP1->getValueAPF();
957 const APFloat &C2V = CFP2->getValueAPF();
958 APFloat C3V = C1V; // copy for modification
959 switch (Opcode) {
960 default:
961 break;
962 case Instruction::FAdd:
963 (void)C3V.add(C2V, APFloat::rmNearestTiesToEven);
964 return ConstantFP::get(C1->getContext(), C3V);
965 case Instruction::FSub:
966 (void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven);
967 return ConstantFP::get(C1->getContext(), C3V);
968 case Instruction::FMul:
969 (void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven);
970 return ConstantFP::get(C1->getContext(), C3V);
971 case Instruction::FDiv:
972 (void)C3V.divide(C2V, APFloat::rmNearestTiesToEven);
973 return ConstantFP::get(C1->getContext(), C3V);
974 case Instruction::FRem:
975 (void)C3V.mod(C2V);
976 return ConstantFP::get(C1->getContext(), C3V);
977 }
978 }
979 } else if (auto *VTy = dyn_cast<VectorType>(C1->getType())) {
980 // Fast path for splatted constants.
981 if (Constant *C2Splat = C2->getSplatValue()) {
982 if (Instruction::isIntDivRem(Opcode) && C2Splat->isNullValue())
983 return PoisonValue::get(VTy);
984 if (Constant *C1Splat = C1->getSplatValue()) {
985 Constant *Res =
987 ? ConstantExpr::get(Opcode, C1Splat, C2Splat)
988 : ConstantFoldBinaryInstruction(Opcode, C1Splat, C2Splat);
989 if (!Res)
990 return nullptr;
991 return ConstantVector::getSplat(VTy->getElementCount(), Res);
992 }
993 }
994
995 if (auto *FVTy = dyn_cast<FixedVectorType>(VTy)) {
996 // Fold each element and create a vector constant from those constants.
998 Type *Ty = IntegerType::get(FVTy->getContext(), 32);
999 for (unsigned i = 0, e = FVTy->getNumElements(); i != e; ++i) {
1000 Constant *ExtractIdx = ConstantInt::get(Ty, i);
1001 Constant *LHS = ConstantExpr::getExtractElement(C1, ExtractIdx);
1002 Constant *RHS = ConstantExpr::getExtractElement(C2, ExtractIdx);
1003
1004 // If any element of a divisor vector is zero, the whole op is poison.
1005 if (Instruction::isIntDivRem(Opcode) && RHS->isNullValue())
1006 return PoisonValue::get(VTy);
1007
1009 ? ConstantExpr::get(Opcode, LHS, RHS)
1011 if (!Res)
1012 return nullptr;
1013 Result.push_back(Res);
1014 }
1015
1016 return ConstantVector::get(Result);
1017 }
1018 }
1019
1020 if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
1021 // There are many possible foldings we could do here. We should probably
1022 // at least fold add of a pointer with an integer into the appropriate
1023 // getelementptr. This will improve alias analysis a bit.
1024
1025 // Given ((a + b) + c), if (b + c) folds to something interesting, return
1026 // (a + (b + c)).
1027 if (Instruction::isAssociative(Opcode) && CE1->getOpcode() == Opcode) {
1028 Constant *T = ConstantExpr::get(Opcode, CE1->getOperand(1), C2);
1029 if (!isa<ConstantExpr>(T) || cast<ConstantExpr>(T)->getOpcode() != Opcode)
1030 return ConstantExpr::get(Opcode, CE1->getOperand(0), T);
1031 }
1032 } else if (isa<ConstantExpr>(C2)) {
1033 // If C2 is a constant expr and C1 isn't, flop them around and fold the
1034 // other way if possible.
1035 if (Instruction::isCommutative(Opcode))
1036 return ConstantFoldBinaryInstruction(Opcode, C2, C1);
1037 }
1038
1039 // i1 can be simplified in many cases.
1040 if (C1->getType()->isIntegerTy(1)) {
1041 switch (Opcode) {
1042 case Instruction::Add:
1043 case Instruction::Sub:
1044 return ConstantExpr::getXor(C1, C2);
1045 case Instruction::Shl:
1046 case Instruction::LShr:
1047 case Instruction::AShr:
1048 // We can assume that C2 == 0. If it were one the result would be
1049 // undefined because the shift value is as large as the bitwidth.
1050 return C1;
1051 case Instruction::SDiv:
1052 case Instruction::UDiv:
1053 // We can assume that C2 == 1. If it were zero the result would be
1054 // undefined through division by zero.
1055 return C1;
1056 case Instruction::URem:
1057 case Instruction::SRem:
1058 // We can assume that C2 == 1. If it were zero the result would be
1059 // undefined through division by zero.
1060 return ConstantInt::getFalse(C1->getContext());
1061 default:
1062 break;
1063 }
1064 }
1065
1066 // We don't know how to fold this.
1067 return nullptr;
1068}
1069
1071 const GlobalValue *GV2) {
1072 auto isGlobalUnsafeForEquality = [](const GlobalValue *GV) {
1073 if (GV->isInterposable() || GV->hasGlobalUnnamedAddr())
1074 return true;
1075 if (const auto *GVar = dyn_cast<GlobalVariable>(GV)) {
1076 Type *Ty = GVar->getValueType();
1077 // A global with opaque type might end up being zero sized.
1078 if (!Ty->isSized())
1079 return true;
1080 // A global with an empty type might lie at the address of any other
1081 // global.
1082 if (Ty->isEmptyTy())
1083 return true;
1084 }
1085 return false;
1086 };
1087 // Don't try to decide equality of aliases.
1088 if (!isa<GlobalAlias>(GV1) && !isa<GlobalAlias>(GV2))
1089 if (!isGlobalUnsafeForEquality(GV1) && !isGlobalUnsafeForEquality(GV2))
1090 return ICmpInst::ICMP_NE;
1091 return ICmpInst::BAD_ICMP_PREDICATE;
1092}
1093
1094/// This function determines if there is anything we can decide about the two
1095/// constants provided. This doesn't need to handle simple things like integer
1096/// comparisons, but should instead handle ConstantExprs and GlobalValues.
1097/// If we can determine that the two constants have a particular relation to
1098/// each other, we should return the corresponding ICmp predicate, otherwise
1099/// return ICmpInst::BAD_ICMP_PREDICATE.
1101 assert(V1->getType() == V2->getType() &&
1102 "Cannot compare different types of values!");
1103 if (V1 == V2) return ICmpInst::ICMP_EQ;
1104
1105 // The following folds only apply to pointers.
1106 if (!V1->getType()->isPointerTy())
1107 return ICmpInst::BAD_ICMP_PREDICATE;
1108
1109 // To simplify this code we canonicalize the relation so that the first
1110 // operand is always the most "complex" of the two. We consider simple
1111 // constants (like ConstantPointerNull) to be the simplest, followed by
1112 // BlockAddress, GlobalValues, and ConstantExpr's (the most complex).
1113 auto GetComplexity = [](Constant *V) {
1114 if (isa<ConstantExpr>(V))
1115 return 3;
1116 if (isa<GlobalValue>(V))
1117 return 2;
1118 if (isa<BlockAddress>(V))
1119 return 1;
1120 return 0;
1121 };
1122 if (GetComplexity(V1) < GetComplexity(V2)) {
1123 ICmpInst::Predicate SwappedRelation = evaluateICmpRelation(V2, V1);
1124 if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE)
1125 return ICmpInst::getSwappedPredicate(SwappedRelation);
1126 return ICmpInst::BAD_ICMP_PREDICATE;
1127 }
1128
1129 if (const BlockAddress *BA = dyn_cast<BlockAddress>(V1)) {
1130 // Now we know that the RHS is a BlockAddress or simple constant.
1131 if (const BlockAddress *BA2 = dyn_cast<BlockAddress>(V2)) {
1132 // Block address in another function can't equal this one, but block
1133 // addresses in the current function might be the same if blocks are
1134 // empty.
1135 if (BA2->getFunction() != BA->getFunction())
1136 return ICmpInst::ICMP_NE;
1137 } else if (isa<ConstantPointerNull>(V2)) {
1138 return ICmpInst::ICMP_NE;
1139 }
1140 } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V1)) {
1141 // Now we know that the RHS is a GlobalValue, BlockAddress or simple
1142 // constant.
1143 if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2)) {
1144 return areGlobalsPotentiallyEqual(GV, GV2);
1145 } else if (isa<BlockAddress>(V2)) {
1146 return ICmpInst::ICMP_NE; // Globals never equal labels.
1147 } else if (isa<ConstantPointerNull>(V2)) {
1148 // GlobalVals can never be null unless they have external weak linkage.
1149 // We don't try to evaluate aliases here.
1150 // NOTE: We should not be doing this constant folding if null pointer
1151 // is considered valid for the function. But currently there is no way to
1152 // query it from the Constant type.
1153 if (!GV->hasExternalWeakLinkage() && !isa<GlobalAlias>(GV) &&
1154 !NullPointerIsDefined(nullptr /* F */,
1155 GV->getType()->getAddressSpace()))
1156 return ICmpInst::ICMP_UGT;
1157 }
1158 } else if (auto *CE1 = dyn_cast<ConstantExpr>(V1)) {
1159 // Ok, the LHS is known to be a constantexpr. The RHS can be any of a
1160 // constantexpr, a global, block address, or a simple constant.
1161 Constant *CE1Op0 = CE1->getOperand(0);
1162
1163 switch (CE1->getOpcode()) {
1164 case Instruction::GetElementPtr: {
1165 GEPOperator *CE1GEP = cast<GEPOperator>(CE1);
1166 // Ok, since this is a getelementptr, we know that the constant has a
1167 // pointer type. Check the various cases.
1168 if (isa<ConstantPointerNull>(V2)) {
1169 // If we are comparing a GEP to a null pointer, check to see if the base
1170 // of the GEP equals the null pointer.
1171 if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0)) {
1172 // If its not weak linkage, the GVal must have a non-zero address
1173 // so the result is greater-than
1174 if (!GV->hasExternalWeakLinkage() && CE1GEP->isInBounds())
1175 return ICmpInst::ICMP_UGT;
1176 }
1177 } else if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2)) {
1178 if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0)) {
1179 if (GV != GV2) {
1180 if (CE1GEP->hasAllZeroIndices())
1181 return areGlobalsPotentiallyEqual(GV, GV2);
1182 return ICmpInst::BAD_ICMP_PREDICATE;
1183 }
1184 }
1185 } else if (const auto *CE2GEP = dyn_cast<GEPOperator>(V2)) {
1186 // By far the most common case to handle is when the base pointers are
1187 // obviously to the same global.
1188 const Constant *CE2Op0 = cast<Constant>(CE2GEP->getPointerOperand());
1189 if (isa<GlobalValue>(CE1Op0) && isa<GlobalValue>(CE2Op0)) {
1190 // Don't know relative ordering, but check for inequality.
1191 if (CE1Op0 != CE2Op0) {
1192 if (CE1GEP->hasAllZeroIndices() && CE2GEP->hasAllZeroIndices())
1193 return areGlobalsPotentiallyEqual(cast<GlobalValue>(CE1Op0),
1194 cast<GlobalValue>(CE2Op0));
1195 return ICmpInst::BAD_ICMP_PREDICATE;
1196 }
1197 }
1198 }
1199 break;
1200 }
1201 default:
1202 break;
1203 }
1204 }
1205
1206 return ICmpInst::BAD_ICMP_PREDICATE;
1207}
1208
1210 Constant *C1, Constant *C2) {
1211 Type *ResultTy;
1212 if (VectorType *VT = dyn_cast<VectorType>(C1->getType()))
1213 ResultTy = VectorType::get(Type::getInt1Ty(C1->getContext()),
1214 VT->getElementCount());
1215 else
1216 ResultTy = Type::getInt1Ty(C1->getContext());
1217
1218 // Fold FCMP_FALSE/FCMP_TRUE unconditionally.
1219 if (Predicate == FCmpInst::FCMP_FALSE)
1220 return Constant::getNullValue(ResultTy);
1221
1222 if (Predicate == FCmpInst::FCMP_TRUE)
1223 return Constant::getAllOnesValue(ResultTy);
1224
1225 // Handle some degenerate cases first
1226 if (isa<PoisonValue>(C1) || isa<PoisonValue>(C2))
1227 return PoisonValue::get(ResultTy);
1228
1229 if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) {
1230 bool isIntegerPredicate = ICmpInst::isIntPredicate(Predicate);
1231 // For EQ and NE, we can always pick a value for the undef to make the
1232 // predicate pass or fail, so we can return undef.
1233 // Also, if both operands are undef, we can return undef for int comparison.
1234 if (ICmpInst::isEquality(Predicate) || (isIntegerPredicate && C1 == C2))
1235 return UndefValue::get(ResultTy);
1236
1237 // Otherwise, for integer compare, pick the same value as the non-undef
1238 // operand, and fold it to true or false.
1239 if (isIntegerPredicate)
1240 return ConstantInt::get(ResultTy, CmpInst::isTrueWhenEqual(Predicate));
1241
1242 // Choosing NaN for the undef will always make unordered comparison succeed
1243 // and ordered comparison fails.
1244 return ConstantInt::get(ResultTy, CmpInst::isUnordered(Predicate));
1245 }
1246
1247 if (C2->isNullValue()) {
1248 // The caller is expected to commute the operands if the constant expression
1249 // is C2.
1250 // C1 >= 0 --> true
1251 if (Predicate == ICmpInst::ICMP_UGE)
1252 return Constant::getAllOnesValue(ResultTy);
1253 // C1 < 0 --> false
1254 if (Predicate == ICmpInst::ICMP_ULT)
1255 return Constant::getNullValue(ResultTy);
1256 }
1257
1258 // If the comparison is a comparison between two i1's, simplify it.
1259 if (C1->getType()->isIntegerTy(1)) {
1260 switch (Predicate) {
1261 case ICmpInst::ICMP_EQ:
1262 if (isa<ConstantInt>(C2))
1265 case ICmpInst::ICMP_NE:
1266 return ConstantExpr::getXor(C1, C2);
1267 default:
1268 break;
1269 }
1270 }
1271
1272 if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2)) {
1273 const APInt &V1 = cast<ConstantInt>(C1)->getValue();
1274 const APInt &V2 = cast<ConstantInt>(C2)->getValue();
1275 return ConstantInt::get(ResultTy, ICmpInst::compare(V1, V2, Predicate));
1276 } else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) {
1277 const APFloat &C1V = cast<ConstantFP>(C1)->getValueAPF();
1278 const APFloat &C2V = cast<ConstantFP>(C2)->getValueAPF();
1279 return ConstantInt::get(ResultTy, FCmpInst::compare(C1V, C2V, Predicate));
1280 } else if (auto *C1VTy = dyn_cast<VectorType>(C1->getType())) {
1281
1282 // Fast path for splatted constants.
1283 if (Constant *C1Splat = C1->getSplatValue())
1284 if (Constant *C2Splat = C2->getSplatValue())
1286 C1VTy->getElementCount(),
1287 ConstantExpr::getCompare(Predicate, C1Splat, C2Splat));
1288
1289 // Do not iterate on scalable vector. The number of elements is unknown at
1290 // compile-time.
1291 if (isa<ScalableVectorType>(C1VTy))
1292 return nullptr;
1293
1294 // If we can constant fold the comparison of each element, constant fold
1295 // the whole vector comparison.
1297 Type *Ty = IntegerType::get(C1->getContext(), 32);
1298 // Compare the elements, producing an i1 result or constant expr.
1299 for (unsigned I = 0, E = C1VTy->getElementCount().getKnownMinValue();
1300 I != E; ++I) {
1301 Constant *C1E =
1302 ConstantExpr::getExtractElement(C1, ConstantInt::get(Ty, I));
1303 Constant *C2E =
1304 ConstantExpr::getExtractElement(C2, ConstantInt::get(Ty, I));
1305
1306 ResElts.push_back(ConstantExpr::getCompare(Predicate, C1E, C2E));
1307 }
1308
1309 return ConstantVector::get(ResElts);
1310 }
1311
1312 if (C1->getType()->isFPOrFPVectorTy()) {
1313 if (C1 == C2) {
1314 // We know that C1 == C2 || isUnordered(C1, C2).
1315 if (Predicate == FCmpInst::FCMP_ONE)
1316 return ConstantInt::getFalse(ResultTy);
1317 else if (Predicate == FCmpInst::FCMP_UEQ)
1318 return ConstantInt::getTrue(ResultTy);
1319 }
1320 } else {
1321 // Evaluate the relation between the two constants, per the predicate.
1322 int Result = -1; // -1 = unknown, 0 = known false, 1 = known true.
1323 switch (evaluateICmpRelation(C1, C2)) {
1324 default: llvm_unreachable("Unknown relational!");
1325 case ICmpInst::BAD_ICMP_PREDICATE:
1326 break; // Couldn't determine anything about these constants.
1327 case ICmpInst::ICMP_EQ: // We know the constants are equal!
1328 // If we know the constants are equal, we can decide the result of this
1329 // computation precisely.
1330 Result = ICmpInst::isTrueWhenEqual(Predicate);
1331 break;
1332 case ICmpInst::ICMP_ULT:
1333 switch (Predicate) {
1334 case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_ULE:
1335 Result = 1; break;
1336 case ICmpInst::ICMP_UGT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_UGE:
1337 Result = 0; break;
1338 default:
1339 break;
1340 }
1341 break;
1342 case ICmpInst::ICMP_SLT:
1343 switch (Predicate) {
1344 case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_SLE:
1345 Result = 1; break;
1346 case ICmpInst::ICMP_SGT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_SGE:
1347 Result = 0; break;
1348 default:
1349 break;
1350 }
1351 break;
1352 case ICmpInst::ICMP_UGT:
1353 switch (Predicate) {
1354 case ICmpInst::ICMP_UGT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_UGE:
1355 Result = 1; break;
1356 case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_ULE:
1357 Result = 0; break;
1358 default:
1359 break;
1360 }
1361 break;
1362 case ICmpInst::ICMP_SGT:
1363 switch (Predicate) {
1364 case ICmpInst::ICMP_SGT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_SGE:
1365 Result = 1; break;
1366 case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_SLE:
1367 Result = 0; break;
1368 default:
1369 break;
1370 }
1371 break;
1372 case ICmpInst::ICMP_ULE:
1373 if (Predicate == ICmpInst::ICMP_UGT)
1374 Result = 0;
1375 if (Predicate == ICmpInst::ICMP_ULT || Predicate == ICmpInst::ICMP_ULE)
1376 Result = 1;
1377 break;
1378 case ICmpInst::ICMP_SLE:
1379 if (Predicate == ICmpInst::ICMP_SGT)
1380 Result = 0;
1381 if (Predicate == ICmpInst::ICMP_SLT || Predicate == ICmpInst::ICMP_SLE)
1382 Result = 1;
1383 break;
1384 case ICmpInst::ICMP_UGE:
1385 if (Predicate == ICmpInst::ICMP_ULT)
1386 Result = 0;
1387 if (Predicate == ICmpInst::ICMP_UGT || Predicate == ICmpInst::ICMP_UGE)
1388 Result = 1;
1389 break;
1390 case ICmpInst::ICMP_SGE:
1391 if (Predicate == ICmpInst::ICMP_SLT)
1392 Result = 0;
1393 if (Predicate == ICmpInst::ICMP_SGT || Predicate == ICmpInst::ICMP_SGE)
1394 Result = 1;
1395 break;
1396 case ICmpInst::ICMP_NE:
1397 if (Predicate == ICmpInst::ICMP_EQ)
1398 Result = 0;
1399 if (Predicate == ICmpInst::ICMP_NE)
1400 Result = 1;
1401 break;
1402 }
1403
1404 // If we evaluated the result, return it now.
1405 if (Result != -1)
1406 return ConstantInt::get(ResultTy, Result);
1407
1408 if ((!isa<ConstantExpr>(C1) && isa<ConstantExpr>(C2)) ||
1409 (C1->isNullValue() && !C2->isNullValue())) {
1410 // If C2 is a constant expr and C1 isn't, flip them around and fold the
1411 // other way if possible.
1412 // Also, if C1 is null and C2 isn't, flip them around.
1413 Predicate = ICmpInst::getSwappedPredicate(Predicate);
1414 return ConstantExpr::getICmp(Predicate, C2, C1);
1415 }
1416 }
1417 return nullptr;
1418}
1419
1420/// Test whether the given sequence of *normalized* indices is "inbounds".
1421template<typename IndexTy>
1423 // No indices means nothing that could be out of bounds.
1424 if (Idxs.empty()) return true;
1425
1426 // If the first index is zero, it's in bounds.
1427 if (cast<Constant>(Idxs[0])->isNullValue()) return true;
1428
1429 // If the first index is one and all the rest are zero, it's in bounds,
1430 // by the one-past-the-end rule.
1431 if (auto *CI = dyn_cast<ConstantInt>(Idxs[0])) {
1432 if (!CI->isOne())
1433 return false;
1434 } else {
1435 auto *CV = cast<ConstantDataVector>(Idxs[0]);
1436 CI = dyn_cast_or_null<ConstantInt>(CV->getSplatValue());
1437 if (!CI || !CI->isOne())
1438 return false;
1439 }
1440
1441 for (unsigned i = 1, e = Idxs.size(); i != e; ++i)
1442 if (!cast<Constant>(Idxs[i])->isNullValue())
1443 return false;
1444 return true;
1445}
1446
1447/// Test whether a given ConstantInt is in-range for a SequentialType.
1448static bool isIndexInRangeOfArrayType(uint64_t NumElements,
1449 const ConstantInt *CI) {
1450 // We cannot bounds check the index if it doesn't fit in an int64_t.
1451 if (CI->getValue().getSignificantBits() > 64)
1452 return false;
1453
1454 // A negative index or an index past the end of our sequential type is
1455 // considered out-of-range.
1456 int64_t IndexVal = CI->getSExtValue();
1457 if (IndexVal < 0 || (IndexVal != 0 && (uint64_t)IndexVal >= NumElements))
1458 return false;
1459
1460 // Otherwise, it is in-range.
1461 return true;
1462}
1463
1464// Combine Indices - If the source pointer to this getelementptr instruction
1465// is a getelementptr instruction, combine the indices of the two
1466// getelementptr instructions into a single instruction.
1467static Constant *foldGEPOfGEP(GEPOperator *GEP, Type *PointeeTy, bool InBounds,
1468 ArrayRef<Value *> Idxs) {
1469 if (PointeeTy != GEP->getResultElementType())
1470 return nullptr;
1471
1472 // Leave inrange handling to DL-aware constant folding.
1473 if (GEP->getInRange())
1474 return nullptr;
1475
1476 Constant *Idx0 = cast<Constant>(Idxs[0]);
1477 if (Idx0->isNullValue()) {
1478 // Handle the simple case of a zero index.
1479 SmallVector<Value*, 16> NewIndices;
1480 NewIndices.reserve(Idxs.size() + GEP->getNumIndices());
1481 NewIndices.append(GEP->idx_begin(), GEP->idx_end());
1482 NewIndices.append(Idxs.begin() + 1, Idxs.end());
1484 GEP->getSourceElementType(), cast<Constant>(GEP->getPointerOperand()),
1485 NewIndices, InBounds && GEP->isInBounds());
1486 }
1487
1490 I != E; ++I)
1491 LastI = I;
1492
1493 // We can't combine GEPs if the last index is a struct type.
1494 if (!LastI.isSequential())
1495 return nullptr;
1496 // We could perform the transform with non-constant index, but prefer leaving
1497 // it as GEP of GEP rather than GEP of add for now.
1498 ConstantInt *CI = dyn_cast<ConstantInt>(Idx0);
1499 if (!CI)
1500 return nullptr;
1501
1502 // TODO: This code may be extended to handle vectors as well.
1503 auto *LastIdx = cast<Constant>(GEP->getOperand(GEP->getNumOperands()-1));
1504 Type *LastIdxTy = LastIdx->getType();
1505 if (LastIdxTy->isVectorTy())
1506 return nullptr;
1507
1508 SmallVector<Value*, 16> NewIndices;
1509 NewIndices.reserve(Idxs.size() + GEP->getNumIndices());
1510 NewIndices.append(GEP->idx_begin(), GEP->idx_end() - 1);
1511
1512 // Add the last index of the source with the first index of the new GEP.
1513 // Make sure to handle the case when they are actually different types.
1514 if (LastIdxTy != Idx0->getType()) {
1515 unsigned CommonExtendedWidth =
1516 std::max(LastIdxTy->getIntegerBitWidth(),
1517 Idx0->getType()->getIntegerBitWidth());
1518 CommonExtendedWidth = std::max(CommonExtendedWidth, 64U);
1519
1520 Type *CommonTy =
1521 Type::getIntNTy(LastIdxTy->getContext(), CommonExtendedWidth);
1522 if (Idx0->getType() != CommonTy)
1523 Idx0 = ConstantFoldCastInstruction(Instruction::SExt, Idx0, CommonTy);
1524 if (LastIdx->getType() != CommonTy)
1525 LastIdx =
1526 ConstantFoldCastInstruction(Instruction::SExt, LastIdx, CommonTy);
1527 if (!Idx0 || !LastIdx)
1528 return nullptr;
1529 }
1530
1531 NewIndices.push_back(ConstantExpr::get(Instruction::Add, Idx0, LastIdx));
1532 NewIndices.append(Idxs.begin() + 1, Idxs.end());
1533
1535 GEP->getSourceElementType(), cast<Constant>(GEP->getPointerOperand()),
1536 NewIndices, InBounds && GEP->isInBounds());
1537}
1538
1540 bool InBounds,
1541 std::optional<ConstantRange> InRange,
1542 ArrayRef<Value *> Idxs) {
1543 if (Idxs.empty()) return C;
1544
1546 C, ArrayRef((Value *const *)Idxs.data(), Idxs.size()));
1547
1548 if (isa<PoisonValue>(C))
1549 return PoisonValue::get(GEPTy);
1550
1551 if (isa<UndefValue>(C))
1552 // If inbounds, we can choose an out-of-bounds pointer as a base pointer.
1553 return InBounds ? PoisonValue::get(GEPTy) : UndefValue::get(GEPTy);
1554
1555 auto IsNoOp = [&]() {
1556 // Avoid losing inrange information.
1557 if (InRange)
1558 return false;
1559
1560 return all_of(Idxs, [](Value *Idx) {
1561 Constant *IdxC = cast<Constant>(Idx);
1562 return IdxC->isNullValue() || isa<UndefValue>(IdxC);
1563 });
1564 };
1565 if (IsNoOp())
1566 return GEPTy->isVectorTy() && !C->getType()->isVectorTy()
1568 cast<VectorType>(GEPTy)->getElementCount(), C)
1569 : C;
1570
1571 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
1572 if (auto *GEP = dyn_cast<GEPOperator>(CE))
1573 if (Constant *C = foldGEPOfGEP(GEP, PointeeTy, InBounds, Idxs))
1574 return C;
1575
1576 // Check to see if any array indices are not within the corresponding
1577 // notional array or vector bounds. If so, try to determine if they can be
1578 // factored out into preceding dimensions.
1580 Type *Ty = PointeeTy;
1581 Type *Prev = C->getType();
1582 auto GEPIter = gep_type_begin(PointeeTy, Idxs);
1583 bool Unknown =
1584 !isa<ConstantInt>(Idxs[0]) && !isa<ConstantDataVector>(Idxs[0]);
1585 for (unsigned i = 1, e = Idxs.size(); i != e;
1586 Prev = Ty, Ty = (++GEPIter).getIndexedType(), ++i) {
1587 if (!isa<ConstantInt>(Idxs[i]) && !isa<ConstantDataVector>(Idxs[i])) {
1588 // We don't know if it's in range or not.
1589 Unknown = true;
1590 continue;
1591 }
1592 if (!isa<ConstantInt>(Idxs[i - 1]) && !isa<ConstantDataVector>(Idxs[i - 1]))
1593 // Skip if the type of the previous index is not supported.
1594 continue;
1595 if (isa<StructType>(Ty)) {
1596 // The verify makes sure that GEPs into a struct are in range.
1597 continue;
1598 }
1599 if (isa<VectorType>(Ty)) {
1600 // There can be awkward padding in after a non-power of two vector.
1601 Unknown = true;
1602 continue;
1603 }
1604 auto *STy = cast<ArrayType>(Ty);
1605 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idxs[i])) {
1606 if (isIndexInRangeOfArrayType(STy->getNumElements(), CI))
1607 // It's in range, skip to the next index.
1608 continue;
1609 if (CI->isNegative()) {
1610 // It's out of range and negative, don't try to factor it.
1611 Unknown = true;
1612 continue;
1613 }
1614 } else {
1615 auto *CV = cast<ConstantDataVector>(Idxs[i]);
1616 bool IsInRange = true;
1617 for (unsigned I = 0, E = CV->getNumElements(); I != E; ++I) {
1618 auto *CI = cast<ConstantInt>(CV->getElementAsConstant(I));
1619 IsInRange &= isIndexInRangeOfArrayType(STy->getNumElements(), CI);
1620 if (CI->isNegative()) {
1621 Unknown = true;
1622 break;
1623 }
1624 }
1625 if (IsInRange || Unknown)
1626 // It's in range, skip to the next index.
1627 // It's out of range and negative, don't try to factor it.
1628 continue;
1629 }
1630 if (isa<StructType>(Prev)) {
1631 // It's out of range, but the prior dimension is a struct
1632 // so we can't do anything about it.
1633 Unknown = true;
1634 continue;
1635 }
1636
1637 // Determine the number of elements in our sequential type.
1638 uint64_t NumElements = STy->getArrayNumElements();
1639 if (!NumElements) {
1640 Unknown = true;
1641 continue;
1642 }
1643
1644 // It's out of range, but we can factor it into the prior
1645 // dimension.
1646 NewIdxs.resize(Idxs.size());
1647
1648 // Expand the current index or the previous index to a vector from a scalar
1649 // if necessary.
1650 Constant *CurrIdx = cast<Constant>(Idxs[i]);
1651 auto *PrevIdx =
1652 NewIdxs[i - 1] ? NewIdxs[i - 1] : cast<Constant>(Idxs[i - 1]);
1653 bool IsCurrIdxVector = CurrIdx->getType()->isVectorTy();
1654 bool IsPrevIdxVector = PrevIdx->getType()->isVectorTy();
1655 bool UseVector = IsCurrIdxVector || IsPrevIdxVector;
1656
1657 if (!IsCurrIdxVector && IsPrevIdxVector)
1659 cast<FixedVectorType>(PrevIdx->getType())->getNumElements(), CurrIdx);
1660
1661 if (!IsPrevIdxVector && IsCurrIdxVector)
1663 cast<FixedVectorType>(CurrIdx->getType())->getNumElements(), PrevIdx);
1664
1665 Constant *Factor =
1666 ConstantInt::get(CurrIdx->getType()->getScalarType(), NumElements);
1667 if (UseVector)
1669 IsPrevIdxVector
1670 ? cast<FixedVectorType>(PrevIdx->getType())->getNumElements()
1671 : cast<FixedVectorType>(CurrIdx->getType())->getNumElements(),
1672 Factor);
1673
1674 NewIdxs[i] =
1675 ConstantFoldBinaryInstruction(Instruction::SRem, CurrIdx, Factor);
1676
1677 Constant *Div =
1678 ConstantFoldBinaryInstruction(Instruction::SDiv, CurrIdx, Factor);
1679
1680 // We're working on either ConstantInt or vectors of ConstantInt,
1681 // so these should always fold.
1682 assert(NewIdxs[i] != nullptr && Div != nullptr && "Should have folded");
1683
1684 unsigned CommonExtendedWidth =
1685 std::max(PrevIdx->getType()->getScalarSizeInBits(),
1686 Div->getType()->getScalarSizeInBits());
1687 CommonExtendedWidth = std::max(CommonExtendedWidth, 64U);
1688
1689 // Before adding, extend both operands to i64 to avoid
1690 // overflow trouble.
1691 Type *ExtendedTy = Type::getIntNTy(Div->getContext(), CommonExtendedWidth);
1692 if (UseVector)
1693 ExtendedTy = FixedVectorType::get(
1694 ExtendedTy,
1695 IsPrevIdxVector
1696 ? cast<FixedVectorType>(PrevIdx->getType())->getNumElements()
1697 : cast<FixedVectorType>(CurrIdx->getType())->getNumElements());
1698
1699 if (!PrevIdx->getType()->isIntOrIntVectorTy(CommonExtendedWidth))
1700 PrevIdx =
1701 ConstantFoldCastInstruction(Instruction::SExt, PrevIdx, ExtendedTy);
1702
1703 if (!Div->getType()->isIntOrIntVectorTy(CommonExtendedWidth))
1704 Div = ConstantFoldCastInstruction(Instruction::SExt, Div, ExtendedTy);
1705
1706 assert(PrevIdx && Div && "Should have folded");
1707 NewIdxs[i - 1] = ConstantExpr::getAdd(PrevIdx, Div);
1708 }
1709
1710 // If we did any factoring, start over with the adjusted indices.
1711 if (!NewIdxs.empty()) {
1712 for (unsigned i = 0, e = Idxs.size(); i != e; ++i)
1713 if (!NewIdxs[i]) NewIdxs[i] = cast<Constant>(Idxs[i]);
1714 return ConstantExpr::getGetElementPtr(PointeeTy, C, NewIdxs, InBounds,
1715 InRange);
1716 }
1717
1718 // If all indices are known integers and normalized, we can do a simple
1719 // check for the "inbounds" property.
1720 if (!Unknown && !InBounds)
1721 if (auto *GV = dyn_cast<GlobalVariable>(C))
1722 if (!GV->hasExternalWeakLinkage() && GV->getValueType() == PointeeTy &&
1723 isInBoundsIndices(Idxs))
1724 return ConstantExpr::getGetElementPtr(PointeeTy, C, Idxs,
1725 /*InBounds=*/true, InRange);
1726
1727 return nullptr;
1728}
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
static unsigned foldConstantCastPair(unsigned opc, ConstantExpr *Op, Type *DstTy)
This function determines which opcode to use to fold two constant cast expressions together.
static Constant * foldMaybeUndesirableCast(unsigned opc, Constant *V, Type *DestTy)
static ICmpInst::Predicate areGlobalsPotentiallyEqual(const GlobalValue *GV1, const GlobalValue *GV2)
static Constant * FoldBitCast(Constant *V, Type *DestTy)
static bool isIndexInRangeOfArrayType(uint64_t NumElements, const ConstantInt *CI)
Test whether a given ConstantInt is in-range for a SequentialType.
static Constant * foldGEPOfGEP(GEPOperator *GEP, Type *PointeeTy, bool InBounds, ArrayRef< Value * > Idxs)
static bool isInBoundsIndices(ArrayRef< IndexTy > Idxs)
Test whether the given sequence of normalized indices is "inbounds".
static Constant * ExtractConstantBytes(Constant *C, unsigned ByteStart, unsigned ByteSize)
V is an integer constant which only has a subset of its bytes used.
static ICmpInst::Predicate evaluateICmpRelation(Constant *V1, Constant *V2)
This function determines if there is anything we can decide about the two constants provided.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
Looks at all the uses of the given value Returns the Liveness deduced from the uses of this value Adds all uses that cause the result to be MaybeLive to MaybeLiveRetUses If the result is MaybeLiveUses might be modified but its content should be ignored(since it might not be complete). DeadArgumentEliminationPass
Hexagon Common GEP
hexagon gen pred
#define I(x, y, z)
Definition: MD5.cpp:58
static bool InRange(int64_t Value, unsigned short Shift, int LBound, int HBound)
Module.h This file contains the declarations for the Module class.
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
Definition: VPlanSLP.cpp:191
Value * RHS
Value * LHS
opStatus divide(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1069
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition: APFloat.cpp:5191
opStatus subtract(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1051
opStatus add(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1042
opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)
Definition: APFloat.h:1193
opStatus multiply(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1060
opStatus mod(const APFloat &RHS)
Definition: APFloat.h:1087
Class for arbitrary precision integers.
Definition: APInt.h:76
APInt udiv(const APInt &RHS) const
Unsigned division operation.
Definition: APInt.cpp:1543
bool isMinSignedValue() const
Determine if this is the smallest signed value.
Definition: APInt.h:401
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1498
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
Definition: APInt.cpp:1636
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1446
APInt sdiv(const APInt &RHS) const
Signed division function for APInt.
Definition: APInt.cpp:1614
unsigned getSignificantBits() const
Get the minimum bit size for this signed APInt.
Definition: APInt.h:1489
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
Definition: APInt.h:805
APInt srem(const APInt &RHS) const
Function for signed remainder operation.
Definition: APInt.cpp:1706
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
Definition: APInt.h:1128
APInt shl(unsigned shiftAmt) const
Left-shift function.
Definition: APInt.h:851
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Constructs an APInt value that has the bottom loBitsSet bits set.
Definition: APInt.h:284
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
Definition: APInt.h:178
void lshrInPlace(unsigned ShiftAmt)
Logical right-shift this APInt by ShiftAmt in place.
Definition: APInt.h:836
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
Definition: APInt.h:829
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
Definition: APInt.h:1199
An arbitrary precision integer that knows its signedness.
Definition: APSInt.h:23
static bool isSameValue(const APSInt &I1, const APSInt &I2)
Determine if two APSInts have the same value, zero- or sign-extending as needed.
Definition: APSInt.h:319
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
iterator end() const
Definition: ArrayRef.h:154
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
iterator begin() const
Definition: ArrayRef.h:153
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
const T * data() const
Definition: ArrayRef.h:162
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Definition: ArrayRef.h:195
The address of a basic block.
Definition: Constants.h:889
static unsigned isEliminableCastPair(Instruction::CastOps firstOpcode, Instruction::CastOps secondOpcode, Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy, Type *DstIntPtrTy)
Determine how a pair of casts can be eliminated, if they can be at all.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:993
bool isTrueWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:1314
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE,...
Definition: InstrTypes.h:1129
static bool isUnordered(Predicate predicate)
Determine if the predicate is an unordered operation.
static ConstantAggregateZero * get(Type *Ty)
Definition: Constants.cpp:1663
static Constant * get(ArrayType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:1291
static Constant * getSplat(unsigned NumElts, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
Definition: Constants.cpp:2958
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:1017
static Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2452
static bool isDesirableCastOp(unsigned Opcode)
Whether creating a constant expression for this cast is desirable.
Definition: Constants.cpp:2261
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:2041
static Constant * getNot(Constant *C)
Definition: Constants.cpp:2529
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
Definition: Constants.cpp:2402
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, bool InBounds=false, std::optional< ConstantRange > InRange=std::nullopt, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
Definition: Constants.h:1200
static Constant * getXor(Constant *C1, Constant *C2)
Definition: Constants.cpp:2556
static Constant * get(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags=0, Type *OnlyIfReducedTy=nullptr)
get - Return a binary or shift operator constant expression, folding if possible.
Definition: Constants.cpp:2159
static bool isDesirableBinOp(unsigned Opcode)
Whether creating a constant expression for this binary operator is desirable.
Definition: Constants.cpp:2207
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2535
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2140
static Constant * getBinOpIdentity(unsigned Opcode, Type *Ty, bool AllowRHSConstant=false, bool NSZ=false)
Return the identity constant for a binary opcode.
Definition: Constants.cpp:2596
static Constant * getCompare(unsigned short pred, Constant *C1, Constant *C2, bool OnlyIfReduced=false)
Return an ICmp or FCmp comparison operator constant expression.
Definition: Constants.cpp:2328
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:268
static Constant * getNaN(Type *Ty, bool Negative=false, uint64_t Payload=0)
Definition: Constants.cpp:1004
This is the shared class of boolean and integer constants.
Definition: Constants.h:80
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:849
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:856
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
Definition: Constants.h:160
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:154
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:145
bool uge(uint64_t Num) const
This function will return true iff this constant represents a value with active bits bigger than 64 b...
Definition: Constants.h:248
static Constant * get(StructType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:1356
Constant Vector Declarations.
Definition: Constants.h:507
static Constant * getSplat(ElementCount EC, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
Definition: Constants.cpp:1449
static Constant * get(ArrayRef< Constant * > V)
Definition: Constants.cpp:1398
This is an important base class in LLVM.
Definition: Constant.h:41
Constant * getSplatValue(bool AllowPoison=false) const
If all elements of the vector constant have the same value, return that value.
Definition: Constants.cpp:1699
static Constant * getAllOnesValue(Type *Ty)
Definition: Constants.cpp:417
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:370
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:432
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:90
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
static constexpr ElementCount get(ScalarTy MinVal, bool Scalable)
Definition: TypeSize.h:314
static bool compare(const APFloat &LHS, const APFloat &RHS, FCmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
static FixedVectorType * get(Type *ElementType, unsigned NumElts)
Definition: Type.cpp:692
bool isInBounds() const
Test whether this is an inbounds GEP, as defined by LangRef.html.
Definition: Operator.h:420
bool hasAllZeroIndices() const
Return true if all of the indices of this GEP are zeros.
Definition: Operator.h:475
static Type * getGEPReturnType(Value *Ptr, ArrayRef< Value * > IdxList)
Returns the pointer type returned by the GEP instruction, which may be a vector of pointers.
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:655
static bool compare(const APInt &LHS, const APInt &RHS, ICmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
bool isEquality() const
Return true if this predicate is either EQ or NE.
bool isAssociative() const LLVM_READONLY
Return true if the instruction is associative:
bool isCommutative() const LLVM_READONLY
Return true if the instruction is commutative:
bool isBinaryOp() const
Definition: Instruction.h:257
bool isUnaryOp() const
Definition: Instruction.h:256
bool isIntDivRem() const
Definition: Instruction.h:258
Class to represent integer types.
Definition: DerivedTypes.h:40
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:278
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Definition: Constants.cpp:1827
bool empty() const
Definition: SmallVector.h:94
void reserve(size_type N)
Definition: SmallVector.h:676
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:696
void resize(size_type N)
Definition: SmallVector.h:651
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
Class to represent struct types.
Definition: DerivedTypes.h:216
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
unsigned getIntegerBitWidth() const
const fltSemantics & getFltSemantics() const
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:265
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:234
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:255
static IntegerType * getInt1Ty(LLVMContext &C)
bool isEmptyTy() const
Return true if this type is empty, that is, it has no elements or all of its elements are empty.
bool isX86_MMXTy() const
Return true if this is X86 MMX.
Definition: Type.h:201
bool isPPC_FP128Ty() const
Return true if this is powerpc long double.
Definition: Type.h:166
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isFirstClassType() const
Return true if the type is "first class", meaning it is a valid type for a Value.
Definition: Type.h:281
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:302
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:129
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
Definition: Type.h:185
bool isX86_AMXTy() const
Return true if this is X86 AMX.
Definition: Type.h:204
static IntegerType * getInt32Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:228
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
Definition: Type.h:216
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
Definition: Type.h:348
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1808
Value * getOperand(unsigned i) const
Definition: User.h:169
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
Align getPointerAlignment(const DataLayout &DL) const
Returns an alignment of the pointer value.
Definition: Value.cpp:926
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:1074
Base class of all SIMD vector types.
Definition: DerivedTypes.h:403
Type * getElementType() const
Definition: DerivedTypes.h:436
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
cstfp_pred_ty< is_neg_zero_fp > m_NegZeroFP()
Match a floating-point negative zero.
Definition: PatternMatch.h:782
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
Definition: PatternMatch.h:299
auto m_Undef()
Match an arbitrary undef constant.
Definition: PatternMatch.h:152
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
Definition: PatternMatch.h:612
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
Definition: PatternMatch.h:239
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Constant * ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool InBounds, std::optional< ConstantRange > InRange, ArrayRef< Value * > Idxs)
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1722
Constant * ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2)
Attempt to constant fold a select instruction with the specified operands.
Constant * ConstantFoldCompareInstruction(CmpInst::Predicate Predicate, Constant *C1, Constant *C2)
Constant * ConstantFoldUnaryInstruction(unsigned Opcode, Constant *V)
gep_type_iterator gep_type_end(const User *GEP)
Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)
Attempt to constant fold an extractvalue instruction with the specified operands and indices.
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
Definition: Function.cpp:2058
Constant * ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt, Constant *Idx)
Attempt to constant fold an insertelement instruction with the specified operands and indices.
constexpr int PoisonMaskElem
Constant * ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx)
Attempt to constant fold an extractelement instruction with the specified operands and indices.
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:191
gep_type_iterator gep_type_begin(const User *GEP)
APFloat neg(APFloat X)
Returns the negated value of the argument.
Definition: APFloat.h:1387
Constant * ConstantFoldCastInstruction(unsigned opcode, Constant *V, Type *DestTy)
Constant * ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs)
ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue instruction with the spe...
unsigned Log2(Align A)
Returns the log2 of the alignment.
Definition: Alignment.h:208
Constant * ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, ArrayRef< int > Mask)
Attempt to constant fold a shufflevector instruction with the specified operands and mask.
Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39