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())
1285 if (Constant *Elt =
1286 ConstantFoldCompareInstruction(Predicate, C1Splat, C2Splat))
1287 return ConstantVector::getSplat(C1VTy->getElementCount(), Elt);
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 Constant *Elt = ConstantFoldCompareInstruction(Predicate, C1E, C2E);
1306 if (!Elt)
1307 return nullptr;
1308
1309 ResElts.push_back(Elt);
1310 }
1311
1312 return ConstantVector::get(ResElts);
1313 }
1314
1315 if (C1->getType()->isFPOrFPVectorTy()) {
1316 if (C1 == C2) {
1317 // We know that C1 == C2 || isUnordered(C1, C2).
1318 if (Predicate == FCmpInst::FCMP_ONE)
1319 return ConstantInt::getFalse(ResultTy);
1320 else if (Predicate == FCmpInst::FCMP_UEQ)
1321 return ConstantInt::getTrue(ResultTy);
1322 }
1323 } else {
1324 // Evaluate the relation between the two constants, per the predicate.
1325 int Result = -1; // -1 = unknown, 0 = known false, 1 = known true.
1326 switch (evaluateICmpRelation(C1, C2)) {
1327 default: llvm_unreachable("Unknown relational!");
1328 case ICmpInst::BAD_ICMP_PREDICATE:
1329 break; // Couldn't determine anything about these constants.
1330 case ICmpInst::ICMP_EQ: // We know the constants are equal!
1331 // If we know the constants are equal, we can decide the result of this
1332 // computation precisely.
1333 Result = ICmpInst::isTrueWhenEqual(Predicate);
1334 break;
1335 case ICmpInst::ICMP_ULT:
1336 switch (Predicate) {
1337 case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_ULE:
1338 Result = 1; break;
1339 case ICmpInst::ICMP_UGT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_UGE:
1340 Result = 0; break;
1341 default:
1342 break;
1343 }
1344 break;
1345 case ICmpInst::ICMP_SLT:
1346 switch (Predicate) {
1347 case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_SLE:
1348 Result = 1; break;
1349 case ICmpInst::ICMP_SGT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_SGE:
1350 Result = 0; break;
1351 default:
1352 break;
1353 }
1354 break;
1355 case ICmpInst::ICMP_UGT:
1356 switch (Predicate) {
1357 case ICmpInst::ICMP_UGT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_UGE:
1358 Result = 1; break;
1359 case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_ULE:
1360 Result = 0; break;
1361 default:
1362 break;
1363 }
1364 break;
1365 case ICmpInst::ICMP_SGT:
1366 switch (Predicate) {
1367 case ICmpInst::ICMP_SGT: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_SGE:
1368 Result = 1; break;
1369 case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_SLE:
1370 Result = 0; break;
1371 default:
1372 break;
1373 }
1374 break;
1375 case ICmpInst::ICMP_ULE:
1376 if (Predicate == ICmpInst::ICMP_UGT)
1377 Result = 0;
1378 if (Predicate == ICmpInst::ICMP_ULT || Predicate == ICmpInst::ICMP_ULE)
1379 Result = 1;
1380 break;
1381 case ICmpInst::ICMP_SLE:
1382 if (Predicate == ICmpInst::ICMP_SGT)
1383 Result = 0;
1384 if (Predicate == ICmpInst::ICMP_SLT || Predicate == ICmpInst::ICMP_SLE)
1385 Result = 1;
1386 break;
1387 case ICmpInst::ICMP_UGE:
1388 if (Predicate == ICmpInst::ICMP_ULT)
1389 Result = 0;
1390 if (Predicate == ICmpInst::ICMP_UGT || Predicate == ICmpInst::ICMP_UGE)
1391 Result = 1;
1392 break;
1393 case ICmpInst::ICMP_SGE:
1394 if (Predicate == ICmpInst::ICMP_SLT)
1395 Result = 0;
1396 if (Predicate == ICmpInst::ICMP_SGT || Predicate == ICmpInst::ICMP_SGE)
1397 Result = 1;
1398 break;
1399 case ICmpInst::ICMP_NE:
1400 if (Predicate == ICmpInst::ICMP_EQ)
1401 Result = 0;
1402 if (Predicate == ICmpInst::ICMP_NE)
1403 Result = 1;
1404 break;
1405 }
1406
1407 // If we evaluated the result, return it now.
1408 if (Result != -1)
1409 return ConstantInt::get(ResultTy, Result);
1410
1411 if ((!isa<ConstantExpr>(C1) && isa<ConstantExpr>(C2)) ||
1412 (C1->isNullValue() && !C2->isNullValue())) {
1413 // If C2 is a constant expr and C1 isn't, flip them around and fold the
1414 // other way if possible.
1415 // Also, if C1 is null and C2 isn't, flip them around.
1416 Predicate = ICmpInst::getSwappedPredicate(Predicate);
1417 return ConstantFoldCompareInstruction(Predicate, C2, C1);
1418 }
1419 }
1420 return nullptr;
1421}
1422
1423/// Test whether the given sequence of *normalized* indices is "inbounds".
1424template<typename IndexTy>
1426 // No indices means nothing that could be out of bounds.
1427 if (Idxs.empty()) return true;
1428
1429 // If the first index is zero, it's in bounds.
1430 if (cast<Constant>(Idxs[0])->isNullValue()) return true;
1431
1432 // If the first index is one and all the rest are zero, it's in bounds,
1433 // by the one-past-the-end rule.
1434 if (auto *CI = dyn_cast<ConstantInt>(Idxs[0])) {
1435 if (!CI->isOne())
1436 return false;
1437 } else {
1438 auto *CV = cast<ConstantDataVector>(Idxs[0]);
1439 CI = dyn_cast_or_null<ConstantInt>(CV->getSplatValue());
1440 if (!CI || !CI->isOne())
1441 return false;
1442 }
1443
1444 for (unsigned i = 1, e = Idxs.size(); i != e; ++i)
1445 if (!cast<Constant>(Idxs[i])->isNullValue())
1446 return false;
1447 return true;
1448}
1449
1450/// Test whether a given ConstantInt is in-range for a SequentialType.
1451static bool isIndexInRangeOfArrayType(uint64_t NumElements,
1452 const ConstantInt *CI) {
1453 // We cannot bounds check the index if it doesn't fit in an int64_t.
1454 if (CI->getValue().getSignificantBits() > 64)
1455 return false;
1456
1457 // A negative index or an index past the end of our sequential type is
1458 // considered out-of-range.
1459 int64_t IndexVal = CI->getSExtValue();
1460 if (IndexVal < 0 || (IndexVal != 0 && (uint64_t)IndexVal >= NumElements))
1461 return false;
1462
1463 // Otherwise, it is in-range.
1464 return true;
1465}
1466
1467// Combine Indices - If the source pointer to this getelementptr instruction
1468// is a getelementptr instruction, combine the indices of the two
1469// getelementptr instructions into a single instruction.
1470static Constant *foldGEPOfGEP(GEPOperator *GEP, Type *PointeeTy, bool InBounds,
1471 ArrayRef<Value *> Idxs) {
1472 if (PointeeTy != GEP->getResultElementType())
1473 return nullptr;
1474
1475 // Leave inrange handling to DL-aware constant folding.
1476 if (GEP->getInRange())
1477 return nullptr;
1478
1479 Constant *Idx0 = cast<Constant>(Idxs[0]);
1480 if (Idx0->isNullValue()) {
1481 // Handle the simple case of a zero index.
1482 SmallVector<Value*, 16> NewIndices;
1483 NewIndices.reserve(Idxs.size() + GEP->getNumIndices());
1484 NewIndices.append(GEP->idx_begin(), GEP->idx_end());
1485 NewIndices.append(Idxs.begin() + 1, Idxs.end());
1487 GEP->getSourceElementType(), cast<Constant>(GEP->getPointerOperand()),
1488 NewIndices, InBounds && GEP->isInBounds());
1489 }
1490
1493 I != E; ++I)
1494 LastI = I;
1495
1496 // We can't combine GEPs if the last index is a struct type.
1497 if (!LastI.isSequential())
1498 return nullptr;
1499 // We could perform the transform with non-constant index, but prefer leaving
1500 // it as GEP of GEP rather than GEP of add for now.
1501 ConstantInt *CI = dyn_cast<ConstantInt>(Idx0);
1502 if (!CI)
1503 return nullptr;
1504
1505 // TODO: This code may be extended to handle vectors as well.
1506 auto *LastIdx = cast<Constant>(GEP->getOperand(GEP->getNumOperands()-1));
1507 Type *LastIdxTy = LastIdx->getType();
1508 if (LastIdxTy->isVectorTy())
1509 return nullptr;
1510
1511 SmallVector<Value*, 16> NewIndices;
1512 NewIndices.reserve(Idxs.size() + GEP->getNumIndices());
1513 NewIndices.append(GEP->idx_begin(), GEP->idx_end() - 1);
1514
1515 // Add the last index of the source with the first index of the new GEP.
1516 // Make sure to handle the case when they are actually different types.
1517 if (LastIdxTy != Idx0->getType()) {
1518 unsigned CommonExtendedWidth =
1519 std::max(LastIdxTy->getIntegerBitWidth(),
1520 Idx0->getType()->getIntegerBitWidth());
1521 CommonExtendedWidth = std::max(CommonExtendedWidth, 64U);
1522
1523 Type *CommonTy =
1524 Type::getIntNTy(LastIdxTy->getContext(), CommonExtendedWidth);
1525 if (Idx0->getType() != CommonTy)
1526 Idx0 = ConstantFoldCastInstruction(Instruction::SExt, Idx0, CommonTy);
1527 if (LastIdx->getType() != CommonTy)
1528 LastIdx =
1529 ConstantFoldCastInstruction(Instruction::SExt, LastIdx, CommonTy);
1530 if (!Idx0 || !LastIdx)
1531 return nullptr;
1532 }
1533
1534 NewIndices.push_back(ConstantExpr::get(Instruction::Add, Idx0, LastIdx));
1535 NewIndices.append(Idxs.begin() + 1, Idxs.end());
1536
1538 GEP->getSourceElementType(), cast<Constant>(GEP->getPointerOperand()),
1539 NewIndices, InBounds && GEP->isInBounds());
1540}
1541
1543 bool InBounds,
1544 std::optional<ConstantRange> InRange,
1545 ArrayRef<Value *> Idxs) {
1546 if (Idxs.empty()) return C;
1547
1549 C, ArrayRef((Value *const *)Idxs.data(), Idxs.size()));
1550
1551 if (isa<PoisonValue>(C))
1552 return PoisonValue::get(GEPTy);
1553
1554 if (isa<UndefValue>(C))
1555 // If inbounds, we can choose an out-of-bounds pointer as a base pointer.
1556 return InBounds ? PoisonValue::get(GEPTy) : UndefValue::get(GEPTy);
1557
1558 auto IsNoOp = [&]() {
1559 // Avoid losing inrange information.
1560 if (InRange)
1561 return false;
1562
1563 return all_of(Idxs, [](Value *Idx) {
1564 Constant *IdxC = cast<Constant>(Idx);
1565 return IdxC->isNullValue() || isa<UndefValue>(IdxC);
1566 });
1567 };
1568 if (IsNoOp())
1569 return GEPTy->isVectorTy() && !C->getType()->isVectorTy()
1571 cast<VectorType>(GEPTy)->getElementCount(), C)
1572 : C;
1573
1574 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
1575 if (auto *GEP = dyn_cast<GEPOperator>(CE))
1576 if (Constant *C = foldGEPOfGEP(GEP, PointeeTy, InBounds, Idxs))
1577 return C;
1578
1579 // Check to see if any array indices are not within the corresponding
1580 // notional array or vector bounds. If so, try to determine if they can be
1581 // factored out into preceding dimensions.
1583 Type *Ty = PointeeTy;
1584 Type *Prev = C->getType();
1585 auto GEPIter = gep_type_begin(PointeeTy, Idxs);
1586 bool Unknown =
1587 !isa<ConstantInt>(Idxs[0]) && !isa<ConstantDataVector>(Idxs[0]);
1588 for (unsigned i = 1, e = Idxs.size(); i != e;
1589 Prev = Ty, Ty = (++GEPIter).getIndexedType(), ++i) {
1590 if (!isa<ConstantInt>(Idxs[i]) && !isa<ConstantDataVector>(Idxs[i])) {
1591 // We don't know if it's in range or not.
1592 Unknown = true;
1593 continue;
1594 }
1595 if (!isa<ConstantInt>(Idxs[i - 1]) && !isa<ConstantDataVector>(Idxs[i - 1]))
1596 // Skip if the type of the previous index is not supported.
1597 continue;
1598 if (isa<StructType>(Ty)) {
1599 // The verify makes sure that GEPs into a struct are in range.
1600 continue;
1601 }
1602 if (isa<VectorType>(Ty)) {
1603 // There can be awkward padding in after a non-power of two vector.
1604 Unknown = true;
1605 continue;
1606 }
1607 auto *STy = cast<ArrayType>(Ty);
1608 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idxs[i])) {
1609 if (isIndexInRangeOfArrayType(STy->getNumElements(), CI))
1610 // It's in range, skip to the next index.
1611 continue;
1612 if (CI->isNegative()) {
1613 // It's out of range and negative, don't try to factor it.
1614 Unknown = true;
1615 continue;
1616 }
1617 } else {
1618 auto *CV = cast<ConstantDataVector>(Idxs[i]);
1619 bool IsInRange = true;
1620 for (unsigned I = 0, E = CV->getNumElements(); I != E; ++I) {
1621 auto *CI = cast<ConstantInt>(CV->getElementAsConstant(I));
1622 IsInRange &= isIndexInRangeOfArrayType(STy->getNumElements(), CI);
1623 if (CI->isNegative()) {
1624 Unknown = true;
1625 break;
1626 }
1627 }
1628 if (IsInRange || Unknown)
1629 // It's in range, skip to the next index.
1630 // It's out of range and negative, don't try to factor it.
1631 continue;
1632 }
1633 if (isa<StructType>(Prev)) {
1634 // It's out of range, but the prior dimension is a struct
1635 // so we can't do anything about it.
1636 Unknown = true;
1637 continue;
1638 }
1639
1640 // Determine the number of elements in our sequential type.
1641 uint64_t NumElements = STy->getArrayNumElements();
1642 if (!NumElements) {
1643 Unknown = true;
1644 continue;
1645 }
1646
1647 // It's out of range, but we can factor it into the prior
1648 // dimension.
1649 NewIdxs.resize(Idxs.size());
1650
1651 // Expand the current index or the previous index to a vector from a scalar
1652 // if necessary.
1653 Constant *CurrIdx = cast<Constant>(Idxs[i]);
1654 auto *PrevIdx =
1655 NewIdxs[i - 1] ? NewIdxs[i - 1] : cast<Constant>(Idxs[i - 1]);
1656 bool IsCurrIdxVector = CurrIdx->getType()->isVectorTy();
1657 bool IsPrevIdxVector = PrevIdx->getType()->isVectorTy();
1658 bool UseVector = IsCurrIdxVector || IsPrevIdxVector;
1659
1660 if (!IsCurrIdxVector && IsPrevIdxVector)
1662 cast<FixedVectorType>(PrevIdx->getType())->getNumElements(), CurrIdx);
1663
1664 if (!IsPrevIdxVector && IsCurrIdxVector)
1666 cast<FixedVectorType>(CurrIdx->getType())->getNumElements(), PrevIdx);
1667
1668 Constant *Factor =
1669 ConstantInt::get(CurrIdx->getType()->getScalarType(), NumElements);
1670 if (UseVector)
1672 IsPrevIdxVector
1673 ? cast<FixedVectorType>(PrevIdx->getType())->getNumElements()
1674 : cast<FixedVectorType>(CurrIdx->getType())->getNumElements(),
1675 Factor);
1676
1677 NewIdxs[i] =
1678 ConstantFoldBinaryInstruction(Instruction::SRem, CurrIdx, Factor);
1679
1680 Constant *Div =
1681 ConstantFoldBinaryInstruction(Instruction::SDiv, CurrIdx, Factor);
1682
1683 // We're working on either ConstantInt or vectors of ConstantInt,
1684 // so these should always fold.
1685 assert(NewIdxs[i] != nullptr && Div != nullptr && "Should have folded");
1686
1687 unsigned CommonExtendedWidth =
1688 std::max(PrevIdx->getType()->getScalarSizeInBits(),
1689 Div->getType()->getScalarSizeInBits());
1690 CommonExtendedWidth = std::max(CommonExtendedWidth, 64U);
1691
1692 // Before adding, extend both operands to i64 to avoid
1693 // overflow trouble.
1694 Type *ExtendedTy = Type::getIntNTy(Div->getContext(), CommonExtendedWidth);
1695 if (UseVector)
1696 ExtendedTy = FixedVectorType::get(
1697 ExtendedTy,
1698 IsPrevIdxVector
1699 ? cast<FixedVectorType>(PrevIdx->getType())->getNumElements()
1700 : cast<FixedVectorType>(CurrIdx->getType())->getNumElements());
1701
1702 if (!PrevIdx->getType()->isIntOrIntVectorTy(CommonExtendedWidth))
1703 PrevIdx =
1704 ConstantFoldCastInstruction(Instruction::SExt, PrevIdx, ExtendedTy);
1705
1706 if (!Div->getType()->isIntOrIntVectorTy(CommonExtendedWidth))
1707 Div = ConstantFoldCastInstruction(Instruction::SExt, Div, ExtendedTy);
1708
1709 assert(PrevIdx && Div && "Should have folded");
1710 NewIdxs[i - 1] = ConstantExpr::getAdd(PrevIdx, Div);
1711 }
1712
1713 // If we did any factoring, start over with the adjusted indices.
1714 if (!NewIdxs.empty()) {
1715 for (unsigned i = 0, e = Idxs.size(); i != e; ++i)
1716 if (!NewIdxs[i]) NewIdxs[i] = cast<Constant>(Idxs[i]);
1717 return ConstantExpr::getGetElementPtr(PointeeTy, C, NewIdxs, InBounds,
1718 InRange);
1719 }
1720
1721 // If all indices are known integers and normalized, we can do a simple
1722 // check for the "inbounds" property.
1723 if (!Unknown && !InBounds)
1724 if (auto *GV = dyn_cast<GlobalVariable>(C))
1725 if (!GV->hasExternalWeakLinkage() && GV->getValueType() == PointeeTy &&
1726 isInBoundsIndices(Idxs))
1727 return ConstantExpr::getGetElementPtr(PointeeTy, C, Idxs,
1728 /*InBounds=*/true, InRange);
1729
1730 return nullptr;
1731}
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 * 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