Lines Matching defs:Ty
370 Constant *Constant::getNullValue(Type *Ty) {
371 switch (Ty->getTypeID()) {
373 return ConstantInt::get(Ty, 0);
381 return ConstantFP::get(Ty->getContext(),
382 APFloat::getZero(Ty->getFltSemantics()));
384 return ConstantPointerNull::get(cast<PointerType>(Ty));
389 return ConstantAggregateZero::get(Ty);
391 return ConstantTokenNone::get(Ty->getContext());
393 return ConstantTargetNone::get(cast<TargetExtType>(Ty));
400 Constant *Constant::getIntegerValue(Type *Ty, const APInt &V) {
401 Type *ScalarTy = Ty->getScalarType();
404 Constant *C = ConstantInt::get(Ty->getContext(), V);
411 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
417 Constant *Constant::getAllOnesValue(Type *Ty) {
418 if (IntegerType *ITy = dyn_cast<IntegerType>(Ty))
419 return ConstantInt::get(Ty->getContext(),
422 if (Ty->isFloatingPointTy()) {
423 APFloat FL = APFloat::getAllOnesValue(Ty->getFltSemantics());
424 return ConstantFP::get(Ty->getContext(), FL);
427 VectorType *VTy = cast<VectorType>(Ty);
770 Type *Ty = C->getType();
772 assert(Ty == Replacement->getType() && "Expected matching types");
777 auto *VTy = dyn_cast<FixedVectorType>(Ty);
797 Type *Ty = C->getType();
799 return UndefValue::get(Ty);
801 auto *VTy = dyn_cast<FixedVectorType>(Ty);
843 ConstantInt::ConstantInt(Type *Ty, const APInt &V)
844 : ConstantData(Ty, ConstantIntVal), Val(V) {
846 cast<IntegerType>(Ty->getScalarType())->getBitWidth() &&
868 Constant *ConstantInt::getTrue(Type *Ty) {
869 assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
870 ConstantInt *TrueC = ConstantInt::getTrue(Ty->getContext());
871 if (auto *VTy = dyn_cast<VectorType>(Ty))
876 Constant *ConstantInt::getFalse(Type *Ty) {
877 assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
878 ConstantInt *FalseC = ConstantInt::getFalse(Ty->getContext());
879 if (auto *VTy = dyn_cast<VectorType>(Ty))
884 Constant *ConstantInt::getBool(Type *Ty, bool V) {
885 return V ? getTrue(Ty) : getFalse(Ty);
925 Constant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) {
926 Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned);
929 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
935 ConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V, bool isSigned) {
936 return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned));
939 Constant *ConstantInt::get(Type *Ty, const APInt& V) {
940 ConstantInt *C = get(Ty->getContext(), V);
941 assert(C->getType() == Ty->getScalarType() &&
945 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
951 ConstantInt *ConstantInt::get(IntegerType* Ty, StringRef Str, uint8_t radix) {
952 return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix));
964 Constant *ConstantFP::get(Type *Ty, double V) {
965 LLVMContext &Context = Ty->getContext();
969 FV.convert(Ty->getScalarType()->getFltSemantics(),
974 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
980 Constant *ConstantFP::get(Type *Ty, const APFloat &V) {
981 ConstantFP *C = get(Ty->getContext(), V);
982 assert(C->getType() == Ty->getScalarType() &&
986 if (auto *VTy = dyn_cast<VectorType>(Ty))
992 Constant *ConstantFP::get(Type *Ty, StringRef Str) {
993 LLVMContext &Context = Ty->getContext();
995 APFloat FV(Ty->getScalarType()->getFltSemantics(), Str);
999 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1005 Constant *ConstantFP::getNaN(Type *Ty, bool Negative, uint64_t Payload) {
1006 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1008 Constant *C = get(Ty->getContext(), NaN);
1010 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1016 Constant *ConstantFP::getQNaN(Type *Ty, bool Negative, APInt *Payload) {
1017 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1019 Constant *C = get(Ty->getContext(), NaN);
1021 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1027 Constant *ConstantFP::getSNaN(Type *Ty, bool Negative, APInt *Payload) {
1028 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1030 Constant *C = get(Ty->getContext(), NaN);
1032 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1038 Constant *ConstantFP::getZero(Type *Ty, bool Negative) {
1039 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1041 Constant *C = get(Ty->getContext(), NegZero);
1043 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1057 Type *Ty = Type::getFloatingPointTy(Context, V.getSemantics());
1058 Slot.reset(new ConstantFP(Ty, V));
1084 Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) {
1085 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1086 Constant *C = get(Ty->getContext(), APFloat::getInf(Semantics, Negative));
1088 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1094 ConstantFP::ConstantFP(Type *Ty, const APFloat &V)
1095 : ConstantData(Ty, ConstantFPVal), Val(V) {
1096 assert(&V.getSemantics() == &Ty->getScalarType()->getFltSemantics() &&
1136 Type *Ty = getType();
1137 if (auto *AT = dyn_cast<ArrayType>(Ty))
1139 if (auto *VT = dyn_cast<VectorType>(Ty))
1141 return ElementCount::getFixed(Ty->getStructNumElements());
1171 Type *Ty = getType();
1172 if (auto *AT = dyn_cast<ArrayType>(Ty))
1174 if (auto *VT = dyn_cast<VectorType>(Ty))
1176 return Ty->getStructNumElements();
1292 Constant *ConstantArray::get(ArrayType *Ty, ArrayRef<Constant*> V) {
1293 if (Constant *C = getImpl(Ty, V))
1295 return Ty->getContext().pImpl->ArrayConstants.getOrCreate(Ty, V);
1298 Constant *ConstantArray::getImpl(ArrayType *Ty, ArrayRef<Constant*> V) {
1301 return ConstantAggregateZero::get(Ty);
1304 assert(C->getType() == Ty->getElementType() &&
1314 return PoisonValue::get(Ty);
1317 return UndefValue::get(Ty);
1320 return ConstantAggregateZero::get(Ty);
1402 auto *Ty = FixedVectorType::get(V.front()->getType(), V.size());
1403 return Ty->getContext().pImpl->VectorConstants.getOrCreate(Ty, V);
1525 Constant *ConstantExpr::getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
1530 if (Ty == getType() && std::equal(Ops.begin(), Ops.end(), op_begin()))
1533 Type *OnlyIfReducedTy = OnlyIfReduced ? Ty : nullptr;
1548 return ConstantExpr::getCast(getOpcode(), Ops[0], Ty, OnlyIfReduced);
1575 bool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) {
1576 unsigned NumBits = Ty->getIntegerBitWidth(); // assert okay
1577 if (Ty->isIntegerTy(1))
1582 bool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) {
1583 unsigned NumBits = Ty->getIntegerBitWidth();
1584 if (Ty->isIntegerTy(1))
1589 bool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) {
1593 switch (Ty->getTypeID()) {
1650 ConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) {
1651 assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) &&
1655 Ty->getContext().pImpl->CAZConstants[Ty];
1657 Entry.reset(new ConstantAggregateZero(Ty));
1800 ConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) {
1802 Ty->getContext().pImpl->CPNConstants[Ty];
1804 Entry.reset(new ConstantPointerNull(Ty));
1817 ConstantTargetNone *ConstantTargetNone::get(TargetExtType *Ty) {
1818 assert(Ty->hasProperty(TargetExtType::HasZeroInit) &&
1821 Ty->getContext().pImpl->CTNConstants[Ty];
1823 Entry.reset(new ConstantTargetNone(Ty));
1833 UndefValue *UndefValue::get(Type *Ty) {
1834 std::unique_ptr<UndefValue> &Entry = Ty->getContext().pImpl->UVConstants[Ty];
1836 Entry.reset(new UndefValue(Ty));
1852 PoisonValue *PoisonValue::get(Type *Ty) {
1853 std::unique_ptr<PoisonValue> &Entry = Ty->getContext().pImpl->PVConstants[Ty];
1855 Entry.reset(new PoisonValue(Ty));
2166 static Constant *getFoldedCast(Instruction::CastOps opc, Constant *C, Type *Ty,
2168 assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
2170 if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
2176 LLVMContextImpl *pImpl = Ty->getContext().pImpl;
2181 return pImpl->ExprConstants.getOrCreate(Ty, Key);
2184 Constant *ConstantExpr::getCast(unsigned oc, Constant *C, Type *Ty,
2190 assert(C && Ty && "Null arguments to getCast");
2191 assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!");
2197 return getTrunc(C, Ty, OnlyIfReduced);
2199 return getPtrToInt(C, Ty, OnlyIfReduced);
2201 return getIntToPtr(C, Ty, OnlyIfReduced);
2203 return getBitCast(C, Ty, OnlyIfReduced);
2205 return getAddrSpaceCast(C, Ty, OnlyIfReduced);
2209 Constant *ConstantExpr::getTruncOrBitCast(Constant *C, Type *Ty) {
2210 if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2211 return getBitCast(C, Ty);
2212 return getTrunc(C, Ty);
2215 Constant *ConstantExpr::getPointerCast(Constant *S, Type *Ty) {
2217 assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
2220 if (Ty->isIntOrIntVectorTy())
2221 return getPtrToInt(S, Ty);
2224 if (Ty->isPtrOrPtrVectorTy() && SrcAS != Ty->getPointerAddressSpace())
2225 return getAddrSpaceCast(S, Ty);
2227 return getBitCast(S, Ty);
2231 Type *Ty) {
2233 assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
2235 if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace())
2236 return getAddrSpaceCast(S, Ty);
2238 return getBitCast(S, Ty);
2241 Constant *ConstantExpr::getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
2244 bool toVec = isa<VectorType>(Ty);
2248 assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral");
2249 assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
2252 return getFoldedCast(Instruction::Trunc, C, Ty, OnlyIfReduced);
2442 Constant *ConstantExpr::getSizeOf(Type* Ty) {
2443 // sizeof is implemented as: (i64) gep (Ty*)null, 1
2445 Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
2447 Ty, Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
2449 Type::getInt64Ty(Ty->getContext()));
2452 Constant *ConstantExpr::getAlignOf(Type* Ty) {
2453 // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1
2455 Type *AligningTy = StructType::get(Type::getInt1Ty(Ty->getContext()), Ty);
2458 Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0);
2459 Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
2462 return getPtrToInt(GEP, Type::getInt64Ty(Ty->getContext()));
2465 Constant *ConstantExpr::getGetElementPtr(Type *Ty, Constant *C,
2470 assert(Ty && "Must specify element type");
2471 assert(isSupportedGetElementPtr(Ty) && "Element type is unsupported!");
2473 if (Constant *FC = ConstantFoldGetElementPtr(Ty, C, InRange, Idxs))
2476 assert(GetElementPtrInst::getIndexedType(Ty, Idxs) && "GEP indices invalid!");
2492 auto GTI = gep_type_begin(Ty, Idxs), GTE = gep_type_end(Ty, Idxs);
2510 std::nullopt, Ty, InRange);
2625 Type *Ty = C->getType();
2628 return ConstantInt::get(Ty, IVal->logBase2());
2631 auto *VecTy = dyn_cast<FixedVectorType>(Ty);
2642 Elts.push_back(Constant::getNullValue(Ty->getScalarType()));
2647 Elts.push_back(ConstantInt::get(Ty->getScalarType(), IVal->logBase2()));
2653 Constant *ConstantExpr::getBinOpIdentity(unsigned Opcode, Type *Ty,
2663 return Constant::getNullValue(Ty);
2665 return ConstantInt::get(Ty, 1);
2667 return Constant::getAllOnesValue(Ty);
2669 return ConstantFP::getZero(Ty, !NSZ);
2671 return ConstantFP::get(Ty, 1.0);
2687 return Constant::getNullValue(Ty);
2690 return ConstantInt::get(Ty, 1);
2692 return ConstantFP::get(Ty, 1.0);
2698 Constant *ConstantExpr::getIntrinsicIdentity(Intrinsic::ID ID, Type *Ty) {
2701 return Constant::getNullValue(Ty);
2703 return Constant::getAllOnesValue(Ty);
2706 Ty, APInt::getSignedMinValue(Ty->getIntegerBitWidth()));
2709 Ty, APInt::getSignedMaxValue(Ty->getIntegerBitWidth()));
2715 Constant *ConstantExpr::getIdentity(Instruction *I, Type *Ty,
2718 return getBinOpIdentity(I->getOpcode(), Ty, AllowRHSConstant, NSZ);
2720 return getIntrinsicIdentity(II->getIntrinsicID(), Ty);
2724 Constant *ConstantExpr::getBinOpAbsorber(unsigned Opcode, Type *Ty) {
2731 return Constant::getAllOnesValue(Ty);
2735 return Constant::getNullValue(Ty);
2789 bool ConstantDataSequential::isElementTypeCompatible(Type *Ty) {
2790 if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() || Ty->isDoubleTy())
2792 if (auto *IT = dyn_cast<IntegerType>(Ty)) {
2835 Constant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) {
2837 if (ArrayType *ATy = dyn_cast<ArrayType>(Ty))
2840 assert(isElementTypeCompatible(cast<VectorType>(Ty)->getElementType()));
2845 return ConstantAggregateZero::get(Ty);
2849 *Ty->getContext()
2859 if ((*Entry)->getType() == Ty)
2864 if (isa<ArrayType>(Ty)) {
2866 Entry->reset(new ConstantDataArray(Ty, Slot.first().data()));
2870 assert(isa<VectorType>(Ty));
2872 Entry->reset(new ConstantDataVector(Ty, Slot.first().data()));
2920 Type *Ty = ArrayType::get(ElementType, Elts.size());
2922 return getImpl(StringRef(Data, Elts.size() * 2), Ty);
2926 Type *Ty = ArrayType::get(ElementType, Elts.size());
2928 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
2933 Type *Ty = ArrayType::get(ElementType, Elts.size());
2935 return getImpl(StringRef(Data, Elts.size() * 8), Ty);
2955 auto *Ty = FixedVectorType::get(Type::getInt8Ty(Context), Elts.size());
2957 return getImpl(StringRef(Data, Elts.size() * 1), Ty);
2960 auto *Ty = FixedVectorType::get(Type::getInt16Ty(Context), Elts.size());
2962 return getImpl(StringRef(Data, Elts.size() * 2), Ty);
2965 auto *Ty = FixedVectorType::get(Type::getInt32Ty(Context), Elts.size());
2967 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
2970 auto *Ty = FixedVectorType::get(Type::getInt64Ty(Context), Elts.size());
2972 return getImpl(StringRef(Data, Elts.size() * 8), Ty);
2975 auto *Ty = FixedVectorType::get(Type::getFloatTy(Context), Elts.size());
2977 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
2980 auto *Ty = FixedVectorType::get(Type::getDoubleTy(Context), Elts.size());
2982 return getImpl(StringRef(Data, Elts.size() * 8), Ty);
2995 auto *Ty = FixedVectorType::get(ElementType, Elts.size());
2997 return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3002 auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3004 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3010 auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3012 return getImpl(StringRef(Data, Elts.size() * 8), Ty);