Lines Matching +full:get +full:- +full:intrinsic
1 //===-- ConstantFolding.cpp - Fold instructions into constants ------------===//
8 //===----------------------------------------------------------------------===//
17 //===----------------------------------------------------------------------===//
48 //===----------------------------------------------------------------------===//
50 //===----------------------------------------------------------------------===//
53 /// This always returns a non-null constant, but it may be a
57 if (C->isNullValue() && !DestTy->isX86_MMXTy()) in FoldBitCast()
59 if (C->isAllOnesValue() && !DestTy->isX86_MMXTy() && in FoldBitCast()
60 !DestTy->isPtrOrPtrVectorTy()) // Don't get ones for ptr types! in FoldBitCast()
63 // Handle a vector->integer cast. in FoldBitCast()
65 auto *VTy = dyn_cast<VectorType>(C->getType()); in FoldBitCast()
69 unsigned NumSrcElts = VTy->getNumElements(); in FoldBitCast()
70 Type *SrcEltTy = VTy->getElementType(); in FoldBitCast()
74 if (SrcEltTy->isFloatingPointTy()) { in FoldBitCast()
75 unsigned FPWidth = SrcEltTy->getPrimitiveSizeInBits(); in FoldBitCast()
77 VectorType::get(IntegerType::get(C->getContext(), FPWidth), NumSrcElts); in FoldBitCast()
85 APInt Result(IT->getBitWidth(), 0); in FoldBitCast()
89 Element = C->getAggregateElement(NumSrcElts-i-1); in FoldBitCast()
91 Element = C->getAggregateElement(i); in FoldBitCast()
98 Result |= ElementCI->getValue().zextOrSelf(IT->getBitWidth()); in FoldBitCast()
101 return ConstantInt::get(IT, Result); in FoldBitCast()
109 // If this is a scalar -> vector cast, convert the input into a <1 x scalar> in FoldBitCast()
113 return FoldBitCast(ConstantVector::get(Ops), DestTy, DL); in FoldBitCast()
116 // If this is a bitcast from constant vector -> vector, fold it. in FoldBitCast()
121 unsigned NumDstElt = DestVTy->getNumElements(); in FoldBitCast()
122 unsigned NumSrcElt = C->getType()->getVectorNumElements(); in FoldBitCast()
126 Type *SrcEltTy = C->getType()->getVectorElementType(); in FoldBitCast()
127 Type *DstEltTy = DestVTy->getElementType(); in FoldBitCast()
139 if (DstEltTy->isFloatingPointTy()) { in FoldBitCast()
141 unsigned FPWidth = DstEltTy->getPrimitiveSizeInBits(); in FoldBitCast()
143 VectorType::get(IntegerType::get(C->getContext(), FPWidth), NumDstElt); in FoldBitCast()
153 if (SrcEltTy->isFloatingPointTy()) { in FoldBitCast()
154 unsigned FPWidth = SrcEltTy->getPrimitiveSizeInBits(); in FoldBitCast()
156 VectorType::get(IntegerType::get(C->getContext(), FPWidth), NumSrcElt); in FoldBitCast()
176 unsigned SrcBitSize = SrcEltTy->getPrimitiveSizeInBits(); in FoldBitCast()
181 unsigned ShiftAmt = isLittleEndian ? 0 : SrcBitSize*(Ratio-1); in FoldBitCast()
183 Constant *Src = dyn_cast<ConstantInt>(C->getAggregateElement(SrcElt++)); in FoldBitCast()
188 Src = ConstantExpr::getZExt(Src, Elt->getType()); in FoldBitCast()
192 ConstantInt::get(Src->getType(), ShiftAmt)); in FoldBitCast()
193 ShiftAmt += isLittleEndian ? SrcBitSize : -SrcBitSize; in FoldBitCast()
200 return ConstantVector::get(Result); in FoldBitCast()
209 auto *Src = dyn_cast<ConstantInt>(C->getAggregateElement(i)); in FoldBitCast()
213 unsigned ShiftAmt = isLittleEndian ? 0 : DstBitSize*(Ratio-1); in FoldBitCast()
218 ConstantInt::get(Src->getType(), ShiftAmt)); in FoldBitCast()
219 ShiftAmt += isLittleEndian ? DstBitSize : -DstBitSize; in FoldBitCast()
223 if (DstEltTy->isPointerTy()) { in FoldBitCast()
224 IntegerType *DstIntTy = Type::getIntNTy(C->getContext(), DstBitSize); in FoldBitCast()
235 return ConstantVector::get(Result); in FoldBitCast()
246 unsigned BitWidth = DL.getPointerTypeSizeInBits(GV->getType()); in IsConstantOffsetFromGlobal()
255 // Look through ptr->int and ptr->ptr casts. in IsConstantOffsetFromGlobal()
256 if (CE->getOpcode() == Instruction::PtrToInt || in IsConstantOffsetFromGlobal()
257 CE->getOpcode() == Instruction::BitCast) in IsConstantOffsetFromGlobal()
258 return IsConstantOffsetFromGlobal(CE->getOperand(0), GV, Offset, DL); in IsConstantOffsetFromGlobal()
265 unsigned BitWidth = DL.getPointerTypeSizeInBits(GEP->getType()); in IsConstantOffsetFromGlobal()
269 if (!IsConstantOffsetFromGlobal(CE->getOperand(0), GV, TmpOffset, DL)) in IsConstantOffsetFromGlobal()
273 if (!GEP->accumulateConstantOffset(DL, TmpOffset)) in IsConstantOffsetFromGlobal()
288 assert(ByteOffset <= DL.getTypeAllocSize(C->getType()) && in ReadDataFromGlobal()
297 if (CI->getBitWidth() > 64 || in ReadDataFromGlobal()
298 (CI->getBitWidth() & 7) != 0) in ReadDataFromGlobal()
301 uint64_t Val = CI->getZExtValue(); in ReadDataFromGlobal()
302 unsigned IntBytes = unsigned(CI->getBitWidth()/8); in ReadDataFromGlobal()
307 n = IntBytes - n - 1; in ReadDataFromGlobal()
315 if (CFP->getType()->isDoubleTy()) { in ReadDataFromGlobal()
316 C = FoldBitCast(C, Type::getInt64Ty(C->getContext()), DL); in ReadDataFromGlobal()
319 if (CFP->getType()->isFloatTy()){ in ReadDataFromGlobal()
320 C = FoldBitCast(C, Type::getInt32Ty(C->getContext()), DL); in ReadDataFromGlobal()
323 if (CFP->getType()->isHalfTy()){ in ReadDataFromGlobal()
324 C = FoldBitCast(C, Type::getInt16Ty(C->getContext()), DL); in ReadDataFromGlobal()
331 const StructLayout *SL = DL.getStructLayout(CS->getType()); in ReadDataFromGlobal()
332 unsigned Index = SL->getElementContainingOffset(ByteOffset); in ReadDataFromGlobal()
333 uint64_t CurEltOffset = SL->getElementOffset(Index); in ReadDataFromGlobal()
334 ByteOffset -= CurEltOffset; in ReadDataFromGlobal()
339 uint64_t EltSize = DL.getTypeAllocSize(CS->getOperand(Index)->getType()); in ReadDataFromGlobal()
342 !ReadDataFromGlobal(CS->getOperand(Index), ByteOffset, CurPtr, in ReadDataFromGlobal()
349 if (Index == CS->getType()->getNumElements()) in ReadDataFromGlobal()
353 uint64_t NextEltOffset = SL->getElementOffset(Index); in ReadDataFromGlobal()
355 if (BytesLeft <= NextEltOffset - CurEltOffset - ByteOffset) in ReadDataFromGlobal()
359 CurPtr += NextEltOffset - CurEltOffset - ByteOffset; in ReadDataFromGlobal()
360 BytesLeft -= NextEltOffset - CurEltOffset - ByteOffset; in ReadDataFromGlobal()
369 Type *EltTy = C->getType()->getSequentialElementType(); in ReadDataFromGlobal()
372 uint64_t Offset = ByteOffset - Index * EltSize; in ReadDataFromGlobal()
374 if (auto *AT = dyn_cast<ArrayType>(C->getType())) in ReadDataFromGlobal()
375 NumElts = AT->getNumElements(); in ReadDataFromGlobal()
377 NumElts = C->getType()->getVectorNumElements(); in ReadDataFromGlobal()
380 if (!ReadDataFromGlobal(C->getAggregateElement(Index), Offset, CurPtr, in ReadDataFromGlobal()
384 uint64_t BytesWritten = EltSize - Offset; in ReadDataFromGlobal()
390 BytesLeft -= BytesWritten; in ReadDataFromGlobal()
397 if (CE->getOpcode() == Instruction::IntToPtr && in ReadDataFromGlobal()
398 CE->getOperand(0)->getType() == DL.getIntPtrType(CE->getType())) { in ReadDataFromGlobal()
399 return ReadDataFromGlobal(CE->getOperand(0), ByteOffset, CurPtr, in ReadDataFromGlobal()
410 auto *PTy = cast<PointerType>(C->getType()); in FoldReinterpretLoadFromConstPtr()
415 unsigned AS = PTy->getAddressSpace(); in FoldReinterpretLoadFromConstPtr()
422 if (LoadTy->isHalfTy()) in FoldReinterpretLoadFromConstPtr()
423 MapTy = Type::getInt16Ty(C->getContext()); in FoldReinterpretLoadFromConstPtr()
424 else if (LoadTy->isFloatTy()) in FoldReinterpretLoadFromConstPtr()
425 MapTy = Type::getInt32Ty(C->getContext()); in FoldReinterpretLoadFromConstPtr()
426 else if (LoadTy->isDoubleTy()) in FoldReinterpretLoadFromConstPtr()
427 MapTy = Type::getInt64Ty(C->getContext()); in FoldReinterpretLoadFromConstPtr()
428 else if (LoadTy->isVectorTy()) { in FoldReinterpretLoadFromConstPtr()
429 MapTy = PointerType::getIntNTy(C->getContext(), in FoldReinterpretLoadFromConstPtr()
434 C = FoldBitCast(C, MapTy->getPointerTo(AS), DL); in FoldReinterpretLoadFromConstPtr()
440 unsigned BytesLoaded = (IntType->getBitWidth() + 7) / 8; in FoldReinterpretLoadFromConstPtr()
450 if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer() || in FoldReinterpretLoadFromConstPtr()
451 !GV->getInitializer()->getType()->isSized()) in FoldReinterpretLoadFromConstPtr()
455 int64_t InitializerSize = DL.getTypeAllocSize(GV->getInitializer()->getType()); in FoldReinterpretLoadFromConstPtr()
459 return UndefValue::get(IntType); in FoldReinterpretLoadFromConstPtr()
463 return UndefValue::get(IntType); in FoldReinterpretLoadFromConstPtr()
471 CurPtr += -Offset; in FoldReinterpretLoadFromConstPtr()
476 if (!ReadDataFromGlobal(GV->getInitializer(), Offset, CurPtr, BytesLeft, DL)) in FoldReinterpretLoadFromConstPtr()
479 APInt ResultVal = APInt(IntType->getBitWidth(), 0); in FoldReinterpretLoadFromConstPtr()
481 ResultVal = RawBytes[BytesLoaded - 1]; in FoldReinterpretLoadFromConstPtr()
484 ResultVal |= RawBytes[BytesLoaded - 1 - i]; in FoldReinterpretLoadFromConstPtr()
494 return ConstantInt::get(IntType->getContext(), ResultVal); in FoldReinterpretLoadFromConstPtr()
499 auto *SrcPtr = CE->getOperand(0); in ConstantFoldLoadThroughBitcast()
500 auto *SrcPtrTy = dyn_cast<PointerType>(SrcPtr->getType()); in ConstantFoldLoadThroughBitcast()
503 Type *SrcTy = SrcPtrTy->getPointerElementType(); in ConstantFoldLoadThroughBitcast()
510 Type *SrcTy = C->getType(); in ConstantFoldLoadThroughBitcast()
518 if (SrcTy->isIntegerTy() && DestTy->isPointerTy()) in ConstantFoldLoadThroughBitcast()
520 else if (SrcTy->isPointerTy() && DestTy->isIntegerTy()) in ConstantFoldLoadThroughBitcast()
529 if (!SrcTy->isAggregateType()) in ConstantFoldLoadThroughBitcast()
536 C = C->getAggregateElement(0u); in ConstantFoldLoadThroughBitcast()
548 if (GV->isConstant() && GV->hasDefinitiveInitializer()) in ConstantFoldLoadFromConstPtr()
549 return GV->getInitializer(); in ConstantFoldLoadFromConstPtr()
552 if (GA->getAliasee() && !GA->isInterposable()) in ConstantFoldLoadFromConstPtr()
553 return ConstantFoldLoadFromConstPtr(GA->getAliasee(), Ty, DL); in ConstantFoldLoadFromConstPtr()
560 if (CE->getOpcode() == Instruction::GetElementPtr) { in ConstantFoldLoadFromConstPtr()
561 if (auto *GV = dyn_cast<GlobalVariable>(CE->getOperand(0))) { in ConstantFoldLoadFromConstPtr()
562 if (GV->isConstant() && GV->hasDefinitiveInitializer()) { in ConstantFoldLoadFromConstPtr()
564 ConstantFoldLoadThroughGEPConstantExpr(GV->getInitializer(), CE)) in ConstantFoldLoadFromConstPtr()
570 if (CE->getOpcode() == Instruction::BitCast) in ConstantFoldLoadFromConstPtr()
579 unsigned NumBits = Ty->getPrimitiveSizeInBits(); in ConstantFoldLoadFromConstPtr()
583 (isa<IntegerType>(Ty) || Ty->isFloatingPointTy())) { in ConstantFoldLoadFromConstPtr()
601 Constant *Res = ConstantInt::get(CE->getContext(), StrVal); in ConstantFoldLoadFromConstPtr()
602 if (Ty->isFloatingPointTy()) in ConstantFoldLoadFromConstPtr()
611 if (GV->isConstant() && GV->hasDefinitiveInitializer()) { in ConstantFoldLoadFromConstPtr()
612 if (GV->getInitializer()->isNullValue()) in ConstantFoldLoadFromConstPtr()
614 if (isa<UndefValue>(GV->getInitializer())) in ConstantFoldLoadFromConstPtr()
615 return UndefValue::get(Ty); in ConstantFoldLoadFromConstPtr()
619 // Try hard to fold loads from bitcasted strange and non-type-safe things. in ConstantFoldLoadFromConstPtr()
626 if (LI->isVolatile()) return nullptr; in ConstantFoldLoadInst()
628 if (auto *C = dyn_cast<Constant>(LI->getOperand(0))) in ConstantFoldLoadInst()
629 return ConstantFoldLoadFromConstPtr(C, LI->getType(), DL); in ConstantFoldLoadInst()
642 // Fold (and 0xffffffff00000000, (shl x, 32)) -> shl. in SymbolicallyEvaluateBinop()
643 // Fold (lshr (or X, Y), 32) -> (lshr [X/Y], 32) if one doesn't contribute in SymbolicallyEvaluateBinop()
647 unsigned BitWidth = DL.getTypeSizeInBits(Op0->getType()->getScalarType()); in SymbolicallyEvaluateBinop()
664 return ConstantInt::get(Op0->getType(), KnownOne); in SymbolicallyEvaluateBinop()
668 // If the constant expr is something like &A[123] - &A[4].f, fold this into a in SymbolicallyEvaluateBinop()
676 unsigned OpSize = DL.getTypeSizeInBits(Op0->getType()); in SymbolicallyEvaluateBinop()
678 // (&GV+C1) - (&GV+C2) -> C1-C2, pointer arithmetic cannot overflow. in SymbolicallyEvaluateBinop()
681 return ConstantInt::get(Op0->getType(), Offs1.zextOrTrunc(OpSize) - in SymbolicallyEvaluateBinop()
689 /// If array indices are not pointer-sized integers, explicitly cast them so
701 Ops.slice(1, i - 1)))) && in CastGEPIndices()
702 Ops[i]->getType() != IntPtrTy) { in CastGEPIndices()
727 assert(Ptr->getType()->isPointerTy() && "Not a pointer type"); in StripPtrCastKeepAS()
728 auto *OldPtrTy = cast<PointerType>(Ptr->getType()); in StripPtrCastKeepAS()
729 Ptr = Ptr->stripPointerCasts(); in StripPtrCastKeepAS()
730 auto *NewPtrTy = cast<PointerType>(Ptr->getType()); in StripPtrCastKeepAS()
732 ElemTy = NewPtrTy->getPointerElementType(); in StripPtrCastKeepAS()
735 if (NewPtrTy->getAddressSpace() != OldPtrTy->getAddressSpace()) { in StripPtrCastKeepAS()
736 NewPtrTy = ElemTy->getPointerTo(OldPtrTy->getAddressSpace()); in StripPtrCastKeepAS()
747 Type *SrcElemTy = GEP->getSourceElementType(); in SymbolicallyEvaluateGEP()
748 Type *ResElemTy = GEP->getResultElementType(); in SymbolicallyEvaluateGEP()
749 Type *ResTy = GEP->getType(); in SymbolicallyEvaluateGEP()
750 if (!SrcElemTy->isSized()) in SymbolicallyEvaluateGEP()
757 if (!Ptr->getType()->isPointerTy()) in SymbolicallyEvaluateGEP()
760 Type *IntPtrTy = DL.getIntPtrType(Ptr->getType()); in SymbolicallyEvaluateGEP()
769 if (Ops.size() == 2 && ResElemTy->isIntegerTy(8)) { in SymbolicallyEvaluateGEP()
771 assert((!CE || CE->getType() == IntPtrTy) && in SymbolicallyEvaluateGEP()
773 if (CE && CE->getOpcode() == Instruction::Sub && in SymbolicallyEvaluateGEP()
774 CE->getOperand(0)->isNullValue()) { in SymbolicallyEvaluateGEP()
775 Constant *Res = ConstantExpr::getPtrToInt(Ptr, CE->getType()); in SymbolicallyEvaluateGEP()
776 Res = ConstantExpr::getSub(Res, CE->getOperand(1)); in SymbolicallyEvaluateGEP()
791 makeArrayRef((Value * const *)Ops.data() + 1, Ops.size() - 1))); in SymbolicallyEvaluateGEP()
796 SmallVector<Value *, 4> NestedOps(GEP->op_begin() + 1, GEP->op_end()); in SymbolicallyEvaluateGEP()
798 // Do not try the incorporate the sub-GEP if some index is not a number. in SymbolicallyEvaluateGEP()
808 Ptr = cast<Constant>(GEP->getOperand(0)); in SymbolicallyEvaluateGEP()
809 SrcElemTy = GEP->getSourceElementType(); in SymbolicallyEvaluateGEP()
818 if (CE->getOpcode() == Instruction::IntToPtr) { in SymbolicallyEvaluateGEP()
819 if (auto *Base = dyn_cast<ConstantInt>(CE->getOperand(0))) in SymbolicallyEvaluateGEP()
820 BasePtr = Base->getValue().zextOrTrunc(BitWidth); in SymbolicallyEvaluateGEP()
824 if (Ptr->isNullValue() || BasePtr != 0) { in SymbolicallyEvaluateGEP()
825 Constant *C = ConstantInt::get(Ptr->getContext(), Offset + BasePtr); in SymbolicallyEvaluateGEP()
830 // we eliminate over-indexing of the notional static type array bounds. in SymbolicallyEvaluateGEP()
833 Type *Ty = Ptr->getType(); in SymbolicallyEvaluateGEP()
834 assert(Ty->isPointerTy() && "Forming regular GEP of non-pointer type"); in SymbolicallyEvaluateGEP()
838 if (!Ty->isStructTy()) { in SymbolicallyEvaluateGEP()
839 if (Ty->isPointerTy()) { in SymbolicallyEvaluateGEP()
847 if (!Ty->isSized()) in SymbolicallyEvaluateGEP()
850 Ty = ATy->getElementType(); in SymbolicallyEvaluateGEP()
852 // We've reached some non-indexable type. in SymbolicallyEvaluateGEP()
862 NewIdxs.push_back(ConstantInt::get(IntPtrTy, 0)); in SymbolicallyEvaluateGEP()
864 // The element size is non-zero divide the offset by the element in SymbolicallyEvaluateGEP()
870 Offset -= NewIdx * ElemSize; in SymbolicallyEvaluateGEP()
871 NewIdxs.push_back(ConstantInt::get(IntPtrTy, NewIdx)); in SymbolicallyEvaluateGEP()
876 // can't re-form this GEP in a regular form, so bail out. The pointer in SymbolicallyEvaluateGEP()
887 NewIdxs.push_back(ConstantInt::get(Type::getInt32Ty(Ty->getContext()), in SymbolicallyEvaluateGEP()
889 Offset -= APInt(BitWidth, SL.getElementOffset(ElIdx)); in SymbolicallyEvaluateGEP()
890 Ty = STy->getTypeAtIndex(ElIdx); in SymbolicallyEvaluateGEP()
902 assert(C->getType()->getPointerElementType() == Ty && in SymbolicallyEvaluateGEP()
939 return ConstantExpr::getGetElementPtr(GEP->getSourceElementType(), in ConstantFoldInstOperandsImpl()
950 return ConstantFoldCall(F, Ops.slice(0, Ops.size() - 1), TLI); in ConstantFoldInstOperandsImpl()
965 //===----------------------------------------------------------------------===//
967 //===----------------------------------------------------------------------===//
975 for (Value *Incoming : PN->incoming_values()) { in ConstantFoldInstruction()
998 return CommonValue ? CommonValue : UndefValue::get(PN->getType()); in ConstantFoldInstruction()
1003 if (!all_of(I->operands(), [](Use &U) { return isa<Constant>(U); })) in ConstantFoldInstruction()
1007 for (const Use &OpU : I->operands()) { in ConstantFoldInstruction()
1017 return ConstantFoldCompareInstOperands(CI->getPredicate(), Ops[0], Ops[1], in ConstantFoldInstruction()
1025 cast<Constant>(IVI->getAggregateOperand()), in ConstantFoldInstruction()
1026 cast<Constant>(IVI->getInsertedValueOperand()), in ConstantFoldInstruction()
1027 IVI->getIndices()); in ConstantFoldInstruction()
1032 cast<Constant>(EVI->getAggregateOperand()), in ConstantFoldInstruction()
1033 EVI->getIndices()); in ConstantFoldInstruction()
1046 for (const Use &NewU : CE->operands()) { in ConstantFoldConstantExpressionImpl()
1057 if (CE->isCompare()) in ConstantFoldConstantExpressionImpl()
1058 return ConstantFoldCompareInstOperands(CE->getPredicate(), Ops[0], Ops[1], in ConstantFoldConstantExpressionImpl()
1061 return ConstantFoldInstOperandsImpl(CE, CE->getType(), CE->getOpcode(), Ops, in ConstantFoldConstantExpressionImpl()
1078 return ConstantFoldInstOperandsImpl(I, I->getType(), I->getOpcode(), Ops, DL, in ConstantFoldInstOperands()
1094 // fold: icmp (inttoptr x), null -> icmp x, 0 in ConstantFoldCompareInstOperands()
1095 // fold: icmp (ptrtoint x), 0 -> icmp x, null in ConstantFoldCompareInstOperands()
1096 // fold: icmp (inttoptr x), (inttoptr y) -> icmp trunc/zext x, trunc/zext y in ConstantFoldCompareInstOperands()
1097 // fold: icmp (ptrtoint x), (ptrtoint y) -> icmp x, y in ConstantFoldCompareInstOperands()
1103 if (Ops1->isNullValue()) { in ConstantFoldCompareInstOperands()
1104 if (CE0->getOpcode() == Instruction::IntToPtr) { in ConstantFoldCompareInstOperands()
1105 Type *IntPtrTy = DL.getIntPtrType(CE0->getType()); in ConstantFoldCompareInstOperands()
1106 // Convert the integer value to the right size to ensure we get the in ConstantFoldCompareInstOperands()
1108 Constant *C = ConstantExpr::getIntegerCast(CE0->getOperand(0), in ConstantFoldCompareInstOperands()
1110 Constant *Null = Constant::getNullValue(C->getType()); in ConstantFoldCompareInstOperands()
1116 if (CE0->getOpcode() == Instruction::PtrToInt) { in ConstantFoldCompareInstOperands()
1117 Type *IntPtrTy = DL.getIntPtrType(CE0->getOperand(0)->getType()); in ConstantFoldCompareInstOperands()
1118 if (CE0->getType() == IntPtrTy) { in ConstantFoldCompareInstOperands()
1119 Constant *C = CE0->getOperand(0); in ConstantFoldCompareInstOperands()
1120 Constant *Null = Constant::getNullValue(C->getType()); in ConstantFoldCompareInstOperands()
1127 if (CE0->getOpcode() == CE1->getOpcode()) { in ConstantFoldCompareInstOperands()
1128 if (CE0->getOpcode() == Instruction::IntToPtr) { in ConstantFoldCompareInstOperands()
1129 Type *IntPtrTy = DL.getIntPtrType(CE0->getType()); in ConstantFoldCompareInstOperands()
1131 // Convert the integer value to the right size to ensure we get the in ConstantFoldCompareInstOperands()
1133 Constant *C0 = ConstantExpr::getIntegerCast(CE0->getOperand(0), in ConstantFoldCompareInstOperands()
1135 Constant *C1 = ConstantExpr::getIntegerCast(CE1->getOperand(0), in ConstantFoldCompareInstOperands()
1142 if (CE0->getOpcode() == Instruction::PtrToInt) { in ConstantFoldCompareInstOperands()
1143 Type *IntPtrTy = DL.getIntPtrType(CE0->getOperand(0)->getType()); in ConstantFoldCompareInstOperands()
1144 if (CE0->getType() == IntPtrTy && in ConstantFoldCompareInstOperands()
1145 CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType()) { in ConstantFoldCompareInstOperands()
1147 Predicate, CE0->getOperand(0), CE1->getOperand(0), DL, TLI); in ConstantFoldCompareInstOperands()
1153 // icmp eq (or x, y), 0 -> (icmp eq x, 0) & (icmp eq y, 0) in ConstantFoldCompareInstOperands()
1154 // icmp ne (or x, y), 0 -> (icmp ne x, 0) | (icmp ne y, 0) in ConstantFoldCompareInstOperands()
1156 CE0->getOpcode() == Instruction::Or && Ops1->isNullValue()) { in ConstantFoldCompareInstOperands()
1158 Predicate, CE0->getOperand(0), Ops1, DL, TLI); in ConstantFoldCompareInstOperands()
1160 Predicate, CE0->getOperand(1), Ops1, DL, TLI); in ConstantFoldCompareInstOperands()
1178 return ConstantExpr::get(Opcode, LHS, RHS); in ConstantFoldBinaryOpOperands()
1191 if (CE->getOpcode() == Instruction::IntToPtr) { in ConstantFoldCastOperand()
1192 Constant *Input = CE->getOperand(0); in ConstantFoldCastOperand()
1193 unsigned InWidth = Input->getType()->getScalarSizeInBits(); in ConstantFoldCastOperand()
1194 unsigned PtrWidth = DL.getPointerTypeSizeInBits(CE->getType()); in ConstantFoldCastOperand()
1197 ConstantInt::get(CE->getContext(), in ConstantFoldCastOperand()
1201 // Do a zext or trunc to get to the dest size. in ConstantFoldCastOperand()
1212 if (CE->getOpcode() == Instruction::PtrToInt) { in ConstantFoldCastOperand()
1213 Constant *SrcPtr = CE->getOperand(0); in ConstantFoldCastOperand()
1214 unsigned SrcPtrSize = DL.getPointerTypeSizeInBits(SrcPtr->getType()); in ConstantFoldCastOperand()
1215 unsigned MidIntSize = CE->getType()->getScalarSizeInBits(); in ConstantFoldCastOperand()
1218 unsigned SrcAS = SrcPtr->getType()->getPointerAddressSpace(); in ConstantFoldCastOperand()
1219 if (SrcAS == DestTy->getPointerAddressSpace()) in ConstantFoldCastOperand()
1220 return FoldBitCast(CE->getOperand(0), DestTy, DL); in ConstantFoldCastOperand()
1244 if (!CE->getOperand(1)->isNullValue()) in ConstantFoldLoadThroughGEPConstantExpr()
1249 for (unsigned i = 2, e = CE->getNumOperands(); i != e; ++i) { in ConstantFoldLoadThroughGEPConstantExpr()
1250 C = C->getAggregateElement(CE->getOperand(i)); in ConstantFoldLoadThroughGEPConstantExpr()
1263 C = C->getAggregateElement(Index); in ConstantFoldLoadThroughGEPIndices()
1270 //===----------------------------------------------------------------------===//
1275 switch (F->getIntrinsicID()) { in canConstantFoldCallTo()
1276 case Intrinsic::fabs: in canConstantFoldCallTo()
1277 case Intrinsic::minnum: in canConstantFoldCallTo()
1278 case Intrinsic::maxnum: in canConstantFoldCallTo()
1279 case Intrinsic::log: in canConstantFoldCallTo()
1280 case Intrinsic::log2: in canConstantFoldCallTo()
1281 case Intrinsic::log10: in canConstantFoldCallTo()
1282 case Intrinsic::exp: in canConstantFoldCallTo()
1283 case Intrinsic::exp2: in canConstantFoldCallTo()
1284 case Intrinsic::floor: in canConstantFoldCallTo()
1285 case Intrinsic::ceil: in canConstantFoldCallTo()
1286 case Intrinsic::sqrt: in canConstantFoldCallTo()
1287 case Intrinsic::sin: in canConstantFoldCallTo()
1288 case Intrinsic::cos: in canConstantFoldCallTo()
1289 case Intrinsic::trunc: in canConstantFoldCallTo()
1290 case Intrinsic::rint: in canConstantFoldCallTo()
1291 case Intrinsic::nearbyint: in canConstantFoldCallTo()
1292 case Intrinsic::pow: in canConstantFoldCallTo()
1293 case Intrinsic::powi: in canConstantFoldCallTo()
1294 case Intrinsic::bswap: in canConstantFoldCallTo()
1295 case Intrinsic::ctpop: in canConstantFoldCallTo()
1296 case Intrinsic::ctlz: in canConstantFoldCallTo()
1297 case Intrinsic::cttz: in canConstantFoldCallTo()
1298 case Intrinsic::fma: in canConstantFoldCallTo()
1299 case Intrinsic::fmuladd: in canConstantFoldCallTo()
1300 case Intrinsic::copysign: in canConstantFoldCallTo()
1301 case Intrinsic::round: in canConstantFoldCallTo()
1302 case Intrinsic::masked_load: in canConstantFoldCallTo()
1303 case Intrinsic::sadd_with_overflow: in canConstantFoldCallTo()
1304 case Intrinsic::uadd_with_overflow: in canConstantFoldCallTo()
1305 case Intrinsic::ssub_with_overflow: in canConstantFoldCallTo()
1306 case Intrinsic::usub_with_overflow: in canConstantFoldCallTo()
1307 case Intrinsic::smul_with_overflow: in canConstantFoldCallTo()
1308 case Intrinsic::umul_with_overflow: in canConstantFoldCallTo()
1309 case Intrinsic::convert_from_fp16: in canConstantFoldCallTo()
1310 case Intrinsic::convert_to_fp16: in canConstantFoldCallTo()
1311 case Intrinsic::bitreverse: in canConstantFoldCallTo()
1312 case Intrinsic::x86_sse_cvtss2si: in canConstantFoldCallTo()
1313 case Intrinsic::x86_sse_cvtss2si64: in canConstantFoldCallTo()
1314 case Intrinsic::x86_sse_cvttss2si: in canConstantFoldCallTo()
1315 case Intrinsic::x86_sse_cvttss2si64: in canConstantFoldCallTo()
1316 case Intrinsic::x86_sse2_cvtsd2si: in canConstantFoldCallTo()
1317 case Intrinsic::x86_sse2_cvtsd2si64: in canConstantFoldCallTo()
1318 case Intrinsic::x86_sse2_cvttsd2si: in canConstantFoldCallTo()
1319 case Intrinsic::x86_sse2_cvttsd2si64: in canConstantFoldCallTo()
1326 if (!F->hasName()) in canConstantFoldCallTo()
1328 StringRef Name = F->getName(); in canConstantFoldCallTo()
1364 if (Ty->isHalfTy()) { in GetConstantFoldFPValue()
1368 return ConstantFP::get(Ty->getContext(), APF); in GetConstantFoldFPValue()
1370 if (Ty->isFloatTy()) in GetConstantFoldFPValue()
1371 return ConstantFP::get(Ty->getContext(), APFloat((float)V)); in GetConstantFoldFPValue()
1372 if (Ty->isDoubleTy()) in GetConstantFoldFPValue()
1373 return ConstantFP::get(Ty->getContext(), APFloat(V)); in GetConstantFoldFPValue()
1377 /// Clear the floating-point exception state.
1385 /// Test if a floating-point exception was raised.
1423 /// non-truncating SSE instructions in the default rounding mode. The desired
1430 unsigned ResultWidth = Ty->getIntegerBitWidth(); in ConstantFoldConvertToInt()
1443 return ConstantInt::get(Ty, UIntVal, /*isSigned=*/true); in ConstantFoldConvertToInt()
1447 Type *Ty = Op->getType(); in getValueAsDouble()
1449 if (Ty->isFloatTy()) in getValueAsDouble()
1450 return Op->getValueAPF().convertToFloat(); in getValueAsDouble()
1452 if (Ty->isDoubleTy()) in getValueAsDouble()
1453 return Op->getValueAPF().convertToDouble(); in getValueAsDouble()
1456 APFloat APF = Op->getValueAPF(); in getValueAsDouble()
1466 // cosine(arg) is between -1 and 1. cosine(invalid arg) is NaN in ConstantFoldScalarCall()
1467 if (IntrinsicID == Intrinsic::cos) in ConstantFoldScalarCall()
1471 if (IntrinsicID == Intrinsic::convert_to_fp16) { in ConstantFoldScalarCall()
1472 APFloat Val(Op->getValueAPF()); in ConstantFoldScalarCall()
1477 return ConstantInt::get(Ty->getContext(), Val.bitcastToAPInt()); in ConstantFoldScalarCall()
1480 if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy()) in ConstantFoldScalarCall()
1483 if (IntrinsicID == Intrinsic::round) { in ConstantFoldScalarCall()
1484 APFloat V = Op->getValueAPF(); in ConstantFoldScalarCall()
1486 return ConstantFP::get(Ty->getContext(), V); in ConstantFoldScalarCall()
1489 if (IntrinsicID == Intrinsic::floor) { in ConstantFoldScalarCall()
1490 APFloat V = Op->getValueAPF(); in ConstantFoldScalarCall()
1492 return ConstantFP::get(Ty->getContext(), V); in ConstantFoldScalarCall()
1495 if (IntrinsicID == Intrinsic::ceil) { in ConstantFoldScalarCall()
1496 APFloat V = Op->getValueAPF(); in ConstantFoldScalarCall()
1498 return ConstantFP::get(Ty->getContext(), V); in ConstantFoldScalarCall()
1501 if (IntrinsicID == Intrinsic::trunc) { in ConstantFoldScalarCall()
1502 APFloat V = Op->getValueAPF(); in ConstantFoldScalarCall()
1504 return ConstantFP::get(Ty->getContext(), V); in ConstantFoldScalarCall()
1507 if (IntrinsicID == Intrinsic::rint) { in ConstantFoldScalarCall()
1508 APFloat V = Op->getValueAPF(); in ConstantFoldScalarCall()
1510 return ConstantFP::get(Ty->getContext(), V); in ConstantFoldScalarCall()
1513 if (IntrinsicID == Intrinsic::nearbyint) { in ConstantFoldScalarCall()
1514 APFloat V = Op->getValueAPF(); in ConstantFoldScalarCall()
1516 return ConstantFP::get(Ty->getContext(), V); in ConstantFoldScalarCall()
1522 if (Op->getValueAPF().isNaN() || Op->getValueAPF().isInfinity()) in ConstantFoldScalarCall()
1533 case Intrinsic::fabs: in ConstantFoldScalarCall()
1535 case Intrinsic::log2: in ConstantFoldScalarCall()
1537 case Intrinsic::log: in ConstantFoldScalarCall()
1539 case Intrinsic::log10: in ConstantFoldScalarCall()
1541 case Intrinsic::exp: in ConstantFoldScalarCall()
1543 case Intrinsic::exp2: in ConstantFoldScalarCall()
1545 case Intrinsic::sin: in ConstantFoldScalarCall()
1547 case Intrinsic::cos: in ConstantFoldScalarCall()
1556 if ((Name == "acos" && TLI->has(LibFunc::acos)) || in ConstantFoldScalarCall()
1557 (Name == "acosf" && TLI->has(LibFunc::acosf))) in ConstantFoldScalarCall()
1559 else if ((Name == "asin" && TLI->has(LibFunc::asin)) || in ConstantFoldScalarCall()
1560 (Name == "asinf" && TLI->has(LibFunc::asinf))) in ConstantFoldScalarCall()
1562 else if ((Name == "atan" && TLI->has(LibFunc::atan)) || in ConstantFoldScalarCall()
1563 (Name == "atanf" && TLI->has(LibFunc::atanf))) in ConstantFoldScalarCall()
1567 if ((Name == "ceil" && TLI->has(LibFunc::ceil)) || in ConstantFoldScalarCall()
1568 (Name == "ceilf" && TLI->has(LibFunc::ceilf))) in ConstantFoldScalarCall()
1570 else if ((Name == "cos" && TLI->has(LibFunc::cos)) || in ConstantFoldScalarCall()
1571 (Name == "cosf" && TLI->has(LibFunc::cosf))) in ConstantFoldScalarCall()
1573 else if ((Name == "cosh" && TLI->has(LibFunc::cosh)) || in ConstantFoldScalarCall()
1574 (Name == "coshf" && TLI->has(LibFunc::coshf))) in ConstantFoldScalarCall()
1578 if ((Name == "exp" && TLI->has(LibFunc::exp)) || in ConstantFoldScalarCall()
1579 (Name == "expf" && TLI->has(LibFunc::expf))) in ConstantFoldScalarCall()
1581 if ((Name == "exp2" && TLI->has(LibFunc::exp2)) || in ConstantFoldScalarCall()
1582 (Name == "exp2f" && TLI->has(LibFunc::exp2f))) in ConstantFoldScalarCall()
1588 if ((Name == "fabs" && TLI->has(LibFunc::fabs)) || in ConstantFoldScalarCall()
1589 (Name == "fabsf" && TLI->has(LibFunc::fabsf))) in ConstantFoldScalarCall()
1591 else if ((Name == "floor" && TLI->has(LibFunc::floor)) || in ConstantFoldScalarCall()
1592 (Name == "floorf" && TLI->has(LibFunc::floorf))) in ConstantFoldScalarCall()
1596 if ((Name == "log" && V > 0 && TLI->has(LibFunc::log)) || in ConstantFoldScalarCall()
1597 (Name == "logf" && V > 0 && TLI->has(LibFunc::logf))) in ConstantFoldScalarCall()
1599 else if ((Name == "log10" && V > 0 && TLI->has(LibFunc::log10)) || in ConstantFoldScalarCall()
1600 (Name == "log10f" && V > 0 && TLI->has(LibFunc::log10f))) in ConstantFoldScalarCall()
1602 else if (IntrinsicID == Intrinsic::sqrt && in ConstantFoldScalarCall()
1603 (Ty->isHalfTy() || Ty->isFloatTy() || Ty->isDoubleTy())) { in ConstantFoldScalarCall()
1604 if (V >= -0.0) in ConstantFoldScalarCall()
1607 // Unlike the sqrt definitions in C/C++, POSIX, and IEEE-754 - which in ConstantFoldScalarCall()
1608 // all guarantee or favor returning NaN - the square root of a in ConstantFoldScalarCall()
1609 // negative number is not defined for the LLVM sqrt intrinsic. in ConstantFoldScalarCall()
1610 // This is because the intrinsic should only be emitted in place of in ConstantFoldScalarCall()
1611 // libm's sqrt function when using "no-nans-fp-math". in ConstantFoldScalarCall()
1612 return UndefValue::get(Ty); in ConstantFoldScalarCall()
1617 if ((Name == "sin" && TLI->has(LibFunc::sin)) || in ConstantFoldScalarCall()
1618 (Name == "sinf" && TLI->has(LibFunc::sinf))) in ConstantFoldScalarCall()
1620 else if ((Name == "sinh" && TLI->has(LibFunc::sinh)) || in ConstantFoldScalarCall()
1621 (Name == "sinhf" && TLI->has(LibFunc::sinhf))) in ConstantFoldScalarCall()
1623 else if ((Name == "sqrt" && V >= 0 && TLI->has(LibFunc::sqrt)) || in ConstantFoldScalarCall()
1624 (Name == "sqrtf" && V >= 0 && TLI->has(LibFunc::sqrtf))) in ConstantFoldScalarCall()
1628 if ((Name == "tan" && TLI->has(LibFunc::tan)) || in ConstantFoldScalarCall()
1629 (Name == "tanf" && TLI->has(LibFunc::tanf))) in ConstantFoldScalarCall()
1631 else if ((Name == "tanh" && TLI->has(LibFunc::tanh)) || in ConstantFoldScalarCall()
1632 (Name == "tanhf" && TLI->has(LibFunc::tanhf))) in ConstantFoldScalarCall()
1643 case Intrinsic::bswap: in ConstantFoldScalarCall()
1644 return ConstantInt::get(Ty->getContext(), Op->getValue().byteSwap()); in ConstantFoldScalarCall()
1645 case Intrinsic::ctpop: in ConstantFoldScalarCall()
1646 return ConstantInt::get(Ty, Op->getValue().countPopulation()); in ConstantFoldScalarCall()
1647 case Intrinsic::bitreverse: in ConstantFoldScalarCall()
1648 return ConstantInt::get(Ty->getContext(), Op->getValue().reverseBits()); in ConstantFoldScalarCall()
1649 case Intrinsic::convert_from_fp16: { in ConstantFoldScalarCall()
1650 APFloat Val(APFloat::IEEEhalf, Op->getValue()); in ConstantFoldScalarCall()
1654 Ty->getFltSemantics(), APFloat::rmNearestTiesToEven, &lost); in ConstantFoldScalarCall()
1661 return ConstantFP::get(Ty->getContext(), Val); in ConstantFoldScalarCall()
1674 case Intrinsic::x86_sse_cvtss2si: in ConstantFoldScalarCall()
1675 case Intrinsic::x86_sse_cvtss2si64: in ConstantFoldScalarCall()
1676 case Intrinsic::x86_sse2_cvtsd2si: in ConstantFoldScalarCall()
1677 case Intrinsic::x86_sse2_cvtsd2si64: in ConstantFoldScalarCall()
1679 dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U))) in ConstantFoldScalarCall()
1680 return ConstantFoldConvertToInt(FPOp->getValueAPF(), in ConstantFoldScalarCall()
1682 case Intrinsic::x86_sse_cvttss2si: in ConstantFoldScalarCall()
1683 case Intrinsic::x86_sse_cvttss2si64: in ConstantFoldScalarCall()
1684 case Intrinsic::x86_sse2_cvttsd2si: in ConstantFoldScalarCall()
1685 case Intrinsic::x86_sse2_cvttsd2si64: in ConstantFoldScalarCall()
1687 dyn_cast_or_null<ConstantFP>(Op->getAggregateElement(0U))) in ConstantFoldScalarCall()
1688 return ConstantFoldConvertToInt(FPOp->getValueAPF(), in ConstantFoldScalarCall()
1694 if (IntrinsicID == Intrinsic::bswap) in ConstantFoldScalarCall()
1704 if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy()) in ConstantFoldScalarCall()
1709 if (Op2->getType() != Op1->getType()) in ConstantFoldScalarCall()
1713 if (IntrinsicID == Intrinsic::pow) { in ConstantFoldScalarCall()
1716 if (IntrinsicID == Intrinsic::copysign) { in ConstantFoldScalarCall()
1717 APFloat V1 = Op1->getValueAPF(); in ConstantFoldScalarCall()
1718 const APFloat &V2 = Op2->getValueAPF(); in ConstantFoldScalarCall()
1720 return ConstantFP::get(Ty->getContext(), V1); in ConstantFoldScalarCall()
1723 if (IntrinsicID == Intrinsic::minnum) { in ConstantFoldScalarCall()
1724 const APFloat &C1 = Op1->getValueAPF(); in ConstantFoldScalarCall()
1725 const APFloat &C2 = Op2->getValueAPF(); in ConstantFoldScalarCall()
1726 return ConstantFP::get(Ty->getContext(), minnum(C1, C2)); in ConstantFoldScalarCall()
1729 if (IntrinsicID == Intrinsic::maxnum) { in ConstantFoldScalarCall()
1730 const APFloat &C1 = Op1->getValueAPF(); in ConstantFoldScalarCall()
1731 const APFloat &C2 = Op2->getValueAPF(); in ConstantFoldScalarCall()
1732 return ConstantFP::get(Ty->getContext(), maxnum(C1, C2)); in ConstantFoldScalarCall()
1737 if ((Name == "pow" && TLI->has(LibFunc::pow)) || in ConstantFoldScalarCall()
1738 (Name == "powf" && TLI->has(LibFunc::powf))) in ConstantFoldScalarCall()
1740 if ((Name == "fmod" && TLI->has(LibFunc::fmod)) || in ConstantFoldScalarCall()
1741 (Name == "fmodf" && TLI->has(LibFunc::fmodf))) in ConstantFoldScalarCall()
1743 if ((Name == "atan2" && TLI->has(LibFunc::atan2)) || in ConstantFoldScalarCall()
1744 (Name == "atan2f" && TLI->has(LibFunc::atan2f))) in ConstantFoldScalarCall()
1747 if (IntrinsicID == Intrinsic::powi && Ty->isHalfTy()) in ConstantFoldScalarCall()
1748 return ConstantFP::get(Ty->getContext(), in ConstantFoldScalarCall()
1750 (int)Op2C->getZExtValue()))); in ConstantFoldScalarCall()
1751 if (IntrinsicID == Intrinsic::powi && Ty->isFloatTy()) in ConstantFoldScalarCall()
1752 return ConstantFP::get(Ty->getContext(), in ConstantFoldScalarCall()
1754 (int)Op2C->getZExtValue()))); in ConstantFoldScalarCall()
1755 if (IntrinsicID == Intrinsic::powi && Ty->isDoubleTy()) in ConstantFoldScalarCall()
1756 return ConstantFP::get(Ty->getContext(), in ConstantFoldScalarCall()
1758 (int)Op2C->getZExtValue()))); in ConstantFoldScalarCall()
1767 case Intrinsic::sadd_with_overflow: in ConstantFoldScalarCall()
1768 case Intrinsic::uadd_with_overflow: in ConstantFoldScalarCall()
1769 case Intrinsic::ssub_with_overflow: in ConstantFoldScalarCall()
1770 case Intrinsic::usub_with_overflow: in ConstantFoldScalarCall()
1771 case Intrinsic::smul_with_overflow: in ConstantFoldScalarCall()
1772 case Intrinsic::umul_with_overflow: { in ConstantFoldScalarCall()
1777 case Intrinsic::sadd_with_overflow: in ConstantFoldScalarCall()
1778 Res = Op1->getValue().sadd_ov(Op2->getValue(), Overflow); in ConstantFoldScalarCall()
1780 case Intrinsic::uadd_with_overflow: in ConstantFoldScalarCall()
1781 Res = Op1->getValue().uadd_ov(Op2->getValue(), Overflow); in ConstantFoldScalarCall()
1783 case Intrinsic::ssub_with_overflow: in ConstantFoldScalarCall()
1784 Res = Op1->getValue().ssub_ov(Op2->getValue(), Overflow); in ConstantFoldScalarCall()
1786 case Intrinsic::usub_with_overflow: in ConstantFoldScalarCall()
1787 Res = Op1->getValue().usub_ov(Op2->getValue(), Overflow); in ConstantFoldScalarCall()
1789 case Intrinsic::smul_with_overflow: in ConstantFoldScalarCall()
1790 Res = Op1->getValue().smul_ov(Op2->getValue(), Overflow); in ConstantFoldScalarCall()
1792 case Intrinsic::umul_with_overflow: in ConstantFoldScalarCall()
1793 Res = Op1->getValue().umul_ov(Op2->getValue(), Overflow); in ConstantFoldScalarCall()
1797 ConstantInt::get(Ty->getContext(), Res), in ConstantFoldScalarCall()
1798 ConstantInt::get(Type::getInt1Ty(Ty->getContext()), Overflow) in ConstantFoldScalarCall()
1800 return ConstantStruct::get(cast<StructType>(Ty), Ops); in ConstantFoldScalarCall()
1802 case Intrinsic::cttz: in ConstantFoldScalarCall()
1803 if (Op2->isOne() && Op1->isZero()) // cttz(0, 1) is undef. in ConstantFoldScalarCall()
1804 return UndefValue::get(Ty); in ConstantFoldScalarCall()
1805 return ConstantInt::get(Ty, Op1->getValue().countTrailingZeros()); in ConstantFoldScalarCall()
1806 case Intrinsic::ctlz: in ConstantFoldScalarCall()
1807 if (Op2->isOne() && Op1->isZero()) // ctlz(0, 1) is undef. in ConstantFoldScalarCall()
1808 return UndefValue::get(Ty); in ConstantFoldScalarCall()
1809 return ConstantInt::get(Ty, Op1->getValue().countLeadingZeros()); in ConstantFoldScalarCall()
1826 case Intrinsic::fma: in ConstantFoldScalarCall()
1827 case Intrinsic::fmuladd: { in ConstantFoldScalarCall()
1828 APFloat V = Op1->getValueAPF(); in ConstantFoldScalarCall()
1829 APFloat::opStatus s = V.fusedMultiplyAdd(Op2->getValueAPF(), in ConstantFoldScalarCall()
1830 Op3->getValueAPF(), in ConstantFoldScalarCall()
1833 return ConstantFP::get(Ty->getContext(), V); in ConstantFoldScalarCall()
1849 SmallVector<Constant *, 4> Result(VTy->getNumElements()); in ConstantFoldVectorCall()
1851 Type *Ty = VTy->getElementType(); in ConstantFoldVectorCall()
1853 if (IntrinsicID == Intrinsic::masked_load) { in ConstantFoldVectorCall()
1861 for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) { in ConstantFoldVectorCall()
1862 auto *MaskElt = Mask->getAggregateElement(I); in ConstantFoldVectorCall()
1865 auto *PassthruElt = Passthru->getAggregateElement(I); in ConstantFoldVectorCall()
1866 auto *VecElt = VecData ? VecData->getAggregateElement(I) : nullptr; in ConstantFoldVectorCall()
1875 if (MaskElt->isNullValue()) { in ConstantFoldVectorCall()
1879 } else if (MaskElt->isOneValue()) { in ConstantFoldVectorCall()
1887 if (NewElements.size() != VTy->getNumElements()) in ConstantFoldVectorCall()
1889 return ConstantVector::get(NewElements); in ConstantFoldVectorCall()
1892 for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) { in ConstantFoldVectorCall()
1895 Constant *Agg = Operands[J]->getAggregateElement(I); in ConstantFoldVectorCall()
1909 return ConstantVector::get(Result); in ConstantFoldVectorCall()
1917 if (!F->hasName()) in ConstantFoldCall()
1919 StringRef Name = F->getName(); in ConstantFoldCall()
1921 Type *Ty = F->getReturnType(); in ConstantFoldCall()
1924 return ConstantFoldVectorCall(Name, F->getIntrinsicID(), VTy, Operands, in ConstantFoldCall()
1925 F->getParent()->getDataLayout(), TLI); in ConstantFoldCall()
1927 return ConstantFoldScalarCall(Name, F->getIntrinsicID(), Ty, Operands, TLI); in ConstantFoldCall()