LLVM 20.0.0git
ConstantFolding.cpp
Go to the documentation of this file.
1//===-- ConstantFolding.cpp - Fold instructions into constants ------------===//
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 defines routines for folding instructions into constants.
10//
11// Also, to supplement the basic IR ConstantExpr simplifications,
12// this file defines some additional folding routines that can make use of
13// DataLayout information. These functions cannot go in IR due to library
14// dependency issues.
15//
16//===----------------------------------------------------------------------===//
17
19#include "llvm/ADT/APFloat.h"
20#include "llvm/ADT/APInt.h"
21#include "llvm/ADT/APSInt.h"
22#include "llvm/ADT/ArrayRef.h"
23#include "llvm/ADT/DenseMap.h"
24#include "llvm/ADT/STLExtras.h"
26#include "llvm/ADT/StringRef.h"
31#include "llvm/Config/config.h"
32#include "llvm/IR/Constant.h"
34#include "llvm/IR/Constants.h"
35#include "llvm/IR/DataLayout.h"
37#include "llvm/IR/Function.h"
38#include "llvm/IR/GlobalValue.h"
40#include "llvm/IR/InstrTypes.h"
41#include "llvm/IR/Instruction.h"
44#include "llvm/IR/Intrinsics.h"
45#include "llvm/IR/IntrinsicsAArch64.h"
46#include "llvm/IR/IntrinsicsAMDGPU.h"
47#include "llvm/IR/IntrinsicsARM.h"
48#include "llvm/IR/IntrinsicsNVPTX.h"
49#include "llvm/IR/IntrinsicsWebAssembly.h"
50#include "llvm/IR/IntrinsicsX86.h"
52#include "llvm/IR/Operator.h"
53#include "llvm/IR/Type.h"
54#include "llvm/IR/Value.h"
59#include <cassert>
60#include <cerrno>
61#include <cfenv>
62#include <cmath>
63#include <cstdint>
64
65using namespace llvm;
66
67namespace {
68
69//===----------------------------------------------------------------------===//
70// Constant Folding internal helper functions
71//===----------------------------------------------------------------------===//
72
73static Constant *foldConstVectorToAPInt(APInt &Result, Type *DestTy,
74 Constant *C, Type *SrcEltTy,
75 unsigned NumSrcElts,
76 const DataLayout &DL) {
77 // Now that we know that the input value is a vector of integers, just shift
78 // and insert them into our result.
79 unsigned BitShift = DL.getTypeSizeInBits(SrcEltTy);
80 for (unsigned i = 0; i != NumSrcElts; ++i) {
81 Constant *Element;
82 if (DL.isLittleEndian())
83 Element = C->getAggregateElement(NumSrcElts - i - 1);
84 else
85 Element = C->getAggregateElement(i);
86
87 if (isa_and_nonnull<UndefValue>(Element)) {
88 Result <<= BitShift;
89 continue;
90 }
91
92 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
93 if (!ElementCI)
94 return ConstantExpr::getBitCast(C, DestTy);
95
96 Result <<= BitShift;
97 Result |= ElementCI->getValue().zext(Result.getBitWidth());
98 }
99
100 return nullptr;
101}
102
103/// Constant fold bitcast, symbolically evaluating it with DataLayout.
104/// This always returns a non-null constant, but it may be a
105/// ConstantExpr if unfoldable.
106Constant *FoldBitCast(Constant *C, Type *DestTy, const DataLayout &DL) {
107 assert(CastInst::castIsValid(Instruction::BitCast, C, DestTy) &&
108 "Invalid constantexpr bitcast!");
109
110 // Catch the obvious splat cases.
111 if (Constant *Res = ConstantFoldLoadFromUniformValue(C, DestTy, DL))
112 return Res;
113
114 if (auto *VTy = dyn_cast<VectorType>(C->getType())) {
115 // Handle a vector->scalar integer/fp cast.
116 if (isa<IntegerType>(DestTy) || DestTy->isFloatingPointTy()) {
117 unsigned NumSrcElts = cast<FixedVectorType>(VTy)->getNumElements();
118 Type *SrcEltTy = VTy->getElementType();
119
120 // If the vector is a vector of floating point, convert it to vector of int
121 // to simplify things.
122 if (SrcEltTy->isFloatingPointTy()) {
123 unsigned FPWidth = SrcEltTy->getPrimitiveSizeInBits();
124 auto *SrcIVTy = FixedVectorType::get(
125 IntegerType::get(C->getContext(), FPWidth), NumSrcElts);
126 // Ask IR to do the conversion now that #elts line up.
127 C = ConstantExpr::getBitCast(C, SrcIVTy);
128 }
129
130 APInt Result(DL.getTypeSizeInBits(DestTy), 0);
131 if (Constant *CE = foldConstVectorToAPInt(Result, DestTy, C,
132 SrcEltTy, NumSrcElts, DL))
133 return CE;
134
135 if (isa<IntegerType>(DestTy))
136 return ConstantInt::get(DestTy, Result);
137
138 APFloat FP(DestTy->getFltSemantics(), Result);
139 return ConstantFP::get(DestTy->getContext(), FP);
140 }
141 }
142
143 // The code below only handles casts to vectors currently.
144 auto *DestVTy = dyn_cast<VectorType>(DestTy);
145 if (!DestVTy)
146 return ConstantExpr::getBitCast(C, DestTy);
147
148 // If this is a scalar -> vector cast, convert the input into a <1 x scalar>
149 // vector so the code below can handle it uniformly.
150 if (!isa<VectorType>(C->getType()) &&
151 (isa<ConstantFP>(C) || isa<ConstantInt>(C))) {
152 Constant *Ops = C; // don't take the address of C!
153 return FoldBitCast(ConstantVector::get(Ops), DestTy, DL);
154 }
155
156 // Some of what follows may extend to cover scalable vectors but the current
157 // implementation is fixed length specific.
158 if (!isa<FixedVectorType>(C->getType()))
159 return ConstantExpr::getBitCast(C, DestTy);
160
161 // If this is a bitcast from constant vector -> vector, fold it.
162 if (!isa<ConstantDataVector>(C) && !isa<ConstantVector>(C) &&
163 !isa<ConstantInt>(C) && !isa<ConstantFP>(C))
164 return ConstantExpr::getBitCast(C, DestTy);
165
166 // If the element types match, IR can fold it.
167 unsigned NumDstElt = cast<FixedVectorType>(DestVTy)->getNumElements();
168 unsigned NumSrcElt = cast<FixedVectorType>(C->getType())->getNumElements();
169 if (NumDstElt == NumSrcElt)
170 return ConstantExpr::getBitCast(C, DestTy);
171
172 Type *SrcEltTy = cast<VectorType>(C->getType())->getElementType();
173 Type *DstEltTy = DestVTy->getElementType();
174
175 // Otherwise, we're changing the number of elements in a vector, which
176 // requires endianness information to do the right thing. For example,
177 // bitcast (<2 x i64> <i64 0, i64 1> to <4 x i32>)
178 // folds to (little endian):
179 // <4 x i32> <i32 0, i32 0, i32 1, i32 0>
180 // and to (big endian):
181 // <4 x i32> <i32 0, i32 0, i32 0, i32 1>
182
183 // First thing is first. We only want to think about integer here, so if
184 // we have something in FP form, recast it as integer.
185 if (DstEltTy->isFloatingPointTy()) {
186 // Fold to an vector of integers with same size as our FP type.
187 unsigned FPWidth = DstEltTy->getPrimitiveSizeInBits();
188 auto *DestIVTy = FixedVectorType::get(
189 IntegerType::get(C->getContext(), FPWidth), NumDstElt);
190 // Recursively handle this integer conversion, if possible.
191 C = FoldBitCast(C, DestIVTy, DL);
192
193 // Finally, IR can handle this now that #elts line up.
194 return ConstantExpr::getBitCast(C, DestTy);
195 }
196
197 // Okay, we know the destination is integer, if the input is FP, convert
198 // it to integer first.
199 if (SrcEltTy->isFloatingPointTy()) {
200 unsigned FPWidth = SrcEltTy->getPrimitiveSizeInBits();
201 auto *SrcIVTy = FixedVectorType::get(
202 IntegerType::get(C->getContext(), FPWidth), NumSrcElt);
203 // Ask IR to do the conversion now that #elts line up.
204 C = ConstantExpr::getBitCast(C, SrcIVTy);
205 assert((isa<ConstantVector>(C) || // FIXME: Remove ConstantVector.
206 isa<ConstantDataVector>(C) || isa<ConstantInt>(C)) &&
207 "Constant folding cannot fail for plain fp->int bitcast!");
208 }
209
210 // Now we know that the input and output vectors are both integer vectors
211 // of the same size, and that their #elements is not the same. Do the
212 // conversion here, which depends on whether the input or output has
213 // more elements.
214 bool isLittleEndian = DL.isLittleEndian();
215
217 if (NumDstElt < NumSrcElt) {
218 // Handle: bitcast (<4 x i32> <i32 0, i32 1, i32 2, i32 3> to <2 x i64>)
220 unsigned Ratio = NumSrcElt/NumDstElt;
221 unsigned SrcBitSize = SrcEltTy->getPrimitiveSizeInBits();
222 unsigned SrcElt = 0;
223 for (unsigned i = 0; i != NumDstElt; ++i) {
224 // Build each element of the result.
225 Constant *Elt = Zero;
226 unsigned ShiftAmt = isLittleEndian ? 0 : SrcBitSize*(Ratio-1);
227 for (unsigned j = 0; j != Ratio; ++j) {
228 Constant *Src = C->getAggregateElement(SrcElt++);
229 if (isa_and_nonnull<UndefValue>(Src))
231 cast<VectorType>(C->getType())->getElementType());
232 else
233 Src = dyn_cast_or_null<ConstantInt>(Src);
234 if (!Src) // Reject constantexpr elements.
235 return ConstantExpr::getBitCast(C, DestTy);
236
237 // Zero extend the element to the right size.
238 Src = ConstantFoldCastOperand(Instruction::ZExt, Src, Elt->getType(),
239 DL);
240 assert(Src && "Constant folding cannot fail on plain integers");
241
242 // Shift it to the right place, depending on endianness.
244 Instruction::Shl, Src, ConstantInt::get(Src->getType(), ShiftAmt),
245 DL);
246 assert(Src && "Constant folding cannot fail on plain integers");
247
248 ShiftAmt += isLittleEndian ? SrcBitSize : -SrcBitSize;
249
250 // Mix it in.
251 Elt = ConstantFoldBinaryOpOperands(Instruction::Or, Elt, Src, DL);
252 assert(Elt && "Constant folding cannot fail on plain integers");
253 }
254 Result.push_back(Elt);
255 }
256 return ConstantVector::get(Result);
257 }
258
259 // Handle: bitcast (<2 x i64> <i64 0, i64 1> to <4 x i32>)
260 unsigned Ratio = NumDstElt/NumSrcElt;
261 unsigned DstBitSize = DL.getTypeSizeInBits(DstEltTy);
262
263 // Loop over each source value, expanding into multiple results.
264 for (unsigned i = 0; i != NumSrcElt; ++i) {
265 auto *Element = C->getAggregateElement(i);
266
267 if (!Element) // Reject constantexpr elements.
268 return ConstantExpr::getBitCast(C, DestTy);
269
270 if (isa<UndefValue>(Element)) {
271 // Correctly Propagate undef values.
272 Result.append(Ratio, UndefValue::get(DstEltTy));
273 continue;
274 }
275
276 auto *Src = dyn_cast<ConstantInt>(Element);
277 if (!Src)
278 return ConstantExpr::getBitCast(C, DestTy);
279
280 unsigned ShiftAmt = isLittleEndian ? 0 : DstBitSize*(Ratio-1);
281 for (unsigned j = 0; j != Ratio; ++j) {
282 // Shift the piece of the value into the right place, depending on
283 // endianness.
284 APInt Elt = Src->getValue().lshr(ShiftAmt);
285 ShiftAmt += isLittleEndian ? DstBitSize : -DstBitSize;
286
287 // Truncate and remember this piece.
288 Result.push_back(ConstantInt::get(DstEltTy, Elt.trunc(DstBitSize)));
289 }
290 }
291
292 return ConstantVector::get(Result);
293}
294
295} // end anonymous namespace
296
297/// If this constant is a constant offset from a global, return the global and
298/// the constant. Because of constantexprs, this function is recursive.
300 APInt &Offset, const DataLayout &DL,
301 DSOLocalEquivalent **DSOEquiv) {
302 if (DSOEquiv)
303 *DSOEquiv = nullptr;
304
305 // Trivial case, constant is the global.
306 if ((GV = dyn_cast<GlobalValue>(C))) {
307 unsigned BitWidth = DL.getIndexTypeSizeInBits(GV->getType());
308 Offset = APInt(BitWidth, 0);
309 return true;
310 }
311
312 if (auto *FoundDSOEquiv = dyn_cast<DSOLocalEquivalent>(C)) {
313 if (DSOEquiv)
314 *DSOEquiv = FoundDSOEquiv;
315 GV = FoundDSOEquiv->getGlobalValue();
316 unsigned BitWidth = DL.getIndexTypeSizeInBits(GV->getType());
317 Offset = APInt(BitWidth, 0);
318 return true;
319 }
320
321 // Otherwise, if this isn't a constant expr, bail out.
322 auto *CE = dyn_cast<ConstantExpr>(C);
323 if (!CE) return false;
324
325 // Look through ptr->int and ptr->ptr casts.
326 if (CE->getOpcode() == Instruction::PtrToInt ||
327 CE->getOpcode() == Instruction::BitCast)
328 return IsConstantOffsetFromGlobal(CE->getOperand(0), GV, Offset, DL,
329 DSOEquiv);
330
331 // i32* getelementptr ([5 x i32]* @a, i32 0, i32 5)
332 auto *GEP = dyn_cast<GEPOperator>(CE);
333 if (!GEP)
334 return false;
335
336 unsigned BitWidth = DL.getIndexTypeSizeInBits(GEP->getType());
337 APInt TmpOffset(BitWidth, 0);
338
339 // If the base isn't a global+constant, we aren't either.
340 if (!IsConstantOffsetFromGlobal(CE->getOperand(0), GV, TmpOffset, DL,
341 DSOEquiv))
342 return false;
343
344 // Otherwise, add any offset that our operands provide.
345 if (!GEP->accumulateConstantOffset(DL, TmpOffset))
346 return false;
347
348 Offset = TmpOffset;
349 return true;
350}
351
353 const DataLayout &DL) {
354 do {
355 Type *SrcTy = C->getType();
356 if (SrcTy == DestTy)
357 return C;
358
359 TypeSize DestSize = DL.getTypeSizeInBits(DestTy);
360 TypeSize SrcSize = DL.getTypeSizeInBits(SrcTy);
361 if (!TypeSize::isKnownGE(SrcSize, DestSize))
362 return nullptr;
363
364 // Catch the obvious splat cases (since all-zeros can coerce non-integral
365 // pointers legally).
366 if (Constant *Res = ConstantFoldLoadFromUniformValue(C, DestTy, DL))
367 return Res;
368
369 // If the type sizes are the same and a cast is legal, just directly
370 // cast the constant.
371 // But be careful not to coerce non-integral pointers illegally.
372 if (SrcSize == DestSize &&
373 DL.isNonIntegralPointerType(SrcTy->getScalarType()) ==
374 DL.isNonIntegralPointerType(DestTy->getScalarType())) {
375 Instruction::CastOps Cast = Instruction::BitCast;
376 // If we are going from a pointer to int or vice versa, we spell the cast
377 // differently.
378 if (SrcTy->isIntegerTy() && DestTy->isPointerTy())
379 Cast = Instruction::IntToPtr;
380 else if (SrcTy->isPointerTy() && DestTy->isIntegerTy())
381 Cast = Instruction::PtrToInt;
382
383 if (CastInst::castIsValid(Cast, C, DestTy))
384 return ConstantFoldCastOperand(Cast, C, DestTy, DL);
385 }
386
387 // If this isn't an aggregate type, there is nothing we can do to drill down
388 // and find a bitcastable constant.
389 if (!SrcTy->isAggregateType() && !SrcTy->isVectorTy())
390 return nullptr;
391
392 // We're simulating a load through a pointer that was bitcast to point to
393 // a different type, so we can try to walk down through the initial
394 // elements of an aggregate to see if some part of the aggregate is
395 // castable to implement the "load" semantic model.
396 if (SrcTy->isStructTy()) {
397 // Struct types might have leading zero-length elements like [0 x i32],
398 // which are certainly not what we are looking for, so skip them.
399 unsigned Elem = 0;
400 Constant *ElemC;
401 do {
402 ElemC = C->getAggregateElement(Elem++);
403 } while (ElemC && DL.getTypeSizeInBits(ElemC->getType()).isZero());
404 C = ElemC;
405 } else {
406 // For non-byte-sized vector elements, the first element is not
407 // necessarily located at the vector base address.
408 if (auto *VT = dyn_cast<VectorType>(SrcTy))
409 if (!DL.typeSizeEqualsStoreSize(VT->getElementType()))
410 return nullptr;
411
412 C = C->getAggregateElement(0u);
413 }
414 } while (C);
415
416 return nullptr;
417}
418
419namespace {
420
421/// Recursive helper to read bits out of global. C is the constant being copied
422/// out of. ByteOffset is an offset into C. CurPtr is the pointer to copy
423/// results into and BytesLeft is the number of bytes left in
424/// the CurPtr buffer. DL is the DataLayout.
425bool ReadDataFromGlobal(Constant *C, uint64_t ByteOffset, unsigned char *CurPtr,
426 unsigned BytesLeft, const DataLayout &DL) {
427 assert(ByteOffset <= DL.getTypeAllocSize(C->getType()) &&
428 "Out of range access");
429
430 // If this element is zero or undefined, we can just return since *CurPtr is
431 // zero initialized.
432 if (isa<ConstantAggregateZero>(C) || isa<UndefValue>(C))
433 return true;
434
435 if (auto *CI = dyn_cast<ConstantInt>(C)) {
436 if ((CI->getBitWidth() & 7) != 0)
437 return false;
438 const APInt &Val = CI->getValue();
439 unsigned IntBytes = unsigned(CI->getBitWidth()/8);
440
441 for (unsigned i = 0; i != BytesLeft && ByteOffset != IntBytes; ++i) {
442 unsigned n = ByteOffset;
443 if (!DL.isLittleEndian())
444 n = IntBytes - n - 1;
445 CurPtr[i] = Val.extractBits(8, n * 8).getZExtValue();
446 ++ByteOffset;
447 }
448 return true;
449 }
450
451 if (auto *CFP = dyn_cast<ConstantFP>(C)) {
452 if (CFP->getType()->isDoubleTy()) {
453 C = FoldBitCast(C, Type::getInt64Ty(C->getContext()), DL);
454 return ReadDataFromGlobal(C, ByteOffset, CurPtr, BytesLeft, DL);
455 }
456 if (CFP->getType()->isFloatTy()){
457 C = FoldBitCast(C, Type::getInt32Ty(C->getContext()), DL);
458 return ReadDataFromGlobal(C, ByteOffset, CurPtr, BytesLeft, DL);
459 }
460 if (CFP->getType()->isHalfTy()){
461 C = FoldBitCast(C, Type::getInt16Ty(C->getContext()), DL);
462 return ReadDataFromGlobal(C, ByteOffset, CurPtr, BytesLeft, DL);
463 }
464 return false;
465 }
466
467 if (auto *CS = dyn_cast<ConstantStruct>(C)) {
468 const StructLayout *SL = DL.getStructLayout(CS->getType());
469 unsigned Index = SL->getElementContainingOffset(ByteOffset);
470 uint64_t CurEltOffset = SL->getElementOffset(Index);
471 ByteOffset -= CurEltOffset;
472
473 while (true) {
474 // If the element access is to the element itself and not to tail padding,
475 // read the bytes from the element.
476 uint64_t EltSize = DL.getTypeAllocSize(CS->getOperand(Index)->getType());
477
478 if (ByteOffset < EltSize &&
479 !ReadDataFromGlobal(CS->getOperand(Index), ByteOffset, CurPtr,
480 BytesLeft, DL))
481 return false;
482
483 ++Index;
484
485 // Check to see if we read from the last struct element, if so we're done.
486 if (Index == CS->getType()->getNumElements())
487 return true;
488
489 // If we read all of the bytes we needed from this element we're done.
490 uint64_t NextEltOffset = SL->getElementOffset(Index);
491
492 if (BytesLeft <= NextEltOffset - CurEltOffset - ByteOffset)
493 return true;
494
495 // Move to the next element of the struct.
496 CurPtr += NextEltOffset - CurEltOffset - ByteOffset;
497 BytesLeft -= NextEltOffset - CurEltOffset - ByteOffset;
498 ByteOffset = 0;
499 CurEltOffset = NextEltOffset;
500 }
501 // not reached.
502 }
503
504 if (isa<ConstantArray>(C) || isa<ConstantVector>(C) ||
505 isa<ConstantDataSequential>(C)) {
506 uint64_t NumElts, EltSize;
507 Type *EltTy;
508 if (auto *AT = dyn_cast<ArrayType>(C->getType())) {
509 NumElts = AT->getNumElements();
510 EltTy = AT->getElementType();
511 EltSize = DL.getTypeAllocSize(EltTy);
512 } else {
513 NumElts = cast<FixedVectorType>(C->getType())->getNumElements();
514 EltTy = cast<FixedVectorType>(C->getType())->getElementType();
515 // TODO: For non-byte-sized vectors, current implementation assumes there is
516 // padding to the next byte boundary between elements.
517 if (!DL.typeSizeEqualsStoreSize(EltTy))
518 return false;
519
520 EltSize = DL.getTypeStoreSize(EltTy);
521 }
522 uint64_t Index = ByteOffset / EltSize;
523 uint64_t Offset = ByteOffset - Index * EltSize;
524
525 for (; Index != NumElts; ++Index) {
526 if (!ReadDataFromGlobal(C->getAggregateElement(Index), Offset, CurPtr,
527 BytesLeft, DL))
528 return false;
529
530 uint64_t BytesWritten = EltSize - Offset;
531 assert(BytesWritten <= EltSize && "Not indexing into this element?");
532 if (BytesWritten >= BytesLeft)
533 return true;
534
535 Offset = 0;
536 BytesLeft -= BytesWritten;
537 CurPtr += BytesWritten;
538 }
539 return true;
540 }
541
542 if (auto *CE = dyn_cast<ConstantExpr>(C)) {
543 if (CE->getOpcode() == Instruction::IntToPtr &&
544 CE->getOperand(0)->getType() == DL.getIntPtrType(CE->getType())) {
545 return ReadDataFromGlobal(CE->getOperand(0), ByteOffset, CurPtr,
546 BytesLeft, DL);
547 }
548 }
549
550 // Otherwise, unknown initializer type.
551 return false;
552}
553
554Constant *FoldReinterpretLoadFromConst(Constant *C, Type *LoadTy,
555 int64_t Offset, const DataLayout &DL) {
556 // Bail out early. Not expect to load from scalable global variable.
557 if (isa<ScalableVectorType>(LoadTy))
558 return nullptr;
559
560 auto *IntType = dyn_cast<IntegerType>(LoadTy);
561
562 // If this isn't an integer load we can't fold it directly.
563 if (!IntType) {
564 // If this is a non-integer load, we can try folding it as an int load and
565 // then bitcast the result. This can be useful for union cases. Note
566 // that address spaces don't matter here since we're not going to result in
567 // an actual new load.
568 if (!LoadTy->isFloatingPointTy() && !LoadTy->isPointerTy() &&
569 !LoadTy->isVectorTy())
570 return nullptr;
571
572 Type *MapTy = Type::getIntNTy(C->getContext(),
573 DL.getTypeSizeInBits(LoadTy).getFixedValue());
574 if (Constant *Res = FoldReinterpretLoadFromConst(C, MapTy, Offset, DL)) {
575 if (Res->isNullValue() && !LoadTy->isX86_AMXTy())
576 // Materializing a zero can be done trivially without a bitcast
577 return Constant::getNullValue(LoadTy);
578 Type *CastTy = LoadTy->isPtrOrPtrVectorTy() ? DL.getIntPtrType(LoadTy) : LoadTy;
579 Res = FoldBitCast(Res, CastTy, DL);
580 if (LoadTy->isPtrOrPtrVectorTy()) {
581 // For vector of pointer, we needed to first convert to a vector of integer, then do vector inttoptr
582 if (Res->isNullValue() && !LoadTy->isX86_AMXTy())
583 return Constant::getNullValue(LoadTy);
584 if (DL.isNonIntegralPointerType(LoadTy->getScalarType()))
585 // Be careful not to replace a load of an addrspace value with an inttoptr here
586 return nullptr;
587 Res = ConstantExpr::getIntToPtr(Res, LoadTy);
588 }
589 return Res;
590 }
591 return nullptr;
592 }
593
594 unsigned BytesLoaded = (IntType->getBitWidth() + 7) / 8;
595 if (BytesLoaded > 32 || BytesLoaded == 0)
596 return nullptr;
597
598 // If we're not accessing anything in this constant, the result is undefined.
599 if (Offset <= -1 * static_cast<int64_t>(BytesLoaded))
600 return PoisonValue::get(IntType);
601
602 // TODO: We should be able to support scalable types.
603 TypeSize InitializerSize = DL.getTypeAllocSize(C->getType());
604 if (InitializerSize.isScalable())
605 return nullptr;
606
607 // If we're not accessing anything in this constant, the result is undefined.
608 if (Offset >= (int64_t)InitializerSize.getFixedValue())
609 return PoisonValue::get(IntType);
610
611 unsigned char RawBytes[32] = {0};
612 unsigned char *CurPtr = RawBytes;
613 unsigned BytesLeft = BytesLoaded;
614
615 // If we're loading off the beginning of the global, some bytes may be valid.
616 if (Offset < 0) {
617 CurPtr += -Offset;
618 BytesLeft += Offset;
619 Offset = 0;
620 }
621
622 if (!ReadDataFromGlobal(C, Offset, CurPtr, BytesLeft, DL))
623 return nullptr;
624
625 APInt ResultVal = APInt(IntType->getBitWidth(), 0);
626 if (DL.isLittleEndian()) {
627 ResultVal = RawBytes[BytesLoaded - 1];
628 for (unsigned i = 1; i != BytesLoaded; ++i) {
629 ResultVal <<= 8;
630 ResultVal |= RawBytes[BytesLoaded - 1 - i];
631 }
632 } else {
633 ResultVal = RawBytes[0];
634 for (unsigned i = 1; i != BytesLoaded; ++i) {
635 ResultVal <<= 8;
636 ResultVal |= RawBytes[i];
637 }
638 }
639
640 return ConstantInt::get(IntType->getContext(), ResultVal);
641}
642
643} // anonymous namespace
644
645// If GV is a constant with an initializer read its representation starting
646// at Offset and return it as a constant array of unsigned char. Otherwise
647// return null.
650 if (!GV->isConstant() || !GV->hasDefinitiveInitializer())
651 return nullptr;
652
653 const DataLayout &DL = GV->getDataLayout();
654 Constant *Init = const_cast<Constant *>(GV->getInitializer());
655 TypeSize InitSize = DL.getTypeAllocSize(Init->getType());
656 if (InitSize < Offset)
657 return nullptr;
658
659 uint64_t NBytes = InitSize - Offset;
660 if (NBytes > UINT16_MAX)
661 // Bail for large initializers in excess of 64K to avoid allocating
662 // too much memory.
663 // Offset is assumed to be less than or equal than InitSize (this
664 // is enforced in ReadDataFromGlobal).
665 return nullptr;
666
667 SmallVector<unsigned char, 256> RawBytes(static_cast<size_t>(NBytes));
668 unsigned char *CurPtr = RawBytes.data();
669
670 if (!ReadDataFromGlobal(Init, Offset, CurPtr, NBytes, DL))
671 return nullptr;
672
673 return ConstantDataArray::get(GV->getContext(), RawBytes);
674}
675
676/// If this Offset points exactly to the start of an aggregate element, return
677/// that element, otherwise return nullptr.
679 const DataLayout &DL) {
680 if (Offset.isZero())
681 return Base;
682
683 if (!isa<ConstantAggregate>(Base) && !isa<ConstantDataSequential>(Base))
684 return nullptr;
685
686 Type *ElemTy = Base->getType();
687 SmallVector<APInt> Indices = DL.getGEPIndicesForOffset(ElemTy, Offset);
688 if (!Offset.isZero() || !Indices[0].isZero())
689 return nullptr;
690
691 Constant *C = Base;
692 for (const APInt &Index : drop_begin(Indices)) {
693 if (Index.isNegative() || Index.getActiveBits() >= 32)
694 return nullptr;
695
696 C = C->getAggregateElement(Index.getZExtValue());
697 if (!C)
698 return nullptr;
699 }
700
701 return C;
702}
703
705 const APInt &Offset,
706 const DataLayout &DL) {
707 if (Constant *AtOffset = getConstantAtOffset(C, Offset, DL))
708 if (Constant *Result = ConstantFoldLoadThroughBitcast(AtOffset, Ty, DL))
709 return Result;
710
711 // Explicitly check for out-of-bounds access, so we return poison even if the
712 // constant is a uniform value.
713 TypeSize Size = DL.getTypeAllocSize(C->getType());
714 if (!Size.isScalable() && Offset.sge(Size.getFixedValue()))
715 return PoisonValue::get(Ty);
716
717 // Try an offset-independent fold of a uniform value.
718 if (Constant *Result = ConstantFoldLoadFromUniformValue(C, Ty, DL))
719 return Result;
720
721 // Try hard to fold loads from bitcasted strange and non-type-safe things.
722 if (Offset.getSignificantBits() <= 64)
723 if (Constant *Result =
724 FoldReinterpretLoadFromConst(C, Ty, Offset.getSExtValue(), DL))
725 return Result;
726
727 return nullptr;
728}
729
731 const DataLayout &DL) {
732 return ConstantFoldLoadFromConst(C, Ty, APInt(64, 0), DL);
733}
734
737 const DataLayout &DL) {
738 // We can only fold loads from constant globals with a definitive initializer.
739 // Check this upfront, to skip expensive offset calculations.
740 auto *GV = dyn_cast<GlobalVariable>(getUnderlyingObject(C));
741 if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer())
742 return nullptr;
743
744 C = cast<Constant>(C->stripAndAccumulateConstantOffsets(
745 DL, Offset, /* AllowNonInbounds */ true));
746
747 if (C == GV)
748 if (Constant *Result = ConstantFoldLoadFromConst(GV->getInitializer(), Ty,
749 Offset, DL))
750 return Result;
751
752 // If this load comes from anywhere in a uniform constant global, the value
753 // is always the same, regardless of the loaded offset.
754 return ConstantFoldLoadFromUniformValue(GV->getInitializer(), Ty, DL);
755}
756
758 const DataLayout &DL) {
759 APInt Offset(DL.getIndexTypeSizeInBits(C->getType()), 0);
760 return ConstantFoldLoadFromConstPtr(C, Ty, std::move(Offset), DL);
761}
762
764 const DataLayout &DL) {
765 if (isa<PoisonValue>(C))
766 return PoisonValue::get(Ty);
767 if (isa<UndefValue>(C))
768 return UndefValue::get(Ty);
769 // If padding is needed when storing C to memory, then it isn't considered as
770 // uniform.
771 if (!DL.typeSizeEqualsStoreSize(C->getType()))
772 return nullptr;
773 if (C->isNullValue() && !Ty->isX86_AMXTy())
774 return Constant::getNullValue(Ty);
775 if (C->isAllOnesValue() &&
776 (Ty->isIntOrIntVectorTy() || Ty->isFPOrFPVectorTy()))
777 return Constant::getAllOnesValue(Ty);
778 return nullptr;
779}
780
781namespace {
782
783/// One of Op0/Op1 is a constant expression.
784/// Attempt to symbolically evaluate the result of a binary operator merging
785/// these together. If target data info is available, it is provided as DL,
786/// otherwise DL is null.
787Constant *SymbolicallyEvaluateBinop(unsigned Opc, Constant *Op0, Constant *Op1,
788 const DataLayout &DL) {
789 // SROA
790
791 // Fold (and 0xffffffff00000000, (shl x, 32)) -> shl.
792 // Fold (lshr (or X, Y), 32) -> (lshr [X/Y], 32) if one doesn't contribute
793 // bits.
794
795 if (Opc == Instruction::And) {
796 KnownBits Known0 = computeKnownBits(Op0, DL);
797 KnownBits Known1 = computeKnownBits(Op1, DL);
798 if ((Known1.One | Known0.Zero).isAllOnes()) {
799 // All the bits of Op0 that the 'and' could be masking are already zero.
800 return Op0;
801 }
802 if ((Known0.One | Known1.Zero).isAllOnes()) {
803 // All the bits of Op1 that the 'and' could be masking are already zero.
804 return Op1;
805 }
806
807 Known0 &= Known1;
808 if (Known0.isConstant())
809 return ConstantInt::get(Op0->getType(), Known0.getConstant());
810 }
811
812 // If the constant expr is something like &A[123] - &A[4].f, fold this into a
813 // constant. This happens frequently when iterating over a global array.
814 if (Opc == Instruction::Sub) {
815 GlobalValue *GV1, *GV2;
816 APInt Offs1, Offs2;
817
818 if (IsConstantOffsetFromGlobal(Op0, GV1, Offs1, DL))
819 if (IsConstantOffsetFromGlobal(Op1, GV2, Offs2, DL) && GV1 == GV2) {
820 unsigned OpSize = DL.getTypeSizeInBits(Op0->getType());
821
822 // (&GV+C1) - (&GV+C2) -> C1-C2, pointer arithmetic cannot overflow.
823 // PtrToInt may change the bitwidth so we have convert to the right size
824 // first.
825 return ConstantInt::get(Op0->getType(), Offs1.zextOrTrunc(OpSize) -
826 Offs2.zextOrTrunc(OpSize));
827 }
828 }
829
830 return nullptr;
831}
832
833/// If array indices are not pointer-sized integers, explicitly cast them so
834/// that they aren't implicitly casted by the getelementptr.
835Constant *CastGEPIndices(Type *SrcElemTy, ArrayRef<Constant *> Ops,
836 Type *ResultTy, GEPNoWrapFlags NW,
837 std::optional<ConstantRange> InRange,
838 const DataLayout &DL, const TargetLibraryInfo *TLI) {
839 Type *IntIdxTy = DL.getIndexType(ResultTy);
840 Type *IntIdxScalarTy = IntIdxTy->getScalarType();
841
842 bool Any = false;
844 for (unsigned i = 1, e = Ops.size(); i != e; ++i) {
845 if ((i == 1 ||
846 !isa<StructType>(GetElementPtrInst::getIndexedType(
847 SrcElemTy, Ops.slice(1, i - 1)))) &&
848 Ops[i]->getType()->getScalarType() != IntIdxScalarTy) {
849 Any = true;
850 Type *NewType =
851 Ops[i]->getType()->isVectorTy() ? IntIdxTy : IntIdxScalarTy;
853 CastInst::getCastOpcode(Ops[i], true, NewType, true), Ops[i], NewType,
854 DL);
855 if (!NewIdx)
856 return nullptr;
857 NewIdxs.push_back(NewIdx);
858 } else
859 NewIdxs.push_back(Ops[i]);
860 }
861
862 if (!Any)
863 return nullptr;
864
865 Constant *C =
866 ConstantExpr::getGetElementPtr(SrcElemTy, Ops[0], NewIdxs, NW, InRange);
867 return ConstantFoldConstant(C, DL, TLI);
868}
869
870/// If we can symbolically evaluate the GEP constant expression, do so.
871Constant *SymbolicallyEvaluateGEP(const GEPOperator *GEP,
873 const DataLayout &DL,
874 const TargetLibraryInfo *TLI) {
875 Type *SrcElemTy = GEP->getSourceElementType();
876 Type *ResTy = GEP->getType();
877 if (!SrcElemTy->isSized() || isa<ScalableVectorType>(SrcElemTy))
878 return nullptr;
879
880 if (Constant *C = CastGEPIndices(SrcElemTy, Ops, ResTy, GEP->getNoWrapFlags(),
881 GEP->getInRange(), DL, TLI))
882 return C;
883
884 Constant *Ptr = Ops[0];
885 if (!Ptr->getType()->isPointerTy())
886 return nullptr;
887
888 Type *IntIdxTy = DL.getIndexType(Ptr->getType());
889
890 for (unsigned i = 1, e = Ops.size(); i != e; ++i)
891 if (!isa<ConstantInt>(Ops[i]) || !Ops[i]->getType()->isIntegerTy())
892 return nullptr;
893
894 unsigned BitWidth = DL.getTypeSizeInBits(IntIdxTy);
896 BitWidth,
897 DL.getIndexedOffsetInType(
898 SrcElemTy, ArrayRef((Value *const *)Ops.data() + 1, Ops.size() - 1)),
899 /*isSigned=*/true, /*implicitTrunc=*/true);
900
901 std::optional<ConstantRange> InRange = GEP->getInRange();
902 if (InRange)
903 InRange = InRange->sextOrTrunc(BitWidth);
904
905 // If this is a GEP of a GEP, fold it all into a single GEP.
906 GEPNoWrapFlags NW = GEP->getNoWrapFlags();
907 bool Overflow = false;
908 while (auto *GEP = dyn_cast<GEPOperator>(Ptr)) {
909 NW &= GEP->getNoWrapFlags();
910
911 SmallVector<Value *, 4> NestedOps(llvm::drop_begin(GEP->operands()));
912
913 // Do not try the incorporate the sub-GEP if some index is not a number.
914 bool AllConstantInt = true;
915 for (Value *NestedOp : NestedOps)
916 if (!isa<ConstantInt>(NestedOp)) {
917 AllConstantInt = false;
918 break;
919 }
920 if (!AllConstantInt)
921 break;
922
923 // TODO: Try to intersect two inrange attributes?
924 if (!InRange) {
925 InRange = GEP->getInRange();
926 if (InRange)
927 // Adjust inrange by offset until now.
928 InRange = InRange->sextOrTrunc(BitWidth).subtract(Offset);
929 }
930
931 Ptr = cast<Constant>(GEP->getOperand(0));
932 SrcElemTy = GEP->getSourceElementType();
933 Offset = Offset.sadd_ov(
934 APInt(BitWidth, DL.getIndexedOffsetInType(SrcElemTy, NestedOps),
935 /*isSigned=*/true, /*implicitTrunc=*/true),
936 Overflow);
937 }
938
939 // Preserving nusw (without inbounds) also requires that the offset
940 // additions did not overflow.
941 if (NW.hasNoUnsignedSignedWrap() && !NW.isInBounds() && Overflow)
943
944 // If the base value for this address is a literal integer value, fold the
945 // getelementptr to the resulting integer value casted to the pointer type.
947 if (auto *CE = dyn_cast<ConstantExpr>(Ptr)) {
948 if (CE->getOpcode() == Instruction::IntToPtr) {
949 if (auto *Base = dyn_cast<ConstantInt>(CE->getOperand(0)))
950 BasePtr = Base->getValue().zextOrTrunc(BitWidth);
951 }
952 }
953
954 auto *PTy = cast<PointerType>(Ptr->getType());
955 if ((Ptr->isNullValue() || BasePtr != 0) &&
956 !DL.isNonIntegralPointerType(PTy)) {
957 Constant *C = ConstantInt::get(Ptr->getContext(), Offset + BasePtr);
958 return ConstantExpr::getIntToPtr(C, ResTy);
959 }
960
961 // Try to infer inbounds for GEPs of globals.
962 if (!NW.isInBounds() && Offset.isNonNegative()) {
963 bool CanBeNull, CanBeFreed;
964 uint64_t DerefBytes =
965 Ptr->getPointerDereferenceableBytes(DL, CanBeNull, CanBeFreed);
966 if (DerefBytes != 0 && !CanBeNull && Offset.sle(DerefBytes))
968 }
969
970 // nusw + nneg -> nuw
971 if (NW.hasNoUnsignedSignedWrap() && Offset.isNonNegative())
973
974 // Otherwise canonicalize this to a single ptradd.
975 LLVMContext &Ctx = Ptr->getContext();
977 ConstantInt::get(Ctx, Offset), NW,
978 InRange);
979}
980
981/// Attempt to constant fold an instruction with the
982/// specified opcode and operands. If successful, the constant result is
983/// returned, if not, null is returned. Note that this function can fail when
984/// attempting to fold instructions like loads and stores, which have no
985/// constant expression form.
986Constant *ConstantFoldInstOperandsImpl(const Value *InstOrCE, unsigned Opcode,
988 const DataLayout &DL,
989 const TargetLibraryInfo *TLI,
990 bool AllowNonDeterministic) {
991 Type *DestTy = InstOrCE->getType();
992
993 if (Instruction::isUnaryOp(Opcode))
994 return ConstantFoldUnaryOpOperand(Opcode, Ops[0], DL);
995
996 if (Instruction::isBinaryOp(Opcode)) {
997 switch (Opcode) {
998 default:
999 break;
1000 case Instruction::FAdd:
1001 case Instruction::FSub:
1002 case Instruction::FMul:
1003 case Instruction::FDiv:
1004 case Instruction::FRem:
1005 // Handle floating point instructions separately to account for denormals
1006 // TODO: If a constant expression is being folded rather than an
1007 // instruction, denormals will not be flushed/treated as zero
1008 if (const auto *I = dyn_cast<Instruction>(InstOrCE)) {
1009 return ConstantFoldFPInstOperands(Opcode, Ops[0], Ops[1], DL, I,
1010 AllowNonDeterministic);
1011 }
1012 }
1013 return ConstantFoldBinaryOpOperands(Opcode, Ops[0], Ops[1], DL);
1014 }
1015
1016 if (Instruction::isCast(Opcode))
1017 return ConstantFoldCastOperand(Opcode, Ops[0], DestTy, DL);
1018
1019 if (auto *GEP = dyn_cast<GEPOperator>(InstOrCE)) {
1020 Type *SrcElemTy = GEP->getSourceElementType();
1022 return nullptr;
1023
1024 if (Constant *C = SymbolicallyEvaluateGEP(GEP, Ops, DL, TLI))
1025 return C;
1026
1027 return ConstantExpr::getGetElementPtr(SrcElemTy, Ops[0], Ops.slice(1),
1028 GEP->getNoWrapFlags(),
1029 GEP->getInRange());
1030 }
1031
1032 if (auto *CE = dyn_cast<ConstantExpr>(InstOrCE))
1033 return CE->getWithOperands(Ops);
1034
1035 switch (Opcode) {
1036 default: return nullptr;
1037 case Instruction::ICmp:
1038 case Instruction::FCmp: {
1039 auto *C = cast<CmpInst>(InstOrCE);
1040 return ConstantFoldCompareInstOperands(C->getPredicate(), Ops[0], Ops[1],
1041 DL, TLI, C);
1042 }
1043 case Instruction::Freeze:
1044 return isGuaranteedNotToBeUndefOrPoison(Ops[0]) ? Ops[0] : nullptr;
1045 case Instruction::Call:
1046 if (auto *F = dyn_cast<Function>(Ops.back())) {
1047 const auto *Call = cast<CallBase>(InstOrCE);
1048 if (canConstantFoldCallTo(Call, F))
1049 return ConstantFoldCall(Call, F, Ops.slice(0, Ops.size() - 1), TLI,
1050 AllowNonDeterministic);
1051 }
1052 return nullptr;
1053 case Instruction::Select:
1054 return ConstantFoldSelectInstruction(Ops[0], Ops[1], Ops[2]);
1055 case Instruction::ExtractElement:
1056 return ConstantExpr::getExtractElement(Ops[0], Ops[1]);
1057 case Instruction::ExtractValue:
1059 Ops[0], cast<ExtractValueInst>(InstOrCE)->getIndices());
1060 case Instruction::InsertElement:
1061 return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]);
1062 case Instruction::InsertValue:
1064 Ops[0], Ops[1], cast<InsertValueInst>(InstOrCE)->getIndices());
1065 case Instruction::ShuffleVector:
1067 Ops[0], Ops[1], cast<ShuffleVectorInst>(InstOrCE)->getShuffleMask());
1068 case Instruction::Load: {
1069 const auto *LI = dyn_cast<LoadInst>(InstOrCE);
1070 if (LI->isVolatile())
1071 return nullptr;
1072 return ConstantFoldLoadFromConstPtr(Ops[0], LI->getType(), DL);
1073 }
1074 }
1075}
1076
1077} // end anonymous namespace
1078
1079//===----------------------------------------------------------------------===//
1080// Constant Folding public APIs
1081//===----------------------------------------------------------------------===//
1082
1083namespace {
1084
1085Constant *
1086ConstantFoldConstantImpl(const Constant *C, const DataLayout &DL,
1087 const TargetLibraryInfo *TLI,
1089 if (!isa<ConstantVector>(C) && !isa<ConstantExpr>(C))
1090 return const_cast<Constant *>(C);
1091
1093 for (const Use &OldU : C->operands()) {
1094 Constant *OldC = cast<Constant>(&OldU);
1095 Constant *NewC = OldC;
1096 // Recursively fold the ConstantExpr's operands. If we have already folded
1097 // a ConstantExpr, we don't have to process it again.
1098 if (isa<ConstantVector>(OldC) || isa<ConstantExpr>(OldC)) {
1099 auto It = FoldedOps.find(OldC);
1100 if (It == FoldedOps.end()) {
1101 NewC = ConstantFoldConstantImpl(OldC, DL, TLI, FoldedOps);
1102 FoldedOps.insert({OldC, NewC});
1103 } else {
1104 NewC = It->second;
1105 }
1106 }
1107 Ops.push_back(NewC);
1108 }
1109
1110 if (auto *CE = dyn_cast<ConstantExpr>(C)) {
1111 if (Constant *Res = ConstantFoldInstOperandsImpl(
1112 CE, CE->getOpcode(), Ops, DL, TLI, /*AllowNonDeterministic=*/true))
1113 return Res;
1114 return const_cast<Constant *>(C);
1115 }
1116
1117 assert(isa<ConstantVector>(C));
1118 return ConstantVector::get(Ops);
1119}
1120
1121} // end anonymous namespace
1122
1124 const TargetLibraryInfo *TLI) {
1125 // Handle PHI nodes quickly here...
1126 if (auto *PN = dyn_cast<PHINode>(I)) {
1127 Constant *CommonValue = nullptr;
1128
1130 for (Value *Incoming : PN->incoming_values()) {
1131 // If the incoming value is undef then skip it. Note that while we could
1132 // skip the value if it is equal to the phi node itself we choose not to
1133 // because that would break the rule that constant folding only applies if
1134 // all operands are constants.
1135 if (isa<UndefValue>(Incoming))
1136 continue;
1137 // If the incoming value is not a constant, then give up.
1138 auto *C = dyn_cast<Constant>(Incoming);
1139 if (!C)
1140 return nullptr;
1141 // Fold the PHI's operands.
1142 C = ConstantFoldConstantImpl(C, DL, TLI, FoldedOps);
1143 // If the incoming value is a different constant to
1144 // the one we saw previously, then give up.
1145 if (CommonValue && C != CommonValue)
1146 return nullptr;
1147 CommonValue = C;
1148 }
1149
1150 // If we reach here, all incoming values are the same constant or undef.
1151 return CommonValue ? CommonValue : UndefValue::get(PN->getType());
1152 }
1153
1154 // Scan the operand list, checking to see if they are all constants, if so,
1155 // hand off to ConstantFoldInstOperandsImpl.
1156 if (!all_of(I->operands(), [](Use &U) { return isa<Constant>(U); }))
1157 return nullptr;
1158
1161 for (const Use &OpU : I->operands()) {
1162 auto *Op = cast<Constant>(&OpU);
1163 // Fold the Instruction's operands.
1164 Op = ConstantFoldConstantImpl(Op, DL, TLI, FoldedOps);
1165 Ops.push_back(Op);
1166 }
1167
1168 return ConstantFoldInstOperands(I, Ops, DL, TLI);
1169}
1170
1172 const TargetLibraryInfo *TLI) {
1174 return ConstantFoldConstantImpl(C, DL, TLI, FoldedOps);
1175}
1176
1179 const DataLayout &DL,
1180 const TargetLibraryInfo *TLI,
1181 bool AllowNonDeterministic) {
1182 return ConstantFoldInstOperandsImpl(I, I->getOpcode(), Ops, DL, TLI,
1183 AllowNonDeterministic);
1184}
1185
1187 unsigned IntPredicate, Constant *Ops0, Constant *Ops1, const DataLayout &DL,
1188 const TargetLibraryInfo *TLI, const Instruction *I) {
1189 CmpInst::Predicate Predicate = (CmpInst::Predicate)IntPredicate;
1190 // fold: icmp (inttoptr x), null -> icmp x, 0
1191 // fold: icmp null, (inttoptr x) -> icmp 0, x
1192 // fold: icmp (ptrtoint x), 0 -> icmp x, null
1193 // fold: icmp 0, (ptrtoint x) -> icmp null, x
1194 // fold: icmp (inttoptr x), (inttoptr y) -> icmp trunc/zext x, trunc/zext y
1195 // fold: icmp (ptrtoint x), (ptrtoint y) -> icmp x, y
1196 //
1197 // FIXME: The following comment is out of data and the DataLayout is here now.
1198 // ConstantExpr::getCompare cannot do this, because it doesn't have DL
1199 // around to know if bit truncation is happening.
1200 if (auto *CE0 = dyn_cast<ConstantExpr>(Ops0)) {
1201 if (Ops1->isNullValue()) {
1202 if (CE0->getOpcode() == Instruction::IntToPtr) {
1203 Type *IntPtrTy = DL.getIntPtrType(CE0->getType());
1204 // Convert the integer value to the right size to ensure we get the
1205 // proper extension or truncation.
1206 if (Constant *C = ConstantFoldIntegerCast(CE0->getOperand(0), IntPtrTy,
1207 /*IsSigned*/ false, DL)) {
1208 Constant *Null = Constant::getNullValue(C->getType());
1209 return ConstantFoldCompareInstOperands(Predicate, C, Null, DL, TLI);
1210 }
1211 }
1212
1213 // Only do this transformation if the int is intptrty in size, otherwise
1214 // there is a truncation or extension that we aren't modeling.
1215 if (CE0->getOpcode() == Instruction::PtrToInt) {
1216 Type *IntPtrTy = DL.getIntPtrType(CE0->getOperand(0)->getType());
1217 if (CE0->getType() == IntPtrTy) {
1218 Constant *C = CE0->getOperand(0);
1219 Constant *Null = Constant::getNullValue(C->getType());
1220 return ConstantFoldCompareInstOperands(Predicate, C, Null, DL, TLI);
1221 }
1222 }
1223 }
1224
1225 if (auto *CE1 = dyn_cast<ConstantExpr>(Ops1)) {
1226 if (CE0->getOpcode() == CE1->getOpcode()) {
1227 if (CE0->getOpcode() == Instruction::IntToPtr) {
1228 Type *IntPtrTy = DL.getIntPtrType(CE0->getType());
1229
1230 // Convert the integer value to the right size to ensure we get the
1231 // proper extension or truncation.
1232 Constant *C0 = ConstantFoldIntegerCast(CE0->getOperand(0), IntPtrTy,
1233 /*IsSigned*/ false, DL);
1234 Constant *C1 = ConstantFoldIntegerCast(CE1->getOperand(0), IntPtrTy,
1235 /*IsSigned*/ false, DL);
1236 if (C0 && C1)
1237 return ConstantFoldCompareInstOperands(Predicate, C0, C1, DL, TLI);
1238 }
1239
1240 // Only do this transformation if the int is intptrty in size, otherwise
1241 // there is a truncation or extension that we aren't modeling.
1242 if (CE0->getOpcode() == Instruction::PtrToInt) {
1243 Type *IntPtrTy = DL.getIntPtrType(CE0->getOperand(0)->getType());
1244 if (CE0->getType() == IntPtrTy &&
1245 CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType()) {
1247 Predicate, CE0->getOperand(0), CE1->getOperand(0), DL, TLI);
1248 }
1249 }
1250 }
1251 }
1252
1253 // Convert pointer comparison (base+offset1) pred (base+offset2) into
1254 // offset1 pred offset2, for the case where the offset is inbounds. This
1255 // only works for equality and unsigned comparison, as inbounds permits
1256 // crossing the sign boundary. However, the offset comparison itself is
1257 // signed.
1258 if (Ops0->getType()->isPointerTy() && !ICmpInst::isSigned(Predicate)) {
1259 unsigned IndexWidth = DL.getIndexTypeSizeInBits(Ops0->getType());
1260 APInt Offset0(IndexWidth, 0);
1261 Value *Stripped0 =
1263 APInt Offset1(IndexWidth, 0);
1264 Value *Stripped1 =
1266 if (Stripped0 == Stripped1)
1267 return ConstantInt::getBool(
1268 Ops0->getContext(),
1269 ICmpInst::compare(Offset0, Offset1,
1270 ICmpInst::getSignedPredicate(Predicate)));
1271 }
1272 } else if (isa<ConstantExpr>(Ops1)) {
1273 // If RHS is a constant expression, but the left side isn't, swap the
1274 // operands and try again.
1275 Predicate = ICmpInst::getSwappedPredicate(Predicate);
1276 return ConstantFoldCompareInstOperands(Predicate, Ops1, Ops0, DL, TLI);
1277 }
1278
1279 if (CmpInst::isFPPredicate(Predicate)) {
1280 // Flush any denormal constant float input according to denormal handling
1281 // mode.
1282 Ops0 = FlushFPConstant(Ops0, I, /*IsOutput=*/false);
1283 if (!Ops0)
1284 return nullptr;
1285 Ops1 = FlushFPConstant(Ops1, I, /*IsOutput=*/false);
1286 if (!Ops1)
1287 return nullptr;
1288 }
1289
1290 return ConstantFoldCompareInstruction(Predicate, Ops0, Ops1);
1291}
1292
1294 const DataLayout &DL) {
1296
1297 return ConstantFoldUnaryInstruction(Opcode, Op);
1298}
1299
1301 Constant *RHS,
1302 const DataLayout &DL) {
1304 if (isa<ConstantExpr>(LHS) || isa<ConstantExpr>(RHS))
1305 if (Constant *C = SymbolicallyEvaluateBinop(Opcode, LHS, RHS, DL))
1306 return C;
1307
1309 return ConstantExpr::get(Opcode, LHS, RHS);
1310 return ConstantFoldBinaryInstruction(Opcode, LHS, RHS);
1311}
1312
1315 switch (Mode) {
1317 return nullptr;
1318 case DenormalMode::IEEE:
1319 return ConstantFP::get(Ty->getContext(), APF);
1321 return ConstantFP::get(
1322 Ty->getContext(),
1325 return ConstantFP::get(Ty->getContext(),
1326 APFloat::getZero(APF.getSemantics(), false));
1327 default:
1328 break;
1329 }
1330
1331 llvm_unreachable("unknown denormal mode");
1332}
1333
1334/// Return the denormal mode that can be assumed when executing a floating point
1335/// operation at \p CtxI.
1337 if (!CtxI || !CtxI->getParent() || !CtxI->getFunction())
1338 return DenormalMode::getDynamic();
1339 return CtxI->getFunction()->getDenormalMode(Ty->getFltSemantics());
1340}
1341
1343 const Instruction *Inst,
1344 bool IsOutput) {
1345 const APFloat &APF = CFP->getValueAPF();
1346 if (!APF.isDenormal())
1347 return CFP;
1348
1349 DenormalMode Mode = getInstrDenormalMode(Inst, CFP->getType());
1350 return flushDenormalConstant(CFP->getType(), APF,
1351 IsOutput ? Mode.Output : Mode.Input);
1352}
1353
1355 bool IsOutput) {
1356 if (ConstantFP *CFP = dyn_cast<ConstantFP>(Operand))
1357 return flushDenormalConstantFP(CFP, Inst, IsOutput);
1358
1359 if (isa<ConstantAggregateZero, UndefValue, ConstantExpr>(Operand))
1360 return Operand;
1361
1362 Type *Ty = Operand->getType();
1363 VectorType *VecTy = dyn_cast<VectorType>(Ty);
1364 if (VecTy) {
1365 if (auto *Splat = dyn_cast_or_null<ConstantFP>(Operand->getSplatValue())) {
1366 ConstantFP *Folded = flushDenormalConstantFP(Splat, Inst, IsOutput);
1367 if (!Folded)
1368 return nullptr;
1369 return ConstantVector::getSplat(VecTy->getElementCount(), Folded);
1370 }
1371
1372 Ty = VecTy->getElementType();
1373 }
1374
1375 if (const auto *CV = dyn_cast<ConstantVector>(Operand)) {
1377 for (unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
1378 Constant *Element = CV->getAggregateElement(i);
1379 if (isa<UndefValue>(Element)) {
1380 NewElts.push_back(Element);
1381 continue;
1382 }
1383
1384 ConstantFP *CFP = dyn_cast<ConstantFP>(Element);
1385 if (!CFP)
1386 return nullptr;
1387
1388 ConstantFP *Folded = flushDenormalConstantFP(CFP, Inst, IsOutput);
1389 if (!Folded)
1390 return nullptr;
1391 NewElts.push_back(Folded);
1392 }
1393
1394 return ConstantVector::get(NewElts);
1395 }
1396
1397 if (const auto *CDV = dyn_cast<ConstantDataVector>(Operand)) {
1399 for (unsigned I = 0, E = CDV->getNumElements(); I < E; ++I) {
1400 const APFloat &Elt = CDV->getElementAsAPFloat(I);
1401 if (!Elt.isDenormal()) {
1402 NewElts.push_back(ConstantFP::get(Ty, Elt));
1403 } else {
1404 DenormalMode Mode = getInstrDenormalMode(Inst, Ty);
1405 ConstantFP *Folded =
1406 flushDenormalConstant(Ty, Elt, IsOutput ? Mode.Output : Mode.Input);
1407 if (!Folded)
1408 return nullptr;
1409 NewElts.push_back(Folded);
1410 }
1411 }
1412
1413 return ConstantVector::get(NewElts);
1414 }
1415
1416 return nullptr;
1417}
1418
1420 Constant *RHS, const DataLayout &DL,
1421 const Instruction *I,
1422 bool AllowNonDeterministic) {
1423 if (Instruction::isBinaryOp(Opcode)) {
1424 // Flush denormal inputs if needed.
1425 Constant *Op0 = FlushFPConstant(LHS, I, /* IsOutput */ false);
1426 if (!Op0)
1427 return nullptr;
1428 Constant *Op1 = FlushFPConstant(RHS, I, /* IsOutput */ false);
1429 if (!Op1)
1430 return nullptr;
1431
1432 // If nsz or an algebraic FMF flag is set, the result of the FP operation
1433 // may change due to future optimization. Don't constant fold them if
1434 // non-deterministic results are not allowed.
1435 if (!AllowNonDeterministic)
1436 if (auto *FP = dyn_cast_or_null<FPMathOperator>(I))
1437 if (FP->hasNoSignedZeros() || FP->hasAllowReassoc() ||
1438 FP->hasAllowContract() || FP->hasAllowReciprocal())
1439 return nullptr;
1440
1441 // Calculate constant result.
1442 Constant *C = ConstantFoldBinaryOpOperands(Opcode, Op0, Op1, DL);
1443 if (!C)
1444 return nullptr;
1445
1446 // Flush denormal output if needed.
1447 C = FlushFPConstant(C, I, /* IsOutput */ true);
1448 if (!C)
1449 return nullptr;
1450
1451 // The precise NaN value is non-deterministic.
1452 if (!AllowNonDeterministic && C->isNaN())
1453 return nullptr;
1454
1455 return C;
1456 }
1457 // If instruction lacks a parent/function and the denormal mode cannot be
1458 // determined, use the default (IEEE).
1459 return ConstantFoldBinaryOpOperands(Opcode, LHS, RHS, DL);
1460}
1461
1463 Type *DestTy, const DataLayout &DL) {
1464 assert(Instruction::isCast(Opcode));
1465 switch (Opcode) {
1466 default:
1467 llvm_unreachable("Missing case");
1468 case Instruction::PtrToInt:
1469 if (auto *CE = dyn_cast<ConstantExpr>(C)) {
1470 Constant *FoldedValue = nullptr;
1471 // If the input is a inttoptr, eliminate the pair. This requires knowing
1472 // the width of a pointer, so it can't be done in ConstantExpr::getCast.
1473 if (CE->getOpcode() == Instruction::IntToPtr) {
1474 // zext/trunc the inttoptr to pointer size.
1475 FoldedValue = ConstantFoldIntegerCast(CE->getOperand(0),
1476 DL.getIntPtrType(CE->getType()),
1477 /*IsSigned=*/false, DL);
1478 } else if (auto *GEP = dyn_cast<GEPOperator>(CE)) {
1479 // If we have GEP, we can perform the following folds:
1480 // (ptrtoint (gep null, x)) -> x
1481 // (ptrtoint (gep (gep null, x), y) -> x + y, etc.
1482 unsigned BitWidth = DL.getIndexTypeSizeInBits(GEP->getType());
1483 APInt BaseOffset(BitWidth, 0);
1484 auto *Base = cast<Constant>(GEP->stripAndAccumulateConstantOffsets(
1485 DL, BaseOffset, /*AllowNonInbounds=*/true));
1486 if (Base->isNullValue()) {
1487 FoldedValue = ConstantInt::get(CE->getContext(), BaseOffset);
1488 } else {
1489 // ptrtoint (gep i8, Ptr, (sub 0, V)) -> sub (ptrtoint Ptr), V
1490 if (GEP->getNumIndices() == 1 &&
1491 GEP->getSourceElementType()->isIntegerTy(8)) {
1492 auto *Ptr = cast<Constant>(GEP->getPointerOperand());
1493 auto *Sub = dyn_cast<ConstantExpr>(GEP->getOperand(1));
1494 Type *IntIdxTy = DL.getIndexType(Ptr->getType());
1495 if (Sub && Sub->getType() == IntIdxTy &&
1496 Sub->getOpcode() == Instruction::Sub &&
1497 Sub->getOperand(0)->isNullValue())
1498 FoldedValue = ConstantExpr::getSub(
1499 ConstantExpr::getPtrToInt(Ptr, IntIdxTy), Sub->getOperand(1));
1500 }
1501 }
1502 }
1503 if (FoldedValue) {
1504 // Do a zext or trunc to get to the ptrtoint dest size.
1505 return ConstantFoldIntegerCast(FoldedValue, DestTy, /*IsSigned=*/false,
1506 DL);
1507 }
1508 }
1509 break;
1510 case Instruction::IntToPtr:
1511 // If the input is a ptrtoint, turn the pair into a ptr to ptr bitcast if
1512 // the int size is >= the ptr size and the address spaces are the same.
1513 // This requires knowing the width of a pointer, so it can't be done in
1514 // ConstantExpr::getCast.
1515 if (auto *CE = dyn_cast<ConstantExpr>(C)) {
1516 if (CE->getOpcode() == Instruction::PtrToInt) {
1517 Constant *SrcPtr = CE->getOperand(0);
1518 unsigned SrcPtrSize = DL.getPointerTypeSizeInBits(SrcPtr->getType());
1519 unsigned MidIntSize = CE->getType()->getScalarSizeInBits();
1520
1521 if (MidIntSize >= SrcPtrSize) {
1522 unsigned SrcAS = SrcPtr->getType()->getPointerAddressSpace();
1523 if (SrcAS == DestTy->getPointerAddressSpace())
1524 return FoldBitCast(CE->getOperand(0), DestTy, DL);
1525 }
1526 }
1527 }
1528 break;
1529 case Instruction::Trunc:
1530 case Instruction::ZExt:
1531 case Instruction::SExt:
1532 case Instruction::FPTrunc:
1533 case Instruction::FPExt:
1534 case Instruction::UIToFP:
1535 case Instruction::SIToFP:
1536 case Instruction::FPToUI:
1537 case Instruction::FPToSI:
1538 case Instruction::AddrSpaceCast:
1539 break;
1540 case Instruction::BitCast:
1541 return FoldBitCast(C, DestTy, DL);
1542 }
1543
1545 return ConstantExpr::getCast(Opcode, C, DestTy);
1546 return ConstantFoldCastInstruction(Opcode, C, DestTy);
1547}
1548
1550 bool IsSigned, const DataLayout &DL) {
1551 Type *SrcTy = C->getType();
1552 if (SrcTy == DestTy)
1553 return C;
1554 if (SrcTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
1555 return ConstantFoldCastOperand(Instruction::Trunc, C, DestTy, DL);
1556 if (IsSigned)
1557 return ConstantFoldCastOperand(Instruction::SExt, C, DestTy, DL);
1558 return ConstantFoldCastOperand(Instruction::ZExt, C, DestTy, DL);
1559}
1560
1561//===----------------------------------------------------------------------===//
1562// Constant Folding for Calls
1563//
1564
1566 if (Call->isNoBuiltin())
1567 return false;
1568 if (Call->getFunctionType() != F->getFunctionType())
1569 return false;
1570 switch (F->getIntrinsicID()) {
1571 // Operations that do not operate floating-point numbers and do not depend on
1572 // FP environment can be folded even in strictfp functions.
1573 case Intrinsic::bswap:
1574 case Intrinsic::ctpop:
1575 case Intrinsic::ctlz:
1576 case Intrinsic::cttz:
1577 case Intrinsic::fshl:
1578 case Intrinsic::fshr:
1579 case Intrinsic::launder_invariant_group:
1580 case Intrinsic::strip_invariant_group:
1581 case Intrinsic::masked_load:
1582 case Intrinsic::get_active_lane_mask:
1583 case Intrinsic::abs:
1584 case Intrinsic::smax:
1585 case Intrinsic::smin:
1586 case Intrinsic::umax:
1587 case Intrinsic::umin:
1588 case Intrinsic::scmp:
1589 case Intrinsic::ucmp:
1590 case Intrinsic::sadd_with_overflow:
1591 case Intrinsic::uadd_with_overflow:
1592 case Intrinsic::ssub_with_overflow:
1593 case Intrinsic::usub_with_overflow:
1594 case Intrinsic::smul_with_overflow:
1595 case Intrinsic::umul_with_overflow:
1596 case Intrinsic::sadd_sat:
1597 case Intrinsic::uadd_sat:
1598 case Intrinsic::ssub_sat:
1599 case Intrinsic::usub_sat:
1600 case Intrinsic::smul_fix:
1601 case Intrinsic::smul_fix_sat:
1602 case Intrinsic::bitreverse:
1603 case Intrinsic::is_constant:
1604 case Intrinsic::vector_reduce_add:
1605 case Intrinsic::vector_reduce_mul:
1606 case Intrinsic::vector_reduce_and:
1607 case Intrinsic::vector_reduce_or:
1608 case Intrinsic::vector_reduce_xor:
1609 case Intrinsic::vector_reduce_smin:
1610 case Intrinsic::vector_reduce_smax:
1611 case Intrinsic::vector_reduce_umin:
1612 case Intrinsic::vector_reduce_umax:
1613 // Target intrinsics
1614 case Intrinsic::amdgcn_perm:
1615 case Intrinsic::amdgcn_wave_reduce_umin:
1616 case Intrinsic::amdgcn_wave_reduce_umax:
1617 case Intrinsic::amdgcn_s_wqm:
1618 case Intrinsic::amdgcn_s_quadmask:
1619 case Intrinsic::amdgcn_s_bitreplicate:
1620 case Intrinsic::arm_mve_vctp8:
1621 case Intrinsic::arm_mve_vctp16:
1622 case Intrinsic::arm_mve_vctp32:
1623 case Intrinsic::arm_mve_vctp64:
1624 case Intrinsic::aarch64_sve_convert_from_svbool:
1625 // WebAssembly float semantics are always known
1626 case Intrinsic::wasm_trunc_signed:
1627 case Intrinsic::wasm_trunc_unsigned:
1628 return true;
1629
1630 // Floating point operations cannot be folded in strictfp functions in
1631 // general case. They can be folded if FP environment is known to compiler.
1632 case Intrinsic::minnum:
1633 case Intrinsic::maxnum:
1634 case Intrinsic::minimum:
1635 case Intrinsic::maximum:
1636 case Intrinsic::log:
1637 case Intrinsic::log2:
1638 case Intrinsic::log10:
1639 case Intrinsic::exp:
1640 case Intrinsic::exp2:
1641 case Intrinsic::exp10:
1642 case Intrinsic::sqrt:
1643 case Intrinsic::sin:
1644 case Intrinsic::cos:
1645 case Intrinsic::sincos:
1646 case Intrinsic::pow:
1647 case Intrinsic::powi:
1648 case Intrinsic::ldexp:
1649 case Intrinsic::fma:
1650 case Intrinsic::fmuladd:
1651 case Intrinsic::frexp:
1652 case Intrinsic::fptoui_sat:
1653 case Intrinsic::fptosi_sat:
1654 case Intrinsic::convert_from_fp16:
1655 case Intrinsic::convert_to_fp16:
1656 case Intrinsic::amdgcn_cos:
1657 case Intrinsic::amdgcn_cubeid:
1658 case Intrinsic::amdgcn_cubema:
1659 case Intrinsic::amdgcn_cubesc:
1660 case Intrinsic::amdgcn_cubetc:
1661 case Intrinsic::amdgcn_fmul_legacy:
1662 case Intrinsic::amdgcn_fma_legacy:
1663 case Intrinsic::amdgcn_fract:
1664 case Intrinsic::amdgcn_sin:
1665 // The intrinsics below depend on rounding mode in MXCSR.
1666 case Intrinsic::x86_sse_cvtss2si:
1667 case Intrinsic::x86_sse_cvtss2si64:
1668 case Intrinsic::x86_sse_cvttss2si:
1669 case Intrinsic::x86_sse_cvttss2si64:
1670 case Intrinsic::x86_sse2_cvtsd2si:
1671 case Intrinsic::x86_sse2_cvtsd2si64:
1672 case Intrinsic::x86_sse2_cvttsd2si:
1673 case Intrinsic::x86_sse2_cvttsd2si64:
1674 case Intrinsic::x86_avx512_vcvtss2si32:
1675 case Intrinsic::x86_avx512_vcvtss2si64:
1676 case Intrinsic::x86_avx512_cvttss2si:
1677 case Intrinsic::x86_avx512_cvttss2si64:
1678 case Intrinsic::x86_avx512_vcvtsd2si32:
1679 case Intrinsic::x86_avx512_vcvtsd2si64:
1680 case Intrinsic::x86_avx512_cvttsd2si:
1681 case Intrinsic::x86_avx512_cvttsd2si64:
1682 case Intrinsic::x86_avx512_vcvtss2usi32:
1683 case Intrinsic::x86_avx512_vcvtss2usi64:
1684 case Intrinsic::x86_avx512_cvttss2usi:
1685 case Intrinsic::x86_avx512_cvttss2usi64:
1686 case Intrinsic::x86_avx512_vcvtsd2usi32:
1687 case Intrinsic::x86_avx512_vcvtsd2usi64:
1688 case Intrinsic::x86_avx512_cvttsd2usi:
1689 case Intrinsic::x86_avx512_cvttsd2usi64:
1690 return !Call->isStrictFP();
1691
1692 // NVVM FMax intrinsics
1693 case Intrinsic::nvvm_fmax_d:
1694 case Intrinsic::nvvm_fmax_f:
1695 case Intrinsic::nvvm_fmax_ftz_f:
1696 case Intrinsic::nvvm_fmax_ftz_nan_f:
1697 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
1698 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
1699 case Intrinsic::nvvm_fmax_nan_f:
1700 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
1701 case Intrinsic::nvvm_fmax_xorsign_abs_f:
1702
1703 // NVVM FMin intrinsics
1704 case Intrinsic::nvvm_fmin_d:
1705 case Intrinsic::nvvm_fmin_f:
1706 case Intrinsic::nvvm_fmin_ftz_f:
1707 case Intrinsic::nvvm_fmin_ftz_nan_f:
1708 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:
1709 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:
1710 case Intrinsic::nvvm_fmin_nan_f:
1711 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:
1712 case Intrinsic::nvvm_fmin_xorsign_abs_f:
1713
1714 // NVVM float/double to int32/uint32 conversion intrinsics
1715 case Intrinsic::nvvm_f2i_rm:
1716 case Intrinsic::nvvm_f2i_rn:
1717 case Intrinsic::nvvm_f2i_rp:
1718 case Intrinsic::nvvm_f2i_rz:
1719 case Intrinsic::nvvm_f2i_rm_ftz:
1720 case Intrinsic::nvvm_f2i_rn_ftz:
1721 case Intrinsic::nvvm_f2i_rp_ftz:
1722 case Intrinsic::nvvm_f2i_rz_ftz:
1723 case Intrinsic::nvvm_f2ui_rm:
1724 case Intrinsic::nvvm_f2ui_rn:
1725 case Intrinsic::nvvm_f2ui_rp:
1726 case Intrinsic::nvvm_f2ui_rz:
1727 case Intrinsic::nvvm_f2ui_rm_ftz:
1728 case Intrinsic::nvvm_f2ui_rn_ftz:
1729 case Intrinsic::nvvm_f2ui_rp_ftz:
1730 case Intrinsic::nvvm_f2ui_rz_ftz:
1731 case Intrinsic::nvvm_d2i_rm:
1732 case Intrinsic::nvvm_d2i_rn:
1733 case Intrinsic::nvvm_d2i_rp:
1734 case Intrinsic::nvvm_d2i_rz:
1735 case Intrinsic::nvvm_d2ui_rm:
1736 case Intrinsic::nvvm_d2ui_rn:
1737 case Intrinsic::nvvm_d2ui_rp:
1738 case Intrinsic::nvvm_d2ui_rz:
1739
1740 // NVVM float/double to int64/uint64 conversion intrinsics
1741 case Intrinsic::nvvm_f2ll_rm:
1742 case Intrinsic::nvvm_f2ll_rn:
1743 case Intrinsic::nvvm_f2ll_rp:
1744 case Intrinsic::nvvm_f2ll_rz:
1745 case Intrinsic::nvvm_f2ll_rm_ftz:
1746 case Intrinsic::nvvm_f2ll_rn_ftz:
1747 case Intrinsic::nvvm_f2ll_rp_ftz:
1748 case Intrinsic::nvvm_f2ll_rz_ftz:
1749 case Intrinsic::nvvm_f2ull_rm:
1750 case Intrinsic::nvvm_f2ull_rn:
1751 case Intrinsic::nvvm_f2ull_rp:
1752 case Intrinsic::nvvm_f2ull_rz:
1753 case Intrinsic::nvvm_f2ull_rm_ftz:
1754 case Intrinsic::nvvm_f2ull_rn_ftz:
1755 case Intrinsic::nvvm_f2ull_rp_ftz:
1756 case Intrinsic::nvvm_f2ull_rz_ftz:
1757 case Intrinsic::nvvm_d2ll_rm:
1758 case Intrinsic::nvvm_d2ll_rn:
1759 case Intrinsic::nvvm_d2ll_rp:
1760 case Intrinsic::nvvm_d2ll_rz:
1761 case Intrinsic::nvvm_d2ull_rm:
1762 case Intrinsic::nvvm_d2ull_rn:
1763 case Intrinsic::nvvm_d2ull_rp:
1764 case Intrinsic::nvvm_d2ull_rz:
1765
1766 // Sign operations are actually bitwise operations, they do not raise
1767 // exceptions even for SNANs.
1768 case Intrinsic::fabs:
1769 case Intrinsic::copysign:
1770 case Intrinsic::is_fpclass:
1771 // Non-constrained variants of rounding operations means default FP
1772 // environment, they can be folded in any case.
1773 case Intrinsic::ceil:
1774 case Intrinsic::floor:
1775 case Intrinsic::round:
1776 case Intrinsic::roundeven:
1777 case Intrinsic::trunc:
1778 case Intrinsic::nearbyint:
1779 case Intrinsic::rint:
1780 case Intrinsic::canonicalize:
1781 // Constrained intrinsics can be folded if FP environment is known
1782 // to compiler.
1783 case Intrinsic::experimental_constrained_fma:
1784 case Intrinsic::experimental_constrained_fmuladd:
1785 case Intrinsic::experimental_constrained_fadd:
1786 case Intrinsic::experimental_constrained_fsub:
1787 case Intrinsic::experimental_constrained_fmul:
1788 case Intrinsic::experimental_constrained_fdiv:
1789 case Intrinsic::experimental_constrained_frem:
1790 case Intrinsic::experimental_constrained_ceil:
1791 case Intrinsic::experimental_constrained_floor:
1792 case Intrinsic::experimental_constrained_round:
1793 case Intrinsic::experimental_constrained_roundeven:
1794 case Intrinsic::experimental_constrained_trunc:
1795 case Intrinsic::experimental_constrained_nearbyint:
1796 case Intrinsic::experimental_constrained_rint:
1797 case Intrinsic::experimental_constrained_fcmp:
1798 case Intrinsic::experimental_constrained_fcmps:
1799 return true;
1800 default:
1801 return false;
1802 case Intrinsic::not_intrinsic: break;
1803 }
1804
1805 if (!F->hasName() || Call->isStrictFP())
1806 return false;
1807
1808 // In these cases, the check of the length is required. We don't want to
1809 // return true for a name like "cos\0blah" which strcmp would return equal to
1810 // "cos", but has length 8.
1811 StringRef Name = F->getName();
1812 switch (Name[0]) {
1813 default:
1814 return false;
1815 case 'a':
1816 return Name == "acos" || Name == "acosf" ||
1817 Name == "asin" || Name == "asinf" ||
1818 Name == "atan" || Name == "atanf" ||
1819 Name == "atan2" || Name == "atan2f";
1820 case 'c':
1821 return Name == "ceil" || Name == "ceilf" ||
1822 Name == "cos" || Name == "cosf" ||
1823 Name == "cosh" || Name == "coshf";
1824 case 'e':
1825 return Name == "exp" || Name == "expf" || Name == "exp2" ||
1826 Name == "exp2f" || Name == "erf" || Name == "erff";
1827 case 'f':
1828 return Name == "fabs" || Name == "fabsf" ||
1829 Name == "floor" || Name == "floorf" ||
1830 Name == "fmod" || Name == "fmodf";
1831 case 'i':
1832 return Name == "ilogb" || Name == "ilogbf";
1833 case 'l':
1834 return Name == "log" || Name == "logf" || Name == "logl" ||
1835 Name == "log2" || Name == "log2f" || Name == "log10" ||
1836 Name == "log10f" || Name == "logb" || Name == "logbf" ||
1837 Name == "log1p" || Name == "log1pf";
1838 case 'n':
1839 return Name == "nearbyint" || Name == "nearbyintf";
1840 case 'p':
1841 return Name == "pow" || Name == "powf";
1842 case 'r':
1843 return Name == "remainder" || Name == "remainderf" ||
1844 Name == "rint" || Name == "rintf" ||
1845 Name == "round" || Name == "roundf";
1846 case 's':
1847 return Name == "sin" || Name == "sinf" ||
1848 Name == "sinh" || Name == "sinhf" ||
1849 Name == "sqrt" || Name == "sqrtf";
1850 case 't':
1851 return Name == "tan" || Name == "tanf" ||
1852 Name == "tanh" || Name == "tanhf" ||
1853 Name == "trunc" || Name == "truncf";
1854 case '_':
1855 // Check for various function names that get used for the math functions
1856 // when the header files are preprocessed with the macro
1857 // __FINITE_MATH_ONLY__ enabled.
1858 // The '12' here is the length of the shortest name that can match.
1859 // We need to check the size before looking at Name[1] and Name[2]
1860 // so we may as well check a limit that will eliminate mismatches.
1861 if (Name.size() < 12 || Name[1] != '_')
1862 return false;
1863 switch (Name[2]) {
1864 default:
1865 return false;
1866 case 'a':
1867 return Name == "__acos_finite" || Name == "__acosf_finite" ||
1868 Name == "__asin_finite" || Name == "__asinf_finite" ||
1869 Name == "__atan2_finite" || Name == "__atan2f_finite";
1870 case 'c':
1871 return Name == "__cosh_finite" || Name == "__coshf_finite";
1872 case 'e':
1873 return Name == "__exp_finite" || Name == "__expf_finite" ||
1874 Name == "__exp2_finite" || Name == "__exp2f_finite";
1875 case 'l':
1876 return Name == "__log_finite" || Name == "__logf_finite" ||
1877 Name == "__log10_finite" || Name == "__log10f_finite";
1878 case 'p':
1879 return Name == "__pow_finite" || Name == "__powf_finite";
1880 case 's':
1881 return Name == "__sinh_finite" || Name == "__sinhf_finite";
1882 }
1883 }
1884}
1885
1886namespace {
1887
1888Constant *GetConstantFoldFPValue(double V, Type *Ty) {
1889 if (Ty->isHalfTy() || Ty->isFloatTy()) {
1890 APFloat APF(V);
1891 bool unused;
1892 APF.convert(Ty->getFltSemantics(), APFloat::rmNearestTiesToEven, &unused);
1893 return ConstantFP::get(Ty->getContext(), APF);
1894 }
1895 if (Ty->isDoubleTy())
1896 return ConstantFP::get(Ty->getContext(), APFloat(V));
1897 llvm_unreachable("Can only constant fold half/float/double");
1898}
1899
1900#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)
1901Constant *GetConstantFoldFPValue128(float128 V, Type *Ty) {
1902 if (Ty->isFP128Ty())
1903 return ConstantFP::get(Ty, V);
1904 llvm_unreachable("Can only constant fold fp128");
1905}
1906#endif
1907
1908/// Clear the floating-point exception state.
1909inline void llvm_fenv_clearexcept() {
1910#if HAVE_DECL_FE_ALL_EXCEPT
1911 feclearexcept(FE_ALL_EXCEPT);
1912#endif
1913 errno = 0;
1914}
1915
1916/// Test if a floating-point exception was raised.
1917inline bool llvm_fenv_testexcept() {
1918 int errno_val = errno;
1919 if (errno_val == ERANGE || errno_val == EDOM)
1920 return true;
1921#if HAVE_DECL_FE_ALL_EXCEPT && HAVE_DECL_FE_INEXACT
1922 if (fetestexcept(FE_ALL_EXCEPT & ~FE_INEXACT))
1923 return true;
1924#endif
1925 return false;
1926}
1927
1928static const APFloat FTZPreserveSign(const APFloat &V) {
1929 if (V.isDenormal())
1930 return APFloat::getZero(V.getSemantics(), V.isNegative());
1931 return V;
1932}
1933
1934Constant *ConstantFoldFP(double (*NativeFP)(double), const APFloat &V,
1935 Type *Ty) {
1936 llvm_fenv_clearexcept();
1937 double Result = NativeFP(V.convertToDouble());
1938 if (llvm_fenv_testexcept()) {
1939 llvm_fenv_clearexcept();
1940 return nullptr;
1941 }
1942
1943 return GetConstantFoldFPValue(Result, Ty);
1944}
1945
1946#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)
1947Constant *ConstantFoldFP128(float128 (*NativeFP)(float128), const APFloat &V,
1948 Type *Ty) {
1949 llvm_fenv_clearexcept();
1950 float128 Result = NativeFP(V.convertToQuad());
1951 if (llvm_fenv_testexcept()) {
1952 llvm_fenv_clearexcept();
1953 return nullptr;
1954 }
1955
1956 return GetConstantFoldFPValue128(Result, Ty);
1957}
1958#endif
1959
1960Constant *ConstantFoldBinaryFP(double (*NativeFP)(double, double),
1961 const APFloat &V, const APFloat &W, Type *Ty) {
1962 llvm_fenv_clearexcept();
1963 double Result = NativeFP(V.convertToDouble(), W.convertToDouble());
1964 if (llvm_fenv_testexcept()) {
1965 llvm_fenv_clearexcept();
1966 return nullptr;
1967 }
1968
1969 return GetConstantFoldFPValue(Result, Ty);
1970}
1971
1972Constant *constantFoldVectorReduce(Intrinsic::ID IID, Constant *Op) {
1973 FixedVectorType *VT = dyn_cast<FixedVectorType>(Op->getType());
1974 if (!VT)
1975 return nullptr;
1976
1977 // This isn't strictly necessary, but handle the special/common case of zero:
1978 // all integer reductions of a zero input produce zero.
1979 if (isa<ConstantAggregateZero>(Op))
1980 return ConstantInt::get(VT->getElementType(), 0);
1981
1982 // This is the same as the underlying binops - poison propagates.
1983 if (isa<PoisonValue>(Op) || Op->containsPoisonElement())
1984 return PoisonValue::get(VT->getElementType());
1985
1986 // TODO: Handle undef.
1987 if (!isa<ConstantVector>(Op) && !isa<ConstantDataVector>(Op))
1988 return nullptr;
1989
1990 auto *EltC = dyn_cast<ConstantInt>(Op->getAggregateElement(0U));
1991 if (!EltC)
1992 return nullptr;
1993
1994 APInt Acc = EltC->getValue();
1995 for (unsigned I = 1, E = VT->getNumElements(); I != E; I++) {
1996 if (!(EltC = dyn_cast<ConstantInt>(Op->getAggregateElement(I))))
1997 return nullptr;
1998 const APInt &X = EltC->getValue();
1999 switch (IID) {
2000 case Intrinsic::vector_reduce_add:
2001 Acc = Acc + X;
2002 break;
2003 case Intrinsic::vector_reduce_mul:
2004 Acc = Acc * X;
2005 break;
2006 case Intrinsic::vector_reduce_and:
2007 Acc = Acc & X;
2008 break;
2009 case Intrinsic::vector_reduce_or:
2010 Acc = Acc | X;
2011 break;
2012 case Intrinsic::vector_reduce_xor:
2013 Acc = Acc ^ X;
2014 break;
2015 case Intrinsic::vector_reduce_smin:
2016 Acc = APIntOps::smin(Acc, X);
2017 break;
2018 case Intrinsic::vector_reduce_smax:
2019 Acc = APIntOps::smax(Acc, X);
2020 break;
2021 case Intrinsic::vector_reduce_umin:
2022 Acc = APIntOps::umin(Acc, X);
2023 break;
2024 case Intrinsic::vector_reduce_umax:
2025 Acc = APIntOps::umax(Acc, X);
2026 break;
2027 }
2028 }
2029
2030 return ConstantInt::get(Op->getContext(), Acc);
2031}
2032
2033/// Attempt to fold an SSE floating point to integer conversion of a constant
2034/// floating point. If roundTowardZero is false, the default IEEE rounding is
2035/// used (toward nearest, ties to even). This matches the behavior of the
2036/// non-truncating SSE instructions in the default rounding mode. The desired
2037/// integer type Ty is used to select how many bits are available for the
2038/// result. Returns null if the conversion cannot be performed, otherwise
2039/// returns the Constant value resulting from the conversion.
2040Constant *ConstantFoldSSEConvertToInt(const APFloat &Val, bool roundTowardZero,
2041 Type *Ty, bool IsSigned) {
2042 // All of these conversion intrinsics form an integer of at most 64bits.
2043 unsigned ResultWidth = Ty->getIntegerBitWidth();
2044 assert(ResultWidth <= 64 &&
2045 "Can only constant fold conversions to 64 and 32 bit ints");
2046
2047 uint64_t UIntVal;
2048 bool isExact = false;
2049 APFloat::roundingMode mode = roundTowardZero? APFloat::rmTowardZero
2050 : APFloat::rmNearestTiesToEven;
2052 Val.convertToInteger(MutableArrayRef(UIntVal), ResultWidth,
2053 IsSigned, mode, &isExact);
2054 if (status != APFloat::opOK &&
2055 (!roundTowardZero || status != APFloat::opInexact))
2056 return nullptr;
2057 return ConstantInt::get(Ty, UIntVal, IsSigned);
2058}
2059
2060double getValueAsDouble(ConstantFP *Op) {
2061 Type *Ty = Op->getType();
2062
2063 if (Ty->isBFloatTy() || Ty->isHalfTy() || Ty->isFloatTy() || Ty->isDoubleTy())
2064 return Op->getValueAPF().convertToDouble();
2065
2066 bool unused;
2067 APFloat APF = Op->getValueAPF();
2068 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &unused);
2069 return APF.convertToDouble();
2070}
2071
2072static bool getConstIntOrUndef(Value *Op, const APInt *&C) {
2073 if (auto *CI = dyn_cast<ConstantInt>(Op)) {
2074 C = &CI->getValue();
2075 return true;
2076 }
2077 if (isa<UndefValue>(Op)) {
2078 C = nullptr;
2079 return true;
2080 }
2081 return false;
2082}
2083
2084/// Checks if the given intrinsic call, which evaluates to constant, is allowed
2085/// to be folded.
2086///
2087/// \param CI Constrained intrinsic call.
2088/// \param St Exception flags raised during constant evaluation.
2089static bool mayFoldConstrained(ConstrainedFPIntrinsic *CI,
2090 APFloat::opStatus St) {
2091 std::optional<RoundingMode> ORM = CI->getRoundingMode();
2092 std::optional<fp::ExceptionBehavior> EB = CI->getExceptionBehavior();
2093
2094 // If the operation does not change exception status flags, it is safe
2095 // to fold.
2096 if (St == APFloat::opStatus::opOK)
2097 return true;
2098
2099 // If evaluation raised FP exception, the result can depend on rounding
2100 // mode. If the latter is unknown, folding is not possible.
2101 if (ORM && *ORM == RoundingMode::Dynamic)
2102 return false;
2103
2104 // If FP exceptions are ignored, fold the call, even if such exception is
2105 // raised.
2106 if (EB && *EB != fp::ExceptionBehavior::ebStrict)
2107 return true;
2108
2109 // Leave the calculation for runtime so that exception flags be correctly set
2110 // in hardware.
2111 return false;
2112}
2113
2114/// Returns the rounding mode that should be used for constant evaluation.
2115static RoundingMode
2116getEvaluationRoundingMode(const ConstrainedFPIntrinsic *CI) {
2117 std::optional<RoundingMode> ORM = CI->getRoundingMode();
2118 if (!ORM || *ORM == RoundingMode::Dynamic)
2119 // Even if the rounding mode is unknown, try evaluating the operation.
2120 // If it does not raise inexact exception, rounding was not applied,
2121 // so the result is exact and does not depend on rounding mode. Whether
2122 // other FP exceptions are raised, it does not depend on rounding mode.
2123 return RoundingMode::NearestTiesToEven;
2124 return *ORM;
2125}
2126
2127/// Try to constant fold llvm.canonicalize for the given caller and value.
2128static Constant *constantFoldCanonicalize(const Type *Ty, const CallBase *CI,
2129 const APFloat &Src) {
2130 // Zero, positive and negative, is always OK to fold.
2131 if (Src.isZero()) {
2132 // Get a fresh 0, since ppc_fp128 does have non-canonical zeros.
2133 return ConstantFP::get(
2134 CI->getContext(),
2135 APFloat::getZero(Src.getSemantics(), Src.isNegative()));
2136 }
2137
2138 if (!Ty->isIEEELikeFPTy())
2139 return nullptr;
2140
2141 // Zero is always canonical and the sign must be preserved.
2142 //
2143 // Denorms and nans may have special encodings, but it should be OK to fold a
2144 // totally average number.
2145 if (Src.isNormal() || Src.isInfinity())
2146 return ConstantFP::get(CI->getContext(), Src);
2147
2148 if (Src.isDenormal() && CI->getParent() && CI->getFunction()) {
2149 DenormalMode DenormMode =
2150 CI->getFunction()->getDenormalMode(Src.getSemantics());
2151
2152 if (DenormMode == DenormalMode::getIEEE())
2153 return ConstantFP::get(CI->getContext(), Src);
2154
2155 if (DenormMode.Input == DenormalMode::Dynamic)
2156 return nullptr;
2157
2158 // If we know if either input or output is flushed, we can fold.
2159 if ((DenormMode.Input == DenormalMode::Dynamic &&
2160 DenormMode.Output == DenormalMode::IEEE) ||
2161 (DenormMode.Input == DenormalMode::IEEE &&
2162 DenormMode.Output == DenormalMode::Dynamic))
2163 return nullptr;
2164
2165 bool IsPositive =
2166 (!Src.isNegative() || DenormMode.Input == DenormalMode::PositiveZero ||
2167 (DenormMode.Output == DenormalMode::PositiveZero &&
2168 DenormMode.Input == DenormalMode::IEEE));
2169
2170 return ConstantFP::get(CI->getContext(),
2171 APFloat::getZero(Src.getSemantics(), !IsPositive));
2172 }
2173
2174 return nullptr;
2175}
2176
2177static Constant *ConstantFoldScalarCall1(StringRef Name,
2178 Intrinsic::ID IntrinsicID,
2179 Type *Ty,
2181 const TargetLibraryInfo *TLI,
2182 const CallBase *Call) {
2183 assert(Operands.size() == 1 && "Wrong number of operands.");
2184
2185 if (IntrinsicID == Intrinsic::is_constant) {
2186 // We know we have a "Constant" argument. But we want to only
2187 // return true for manifest constants, not those that depend on
2188 // constants with unknowable values, e.g. GlobalValue or BlockAddress.
2189 if (Operands[0]->isManifestConstant())
2190 return ConstantInt::getTrue(Ty->getContext());
2191 return nullptr;
2192 }
2193
2194 if (isa<PoisonValue>(Operands[0])) {
2195 // TODO: All of these operations should probably propagate poison.
2196 if (IntrinsicID == Intrinsic::canonicalize)
2197 return PoisonValue::get(Ty);
2198 }
2199
2200 if (isa<UndefValue>(Operands[0])) {
2201 // cosine(arg) is between -1 and 1. cosine(invalid arg) is NaN.
2202 // ctpop() is between 0 and bitwidth, pick 0 for undef.
2203 // fptoui.sat and fptosi.sat can always fold to zero (for a zero input).
2204 if (IntrinsicID == Intrinsic::cos ||
2205 IntrinsicID == Intrinsic::ctpop ||
2206 IntrinsicID == Intrinsic::fptoui_sat ||
2207 IntrinsicID == Intrinsic::fptosi_sat ||
2208 IntrinsicID == Intrinsic::canonicalize)
2209 return Constant::getNullValue(Ty);
2210 if (IntrinsicID == Intrinsic::bswap ||
2211 IntrinsicID == Intrinsic::bitreverse ||
2212 IntrinsicID == Intrinsic::launder_invariant_group ||
2213 IntrinsicID == Intrinsic::strip_invariant_group)
2214 return Operands[0];
2215 }
2216
2217 if (isa<ConstantPointerNull>(Operands[0])) {
2218 // launder(null) == null == strip(null) iff in addrspace 0
2219 if (IntrinsicID == Intrinsic::launder_invariant_group ||
2220 IntrinsicID == Intrinsic::strip_invariant_group) {
2221 // If instruction is not yet put in a basic block (e.g. when cloning
2222 // a function during inlining), Call's caller may not be available.
2223 // So check Call's BB first before querying Call->getCaller.
2224 const Function *Caller =
2225 Call->getParent() ? Call->getCaller() : nullptr;
2226 if (Caller &&
2228 Caller, Operands[0]->getType()->getPointerAddressSpace())) {
2229 return Operands[0];
2230 }
2231 return nullptr;
2232 }
2233 }
2234
2235 if (auto *Op = dyn_cast<ConstantFP>(Operands[0])) {
2236 if (IntrinsicID == Intrinsic::convert_to_fp16) {
2237 APFloat Val(Op->getValueAPF());
2238
2239 bool lost = false;
2240 Val.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &lost);
2241
2242 return ConstantInt::get(Ty->getContext(), Val.bitcastToAPInt());
2243 }
2244
2245 APFloat U = Op->getValueAPF();
2246
2247 if (IntrinsicID == Intrinsic::wasm_trunc_signed ||
2248 IntrinsicID == Intrinsic::wasm_trunc_unsigned) {
2249 bool Signed = IntrinsicID == Intrinsic::wasm_trunc_signed;
2250
2251 if (U.isNaN())
2252 return nullptr;
2253
2254 unsigned Width = Ty->getIntegerBitWidth();
2255 APSInt Int(Width, !Signed);
2256 bool IsExact = false;
2258 U.convertToInteger(Int, APFloat::rmTowardZero, &IsExact);
2259
2260 if (Status == APFloat::opOK || Status == APFloat::opInexact)
2261 return ConstantInt::get(Ty, Int);
2262
2263 return nullptr;
2264 }
2265
2266 if (IntrinsicID == Intrinsic::fptoui_sat ||
2267 IntrinsicID == Intrinsic::fptosi_sat) {
2268 // convertToInteger() already has the desired saturation semantics.
2270 IntrinsicID == Intrinsic::fptoui_sat);
2271 bool IsExact;
2272 U.convertToInteger(Int, APFloat::rmTowardZero, &IsExact);
2273 return ConstantInt::get(Ty, Int);
2274 }
2275
2276 if (IntrinsicID == Intrinsic::canonicalize)
2277 return constantFoldCanonicalize(Ty, Call, U);
2278
2279#if defined(HAS_IEE754_FLOAT128) && defined(HAS_LOGF128)
2280 if (Ty->isFP128Ty()) {
2281 if (IntrinsicID == Intrinsic::log) {
2282 float128 Result = logf128(Op->getValueAPF().convertToQuad());
2283 return GetConstantFoldFPValue128(Result, Ty);
2284 }
2285
2286 LibFunc Fp128Func = NotLibFunc;
2287 if (TLI && TLI->getLibFunc(Name, Fp128Func) && TLI->has(Fp128Func) &&
2288 Fp128Func == LibFunc_logl)
2289 return ConstantFoldFP128(logf128, Op->getValueAPF(), Ty);
2290 }
2291#endif
2292
2293 if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy() &&
2294 !Ty->isIntegerTy())
2295 return nullptr;
2296
2297 // Use internal versions of these intrinsics.
2298
2299 if (IntrinsicID == Intrinsic::nearbyint || IntrinsicID == Intrinsic::rint) {
2300 U.roundToIntegral(APFloat::rmNearestTiesToEven);
2301 return ConstantFP::get(Ty->getContext(), U);
2302 }
2303
2304 if (IntrinsicID == Intrinsic::round) {
2305 U.roundToIntegral(APFloat::rmNearestTiesToAway);
2306 return ConstantFP::get(Ty->getContext(), U);
2307 }
2308
2309 if (IntrinsicID == Intrinsic::roundeven) {
2310 U.roundToIntegral(APFloat::rmNearestTiesToEven);
2311 return ConstantFP::get(Ty->getContext(), U);
2312 }
2313
2314 if (IntrinsicID == Intrinsic::ceil) {
2315 U.roundToIntegral(APFloat::rmTowardPositive);
2316 return ConstantFP::get(Ty->getContext(), U);
2317 }
2318
2319 if (IntrinsicID == Intrinsic::floor) {
2320 U.roundToIntegral(APFloat::rmTowardNegative);
2321 return ConstantFP::get(Ty->getContext(), U);
2322 }
2323
2324 if (IntrinsicID == Intrinsic::trunc) {
2325 U.roundToIntegral(APFloat::rmTowardZero);
2326 return ConstantFP::get(Ty->getContext(), U);
2327 }
2328
2329 if (IntrinsicID == Intrinsic::fabs) {
2330 U.clearSign();
2331 return ConstantFP::get(Ty->getContext(), U);
2332 }
2333
2334 if (IntrinsicID == Intrinsic::amdgcn_fract) {
2335 // The v_fract instruction behaves like the OpenCL spec, which defines
2336 // fract(x) as fmin(x - floor(x), 0x1.fffffep-1f): "The min() operator is
2337 // there to prevent fract(-small) from returning 1.0. It returns the
2338 // largest positive floating-point number less than 1.0."
2339 APFloat FloorU(U);
2340 FloorU.roundToIntegral(APFloat::rmTowardNegative);
2341 APFloat FractU(U - FloorU);
2342 APFloat AlmostOne(U.getSemantics(), 1);
2343 AlmostOne.next(/*nextDown*/ true);
2344 return ConstantFP::get(Ty->getContext(), minimum(FractU, AlmostOne));
2345 }
2346
2347 // Rounding operations (floor, trunc, ceil, round and nearbyint) do not
2348 // raise FP exceptions, unless the argument is signaling NaN.
2349
2350 std::optional<APFloat::roundingMode> RM;
2351 switch (IntrinsicID) {
2352 default:
2353 break;
2354 case Intrinsic::experimental_constrained_nearbyint:
2355 case Intrinsic::experimental_constrained_rint: {
2356 auto CI = cast<ConstrainedFPIntrinsic>(Call);
2357 RM = CI->getRoundingMode();
2358 if (!RM || *RM == RoundingMode::Dynamic)
2359 return nullptr;
2360 break;
2361 }
2362 case Intrinsic::experimental_constrained_round:
2363 RM = APFloat::rmNearestTiesToAway;
2364 break;
2365 case Intrinsic::experimental_constrained_ceil:
2366 RM = APFloat::rmTowardPositive;
2367 break;
2368 case Intrinsic::experimental_constrained_floor:
2369 RM = APFloat::rmTowardNegative;
2370 break;
2371 case Intrinsic::experimental_constrained_trunc:
2372 RM = APFloat::rmTowardZero;
2373 break;
2374 }
2375 if (RM) {
2376 auto CI = cast<ConstrainedFPIntrinsic>(Call);
2377 if (U.isFinite()) {
2378 APFloat::opStatus St = U.roundToIntegral(*RM);
2379 if (IntrinsicID == Intrinsic::experimental_constrained_rint &&
2380 St == APFloat::opInexact) {
2381 std::optional<fp::ExceptionBehavior> EB = CI->getExceptionBehavior();
2382 if (EB && *EB == fp::ebStrict)
2383 return nullptr;
2384 }
2385 } else if (U.isSignaling()) {
2386 std::optional<fp::ExceptionBehavior> EB = CI->getExceptionBehavior();
2387 if (EB && *EB != fp::ebIgnore)
2388 return nullptr;
2389 U = APFloat::getQNaN(U.getSemantics());
2390 }
2391 return ConstantFP::get(Ty->getContext(), U);
2392 }
2393
2394 // NVVM float/double to signed/unsigned int32/int64 conversions:
2395 switch (IntrinsicID) {
2396 // f2i
2397 case Intrinsic::nvvm_f2i_rm:
2398 case Intrinsic::nvvm_f2i_rn:
2399 case Intrinsic::nvvm_f2i_rp:
2400 case Intrinsic::nvvm_f2i_rz:
2401 case Intrinsic::nvvm_f2i_rm_ftz:
2402 case Intrinsic::nvvm_f2i_rn_ftz:
2403 case Intrinsic::nvvm_f2i_rp_ftz:
2404 case Intrinsic::nvvm_f2i_rz_ftz:
2405 // f2ui
2406 case Intrinsic::nvvm_f2ui_rm:
2407 case Intrinsic::nvvm_f2ui_rn:
2408 case Intrinsic::nvvm_f2ui_rp:
2409 case Intrinsic::nvvm_f2ui_rz:
2410 case Intrinsic::nvvm_f2ui_rm_ftz:
2411 case Intrinsic::nvvm_f2ui_rn_ftz:
2412 case Intrinsic::nvvm_f2ui_rp_ftz:
2413 case Intrinsic::nvvm_f2ui_rz_ftz:
2414 // d2i
2415 case Intrinsic::nvvm_d2i_rm:
2416 case Intrinsic::nvvm_d2i_rn:
2417 case Intrinsic::nvvm_d2i_rp:
2418 case Intrinsic::nvvm_d2i_rz:
2419 // d2ui
2420 case Intrinsic::nvvm_d2ui_rm:
2421 case Intrinsic::nvvm_d2ui_rn:
2422 case Intrinsic::nvvm_d2ui_rp:
2423 case Intrinsic::nvvm_d2ui_rz:
2424 // f2ll
2425 case Intrinsic::nvvm_f2ll_rm:
2426 case Intrinsic::nvvm_f2ll_rn:
2427 case Intrinsic::nvvm_f2ll_rp:
2428 case Intrinsic::nvvm_f2ll_rz:
2429 case Intrinsic::nvvm_f2ll_rm_ftz:
2430 case Intrinsic::nvvm_f2ll_rn_ftz:
2431 case Intrinsic::nvvm_f2ll_rp_ftz:
2432 case Intrinsic::nvvm_f2ll_rz_ftz:
2433 // f2ull
2434 case Intrinsic::nvvm_f2ull_rm:
2435 case Intrinsic::nvvm_f2ull_rn:
2436 case Intrinsic::nvvm_f2ull_rp:
2437 case Intrinsic::nvvm_f2ull_rz:
2438 case Intrinsic::nvvm_f2ull_rm_ftz:
2439 case Intrinsic::nvvm_f2ull_rn_ftz:
2440 case Intrinsic::nvvm_f2ull_rp_ftz:
2441 case Intrinsic::nvvm_f2ull_rz_ftz:
2442 // d2ll
2443 case Intrinsic::nvvm_d2ll_rm:
2444 case Intrinsic::nvvm_d2ll_rn:
2445 case Intrinsic::nvvm_d2ll_rp:
2446 case Intrinsic::nvvm_d2ll_rz:
2447 // d2ull
2448 case Intrinsic::nvvm_d2ull_rm:
2449 case Intrinsic::nvvm_d2ull_rn:
2450 case Intrinsic::nvvm_d2ull_rp:
2451 case Intrinsic::nvvm_d2ull_rz: {
2452 // In float-to-integer conversion, NaN inputs are converted to 0.
2453 if (U.isNaN())
2454 return ConstantInt::get(Ty, 0);
2455
2456 APFloat::roundingMode RMode =
2458 bool IsFTZ = nvvm::FPToIntegerIntrinsicShouldFTZ(IntrinsicID);
2459 bool IsSigned = nvvm::FPToIntegerIntrinsicResultIsSigned(IntrinsicID);
2460
2461 APSInt ResInt(Ty->getIntegerBitWidth(), !IsSigned);
2462 auto FloatToRound = IsFTZ ? FTZPreserveSign(U) : U;
2463
2464 bool IsExact = false;
2466 FloatToRound.convertToInteger(ResInt, RMode, &IsExact);
2467
2468 if (Status != APFloat::opInvalidOp)
2469 return ConstantInt::get(Ty, ResInt);
2470 return nullptr;
2471 }
2472 }
2473
2474 /// We only fold functions with finite arguments. Folding NaN and inf is
2475 /// likely to be aborted with an exception anyway, and some host libms
2476 /// have known errors raising exceptions.
2477 if (!U.isFinite())
2478 return nullptr;
2479
2480 /// Currently APFloat versions of these functions do not exist, so we use
2481 /// the host native double versions. Float versions are not called
2482 /// directly but for all these it is true (float)(f((double)arg)) ==
2483 /// f(arg). Long double not supported yet.
2484 const APFloat &APF = Op->getValueAPF();
2485
2486 switch (IntrinsicID) {
2487 default: break;
2488 case Intrinsic::log:
2489 return ConstantFoldFP(log, APF, Ty);
2490 case Intrinsic::log2:
2491 // TODO: What about hosts that lack a C99 library?
2492 return ConstantFoldFP(log2, APF, Ty);
2493 case Intrinsic::log10:
2494 // TODO: What about hosts that lack a C99 library?
2495 return ConstantFoldFP(log10, APF, Ty);
2496 case Intrinsic::exp:
2497 return ConstantFoldFP(exp, APF, Ty);
2498 case Intrinsic::exp2:
2499 // Fold exp2(x) as pow(2, x), in case the host lacks a C99 library.
2500 return ConstantFoldBinaryFP(pow, APFloat(2.0), APF, Ty);
2501 case Intrinsic::exp10:
2502 // Fold exp10(x) as pow(10, x), in case the host lacks a C99 library.
2503 return ConstantFoldBinaryFP(pow, APFloat(10.0), APF, Ty);
2504 case Intrinsic::sin:
2505 return ConstantFoldFP(sin, APF, Ty);
2506 case Intrinsic::cos:
2507 return ConstantFoldFP(cos, APF, Ty);
2508 case Intrinsic::sqrt:
2509 return ConstantFoldFP(sqrt, APF, Ty);
2510 case Intrinsic::amdgcn_cos:
2511 case Intrinsic::amdgcn_sin: {
2512 double V = getValueAsDouble(Op);
2513 if (V < -256.0 || V > 256.0)
2514 // The gfx8 and gfx9 architectures handle arguments outside the range
2515 // [-256, 256] differently. This should be a rare case so bail out
2516 // rather than trying to handle the difference.
2517 return nullptr;
2518 bool IsCos = IntrinsicID == Intrinsic::amdgcn_cos;
2519 double V4 = V * 4.0;
2520 if (V4 == floor(V4)) {
2521 // Force exact results for quarter-integer inputs.
2522 const double SinVals[4] = { 0.0, 1.0, 0.0, -1.0 };
2523 V = SinVals[((int)V4 + (IsCos ? 1 : 0)) & 3];
2524 } else {
2525 if (IsCos)
2526 V = cos(V * 2.0 * numbers::pi);
2527 else
2528 V = sin(V * 2.0 * numbers::pi);
2529 }
2530 return GetConstantFoldFPValue(V, Ty);
2531 }
2532 }
2533
2534 if (!TLI)
2535 return nullptr;
2536
2538 if (!TLI->getLibFunc(Name, Func))
2539 return nullptr;
2540
2541 switch (Func) {
2542 default:
2543 break;
2544 case LibFunc_acos:
2545 case LibFunc_acosf:
2546 case LibFunc_acos_finite:
2547 case LibFunc_acosf_finite:
2548 if (TLI->has(Func))
2549 return ConstantFoldFP(acos, APF, Ty);
2550 break;
2551 case LibFunc_asin:
2552 case LibFunc_asinf:
2553 case LibFunc_asin_finite:
2554 case LibFunc_asinf_finite:
2555 if (TLI->has(Func))
2556 return ConstantFoldFP(asin, APF, Ty);
2557 break;
2558 case LibFunc_atan:
2559 case LibFunc_atanf:
2560 if (TLI->has(Func))
2561 return ConstantFoldFP(atan, APF, Ty);
2562 break;
2563 case LibFunc_ceil:
2564 case LibFunc_ceilf:
2565 if (TLI->has(Func)) {
2566 U.roundToIntegral(APFloat::rmTowardPositive);
2567 return ConstantFP::get(Ty->getContext(), U);
2568 }
2569 break;
2570 case LibFunc_cos:
2571 case LibFunc_cosf:
2572 if (TLI->has(Func))
2573 return ConstantFoldFP(cos, APF, Ty);
2574 break;
2575 case LibFunc_cosh:
2576 case LibFunc_coshf:
2577 case LibFunc_cosh_finite:
2578 case LibFunc_coshf_finite:
2579 if (TLI->has(Func))
2580 return ConstantFoldFP(cosh, APF, Ty);
2581 break;
2582 case LibFunc_exp:
2583 case LibFunc_expf:
2584 case LibFunc_exp_finite:
2585 case LibFunc_expf_finite:
2586 if (TLI->has(Func))
2587 return ConstantFoldFP(exp, APF, Ty);
2588 break;
2589 case LibFunc_exp2:
2590 case LibFunc_exp2f:
2591 case LibFunc_exp2_finite:
2592 case LibFunc_exp2f_finite:
2593 if (TLI->has(Func))
2594 // Fold exp2(x) as pow(2, x), in case the host lacks a C99 library.
2595 return ConstantFoldBinaryFP(pow, APFloat(2.0), APF, Ty);
2596 break;
2597 case LibFunc_fabs:
2598 case LibFunc_fabsf:
2599 if (TLI->has(Func)) {
2600 U.clearSign();
2601 return ConstantFP::get(Ty->getContext(), U);
2602 }
2603 break;
2604 case LibFunc_floor:
2605 case LibFunc_floorf:
2606 if (TLI->has(Func)) {
2607 U.roundToIntegral(APFloat::rmTowardNegative);
2608 return ConstantFP::get(Ty->getContext(), U);
2609 }
2610 break;
2611 case LibFunc_log:
2612 case LibFunc_logf:
2613 case LibFunc_log_finite:
2614 case LibFunc_logf_finite:
2615 if (!APF.isNegative() && !APF.isZero() && TLI->has(Func))
2616 return ConstantFoldFP(log, APF, Ty);
2617 break;
2618 case LibFunc_log2:
2619 case LibFunc_log2f:
2620 case LibFunc_log2_finite:
2621 case LibFunc_log2f_finite:
2622 if (!APF.isNegative() && !APF.isZero() && TLI->has(Func))
2623 // TODO: What about hosts that lack a C99 library?
2624 return ConstantFoldFP(log2, APF, Ty);
2625 break;
2626 case LibFunc_log10:
2627 case LibFunc_log10f:
2628 case LibFunc_log10_finite:
2629 case LibFunc_log10f_finite:
2630 if (!APF.isNegative() && !APF.isZero() && TLI->has(Func))
2631 // TODO: What about hosts that lack a C99 library?
2632 return ConstantFoldFP(log10, APF, Ty);
2633 break;
2634 case LibFunc_ilogb:
2635 case LibFunc_ilogbf:
2636 if (!APF.isZero() && TLI->has(Func))
2637 return ConstantInt::get(Ty, ilogb(APF), true);
2638 break;
2639 case LibFunc_logb:
2640 case LibFunc_logbf:
2641 if (!APF.isZero() && TLI->has(Func))
2642 return ConstantFoldFP(logb, APF, Ty);
2643 break;
2644 case LibFunc_log1p:
2645 case LibFunc_log1pf:
2646 // Implement optional behavior from C's Annex F for +/-0.0.
2647 if (U.isZero())
2648 return ConstantFP::get(Ty->getContext(), U);
2649 if (APF > APFloat::getOne(APF.getSemantics(), true) && TLI->has(Func))
2650 return ConstantFoldFP(log1p, APF, Ty);
2651 break;
2652 case LibFunc_logl:
2653 return nullptr;
2654 case LibFunc_erf:
2655 case LibFunc_erff:
2656 if (TLI->has(Func))
2657 return ConstantFoldFP(erf, APF, Ty);
2658 break;
2659 case LibFunc_nearbyint:
2660 case LibFunc_nearbyintf:
2661 case LibFunc_rint:
2662 case LibFunc_rintf:
2663 if (TLI->has(Func)) {
2664 U.roundToIntegral(APFloat::rmNearestTiesToEven);
2665 return ConstantFP::get(Ty->getContext(), U);
2666 }
2667 break;
2668 case LibFunc_round:
2669 case LibFunc_roundf:
2670 if (TLI->has(Func)) {
2671 U.roundToIntegral(APFloat::rmNearestTiesToAway);
2672 return ConstantFP::get(Ty->getContext(), U);
2673 }
2674 break;
2675 case LibFunc_sin:
2676 case LibFunc_sinf:
2677 if (TLI->has(Func))
2678 return ConstantFoldFP(sin, APF, Ty);
2679 break;
2680 case LibFunc_sinh:
2681 case LibFunc_sinhf:
2682 case LibFunc_sinh_finite:
2683 case LibFunc_sinhf_finite:
2684 if (TLI->has(Func))
2685 return ConstantFoldFP(sinh, APF, Ty);
2686 break;
2687 case LibFunc_sqrt:
2688 case LibFunc_sqrtf:
2689 if (!APF.isNegative() && TLI->has(Func))
2690 return ConstantFoldFP(sqrt, APF, Ty);
2691 break;
2692 case LibFunc_tan:
2693 case LibFunc_tanf:
2694 if (TLI->has(Func))
2695 return ConstantFoldFP(tan, APF, Ty);
2696 break;
2697 case LibFunc_tanh:
2698 case LibFunc_tanhf:
2699 if (TLI->has(Func))
2700 return ConstantFoldFP(tanh, APF, Ty);
2701 break;
2702 case LibFunc_trunc:
2703 case LibFunc_truncf:
2704 if (TLI->has(Func)) {
2705 U.roundToIntegral(APFloat::rmTowardZero);
2706 return ConstantFP::get(Ty->getContext(), U);
2707 }
2708 break;
2709 }
2710 return nullptr;
2711 }
2712
2713 if (auto *Op = dyn_cast<ConstantInt>(Operands[0])) {
2714 switch (IntrinsicID) {
2715 case Intrinsic::bswap:
2716 return ConstantInt::get(Ty->getContext(), Op->getValue().byteSwap());
2717 case Intrinsic::ctpop:
2718 return ConstantInt::get(Ty, Op->getValue().popcount());
2719 case Intrinsic::bitreverse:
2720 return ConstantInt::get(Ty->getContext(), Op->getValue().reverseBits());
2721 case Intrinsic::convert_from_fp16: {
2722 APFloat Val(APFloat::IEEEhalf(), Op->getValue());
2723
2724 bool lost = false;
2726 Ty->getFltSemantics(), APFloat::rmNearestTiesToEven, &lost);
2727
2728 // Conversion is always precise.
2729 (void)status;
2730 assert(status != APFloat::opInexact && !lost &&
2731 "Precision lost during fp16 constfolding");
2732
2733 return ConstantFP::get(Ty->getContext(), Val);
2734 }
2735
2736 case Intrinsic::amdgcn_s_wqm: {
2737 uint64_t Val = Op->getZExtValue();
2738 Val |= (Val & 0x5555555555555555ULL) << 1 |
2739 ((Val >> 1) & 0x5555555555555555ULL);
2740 Val |= (Val & 0x3333333333333333ULL) << 2 |
2741 ((Val >> 2) & 0x3333333333333333ULL);
2742 return ConstantInt::get(Ty, Val);
2743 }
2744
2745 case Intrinsic::amdgcn_s_quadmask: {
2746 uint64_t Val = Op->getZExtValue();
2747 uint64_t QuadMask = 0;
2748 for (unsigned I = 0; I < Op->getBitWidth() / 4; ++I, Val >>= 4) {
2749 if (!(Val & 0xF))
2750 continue;
2751
2752 QuadMask |= (1ULL << I);
2753 }
2754 return ConstantInt::get(Ty, QuadMask);
2755 }
2756
2757 case Intrinsic::amdgcn_s_bitreplicate: {
2758 uint64_t Val = Op->getZExtValue();
2759 Val = (Val & 0x000000000000FFFFULL) | (Val & 0x00000000FFFF0000ULL) << 16;
2760 Val = (Val & 0x000000FF000000FFULL) | (Val & 0x0000FF000000FF00ULL) << 8;
2761 Val = (Val & 0x000F000F000F000FULL) | (Val & 0x00F000F000F000F0ULL) << 4;
2762 Val = (Val & 0x0303030303030303ULL) | (Val & 0x0C0C0C0C0C0C0C0CULL) << 2;
2763 Val = (Val & 0x1111111111111111ULL) | (Val & 0x2222222222222222ULL) << 1;
2764 Val = Val | Val << 1;
2765 return ConstantInt::get(Ty, Val);
2766 }
2767
2768 default:
2769 return nullptr;
2770 }
2771 }
2772
2773 switch (IntrinsicID) {
2774 default: break;
2775 case Intrinsic::vector_reduce_add:
2776 case Intrinsic::vector_reduce_mul:
2777 case Intrinsic::vector_reduce_and:
2778 case Intrinsic::vector_reduce_or:
2779 case Intrinsic::vector_reduce_xor:
2780 case Intrinsic::vector_reduce_smin:
2781 case Intrinsic::vector_reduce_smax:
2782 case Intrinsic::vector_reduce_umin:
2783 case Intrinsic::vector_reduce_umax:
2784 if (Constant *C = constantFoldVectorReduce(IntrinsicID, Operands[0]))
2785 return C;
2786 break;
2787 }
2788
2789 // Support ConstantVector in case we have an Undef in the top.
2790 if (isa<ConstantVector>(Operands[0]) ||
2791 isa<ConstantDataVector>(Operands[0])) {
2792 auto *Op = cast<Constant>(Operands[0]);
2793 switch (IntrinsicID) {
2794 default: break;
2795 case Intrinsic::x86_sse_cvtss2si:
2796 case Intrinsic::x86_sse_cvtss2si64:
2797 case Intrinsic::x86_sse2_cvtsd2si:
2798 case Intrinsic::x86_sse2_cvtsd2si64:
2799 if (ConstantFP *FPOp =
2800 dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U)))
2801 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
2802 /*roundTowardZero=*/false, Ty,
2803 /*IsSigned*/true);
2804 break;
2805 case Intrinsic::x86_sse_cvttss2si:
2806 case Intrinsic::x86_sse_cvttss2si64:
2807 case Intrinsic::x86_sse2_cvttsd2si:
2808 case Intrinsic::x86_sse2_cvttsd2si64:
2809 if (ConstantFP *FPOp =
2810 dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U)))
2811 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
2812 /*roundTowardZero=*/true, Ty,
2813 /*IsSigned*/true);
2814 break;
2815 }
2816 }
2817
2818 return nullptr;
2819}
2820
2821static Constant *evaluateCompare(const APFloat &Op1, const APFloat &Op2,
2822 const ConstrainedFPIntrinsic *Call) {
2823 APFloat::opStatus St = APFloat::opOK;
2824 auto *FCmp = cast<ConstrainedFPCmpIntrinsic>(Call);
2825 FCmpInst::Predicate Cond = FCmp->getPredicate();
2826 if (FCmp->isSignaling()) {
2827 if (Op1.isNaN() || Op2.isNaN())
2828 St = APFloat::opInvalidOp;
2829 } else {
2830 if (Op1.isSignaling() || Op2.isSignaling())
2831 St = APFloat::opInvalidOp;
2832 }
2833 bool Result = FCmpInst::compare(Op1, Op2, Cond);
2834 if (mayFoldConstrained(const_cast<ConstrainedFPCmpIntrinsic *>(FCmp), St))
2835 return ConstantInt::get(Call->getType()->getScalarType(), Result);
2836 return nullptr;
2837}
2838
2839static Constant *ConstantFoldLibCall2(StringRef Name, Type *Ty,
2841 const TargetLibraryInfo *TLI) {
2842 if (!TLI)
2843 return nullptr;
2844
2846 if (!TLI->getLibFunc(Name, Func))
2847 return nullptr;
2848
2849 const auto *Op1 = dyn_cast<ConstantFP>(Operands[0]);
2850 if (!Op1)
2851 return nullptr;
2852
2853 const auto *Op2 = dyn_cast<ConstantFP>(Operands[1]);
2854 if (!Op2)
2855 return nullptr;
2856
2857 const APFloat &Op1V = Op1->getValueAPF();
2858 const APFloat &Op2V = Op2->getValueAPF();
2859
2860 switch (Func) {
2861 default:
2862 break;
2863 case LibFunc_pow:
2864 case LibFunc_powf:
2865 case LibFunc_pow_finite:
2866 case LibFunc_powf_finite:
2867 if (TLI->has(Func))
2868 return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
2869 break;
2870 case LibFunc_fmod:
2871 case LibFunc_fmodf:
2872 if (TLI->has(Func)) {
2873 APFloat V = Op1->getValueAPF();
2874 if (APFloat::opStatus::opOK == V.mod(Op2->getValueAPF()))
2875 return ConstantFP::get(Ty->getContext(), V);
2876 }
2877 break;
2878 case LibFunc_remainder:
2879 case LibFunc_remainderf:
2880 if (TLI->has(Func)) {
2881 APFloat V = Op1->getValueAPF();
2882 if (APFloat::opStatus::opOK == V.remainder(Op2->getValueAPF()))
2883 return ConstantFP::get(Ty->getContext(), V);
2884 }
2885 break;
2886 case LibFunc_atan2:
2887 case LibFunc_atan2f:
2888 // atan2(+/-0.0, +/-0.0) is known to raise an exception on some libm
2889 // (Solaris), so we do not assume a known result for that.
2890 if (Op1V.isZero() && Op2V.isZero())
2891 return nullptr;
2892 [[fallthrough]];
2893 case LibFunc_atan2_finite:
2894 case LibFunc_atan2f_finite:
2895 if (TLI->has(Func))
2896 return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty);
2897 break;
2898 }
2899
2900 return nullptr;
2901}
2902
2903static Constant *ConstantFoldIntrinsicCall2(Intrinsic::ID IntrinsicID, Type *Ty,
2905 const CallBase *Call) {
2906 assert(Operands.size() == 2 && "Wrong number of operands.");
2907
2908 if (Ty->isFloatingPointTy()) {
2909 // TODO: We should have undef handling for all of the FP intrinsics that
2910 // are attempted to be folded in this function.
2911 bool IsOp0Undef = isa<UndefValue>(Operands[0]);
2912 bool IsOp1Undef = isa<UndefValue>(Operands[1]);
2913 switch (IntrinsicID) {
2914 case Intrinsic::maxnum:
2915 case Intrinsic::minnum:
2916 case Intrinsic::maximum:
2917 case Intrinsic::minimum:
2918 case Intrinsic::nvvm_fmax_d:
2919 case Intrinsic::nvvm_fmin_d:
2920 // If one argument is undef, return the other argument.
2921 if (IsOp0Undef)
2922 return Operands[1];
2923 if (IsOp1Undef)
2924 return Operands[0];
2925 break;
2926
2927 case Intrinsic::nvvm_fmax_f:
2928 case Intrinsic::nvvm_fmax_ftz_f:
2929 case Intrinsic::nvvm_fmax_ftz_nan_f:
2930 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
2931 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
2932 case Intrinsic::nvvm_fmax_nan_f:
2933 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
2934 case Intrinsic::nvvm_fmax_xorsign_abs_f:
2935
2936 case Intrinsic::nvvm_fmin_f:
2937 case Intrinsic::nvvm_fmin_ftz_f:
2938 case Intrinsic::nvvm_fmin_ftz_nan_f:
2939 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:
2940 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:
2941 case Intrinsic::nvvm_fmin_nan_f:
2942 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:
2943 case Intrinsic::nvvm_fmin_xorsign_abs_f:
2944 // If one arg is undef, the other arg can be returned only if it is
2945 // constant, as we may need to flush it to sign-preserving zero or
2946 // canonicalize the NaN.
2947 if (!IsOp0Undef && !IsOp1Undef)
2948 break;
2949 if (auto *Op = dyn_cast<ConstantFP>(Operands[IsOp0Undef ? 1 : 0])) {
2950 if (Op->isNaN()) {
2951 APInt NVCanonicalNaN(32, 0x7fffffff);
2952 return ConstantFP::get(
2953 Ty, APFloat(Ty->getFltSemantics(), NVCanonicalNaN));
2954 }
2955 if (nvvm::FMinFMaxShouldFTZ(IntrinsicID))
2956 return ConstantFP::get(Ty, FTZPreserveSign(Op->getValueAPF()));
2957 else
2958 return Op;
2959 }
2960 break;
2961 }
2962 }
2963
2964 if (const auto *Op1 = dyn_cast<ConstantFP>(Operands[0])) {
2965 const APFloat &Op1V = Op1->getValueAPF();
2966
2967 if (const auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
2968 if (Op2->getType() != Op1->getType())
2969 return nullptr;
2970 const APFloat &Op2V = Op2->getValueAPF();
2971
2972 if (const auto *ConstrIntr =
2973 dyn_cast_if_present<ConstrainedFPIntrinsic>(Call)) {
2974 RoundingMode RM = getEvaluationRoundingMode(ConstrIntr);
2975 APFloat Res = Op1V;
2977 switch (IntrinsicID) {
2978 default:
2979 return nullptr;
2980 case Intrinsic::experimental_constrained_fadd:
2981 St = Res.add(Op2V, RM);
2982 break;
2983 case Intrinsic::experimental_constrained_fsub:
2984 St = Res.subtract(Op2V, RM);
2985 break;
2986 case Intrinsic::experimental_constrained_fmul:
2987 St = Res.multiply(Op2V, RM);
2988 break;
2989 case Intrinsic::experimental_constrained_fdiv:
2990 St = Res.divide(Op2V, RM);
2991 break;
2992 case Intrinsic::experimental_constrained_frem:
2993 St = Res.mod(Op2V);
2994 break;
2995 case Intrinsic::experimental_constrained_fcmp:
2996 case Intrinsic::experimental_constrained_fcmps:
2997 return evaluateCompare(Op1V, Op2V, ConstrIntr);
2998 }
2999 if (mayFoldConstrained(const_cast<ConstrainedFPIntrinsic *>(ConstrIntr),
3000 St))
3001 return ConstantFP::get(Ty->getContext(), Res);
3002 return nullptr;
3003 }
3004
3005 switch (IntrinsicID) {
3006 default:
3007 break;
3008 case Intrinsic::copysign:
3009 return ConstantFP::get(Ty->getContext(), APFloat::copySign(Op1V, Op2V));
3010 case Intrinsic::minnum:
3011 return ConstantFP::get(Ty->getContext(), minnum(Op1V, Op2V));
3012 case Intrinsic::maxnum:
3013 return ConstantFP::get(Ty->getContext(), maxnum(Op1V, Op2V));
3014 case Intrinsic::minimum:
3015 return ConstantFP::get(Ty->getContext(), minimum(Op1V, Op2V));
3016 case Intrinsic::maximum:
3017 return ConstantFP::get(Ty->getContext(), maximum(Op1V, Op2V));
3018
3019 case Intrinsic::nvvm_fmax_d:
3020 case Intrinsic::nvvm_fmax_f:
3021 case Intrinsic::nvvm_fmax_ftz_f:
3022 case Intrinsic::nvvm_fmax_ftz_nan_f:
3023 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
3024 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
3025 case Intrinsic::nvvm_fmax_nan_f:
3026 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
3027 case Intrinsic::nvvm_fmax_xorsign_abs_f:
3028
3029 case Intrinsic::nvvm_fmin_d:
3030 case Intrinsic::nvvm_fmin_f:
3031 case Intrinsic::nvvm_fmin_ftz_f:
3032 case Intrinsic::nvvm_fmin_ftz_nan_f:
3033 case Intrinsic::nvvm_fmin_ftz_nan_xorsign_abs_f:
3034 case Intrinsic::nvvm_fmin_ftz_xorsign_abs_f:
3035 case Intrinsic::nvvm_fmin_nan_f:
3036 case Intrinsic::nvvm_fmin_nan_xorsign_abs_f:
3037 case Intrinsic::nvvm_fmin_xorsign_abs_f: {
3038
3039 bool ShouldCanonicalizeNaNs = !(IntrinsicID == Intrinsic::nvvm_fmax_d ||
3040 IntrinsicID == Intrinsic::nvvm_fmin_d);
3041 bool IsFTZ = nvvm::FMinFMaxShouldFTZ(IntrinsicID);
3042 bool IsNaNPropagating = nvvm::FMinFMaxPropagatesNaNs(IntrinsicID);
3043 bool IsXorSignAbs = nvvm::FMinFMaxIsXorSignAbs(IntrinsicID);
3044
3045 APFloat A = IsFTZ ? FTZPreserveSign(Op1V) : Op1V;
3046 APFloat B = IsFTZ ? FTZPreserveSign(Op2V) : Op2V;
3047
3048 bool XorSign = false;
3049 if (IsXorSignAbs) {
3050 XorSign = A.isNegative() ^ B.isNegative();
3051 A = abs(A);
3052 B = abs(B);
3053 }
3054
3055 bool IsFMax = false;
3056 switch (IntrinsicID) {
3057 case Intrinsic::nvvm_fmax_d:
3058 case Intrinsic::nvvm_fmax_f:
3059 case Intrinsic::nvvm_fmax_ftz_f:
3060 case Intrinsic::nvvm_fmax_ftz_nan_f:
3061 case Intrinsic::nvvm_fmax_ftz_nan_xorsign_abs_f:
3062 case Intrinsic::nvvm_fmax_ftz_xorsign_abs_f:
3063 case Intrinsic::nvvm_fmax_nan_f:
3064 case Intrinsic::nvvm_fmax_nan_xorsign_abs_f:
3065 case Intrinsic::nvvm_fmax_xorsign_abs_f:
3066 IsFMax = true;
3067 break;
3068 }
3069 APFloat Res = IsFMax ? maximum(A, B) : minimum(A, B);
3070
3071 if (ShouldCanonicalizeNaNs) {
3072 APFloat NVCanonicalNaN(Res.getSemantics(), APInt(32, 0x7fffffff));
3073 if (A.isNaN() && B.isNaN())
3074 return ConstantFP::get(Ty, NVCanonicalNaN);
3075 else if (IsNaNPropagating && (A.isNaN() || B.isNaN()))
3076 return ConstantFP::get(Ty, NVCanonicalNaN);
3077 }
3078
3079 if (A.isNaN() && B.isNaN())
3080 return Operands[1];
3081 else if (A.isNaN())
3082 Res = B;
3083 else if (B.isNaN())
3084 Res = A;
3085
3086 if (IsXorSignAbs && XorSign != Res.isNegative())
3087 Res.changeSign();
3088
3089 return ConstantFP::get(Ty->getContext(), Res);
3090 }
3091 }
3092
3093 if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy())
3094 return nullptr;
3095
3096 switch (IntrinsicID) {
3097 default:
3098 break;
3099 case Intrinsic::pow:
3100 return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
3101 case Intrinsic::amdgcn_fmul_legacy:
3102 // The legacy behaviour is that multiplying +/- 0.0 by anything, even
3103 // NaN or infinity, gives +0.0.
3104 if (Op1V.isZero() || Op2V.isZero())
3105 return ConstantFP::getZero(Ty);
3106 return ConstantFP::get(Ty->getContext(), Op1V * Op2V);
3107 }
3108
3109 } else if (auto *Op2C = dyn_cast<ConstantInt>(Operands[1])) {
3110 switch (IntrinsicID) {
3111 case Intrinsic::ldexp: {
3112 return ConstantFP::get(
3113 Ty->getContext(),
3114 scalbn(Op1V, Op2C->getSExtValue(), APFloat::rmNearestTiesToEven));
3115 }
3116 case Intrinsic::is_fpclass: {
3117 FPClassTest Mask = static_cast<FPClassTest>(Op2C->getZExtValue());
3118 bool Result =
3119 ((Mask & fcSNan) && Op1V.isNaN() && Op1V.isSignaling()) ||
3120 ((Mask & fcQNan) && Op1V.isNaN() && !Op1V.isSignaling()) ||
3121 ((Mask & fcNegInf) && Op1V.isNegInfinity()) ||
3122 ((Mask & fcNegNormal) && Op1V.isNormal() && Op1V.isNegative()) ||
3123 ((Mask & fcNegSubnormal) && Op1V.isDenormal() && Op1V.isNegative()) ||
3124 ((Mask & fcNegZero) && Op1V.isZero() && Op1V.isNegative()) ||
3125 ((Mask & fcPosZero) && Op1V.isZero() && !Op1V.isNegative()) ||
3126 ((Mask & fcPosSubnormal) && Op1V.isDenormal() && !Op1V.isNegative()) ||
3127 ((Mask & fcPosNormal) && Op1V.isNormal() && !Op1V.isNegative()) ||
3128 ((Mask & fcPosInf) && Op1V.isPosInfinity());
3129 return ConstantInt::get(Ty, Result);
3130 }
3131 case Intrinsic::powi: {
3132 int Exp = static_cast<int>(Op2C->getSExtValue());
3133 switch (Ty->getTypeID()) {
3134 case Type::HalfTyID:
3135 case Type::FloatTyID: {
3136 APFloat Res(static_cast<float>(std::pow(Op1V.convertToFloat(), Exp)));
3137 if (Ty->isHalfTy()) {
3138 bool Unused;
3139 Res.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
3140 &Unused);
3141 }
3142 return ConstantFP::get(Ty->getContext(), Res);
3143 }
3144 case Type::DoubleTyID:
3145 return ConstantFP::get(Ty, std::pow(Op1V.convertToDouble(), Exp));
3146 default:
3147 return nullptr;
3148 }
3149 }
3150 default:
3151 break;
3152 }
3153 }
3154 return nullptr;
3155 }
3156
3157 if (Operands[0]->getType()->isIntegerTy() &&
3158 Operands[1]->getType()->isIntegerTy()) {
3159 const APInt *C0, *C1;
3160 if (!getConstIntOrUndef(Operands[0], C0) ||
3161 !getConstIntOrUndef(Operands[1], C1))
3162 return nullptr;
3163
3164 switch (IntrinsicID) {
3165 default: break;
3166 case Intrinsic::smax:
3167 case Intrinsic::smin:
3168 case Intrinsic::umax:
3169 case Intrinsic::umin:
3170 // This is the same as for binary ops - poison propagates.
3171 // TODO: Poison handling should be consolidated.
3172 if (isa<PoisonValue>(Operands[0]) || isa<PoisonValue>(Operands[1]))
3173 return PoisonValue::get(Ty);
3174
3175 if (!C0 && !C1)
3176 return UndefValue::get(Ty);
3177 if (!C0 || !C1)
3178 return MinMaxIntrinsic::getSaturationPoint(IntrinsicID, Ty);
3179 return ConstantInt::get(
3180 Ty, ICmpInst::compare(*C0, *C1,
3181 MinMaxIntrinsic::getPredicate(IntrinsicID))
3182 ? *C0
3183 : *C1);
3184
3185 case Intrinsic::scmp:
3186 case Intrinsic::ucmp:
3187 if (isa<PoisonValue>(Operands[0]) || isa<PoisonValue>(Operands[1]))
3188 return PoisonValue::get(Ty);
3189
3190 if (!C0 || !C1)
3191 return ConstantInt::get(Ty, 0);
3192
3193 int Res;
3194 if (IntrinsicID == Intrinsic::scmp)
3195 Res = C0->sgt(*C1) ? 1 : C0->slt(*C1) ? -1 : 0;
3196 else
3197 Res = C0->ugt(*C1) ? 1 : C0->ult(*C1) ? -1 : 0;
3198 return ConstantInt::get(Ty, Res, /*IsSigned=*/true);
3199
3200 case Intrinsic::usub_with_overflow:
3201 case Intrinsic::ssub_with_overflow:
3202 // X - undef -> { 0, false }
3203 // undef - X -> { 0, false }
3204 if (!C0 || !C1)
3205 return Constant::getNullValue(Ty);
3206 [[fallthrough]];
3207 case Intrinsic::uadd_with_overflow:
3208 case Intrinsic::sadd_with_overflow:
3209 // X + undef -> { -1, false }
3210 // undef + x -> { -1, false }
3211 if (!C0 || !C1) {
3212 return ConstantStruct::get(
3213 cast<StructType>(Ty),
3216 }
3217 [[fallthrough]];
3218 case Intrinsic::smul_with_overflow:
3219 case Intrinsic::umul_with_overflow: {
3220 // undef * X -> { 0, false }
3221 // X * undef -> { 0, false }
3222 if (!C0 || !C1)
3223 return Constant::getNullValue(Ty);
3224
3225 APInt Res;
3226 bool Overflow;
3227 switch (IntrinsicID) {
3228 default: llvm_unreachable("Invalid case");
3229 case Intrinsic::sadd_with_overflow:
3230 Res = C0->sadd_ov(*C1, Overflow);
3231 break;
3232 case Intrinsic::uadd_with_overflow:
3233 Res = C0->uadd_ov(*C1, Overflow);
3234 break;
3235 case Intrinsic::ssub_with_overflow:
3236 Res = C0->ssub_ov(*C1, Overflow);
3237 break;
3238 case Intrinsic::usub_with_overflow:
3239 Res = C0->usub_ov(*C1, Overflow);
3240 break;
3241 case Intrinsic::smul_with_overflow:
3242 Res = C0->smul_ov(*C1, Overflow);
3243 break;
3244 case Intrinsic::umul_with_overflow:
3245 Res = C0->umul_ov(*C1, Overflow);
3246 break;
3247 }
3248 Constant *Ops[] = {
3249 ConstantInt::get(Ty->getContext(), Res),
3250 ConstantInt::get(Type::getInt1Ty(Ty->getContext()), Overflow)
3251 };
3252 return ConstantStruct::get(cast<StructType>(Ty), Ops);
3253 }
3254 case Intrinsic::uadd_sat:
3255 case Intrinsic::sadd_sat:
3256 // This is the same as for binary ops - poison propagates.
3257 // TODO: Poison handling should be consolidated.
3258 if (isa<PoisonValue>(Operands[0]) || isa<PoisonValue>(Operands[1]))
3259 return PoisonValue::get(Ty);
3260
3261 if (!C0 && !C1)
3262 return UndefValue::get(Ty);
3263 if (!C0 || !C1)
3264 return Constant::getAllOnesValue(Ty);
3265 if (IntrinsicID == Intrinsic::uadd_sat)
3266 return ConstantInt::get(Ty, C0->uadd_sat(*C1));
3267 else
3268 return ConstantInt::get(Ty, C0->sadd_sat(*C1));
3269 case Intrinsic::usub_sat:
3270 case Intrinsic::ssub_sat:
3271 // This is the same as for binary ops - poison propagates.
3272 // TODO: Poison handling should be consolidated.
3273 if (isa<PoisonValue>(Operands[0]) || isa<PoisonValue>(Operands[1]))
3274 return PoisonValue::get(Ty);
3275
3276 if (!C0 && !C1)
3277 return UndefValue::get(Ty);
3278 if (!C0 || !C1)
3279 return Constant::getNullValue(Ty);
3280 if (IntrinsicID == Intrinsic::usub_sat)
3281 return ConstantInt::get(Ty, C0->usub_sat(*C1));
3282 else
3283 return ConstantInt::get(Ty, C0->ssub_sat(*C1));
3284 case Intrinsic::cttz:
3285 case Intrinsic::ctlz:
3286 assert(C1 && "Must be constant int");
3287
3288 // cttz(0, 1) and ctlz(0, 1) are poison.
3289 if (C1->isOne() && (!C0 || C0->isZero()))
3290 return PoisonValue::get(Ty);
3291 if (!C0)
3292 return Constant::getNullValue(Ty);
3293 if (IntrinsicID == Intrinsic::cttz)
3294 return ConstantInt::get(Ty, C0->countr_zero());
3295 else
3296 return ConstantInt::get(Ty, C0->countl_zero());
3297
3298 case Intrinsic::abs:
3299 assert(C1 && "Must be constant int");
3300 assert((C1->isOne() || C1->isZero()) && "Must be 0 or 1");
3301
3302 // Undef or minimum val operand with poison min --> poison
3303 if (C1->isOne() && (!C0 || C0->isMinSignedValue()))
3304 return PoisonValue::get(Ty);
3305
3306 // Undef operand with no poison min --> 0 (sign bit must be clear)
3307 if (!C0)
3308 return Constant::getNullValue(Ty);
3309
3310 return ConstantInt::get(Ty, C0->abs());
3311 case Intrinsic::amdgcn_wave_reduce_umin:
3312 case Intrinsic::amdgcn_wave_reduce_umax:
3313 return dyn_cast<Constant>(Operands[0]);
3314 }
3315
3316 return nullptr;
3317 }
3318
3319 // Support ConstantVector in case we have an Undef in the top.
3320 if ((isa<ConstantVector>(Operands[0]) ||
3321 isa<ConstantDataVector>(Operands[0])) &&
3322 // Check for default rounding mode.
3323 // FIXME: Support other rounding modes?
3324 isa<ConstantInt>(Operands[1]) &&
3325 cast<ConstantInt>(Operands[1])->getValue() == 4) {
3326 auto *Op = cast<Constant>(Operands[0]);
3327 switch (IntrinsicID) {
3328 default: break;
3329 case Intrinsic::x86_avx512_vcvtss2si32:
3330 case Intrinsic::x86_avx512_vcvtss2si64:
3331 case Intrinsic::x86_avx512_vcvtsd2si32:
3332 case Intrinsic::x86_avx512_vcvtsd2si64:
3333 if (ConstantFP *FPOp =
3334 dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U)))
3335 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
3336 /*roundTowardZero=*/false, Ty,
3337 /*IsSigned*/true);
3338 break;
3339 case Intrinsic::x86_avx512_vcvtss2usi32:
3340 case Intrinsic::x86_avx512_vcvtss2usi64:
3341 case Intrinsic::x86_avx512_vcvtsd2usi32:
3342 case Intrinsic::x86_avx512_vcvtsd2usi64:
3343 if (ConstantFP *FPOp =
3344 dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U)))
3345 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
3346 /*roundTowardZero=*/false, Ty,
3347 /*IsSigned*/false);
3348 break;
3349 case Intrinsic::x86_avx512_cvttss2si:
3350 case Intrinsic::x86_avx512_cvttss2si64:
3351 case Intrinsic::x86_avx512_cvttsd2si:
3352 case Intrinsic::x86_avx512_cvttsd2si64:
3353 if (ConstantFP *FPOp =
3354 dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U)))
3355 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
3356 /*roundTowardZero=*/true, Ty,
3357 /*IsSigned*/true);
3358 break;
3359 case Intrinsic::x86_avx512_cvttss2usi:
3360 case Intrinsic::x86_avx512_cvttss2usi64:
3361 case Intrinsic::x86_avx512_cvttsd2usi:
3362 case Intrinsic::x86_avx512_cvttsd2usi64:
3363 if (ConstantFP *FPOp =
3364 dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U)))
3365 return ConstantFoldSSEConvertToInt(FPOp->getValueAPF(),
3366 /*roundTowardZero=*/true, Ty,
3367 /*IsSigned*/false);
3368 break;
3369 }
3370 }
3371 return nullptr;
3372}
3373
3374static APFloat ConstantFoldAMDGCNCubeIntrinsic(Intrinsic::ID IntrinsicID,
3375 const APFloat &S0,
3376 const APFloat &S1,
3377 const APFloat &S2) {
3378 unsigned ID;
3379 const fltSemantics &Sem = S0.getSemantics();
3380 APFloat MA(Sem), SC(Sem), TC(Sem);
3381 if (abs(S2) >= abs(S0) && abs(S2) >= abs(S1)) {
3382 if (S2.isNegative() && S2.isNonZero() && !S2.isNaN()) {
3383 // S2 < 0
3384 ID = 5;
3385 SC = -S0;
3386 } else {
3387 ID = 4;
3388 SC = S0;
3389 }
3390 MA = S2;
3391 TC = -S1;
3392 } else if (abs(S1) >= abs(S0)) {
3393 if (S1.isNegative() && S1.isNonZero() && !S1.isNaN()) {
3394 // S1 < 0
3395 ID = 3;
3396 TC = -S2;
3397 } else {
3398 ID = 2;
3399 TC = S2;
3400 }
3401 MA = S1;
3402 SC = S0;
3403 } else {
3404 if (S0.isNegative() && S0.isNonZero() && !S0.isNaN()) {
3405 // S0 < 0
3406 ID = 1;
3407 SC = S2;
3408 } else {
3409 ID = 0;
3410 SC = -S2;
3411 }
3412 MA = S0;
3413 TC = -S1;
3414 }
3415 switch (IntrinsicID) {
3416 default:
3417 llvm_unreachable("unhandled amdgcn cube intrinsic");
3418 case Intrinsic::amdgcn_cubeid:
3419 return APFloat(Sem, ID);
3420 case Intrinsic::amdgcn_cubema:
3421 return MA + MA;
3422 case Intrinsic::amdgcn_cubesc:
3423 return SC;
3424 case Intrinsic::amdgcn_cubetc:
3425 return TC;
3426 }
3427}
3428
3429static Constant *ConstantFoldAMDGCNPermIntrinsic(ArrayRef<Constant *> Operands,
3430 Type *Ty) {
3431 const APInt *C0, *C1, *C2;
3432 if (!getConstIntOrUndef(Operands[0], C0) ||
3433 !getConstIntOrUndef(Operands[1], C1) ||
3434 !getConstIntOrUndef(Operands[2], C2))
3435 return nullptr;
3436
3437 if (!C2)
3438 return UndefValue::get(Ty);
3439
3440 APInt Val(32, 0);
3441 unsigned NumUndefBytes = 0;
3442 for (unsigned I = 0; I < 32; I += 8) {
3443 unsigned Sel = C2->extractBitsAsZExtValue(8, I);
3444 unsigned B = 0;
3445
3446 if (Sel >= 13)
3447 B = 0xff;
3448 else if (Sel == 12)
3449 B = 0x00;
3450 else {
3451 const APInt *Src = ((Sel & 10) == 10 || (Sel & 12) == 4) ? C0 : C1;
3452 if (!Src)
3453 ++NumUndefBytes;
3454 else if (Sel < 8)
3455 B = Src->extractBitsAsZExtValue(8, (Sel & 3) * 8);
3456 else
3457 B = Src->extractBitsAsZExtValue(1, (Sel & 1) ? 31 : 15) * 0xff;
3458 }
3459
3460 Val.insertBits(B, I, 8);
3461 }
3462
3463 if (NumUndefBytes == 4)
3464 return UndefValue::get(Ty);
3465
3466 return ConstantInt::get(Ty, Val);
3467}
3468
3469static Constant *ConstantFoldScalarCall3(StringRef Name,
3470 Intrinsic::ID IntrinsicID,
3471 Type *Ty,
3473 const TargetLibraryInfo *TLI,
3474 const CallBase *Call) {
3475 assert(Operands.size() == 3 && "Wrong number of operands.");
3476
3477 if (const auto *Op1 = dyn_cast<ConstantFP>(Operands[0])) {
3478 if (const auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
3479 if (const auto *Op3 = dyn_cast<ConstantFP>(Operands[2])) {
3480 const APFloat &C1 = Op1->getValueAPF();
3481 const APFloat &C2 = Op2->getValueAPF();
3482 const APFloat &C3 = Op3->getValueAPF();
3483
3484 if (const auto *ConstrIntr = dyn_cast<ConstrainedFPIntrinsic>(Call)) {
3485 RoundingMode RM = getEvaluationRoundingMode(ConstrIntr);
3486 APFloat Res = C1;
3488 switch (IntrinsicID) {
3489 default:
3490 return nullptr;
3491 case Intrinsic::experimental_constrained_fma:
3492 case Intrinsic::experimental_constrained_fmuladd:
3493 St = Res.fusedMultiplyAdd(C2, C3, RM);
3494 break;
3495 }
3496 if (mayFoldConstrained(
3497 const_cast<ConstrainedFPIntrinsic *>(ConstrIntr), St))
3498 return ConstantFP::get(Ty->getContext(), Res);
3499 return nullptr;
3500 }
3501
3502 switch (IntrinsicID) {
3503 default: break;
3504 case Intrinsic::amdgcn_fma_legacy: {
3505 // The legacy behaviour is that multiplying +/- 0.0 by anything, even
3506 // NaN or infinity, gives +0.0.
3507 if (C1.isZero() || C2.isZero()) {
3508 // It's tempting to just return C3 here, but that would give the
3509 // wrong result if C3 was -0.0.
3510 return ConstantFP::get(Ty->getContext(), APFloat(0.0f) + C3);
3511 }
3512 [[fallthrough]];
3513 }
3514 case Intrinsic::fma:
3515 case Intrinsic::fmuladd: {
3516 APFloat V = C1;
3517 V.fusedMultiplyAdd(C2, C3, APFloat::rmNearestTiesToEven);
3518 return ConstantFP::get(Ty->getContext(), V);
3519 }
3520 case Intrinsic::amdgcn_cubeid:
3521 case Intrinsic::amdgcn_cubema:
3522 case Intrinsic::amdgcn_cubesc:
3523 case Intrinsic::amdgcn_cubetc: {
3524 APFloat V = ConstantFoldAMDGCNCubeIntrinsic(IntrinsicID, C1, C2, C3);
3525 return ConstantFP::get(Ty->getContext(), V);
3526 }
3527 }
3528 }
3529 }
3530 }
3531
3532 if (IntrinsicID == Intrinsic::smul_fix ||
3533 IntrinsicID == Intrinsic::smul_fix_sat) {
3534 // poison * C -> poison
3535 // C * poison -> poison
3536 if (isa<PoisonValue>(Operands[0]) || isa<PoisonValue>(Operands[1]))
3537 return PoisonValue::get(Ty);
3538
3539 const APInt *C0, *C1;
3540 if (!getConstIntOrUndef(Operands[0], C0) ||
3541 !getConstIntOrUndef(Operands[1], C1))
3542 return nullptr;
3543
3544 // undef * C -> 0
3545 // C * undef -> 0
3546 if (!C0 || !C1)
3547 return Constant::getNullValue(Ty);
3548
3549 // This code performs rounding towards negative infinity in case the result
3550 // cannot be represented exactly for the given scale. Targets that do care
3551 // about rounding should use a target hook for specifying how rounding
3552 // should be done, and provide their own folding to be consistent with
3553 // rounding. This is the same approach as used by
3554 // DAGTypeLegalizer::ExpandIntRes_MULFIX.
3555 unsigned Scale = cast<ConstantInt>(Operands[2])->getZExtValue();
3556 unsigned Width = C0->getBitWidth();
3557 assert(Scale < Width && "Illegal scale.");
3558 unsigned ExtendedWidth = Width * 2;
3559 APInt Product =
3560 (C0->sext(ExtendedWidth) * C1->sext(ExtendedWidth)).ashr(Scale);
3561 if (IntrinsicID == Intrinsic::smul_fix_sat) {
3562 APInt Max = APInt::getSignedMaxValue(Width).sext(ExtendedWidth);
3563 APInt Min = APInt::getSignedMinValue(Width).sext(ExtendedWidth);
3564 Product = APIntOps::smin(Product, Max);
3565 Product = APIntOps::smax(Product, Min);
3566 }
3567 return ConstantInt::get(Ty->getContext(), Product.sextOrTrunc(Width));
3568 }
3569
3570 if (IntrinsicID == Intrinsic::fshl || IntrinsicID == Intrinsic::fshr) {
3571 const APInt *C0, *C1, *C2;
3572 if (!getConstIntOrUndef(Operands[0], C0) ||
3573 !getConstIntOrUndef(Operands[1], C1) ||
3574 !getConstIntOrUndef(Operands[2], C2))
3575 return nullptr;
3576
3577 bool IsRight = IntrinsicID == Intrinsic::fshr;
3578 if (!C2)
3579 return Operands[IsRight ? 1 : 0];
3580 if (!C0 && !C1)
3581 return UndefValue::get(Ty);
3582
3583 // The shift amount is interpreted as modulo the bitwidth. If the shift
3584 // amount is effectively 0, avoid UB due to oversized inverse shift below.
3585 unsigned BitWidth = C2->getBitWidth();
3586 unsigned ShAmt = C2->urem(BitWidth);
3587 if (!ShAmt)
3588 return Operands[IsRight ? 1 : 0];
3589
3590 // (C0 << ShlAmt) | (C1 >> LshrAmt)
3591 unsigned LshrAmt = IsRight ? ShAmt : BitWidth - ShAmt;
3592 unsigned ShlAmt = !IsRight ? ShAmt : BitWidth - ShAmt;
3593 if (!C0)
3594 return ConstantInt::get(Ty, C1->lshr(LshrAmt));
3595 if (!C1)
3596 return ConstantInt::get(Ty, C0->shl(ShlAmt));
3597 return ConstantInt::get(Ty, C0->shl(ShlAmt) | C1->lshr(LshrAmt));
3598 }
3599
3600 if (IntrinsicID == Intrinsic::amdgcn_perm)
3601 return ConstantFoldAMDGCNPermIntrinsic(Operands, Ty);
3602
3603 return nullptr;
3604}
3605
3606static Constant *ConstantFoldScalarCall(StringRef Name,
3607 Intrinsic::ID IntrinsicID,
3608 Type *Ty,
3610 const TargetLibraryInfo *TLI,
3611 const CallBase *Call) {
3612 if (Operands.size() == 1)
3613 return ConstantFoldScalarCall1(Name, IntrinsicID, Ty, Operands, TLI, Call);
3614
3615 if (Operands.size() == 2) {
3616 if (Constant *FoldedLibCall =
3617 ConstantFoldLibCall2(Name, Ty, Operands, TLI)) {
3618 return FoldedLibCall;
3619 }
3620 return ConstantFoldIntrinsicCall2(IntrinsicID, Ty, Operands, Call);
3621 }
3622
3623 if (Operands.size() == 3)
3624 return ConstantFoldScalarCall3(Name, IntrinsicID, Ty, Operands, TLI, Call);
3625
3626 return nullptr;
3627}
3628
3629static Constant *ConstantFoldFixedVectorCall(
3630 StringRef Name, Intrinsic::ID IntrinsicID, FixedVectorType *FVTy,
3632 const TargetLibraryInfo *TLI, const CallBase *Call) {
3635 Type *Ty = FVTy->getElementType();
3636
3637 switch (IntrinsicID) {
3638 case Intrinsic::masked_load: {
3639 auto *SrcPtr = Operands[0];
3640 auto *Mask = Operands[2];
3641 auto *Passthru = Operands[3];
3642
3643 Constant *VecData = ConstantFoldLoadFromConstPtr(SrcPtr, FVTy, DL);
3644
3645 SmallVector<Constant *, 32> NewElements;
3646 for (unsigned I = 0, E = FVTy->getNumElements(); I != E; ++I) {
3647 auto *MaskElt = Mask->getAggregateElement(I);
3648 if (!MaskElt)
3649 break;
3650 auto *PassthruElt = Passthru->getAggregateElement(I);
3651 auto *VecElt = VecData ? VecData->getAggregateElement(I) : nullptr;
3652 if (isa<UndefValue>(MaskElt)) {
3653 if (PassthruElt)
3654 NewElements.push_back(PassthruElt);
3655 else if (VecElt)
3656 NewElements.push_back(VecElt);
3657 else
3658 return nullptr;
3659 }
3660 if (MaskElt->isNullValue()) {
3661 if (!PassthruElt)
3662 return nullptr;
3663 NewElements.push_back(PassthruElt);
3664 } else if (MaskElt->isOneValue()) {
3665 if (!VecElt)
3666 return nullptr;
3667 NewElements.push_back(VecElt);
3668 } else {
3669 return nullptr;
3670 }
3671 }
3672 if (NewElements.size() != FVTy->getNumElements())
3673 return nullptr;
3674 return ConstantVector::get(NewElements);
3675 }
3676 case Intrinsic::arm_mve_vctp8:
3677 case Intrinsic::arm_mve_vctp16:
3678 case Intrinsic::arm_mve_vctp32:
3679 case Intrinsic::arm_mve_vctp64: {
3680 if (auto *Op = dyn_cast<ConstantInt>(Operands[0])) {
3681 unsigned Lanes = FVTy->getNumElements();
3682 uint64_t Limit = Op->getZExtValue();
3683
3685 for (unsigned i = 0; i < Lanes; i++) {
3686 if (i < Limit)
3688 else
3690 }
3691 return ConstantVector::get(NCs);
3692 }
3693 return nullptr;
3694 }
3695 case Intrinsic::get_active_lane_mask: {
3696 auto *Op0 = dyn_cast<ConstantInt>(Operands[0]);
3697 auto *Op1 = dyn_cast<ConstantInt>(Operands[1]);
3698 if (Op0 && Op1) {
3699 unsigned Lanes = FVTy->getNumElements();
3700 uint64_t Base = Op0->getZExtValue();
3701 uint64_t Limit = Op1->getZExtValue();
3702
3704 for (unsigned i = 0; i < Lanes; i++) {
3705 if (Base + i < Limit)
3707 else
3709 }
3710 return ConstantVector::get(NCs);
3711 }
3712 return nullptr;
3713 }
3714 default:
3715 break;
3716 }
3717
3718 for (unsigned I = 0, E = FVTy->getNumElements(); I != E; ++I) {
3719 // Gather a column of constants.
3720 for (unsigned J = 0, JE = Operands.size(); J != JE; ++J) {
3721 // Some intrinsics use a scalar type for certain arguments.
3722 if (isVectorIntrinsicWithScalarOpAtArg(IntrinsicID, J, /*TTI=*/nullptr)) {
3723 Lane[J] = Operands[J];
3724 continue;
3725 }
3726
3727 Constant *Agg = Operands[J]->getAggregateElement(I);
3728 if (!Agg)
3729 return nullptr;
3730
3731 Lane[J] = Agg;
3732 }
3733
3734 // Use the regular scalar folding to simplify this column.
3735 Constant *Folded =
3736 ConstantFoldScalarCall(Name, IntrinsicID, Ty, Lane, TLI, Call);
3737 if (!Folded)
3738 return nullptr;
3739 Result[I] = Folded;
3740 }
3741
3742 return ConstantVector::get(Result);
3743}
3744
3745static Constant *ConstantFoldScalableVectorCall(
3746 StringRef Name, Intrinsic::ID IntrinsicID, ScalableVectorType *SVTy,
3748 const TargetLibraryInfo *TLI, const CallBase *Call) {
3749 switch (IntrinsicID) {
3750 case Intrinsic::aarch64_sve_convert_from_svbool: {
3751 auto *Src = dyn_cast<Constant>(Operands[0]);
3752 if (!Src || !Src->isNullValue())
3753 break;
3754
3755 return ConstantInt::getFalse(SVTy);
3756 }
3757 default:
3758 break;
3759 }
3760 return nullptr;
3761}
3762
3763static std::pair<Constant *, Constant *>
3764ConstantFoldScalarFrexpCall(Constant *Op, Type *IntTy) {
3765 if (isa<PoisonValue>(Op))
3766 return {Op, PoisonValue::get(IntTy)};
3767
3768 auto *ConstFP = dyn_cast<ConstantFP>(Op);
3769 if (!ConstFP)
3770 return {};
3771
3772 const APFloat &U = ConstFP->getValueAPF();
3773 int FrexpExp;
3774 APFloat FrexpMant = frexp(U, FrexpExp, APFloat::rmNearestTiesToEven);
3775 Constant *Result0 = ConstantFP::get(ConstFP->getType(), FrexpMant);
3776
3777 // The exponent is an "unspecified value" for inf/nan. We use zero to avoid
3778 // using undef.
3779 Constant *Result1 = FrexpMant.isFinite()
3780 ? ConstantInt::getSigned(IntTy, FrexpExp)
3781 : ConstantInt::getNullValue(IntTy);
3782 return {Result0, Result1};
3783}
3784
3785/// Handle intrinsics that return tuples, which may be tuples of vectors.
3786static Constant *
3787ConstantFoldStructCall(StringRef Name, Intrinsic::ID IntrinsicID,
3789 const DataLayout &DL, const TargetLibraryInfo *TLI,
3790 const CallBase *Call) {
3791
3792 switch (IntrinsicID) {
3793 case Intrinsic::frexp: {
3794 Type *Ty0 = StTy->getContainedType(0);
3795 Type *Ty1 = StTy->getContainedType(1)->getScalarType();
3796
3797 if (auto *FVTy0 = dyn_cast<FixedVectorType>(Ty0)) {
3798 SmallVector<Constant *, 4> Results0(FVTy0->getNumElements());
3799 SmallVector<Constant *, 4> Results1(FVTy0->getNumElements());
3800
3801 for (unsigned I = 0, E = FVTy0->getNumElements(); I != E; ++I) {
3802 Constant *Lane = Operands[0]->getAggregateElement(I);
3803 std::tie(Results0[I], Results1[I]) =
3804 ConstantFoldScalarFrexpCall(Lane, Ty1);
3805 if (!Results0[I])
3806 return nullptr;
3807 }
3808
3809 return ConstantStruct::get(StTy, ConstantVector::get(Results0),
3810 ConstantVector::get(Results1));
3811 }
3812
3813 auto [Result0, Result1] = ConstantFoldScalarFrexpCall(Operands[0], Ty1);
3814 if (!Result0)
3815 return nullptr;
3816 return ConstantStruct::get(StTy, Result0, Result1);
3817 }
3818 case Intrinsic::sincos: {
3819 Type *Ty = StTy->getContainedType(0);
3820 Type *TyScalar = Ty->getScalarType();
3821
3822 auto ConstantFoldScalarSincosCall =
3823 [&](Constant *Op) -> std::pair<Constant *, Constant *> {
3824 Constant *SinResult =
3825 ConstantFoldScalarCall(Name, Intrinsic::sin, TyScalar, Op, TLI, Call);
3826 Constant *CosResult =
3827 ConstantFoldScalarCall(Name, Intrinsic::cos, TyScalar, Op, TLI, Call);
3828 return std::make_pair(SinResult, CosResult);
3829 };
3830
3831 if (auto *FVTy = dyn_cast<FixedVectorType>(Ty)) {
3832 SmallVector<Constant *> SinResults(FVTy->getNumElements());
3833 SmallVector<Constant *> CosResults(FVTy->getNumElements());
3834
3835 for (unsigned I = 0, E = FVTy->getNumElements(); I != E; ++I) {
3836 Constant *Lane = Operands[0]->getAggregateElement(I);
3837 std::tie(SinResults[I], CosResults[I]) =
3838 ConstantFoldScalarSincosCall(Lane);
3839 if (!SinResults[I] || !CosResults[I])
3840 return nullptr;
3841 }
3842
3843 return ConstantStruct::get(StTy, ConstantVector::get(SinResults),
3844 ConstantVector::get(CosResults));
3845 }
3846
3847 auto [SinResult, CosResult] = ConstantFoldScalarSincosCall(Operands[0]);
3848 if (!SinResult || !CosResult)
3849 return nullptr;
3850 return ConstantStruct::get(StTy, SinResult, CosResult);
3851 }
3852 default:
3853 // TODO: Constant folding of vector intrinsics that fall through here does
3854 // not work (e.g. overflow intrinsics)
3855 return ConstantFoldScalarCall(Name, IntrinsicID, StTy, Operands, TLI, Call);
3856 }
3857
3858 return nullptr;
3859}
3860
3861} // end anonymous namespace
3862
3864 Constant *RHS, Type *Ty,
3866 return ConstantFoldIntrinsicCall2(ID, Ty, {LHS, RHS},
3867 dyn_cast_if_present<CallBase>(FMFSource));
3868}
3869
3872 const TargetLibraryInfo *TLI,
3873 bool AllowNonDeterministic) {
3874 if (Call->isNoBuiltin())
3875 return nullptr;
3876 if (!F->hasName())
3877 return nullptr;
3878
3879 // If this is not an intrinsic and not recognized as a library call, bail out.
3880 Intrinsic::ID IID = F->getIntrinsicID();
3881 if (IID == Intrinsic::not_intrinsic) {
3882 if (!TLI)
3883 return nullptr;
3884 LibFunc LibF;
3885 if (!TLI->getLibFunc(*F, LibF))
3886 return nullptr;
3887 }
3888
3889 // Conservatively assume that floating-point libcalls may be
3890 // non-deterministic.
3891 Type *Ty = F->getReturnType();
3892 if (!AllowNonDeterministic && Ty->isFPOrFPVectorTy())
3893 return nullptr;
3894
3895 StringRef Name = F->getName();
3896 if (auto *FVTy = dyn_cast<FixedVectorType>(Ty))
3897 return ConstantFoldFixedVectorCall(
3898 Name, IID, FVTy, Operands, F->getDataLayout(), TLI, Call);
3899
3900 if (auto *SVTy = dyn_cast<ScalableVectorType>(Ty))
3901 return ConstantFoldScalableVectorCall(
3902 Name, IID, SVTy, Operands, F->getDataLayout(), TLI, Call);
3903
3904 if (auto *StTy = dyn_cast<StructType>(Ty))
3905 return ConstantFoldStructCall(Name, IID, StTy, Operands,
3906 F->getDataLayout(), TLI, Call);
3907
3908 // TODO: If this is a library function, we already discovered that above,
3909 // so we should pass the LibFunc, not the name (and it might be better
3910 // still to separate intrinsic handling from libcalls).
3911 return ConstantFoldScalarCall(Name, IID, Ty, Operands, TLI, Call);
3912}
3913
3915 const TargetLibraryInfo *TLI) {
3916 // FIXME: Refactor this code; this duplicates logic in LibCallsShrinkWrap
3917 // (and to some extent ConstantFoldScalarCall).
3918 if (Call->isNoBuiltin() || Call->isStrictFP())
3919 return false;
3920 Function *F = Call->getCalledFunction();
3921 if (!F)
3922 return false;
3923
3924 LibFunc Func;
3925 if (!TLI || !TLI->getLibFunc(*F, Func))
3926 return false;
3927
3928 if (Call->arg_size() == 1) {
3929 if (ConstantFP *OpC = dyn_cast<ConstantFP>(Call->getArgOperand(0))) {
3930 const APFloat &Op = OpC->getValueAPF();
3931 switch (Func) {
3932 case LibFunc_logl:
3933 case LibFunc_log:
3934 case LibFunc_logf:
3935 case LibFunc_log2l:
3936 case LibFunc_log2:
3937 case LibFunc_log2f:
3938 case LibFunc_log10l:
3939 case LibFunc_log10:
3940 case LibFunc_log10f:
3941 return Op.isNaN() || (!Op.isZero() && !Op.isNegative());
3942
3943 case LibFunc_expl:
3944 case LibFunc_exp:
3945 case LibFunc_expf:
3946 // FIXME: These boundaries are slightly conservative.
3947 if (OpC->getType()->isDoubleTy())
3948 return !(Op < APFloat(-745.0) || Op > APFloat(709.0));
3949 if (OpC->getType()->isFloatTy())
3950 return !(Op < APFloat(-103.0f) || Op > APFloat(88.0f));
3951 break;
3952
3953 case LibFunc_exp2l:
3954 case LibFunc_exp2:
3955 case LibFunc_exp2f:
3956 // FIXME: These boundaries are slightly conservative.
3957 if (OpC->getType()->isDoubleTy())
3958 return !(Op < APFloat(-1074.0) || Op > APFloat(1023.0));
3959 if (OpC->getType()->isFloatTy())
3960 return !(Op < APFloat(-149.0f) || Op > APFloat(127.0f));
3961 break;
3962
3963 case LibFunc_sinl:
3964 case LibFunc_sin:
3965 case LibFunc_sinf:
3966 case LibFunc_cosl:
3967 case LibFunc_cos:
3968 case LibFunc_cosf:
3969 return !Op.isInfinity();
3970
3971 case LibFunc_tanl:
3972 case LibFunc_tan:
3973 case LibFunc_tanf: {
3974 // FIXME: Stop using the host math library.
3975 // FIXME: The computation isn't done in the right precision.
3976 Type *Ty = OpC->getType();
3977 if (Ty->isDoubleTy() || Ty->isFloatTy() || Ty->isHalfTy())
3978 return ConstantFoldFP(tan, OpC->getValueAPF(), Ty) != nullptr;
3979 break;
3980 }
3981
3982 case LibFunc_atan:
3983 case LibFunc_atanf:
3984 case LibFunc_atanl:
3985 // Per POSIX, this MAY fail if Op is denormal. We choose not failing.
3986 return true;
3987
3988 case LibFunc_asinl:
3989 case LibFunc_asin:
3990 case LibFunc_asinf:
3991 case LibFunc_acosl:
3992 case LibFunc_acos:
3993 case LibFunc_acosf:
3994 return !(Op < APFloat::getOne(Op.getSemantics(), true) ||
3995 Op > APFloat::getOne(Op.getSemantics()));
3996
3997 case LibFunc_sinh:
3998 case LibFunc_cosh:
3999 case LibFunc_sinhf:
4000 case LibFunc_coshf:
4001 case LibFunc_sinhl:
4002 case LibFunc_coshl:
4003 // FIXME: These boundaries are slightly conservative.
4004 if (OpC->getType()->isDoubleTy())
4005 return !(Op < APFloat(-710.0) || Op > APFloat(710.0));
4006 if (OpC->getType()->isFloatTy())
4007 return !(Op < APFloat(-89.0f) || Op > APFloat(89.0f));
4008 break;
4009
4010 case LibFunc_sqrtl:
4011 case LibFunc_sqrt:
4012 case LibFunc_sqrtf:
4013 return Op.isNaN() || Op.isZero() || !Op.isNegative();
4014
4015 // FIXME: Add more functions: sqrt_finite, atanh, expm1, log1p,
4016 // maybe others?
4017 default:
4018 break;
4019 }
4020 }
4021 }
4022
4023 if (Call->arg_size() == 2) {
4024 ConstantFP *Op0C = dyn_cast<ConstantFP>(Call->getArgOperand(0));
4025 ConstantFP *Op1C = dyn_cast<ConstantFP>(Call->getArgOperand(1));
4026 if (Op0C && Op1C) {
4027 const APFloat &Op0 = Op0C->getValueAPF();
4028 const APFloat &Op1 = Op1C->getValueAPF();
4029
4030 switch (Func) {
4031 case LibFunc_powl:
4032 case LibFunc_pow:
4033 case LibFunc_powf: {
4034 // FIXME: Stop using the host math library.
4035 // FIXME: The computation isn't done in the right precision.
4036 Type *Ty = Op0C->getType();
4037 if (Ty->isDoubleTy() || Ty->isFloatTy() || Ty->isHalfTy()) {
4038 if (Ty == Op1C->getType())
4039 return ConstantFoldBinaryFP(pow, Op0, Op1, Ty) != nullptr;
4040 }
4041 break;
4042 }
4043
4044 case LibFunc_fmodl:
4045 case LibFunc_fmod:
4046 case LibFunc_fmodf:
4047 case LibFunc_remainderl:
4048 case LibFunc_remainder:
4049 case LibFunc_remainderf:
4050 return Op0.isNaN() || Op1.isNaN() ||
4051 (!Op0.isInfinity() && !Op1.isZero());
4052
4053 case LibFunc_atan2:
4054 case LibFunc_atan2f:
4055 case LibFunc_atan2l:
4056 // Although IEEE-754 says atan2(+/-0.0, +/-0.0) are well-defined, and
4057 // GLIBC and MSVC do not appear to raise an error on those, we
4058 // cannot rely on that behavior. POSIX and C11 say that a domain error
4059 // may occur, so allow for that possibility.
4060 return !Op0.isZero() || !Op1.isZero();
4061
4062 default:
4063 break;
4064 }
4065 }
4066 }
4067
4068 return false;
4069}
4070
4071void TargetFolder::anchor() {}
static const LLT S1
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static Constant * FoldBitCast(Constant *V, Type *DestTy)
static ConstantFP * flushDenormalConstant(Type *Ty, const APFloat &APF, DenormalMode::DenormalModeKind Mode)
Constant * getConstantAtOffset(Constant *Base, APInt Offset, const DataLayout &DL)
If this Offset points exactly to the start of an aggregate element, return that element,...
static ConstantFP * flushDenormalConstantFP(ConstantFP *CFP, const Instruction *Inst, bool IsOutput)
static DenormalMode getInstrDenormalMode(const Instruction *CtxI, Type *Ty)
Return the denormal mode that can be assumed when executing a floating point operation at CtxI.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file defines the DenseMap class.
std::string Name
uint64_t Size
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
Hexagon Common GEP
amode Optimize addressing mode
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
mir Rename Register Operands
static bool InRange(int64_t Value, unsigned short Shift, int LBound, int HBound)
This file contains the definitions of the enumerations and flags associated with NVVM Intrinsics,...
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some templates that are useful if you are working with the STL at all.
This file defines the SmallVector class.
static SymbolRef::Type getType(const Symbol *Sym)
Definition: TapiFile.cpp:39
Value * RHS
Value * LHS
static APFloat getQNaN(const fltSemantics &Sem, bool Negative=false, const APInt *payload=nullptr)
Factory for QNaN values.
Definition: APFloat.h:1122
opStatus divide(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1210
void copySign(const APFloat &RHS)
Definition: APFloat.h:1304
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition: APFloat.cpp:5463
opStatus subtract(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1192
bool isNegative() const
Definition: APFloat.h:1445
double convertToDouble() const
Converts this APFloat to host double value.
Definition: APFloat.cpp:5525
bool isPosInfinity() const
Definition: APFloat.h:1458
bool isNormal() const
Definition: APFloat.h:1449
bool isDenormal() const
Definition: APFloat.h:1446
opStatus add(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1183
const fltSemantics & getSemantics() const
Definition: APFloat.h:1453
bool isNonZero() const
Definition: APFloat.h:1454
bool isFinite() const
Definition: APFloat.h:1450
bool isNaN() const
Definition: APFloat.h:1443
static APFloat getOne(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative One.
Definition: APFloat.h:1090
opStatus multiply(const APFloat &RHS, roundingMode RM)
Definition: APFloat.h:1201
float convertToFloat() const
Converts this APFloat to host float value.
Definition: APFloat.cpp:5553
bool isSignaling() const
Definition: APFloat.h:1447
opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend, roundingMode RM)
Definition: APFloat.h:1237
bool isZero() const
Definition: APFloat.h:1441
APInt bitcastToAPInt() const
Definition: APFloat.h:1351
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
Definition: APFloat.h:1326
opStatus mod(const APFloat &RHS)
Definition: APFloat.h:1228
bool isNegInfinity() const
Definition: APFloat.h:1459
void changeSign()
Definition: APFloat.h:1299
static APFloat getZero(const fltSemantics &Sem, bool Negative=false)
Factory for Positive and Negative Zero.
Definition: APFloat.h:1081
bool isInfinity() const
Definition: APFloat.h:1442
Class for arbitrary precision integers.
Definition: APInt.h:78
APInt umul_ov(const APInt &RHS, bool &Overflow) const
Definition: APInt.cpp:1945
APInt usub_sat(const APInt &RHS) const
Definition: APInt.cpp:2029
bool isMinSignedValue() const
Determine if this is the smallest signed value.
Definition: APInt.h:423
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1520
uint64_t extractBitsAsZExtValue(unsigned numBits, unsigned bitPosition) const
Definition: APInt.cpp:493
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
Definition: APInt.cpp:1007
APInt trunc(unsigned width) const
Truncate to new width.
Definition: APInt.cpp:910
APInt abs() const
Get the absolute value.
Definition: APInt.h:1773
APInt sadd_sat(const APInt &RHS) const
Definition: APInt.cpp:2000
bool sgt(const APInt &RHS) const
Signed greater than comparison.
Definition: APInt.h:1201
APInt usub_ov(const APInt &RHS, bool &Overflow) const
Definition: APInt.cpp:1922
bool ugt(const APInt &RHS) const
Unsigned greater than comparison.
Definition: APInt.h:1182
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
Definition: APInt.h:380
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
Definition: APInt.cpp:1640
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1468
bool ult(const APInt &RHS) const
Unsigned less than comparison.
Definition: APInt.h:1111
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
Definition: APInt.h:209
APInt sadd_ov(const APInt &RHS, bool &Overflow) const
Definition: APInt.cpp:1902
APInt uadd_ov(const APInt &RHS, bool &Overflow) const
Definition: APInt.cpp:1909
unsigned countr_zero() const
Count the number of trailing zero bits.
Definition: APInt.h:1618
unsigned countl_zero() const
The APInt version of std::countl_zero.
Definition: APInt.h:1577
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
Definition: APInt.h:219
APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
Definition: APInt.cpp:1015
APInt uadd_sat(const APInt &RHS) const
Definition: APInt.cpp:2010
APInt smul_ov(const APInt &RHS, bool &Overflow) const
Definition: APInt.cpp:1934
APInt sext(unsigned width) const
Sign extend to a new width.
Definition: APInt.cpp:959
APInt shl(unsigned shiftAmt) const
Left-shift function.
Definition: APInt.h:873
bool slt(const APInt &RHS) const
Signed less than comparison.
Definition: APInt.h:1130
APInt extractBits(unsigned numBits, unsigned bitPosition) const
Return an APInt with the extracted bits [bitPosition,bitPosition+numBits).
Definition: APInt.cpp:455
APInt ssub_ov(const APInt &RHS, bool &Overflow) const
Definition: APInt.cpp:1915
bool isOne() const
Determine if this is a value of 1.
Definition: APInt.h:389
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
Definition: APInt.h:851
APInt ssub_sat(const APInt &RHS) const
Definition: APInt.cpp:2019
An arbitrary precision integer that knows its signedness.
Definition: APSInt.h:23
Definition: Any.h:28
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
const T & back() const
back - Get the last element.
Definition: ArrayRef.h:177
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:168
const T * data() const
Definition: ArrayRef.h:165
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:198
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1112
static Instruction::CastOps getCastOpcode(const Value *Val, bool SrcIsSigned, Type *Ty, bool DstIsSigned)
Returns the opcode necessary to cast Val into Ty using usual casting rules.
static bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy)
This method can be used to determine if a cast from SrcTy to DstTy using Opcode op is valid or not.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:673
bool isFPPredicate() const
Definition: InstrTypes.h:780
static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)
get() constructor - Return a constant with array type with an element count and element type matching...
Definition: Constants.h:709
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2307
static Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2554
static bool isDesirableCastOp(unsigned Opcode)
Whether creating a constant expression for this cast is desirable.
Definition: Constants.cpp:2436
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:2222
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2644
static Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2576
static Constant * getPtrToInt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2293
static Constant * getShuffleVector(Constant *V1, Constant *V2, ArrayRef< int > Mask, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2599
static bool isSupportedGetElementPtr(const Type *SrcElemTy)
Whether creating a constant expression for this getelementptr type is supported.
Definition: Constants.h:1379
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:2340
static bool isDesirableBinOp(unsigned Opcode)
Whether creating a constant expression for this binary operator is desirable.
Definition: Constants.cpp:2382
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, GEPNoWrapFlags NW=GEPNoWrapFlags::none(), std::optional< ConstantRange > InRange=std::nullopt, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
Definition: Constants.h:1267
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2321
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:271
const APFloat & getValueAPF() const
Definition: Constants.h:314
static Constant * getZero(Type *Ty, bool Negative=false)
Definition: Constants.cpp:1057
This is the shared class of boolean and integer constants.
Definition: Constants.h:83
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:866
static ConstantInt * getSigned(IntegerType *Ty, int64_t V)
Return a ConstantInt with the specified value for the specified type.
Definition: Constants.h:126
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:873
static ConstantInt * getBool(LLVMContext &Context, bool V)
Definition: Constants.cpp:880
static Constant * get(StructType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:1378
static Constant * getSplat(ElementCount EC, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
Definition: Constants.cpp:1472
static Constant * get(ArrayRef< Constant * > V)
Definition: Constants.cpp:1421
This is an important base class in LLVM.
Definition: Constant.h:42
Constant * getSplatValue(bool AllowPoison=false) const
If all elements of the vector constant have the same value, return that value.
Definition: Constants.cpp:1708
static Constant * getAllOnesValue(Type *Ty)
Definition: Constants.cpp:420
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:373
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:435
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:90
Constrained floating point compare intrinsics.
This is the common base class for constrained floating point intrinsics.
std::optional< fp::ExceptionBehavior > getExceptionBehavior() const
std::optional< RoundingMode > getRoundingMode() const
Wrapper for a function that represents a value that functionally represents the original function.
Definition: Constants.h:941
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:63
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:156
iterator end()
Definition: DenseMap.h:84
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:211
static bool compare(const APFloat &LHS, const APFloat &RHS, FCmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
This provides a helper for copying FMF from an instruction or setting specified flags.
Definition: IRBuilder.h:92
Class to represent fixed width SIMD vectors.
Definition: DerivedTypes.h:563
unsigned getNumElements() const
Definition: DerivedTypes.h:606
static FixedVectorType * get(Type *ElementType, unsigned NumElts)
Definition: Type.cpp:791
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
Definition: Function.cpp:807
Represents flags for the getelementptr instruction/expression.
static GEPNoWrapFlags inBounds()
GEPNoWrapFlags withoutNoUnsignedSignedWrap() const
static GEPNoWrapFlags noUnsignedWrap()
bool hasNoUnsignedSignedWrap() const
bool isInBounds() const
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the result type of a getelementptr with the given source element type and indexes.
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:294
const DataLayout & getDataLayout() const
Get the data layout of the module this global belongs to.
Definition: Globals.cpp:130
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
bool hasDefinitiveInitializer() const
hasDefinitiveInitializer - Whether the global variable has an initializer, and any other instances of...
static bool compare(const APInt &LHS, const APInt &RHS, ICmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
Predicate getSignedPredicate() const
For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
bool isCast() const
Definition: Instruction.h:283
bool isBinaryOp() const
Definition: Instruction.h:279
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:72
bool isUnaryOp() const
Definition: Instruction.h:278
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:311
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
static APInt getSaturationPoint(Intrinsic::ID ID, unsigned numBits)
Min/max intrinsics are monotonic, they operate on a fixed-bitwidth values, so there is a certain thre...
ICmpInst::Predicate getPredicate() const
Returns the comparison predicate underlying the intrinsic.
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:310
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Definition: Constants.cpp:1878
Class to represent scalable SIMD vectors.
Definition: DerivedTypes.h:610
size_t size() const
Definition: SmallVector.h:78
void push_back(const T &Elt)
Definition: SmallVector.h:413
pointer data()
Return a pointer to the vector's buffer, even if empty().
Definition: SmallVector.h:286
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1196
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:51
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:567
unsigned getElementContainingOffset(uint64_t FixedOffset) const
Given a valid byte offset into the structure, returns the structure index that contains it.
Definition: DataLayout.cpp:92
TypeSize getElementOffset(unsigned Idx) const
Definition: DataLayout.h:596
Class to represent struct types.
Definition: DerivedTypes.h:218
Provides information about what library functions are available for the current target.
bool has(LibFunc F) const
Tests whether a library function is available.
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
unsigned getIntegerBitWidth() const
Type * getStructElementType(unsigned N) const
const fltSemantics & getFltSemantics() const
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:270
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:243
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:264
static IntegerType * getInt1Ty(LLVMContext &C)
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:153
bool isBFloatTy() const
Return true if this is 'bfloat', a 16-bit bfloat type.
Definition: Type.h:145
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
@ HalfTyID
16-bit floating point type
Definition: Type.h:56
@ FloatTyID
32-bit floating point type
Definition: Type.h:58
@ DoubleTyID
64-bit floating point type
Definition: Type.h:59
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
bool isFP128Ty() const
Return true if this is 'fp128'.
Definition: Type.h:162
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:258
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:310
static IntegerType * getInt16Ty(LLVMContext &C)
bool isAggregateType() const
Return true if the type is an aggregate type.
Definition: Type.h:303
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
Definition: Type.h:142
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:128
static IntegerType * getInt8Ty(LLVMContext &C)
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:156
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
Definition: Type.h:184
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
Definition: Type.h:267
bool isX86_AMXTy() const
Return true if this is X86 AMX.
Definition: Type.h:200
static IntegerType * getInt32Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:237
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:136
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
Definition: Type.h:225
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Type * getContainedType(unsigned i) const
This method is used to implement the type iterator (defined at the end of the file).
Definition: Type.h:384
bool isIEEELikeFPTy() const
Return true if this is a well-behaved IEEE-like type, which has a IEEE compatible layout as defined b...
Definition: Type.h:170
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
Definition: Type.h:355
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1859
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
Value * getOperand(unsigned i) const
Definition: User.h:228
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
const Value * stripAndAccumulateInBoundsConstantOffsets(const DataLayout &DL, APInt &Offset) const
This is a wrapper around stripAndAccumulateConstantOffsets with the in-bounds requirement set to fals...
Definition: Value.h:740
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:1075
Base class of all SIMD vector types.
Definition: DerivedTypes.h:427
ElementCount getElementCount() const
Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...
Definition: DerivedTypes.h:665
Type * getElementType() const
Definition: DerivedTypes.h:460
constexpr ScalarTy getFixedValue() const
Definition: TypeSize.h:202
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
Definition: TypeSize.h:171
const ParentTy * getParent() const
Definition: ilist_node.h:32
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
const APInt & smin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be signed.
Definition: APInt.h:2217
const APInt & smax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be signed.
Definition: APInt.h:2222
const APInt & umin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be unsigned.
Definition: APInt.h:2227
const APInt & umax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be unsigned.
Definition: APInt.h:2232
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:125
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ SC
CHAIN = SC CHAIN, Imm128 - System call.
@ CE
Windows NT (Windows on ARM)
int ilogb(const IEEEFloat &Arg)
Definition: APFloat.cpp:4771
@ ebStrict
This corresponds to "fpexcept.strict".
Definition: FPEnv.h:41
@ ebIgnore
This corresponds to "fpexcept.ignore".
Definition: FPEnv.h:39
constexpr double pi
Definition: MathExtras.h:54
bool FPToIntegerIntrinsicResultIsSigned(Intrinsic::ID IntrinsicID)
APFloat::roundingMode GetFPToIntegerRoundingMode(Intrinsic::ID IntrinsicID)
bool FPToIntegerIntrinsicShouldFTZ(Intrinsic::ID IntrinsicID)
bool FMinFMaxIsXorSignAbs(Intrinsic::ID IntrinsicID)
bool FMinFMaxShouldFTZ(Intrinsic::ID IntrinsicID)
bool FMinFMaxPropagatesNaNs(Intrinsic::ID IntrinsicID)
NodeAddr< FuncNode * > Func
Definition: RDFGraph.h:393
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Definition: STLExtras.h:329
@ Offset
Definition: DWP.cpp:480
Constant * ConstantFoldBinaryIntrinsic(Intrinsic::ID ID, Constant *LHS, Constant *RHS, Type *Ty, Instruction *FMFSource)
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:1739
Constant * ConstantFoldLoadThroughBitcast(Constant *C, Type *DestTy, const DataLayout &DL)
ConstantFoldLoadThroughBitcast - try to cast constant to destination type returning null if unsuccess...
static double log2(double V)
Constant * ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, Constant *V2)
Attempt to constant fold a select instruction with the specified operands.
Constant * ConstantFoldFPInstOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL, const Instruction *I, bool AllowNonDeterministic=true)
Attempt to constant fold a floating point binary operation with the specified operands,...
bool canConstantFoldCallTo(const CallBase *Call, const Function *F)
canConstantFoldCallTo - Return true if its even possible to fold a call to the specified function.
unsigned getPointerAddressSpace(const Type *T)
Definition: SPIRVUtils.h:262
APFloat abs(APFloat X)
Returns the absolute value of the argument.
Definition: APFloat.h:1534
Constant * ConstantFoldCompareInstruction(CmpInst::Predicate Predicate, Constant *C1, Constant *C2)
Constant * ConstantFoldUnaryInstruction(unsigned Opcode, Constant *V)
bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset, const DataLayout &DL, DSOLocalEquivalent **DSOEquiv=nullptr)
If this constant is a constant offset from a global, return the global and the constant.
bool isMathLibCallNoop(const CallBase *Call, const TargetLibraryInfo *TLI)
Check whether the given call has no side-effects.
Constant * ReadByteArrayFromGlobal(const GlobalVariable *GV, uint64_t Offset)
LLVM_READONLY APFloat maximum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 maximum semantics.
Definition: APFloat.h:1604
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
Constant * ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const Instruction *I=nullptr)
Attempt to constant fold a compare instruction (icmp/fcmp) with the specified operands.
Constant * ConstantFoldCall(const CallBase *Call, Function *F, ArrayRef< Constant * > Operands, const TargetLibraryInfo *TLI=nullptr, bool AllowNonDeterministic=true)
ConstantFoldCall - Attempt to constant fold a call to the specified function with the specified argum...
APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM)
Equivalent of C standard library function.
Definition: APFloat.h:1526
Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)
Attempt to constant fold an extractvalue instruction with the specified operands and indices.
Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Fold the constant using the specified DataLayout.
LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)
Implements IEEE-754 2019 maximumNumber semantics.
Definition: APFloat.h:1563
Constant * ConstantFoldLoadFromUniformValue(Constant *C, Type *Ty, const DataLayout &DL)
If C is a uniform value where all bits are the same (either all zero, all ones, all undef or all pois...
Constant * ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op, const DataLayout &DL)
Attempt to constant fold a unary operation with the specified operand.
Constant * FlushFPConstant(Constant *Operand, const Instruction *I, bool IsOutput)
Attempt to flush float point constant according to denormal mode set in the instruction's parent func...
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM)
Definition: APFloat.h:1514
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:1187
Constant * ConstantFoldInstOperands(Instruction *I, ArrayRef< Constant * > Ops, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, bool AllowNonDeterministic=true)
ConstantFoldInstOperands - Attempt to constant fold an instruction with the specified operands.
Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)
Attempt to constant fold a cast with the specified operand.
Constant * ConstantFoldLoadFromConst(Constant *C, Type *Ty, const APInt &Offset, const DataLayout &DL)
Extract value of C at the given Offset reinterpreted as Ty.
Constant * ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, Constant *RHS, const DataLayout &DL)
Attempt to constant fold a binary operation with the specified operands.
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE-754 2019 minimumNumber semantics.
Definition: APFloat.h:1549
bool isVectorIntrinsicWithScalarOpAtArg(Intrinsic::ID ID, unsigned ScalarOpdIdx, const TargetTransformInfo *TTI)
Identifies if the vector form of the intrinsic has a scalar operand.
void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
DWARFExpression::Operation Op
Constant * ConstantFoldInstruction(Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldInstruction - Try to constant fold the specified instruction.
RoundingMode
Rounding mode.
bool isGuaranteedNotToBeUndefOrPoison(const Value *V, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, unsigned Depth=0)
Return true if this function can prove that V does not have undef bits and is never poison.
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:217
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...
Constant * ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty, APInt Offset, const DataLayout &DL)
Return the value that a load from C with offset Offset would produce if it is constant and determinab...
LLVM_READONLY APFloat minimum(const APFloat &A, const APFloat &B)
Implements IEEE 754-2019 minimum semantics.
Definition: APFloat.h:1577
Constant * ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, const DataLayout &DL)
Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrowe...
Constant * ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1, Constant *V2)
opStatus
IEEE-754R 7: Default exception handling.
Definition: APFloat.h:318
Represent subnormal handling kind for floating point instruction inputs and outputs.
DenormalModeKind Input
Denormal treatment kind for floating point instruction inputs in the default floating-point environme...
DenormalModeKind
Represent handled modes for denormal (aka subnormal) modes in the floating point environment.
@ PreserveSign
The sign of a flushed-to-zero number is preserved in the sign of 0.
@ PositiveZero
Denormals are flushed to positive zero.
@ Dynamic
Denormals have unknown treatment.
@ IEEE
IEEE-754 denormal numbers preserved.
DenormalModeKind Output
Denormal flushing mode for floating point instruction results in the default floating point environme...
static constexpr DenormalMode getDynamic()
static constexpr DenormalMode getIEEE()
Incoming for lane maks phi as machine instruction, incoming register Reg and incoming block Block are...
bool isConstant() const
Returns true if we know the value of all bits.
Definition: KnownBits.h:53
const APInt & getConstant() const
Returns the value when all bits have a known value.
Definition: KnownBits.h:59