Lines Matching defs:Ty
373 Constant *Constant::getNullValue(Type *Ty) {
374 switch (Ty->getTypeID()) {
376 return ConstantInt::get(Ty, 0);
384 return ConstantFP::get(Ty->getContext(),
385 APFloat::getZero(Ty->getFltSemantics()));
387 return ConstantPointerNull::get(cast<PointerType>(Ty));
392 return ConstantAggregateZero::get(Ty);
394 return ConstantTokenNone::get(Ty->getContext());
396 return ConstantTargetNone::get(cast<TargetExtType>(Ty));
403 Constant *Constant::getIntegerValue(Type *Ty, const APInt &V) {
404 Type *ScalarTy = Ty->getScalarType();
407 Constant *C = ConstantInt::get(Ty->getContext(), V);
414 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
420 Constant *Constant::getAllOnesValue(Type *Ty) {
421 if (IntegerType *ITy = dyn_cast<IntegerType>(Ty))
422 return ConstantInt::get(Ty->getContext(),
425 if (Ty->isFloatingPointTy()) {
426 APFloat FL = APFloat::getAllOnesValue(Ty->getFltSemantics());
427 return ConstantFP::get(Ty->getContext(), FL);
430 VectorType *VTy = cast<VectorType>(Ty);
786 Type *Ty = C->getType();
788 assert(Ty == Replacement->getType() && "Expected matching types");
793 auto *VTy = dyn_cast<FixedVectorType>(Ty);
813 Type *Ty = C->getType();
815 return UndefValue::get(Ty);
817 auto *VTy = dyn_cast<FixedVectorType>(Ty);
859 ConstantInt::ConstantInt(Type *Ty, const APInt &V)
860 : ConstantData(Ty, ConstantIntVal), Val(V) {
862 cast<IntegerType>(Ty->getScalarType())->getBitWidth() &&
884 Constant *ConstantInt::getTrue(Type *Ty) {
885 assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
886 ConstantInt *TrueC = ConstantInt::getTrue(Ty->getContext());
887 if (auto *VTy = dyn_cast<VectorType>(Ty))
892 Constant *ConstantInt::getFalse(Type *Ty) {
893 assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
894 ConstantInt *FalseC = ConstantInt::getFalse(Ty->getContext());
895 if (auto *VTy = dyn_cast<VectorType>(Ty))
900 Constant *ConstantInt::getBool(Type *Ty, bool V) {
901 return V ? getTrue(Ty) : getFalse(Ty);
941 Constant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) {
942 Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned);
945 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
951 ConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V, bool isSigned) {
954 return get(Ty->getContext(),
955 APInt(Ty->getBitWidth(), V, isSigned, /*implicitTrunc=*/true));
958 Constant *ConstantInt::get(Type *Ty, const APInt& V) {
959 ConstantInt *C = get(Ty->getContext(), V);
960 assert(C->getType() == Ty->getScalarType() &&
964 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
970 ConstantInt *ConstantInt::get(IntegerType* Ty, StringRef Str, uint8_t radix) {
971 return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix));
983 Constant *ConstantFP::get(Type *Ty, double V) {
984 LLVMContext &Context = Ty->getContext();
988 FV.convert(Ty->getScalarType()->getFltSemantics(),
993 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
999 Constant *ConstantFP::get(Type *Ty, const APFloat &V) {
1000 ConstantFP *C = get(Ty->getContext(), V);
1001 assert(C->getType() == Ty->getScalarType() &&
1005 if (auto *VTy = dyn_cast<VectorType>(Ty))
1011 Constant *ConstantFP::get(Type *Ty, StringRef Str) {
1012 LLVMContext &Context = Ty->getContext();
1014 APFloat FV(Ty->getScalarType()->getFltSemantics(), Str);
1018 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1024 Constant *ConstantFP::getNaN(Type *Ty, bool Negative, uint64_t Payload) {
1025 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1027 Constant *C = get(Ty->getContext(), NaN);
1029 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1035 Constant *ConstantFP::getQNaN(Type *Ty, bool Negative, APInt *Payload) {
1036 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1038 Constant *C = get(Ty->getContext(), NaN);
1040 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1046 Constant *ConstantFP::getSNaN(Type *Ty, bool Negative, APInt *Payload) {
1047 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1049 Constant *C = get(Ty->getContext(), NaN);
1051 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1057 Constant *ConstantFP::getZero(Type *Ty, bool Negative) {
1058 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1060 Constant *C = get(Ty->getContext(), NegZero);
1062 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1076 Type *Ty = Type::getFloatingPointTy(Context, V.getSemantics());
1077 Slot.reset(new ConstantFP(Ty, V));
1103 Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) {
1104 const fltSemantics &Semantics = Ty->getScalarType()->getFltSemantics();
1105 Constant *C = get(Ty->getContext(), APFloat::getInf(Semantics, Negative));
1107 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1113 ConstantFP::ConstantFP(Type *Ty, const APFloat &V)
1114 : ConstantData(Ty, ConstantFPVal), Val(V) {
1115 assert(&V.getSemantics() == &Ty->getScalarType()->getFltSemantics() &&
1155 Type *Ty = getType();
1156 if (auto *AT = dyn_cast<ArrayType>(Ty))
1158 if (auto *VT = dyn_cast<VectorType>(Ty))
1160 return ElementCount::getFixed(Ty->getStructNumElements());
1190 Type *Ty = getType();
1191 if (auto *AT = dyn_cast<ArrayType>(Ty))
1193 if (auto *VT = dyn_cast<VectorType>(Ty))
1195 return Ty->getStructNumElements();
1312 Constant *ConstantArray::get(ArrayType *Ty, ArrayRef<Constant*> V) {
1313 if (Constant *C = getImpl(Ty, V))
1315 return Ty->getContext().pImpl->ArrayConstants.getOrCreate(Ty, V);
1318 Constant *ConstantArray::getImpl(ArrayType *Ty, ArrayRef<Constant*> V) {
1321 return ConstantAggregateZero::get(Ty);
1324 assert(C->getType() == Ty->getElementType() &&
1334 return PoisonValue::get(Ty);
1337 return UndefValue::get(Ty);
1340 return ConstantAggregateZero::get(Ty);
1424 auto *Ty = FixedVectorType::get(V.front()->getType(), V.size());
1425 return Ty->getContext().pImpl->VectorConstants.getOrCreate(Ty, V);
1547 Constant *ConstantExpr::getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
1552 if (Ty == getType() && std::equal(Ops.begin(), Ops.end(), op_begin()))
1555 Type *OnlyIfReducedTy = OnlyIfReduced ? Ty : nullptr;
1570 return ConstantExpr::getCast(getOpcode(), Ops[0], Ty, OnlyIfReduced);
1597 bool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) {
1598 unsigned NumBits = Ty->getIntegerBitWidth(); // assert okay
1599 if (Ty->isIntegerTy(1))
1604 bool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) {
1605 unsigned NumBits = Ty->getIntegerBitWidth();
1606 if (Ty->isIntegerTy(1))
1611 bool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) {
1615 switch (Ty->getTypeID()) {
1672 ConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) {
1673 assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) &&
1677 Ty->getContext().pImpl->CAZConstants[Ty];
1679 Entry.reset(new ConstantAggregateZero(Ty));
1826 ConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) {
1828 Ty->getContext().pImpl->CPNConstants[Ty];
1830 Entry.reset(new ConstantPointerNull(Ty));
1843 ConstantTargetNone *ConstantTargetNone::get(TargetExtType *Ty) {
1844 assert(Ty->hasProperty(TargetExtType::HasZeroInit) &&
1847 Ty->getContext().pImpl->CTNConstants[Ty];
1849 Entry.reset(new ConstantTargetNone(Ty));
1859 UndefValue *UndefValue::get(Type *Ty) {
1860 std::unique_ptr<UndefValue> &Entry = Ty->getContext().pImpl->UVConstants[Ty];
1862 Entry.reset(new UndefValue(Ty));
1878 PoisonValue *PoisonValue::get(Type *Ty) {
1879 std::unique_ptr<PoisonValue> &Entry = Ty->getContext().pImpl->PVConstants[Ty];
1881 Entry.reset(new PoisonValue(Ty));
2204 static Constant *getFoldedCast(Instruction::CastOps opc, Constant *C, Type *Ty,
2206 assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
2208 if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
2214 LLVMContextImpl *pImpl = Ty->getContext().pImpl;
2219 return pImpl->ExprConstants.getOrCreate(Ty, Key);
2222 Constant *ConstantExpr::getCast(unsigned oc, Constant *C, Type *Ty,
2228 assert(C && Ty && "Null arguments to getCast");
2229 assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!");
2235 return getTrunc(C, Ty, OnlyIfReduced);
2237 return getPtrToInt(C, Ty, OnlyIfReduced);
2239 return getIntToPtr(C, Ty, OnlyIfReduced);
2241 return getBitCast(C, Ty, OnlyIfReduced);
2243 return getAddrSpaceCast(C, Ty, OnlyIfReduced);
2247 Constant *ConstantExpr::getTruncOrBitCast(Constant *C, Type *Ty) {
2248 if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
2249 return getBitCast(C, Ty);
2250 return getTrunc(C, Ty);
2253 Constant *ConstantExpr::getPointerCast(Constant *S, Type *Ty) {
2255 assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
2258 if (Ty->isIntOrIntVectorTy())
2259 return getPtrToInt(S, Ty);
2262 if (Ty->isPtrOrPtrVectorTy() && SrcAS != Ty->getPointerAddressSpace())
2263 return getAddrSpaceCast(S, Ty);
2265 return getBitCast(S, Ty);
2269 Type *Ty) {
2271 assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
2273 if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace())
2274 return getAddrSpaceCast(S, Ty);
2276 return getBitCast(S, Ty);
2279 Constant *ConstantExpr::getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
2282 bool toVec = isa<VectorType>(Ty);
2286 assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral");
2287 assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
2290 return getFoldedCast(Instruction::Trunc, C, Ty, OnlyIfReduced);
2480 Constant *ConstantExpr::getSizeOf(Type* Ty) {
2481 // sizeof is implemented as: (i64) gep (Ty*)null, 1
2483 Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
2485 Ty, Constant::getNullValue(PointerType::getUnqual(Ty->getContext())),
2488 Type::getInt64Ty(Ty->getContext()));
2491 Constant *ConstantExpr::getAlignOf(Type* Ty) {
2492 // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1
2494 Type *AligningTy = StructType::get(Type::getInt1Ty(Ty->getContext()), Ty);
2497 Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0);
2498 Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
2501 return getPtrToInt(GEP, Type::getInt64Ty(Ty->getContext()));
2504 Constant *ConstantExpr::getGetElementPtr(Type *Ty, Constant *C,
2509 assert(Ty && "Must specify element type");
2510 assert(isSupportedGetElementPtr(Ty) && "Element type is unsupported!");
2512 if (Constant *FC = ConstantFoldGetElementPtr(Ty, C, InRange, Idxs))
2515 assert(GetElementPtrInst::getIndexedType(Ty, Idxs) && "GEP indices invalid!");
2531 auto GTI = gep_type_begin(Ty, Idxs), GTE = gep_type_end(Ty, Idxs);
2549 {}, Ty, InRange);
2664 Type *Ty = C->getType();
2667 return ConstantInt::get(Ty, IVal->logBase2());
2670 auto *VecTy = dyn_cast<FixedVectorType>(Ty);
2681 Elts.push_back(Constant::getNullValue(Ty->getScalarType()));
2686 Elts.push_back(ConstantInt::get(Ty->getScalarType(), IVal->logBase2()));
2692 Constant *ConstantExpr::getBinOpIdentity(unsigned Opcode, Type *Ty,
2702 return Constant::getNullValue(Ty);
2704 return ConstantInt::get(Ty, 1);
2706 return Constant::getAllOnesValue(Ty);
2708 return ConstantFP::getZero(Ty, !NSZ);
2710 return ConstantFP::get(Ty, 1.0);
2726 return Constant::getNullValue(Ty);
2729 return ConstantInt::get(Ty, 1);
2731 return ConstantFP::get(Ty, 1.0);
2737 Constant *ConstantExpr::getIntrinsicIdentity(Intrinsic::ID ID, Type *Ty) {
2740 return Constant::getNullValue(Ty);
2742 return Constant::getAllOnesValue(Ty);
2745 Ty, APInt::getSignedMinValue(Ty->getIntegerBitWidth()));
2748 Ty, APInt::getSignedMaxValue(Ty->getIntegerBitWidth()));
2754 Constant *ConstantExpr::getIdentity(Instruction *I, Type *Ty,
2757 return getBinOpIdentity(I->getOpcode(), Ty, AllowRHSConstant, NSZ);
2759 return getIntrinsicIdentity(II->getIntrinsicID(), Ty);
2763 Constant *ConstantExpr::getBinOpAbsorber(unsigned Opcode, Type *Ty,
2770 return Constant::getAllOnesValue(Ty);
2774 return Constant::getNullValue(Ty);
2791 return Constant::getNullValue(Ty);
2842 bool ConstantDataSequential::isElementTypeCompatible(Type *Ty) {
2843 if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() || Ty->isDoubleTy())
2845 if (auto *IT = dyn_cast<IntegerType>(Ty)) {
2888 Constant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) {
2890 if (ArrayType *ATy = dyn_cast<ArrayType>(Ty))
2893 assert(isElementTypeCompatible(cast<VectorType>(Ty)->getElementType()));
2898 return ConstantAggregateZero::get(Ty);
2902 *Ty->getContext()
2912 if ((*Entry)->getType() == Ty)
2917 if (isa<ArrayType>(Ty)) {
2919 Entry->reset(new ConstantDataArray(Ty, Slot.first().data()));
2923 assert(isa<VectorType>(Ty));
2925 Entry->reset(new ConstantDataVector(Ty, Slot.first().data()));
2973 Type *Ty = ArrayType::get(ElementType, Elts.size());
2975 return getImpl(StringRef(Data, Elts.size() * 2), Ty);
2979 Type *Ty = ArrayType::get(ElementType, Elts.size());
2981 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
2986 Type *Ty = ArrayType::get(ElementType, Elts.size());
2988 return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3008 auto *Ty = FixedVectorType::get(Type::getInt8Ty(Context), Elts.size());
3010 return getImpl(StringRef(Data, Elts.size() * 1), Ty);
3013 auto *Ty = FixedVectorType::get(Type::getInt16Ty(Context), Elts.size());
3015 return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3018 auto *Ty = FixedVectorType::get(Type::getInt32Ty(Context), Elts.size());
3020 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3023 auto *Ty = FixedVectorType::get(Type::getInt64Ty(Context), Elts.size());
3025 return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3028 auto *Ty = FixedVectorType::get(Type::getFloatTy(Context), Elts.size());
3030 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3033 auto *Ty = FixedVectorType::get(Type::getDoubleTy(Context), Elts.size());
3035 return getImpl(StringRef(Data, Elts.size() * 8), Ty);
3048 auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3050 return getImpl(StringRef(Data, Elts.size() * 2), Ty);
3055 auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3057 return getImpl(StringRef(Data, Elts.size() * 4), Ty);
3063 auto *Ty = FixedVectorType::get(ElementType, Elts.size());
3065 return getImpl(StringRef(Data, Elts.size() * 8), Ty);