Lines Matching refs:Ty
111 Constant *Constant::getNullValue(Type *Ty) {
112 switch (Ty->getTypeID()) {
114 return ConstantInt::get(Ty, 0);
116 return ConstantFP::get(Ty->getContext(),
119 return ConstantFP::get(Ty->getContext(),
122 return ConstantFP::get(Ty->getContext(),
125 return ConstantFP::get(Ty->getContext(),
128 return ConstantFP::get(Ty->getContext(),
131 return ConstantFP::get(Ty->getContext(),
135 return ConstantPointerNull::get(cast<PointerType>(Ty));
139 return ConstantAggregateZero::get(Ty);
146 Constant *Constant::getIntegerValue(Type *Ty, const APInt &V) {
147 Type *ScalarTy = Ty->getScalarType();
150 Constant *C = ConstantInt::get(Ty->getContext(), V);
157 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
163 Constant *Constant::getAllOnesValue(Type *Ty) {
164 if (IntegerType *ITy = dyn_cast<IntegerType>(Ty))
165 return ConstantInt::get(Ty->getContext(),
168 if (Ty->isFloatingPointTy()) {
169 APFloat FL = APFloat::getAllOnesValue(Ty->getPrimitiveSizeInBits(),
170 !Ty->isPPC_FP128Ty());
171 return ConstantFP::get(Ty->getContext(), FL);
174 VectorType *VTy = cast<VectorType>(Ty);
433 ConstantInt::ConstantInt(IntegerType *Ty, const APInt& V)
434 : Constant(Ty, ConstantIntVal, 0, 0), Val(V) {
435 assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type");
452 Constant *ConstantInt::getTrue(Type *Ty) {
453 VectorType *VTy = dyn_cast<VectorType>(Ty);
455 assert(Ty->isIntegerTy(1) && "True must be i1 or vector of i1.");
456 return ConstantInt::getTrue(Ty->getContext());
461 ConstantInt::getTrue(Ty->getContext()));
464 Constant *ConstantInt::getFalse(Type *Ty) {
465 VectorType *VTy = dyn_cast<VectorType>(Ty);
467 assert(Ty->isIntegerTy(1) && "False must be i1 or vector of i1.");
468 return ConstantInt::getFalse(Ty->getContext());
473 ConstantInt::getFalse(Ty->getContext()));
492 Constant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) {
493 Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned);
496 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
502 ConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V,
504 return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned));
507 ConstantInt *ConstantInt::getSigned(IntegerType *Ty, int64_t V) {
508 return get(Ty, V, true);
511 Constant *ConstantInt::getSigned(Type *Ty, int64_t V) {
512 return get(Ty, V, true);
515 Constant *ConstantInt::get(Type *Ty, const APInt& V) {
516 ConstantInt *C = get(Ty->getContext(), V);
517 assert(C->getType() == Ty->getScalarType() &&
521 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
527 ConstantInt *ConstantInt::get(IntegerType* Ty, StringRef Str,
529 return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix));
536 static const fltSemantics *TypeToFloatSemantics(Type *Ty) {
537 if (Ty->isHalfTy())
539 if (Ty->isFloatTy())
541 if (Ty->isDoubleTy())
543 if (Ty->isX86_FP80Ty())
545 else if (Ty->isFP128Ty())
548 assert(Ty->isPPC_FP128Ty() && "Unknown FP format");
557 Constant *ConstantFP::get(Type *Ty, double V) {
558 LLVMContext &Context = Ty->getContext();
562 FV.convert(*TypeToFloatSemantics(Ty->getScalarType()),
567 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
574 Constant *ConstantFP::get(Type *Ty, StringRef Str) {
575 LLVMContext &Context = Ty->getContext();
577 APFloat FV(*TypeToFloatSemantics(Ty->getScalarType()), Str);
581 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
588 ConstantFP *ConstantFP::getNegativeZero(Type *Ty) {
589 LLVMContext &Context = Ty->getContext();
590 APFloat apf = cast<ConstantFP>(Constant::getNullValue(Ty))->getValueAPF();
596 Constant *ConstantFP::getZeroValueForNegation(Type *Ty) {
597 Type *ScalarTy = Ty->getScalarType();
600 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
605 return Constant::getNullValue(Ty);
616 Type *Ty;
618 Ty = Type::getHalfTy(Context);
620 Ty = Type::getFloatTy(Context);
622 Ty = Type::getDoubleTy(Context);
624 Ty = Type::getX86_FP80Ty(Context);
626 Ty = Type::getFP128Ty(Context);
630 Ty = Type::getPPC_FP128Ty(Context);
632 Slot = new ConstantFP(Ty, V);
638 ConstantFP *ConstantFP::getInfinity(Type *Ty, bool Negative) {
639 const fltSemantics &Semantics = *TypeToFloatSemantics(Ty);
640 return ConstantFP::get(Ty->getContext(),
644 ConstantFP::ConstantFP(Type *Ty, const APFloat& V)
645 : Constant(Ty, ConstantFPVal, 0, 0), Val(V) {
646 assert(&V.getSemantics() == TypeToFloatSemantics(Ty) &&
745 Constant *ConstantArray::get(ArrayType *Ty, ArrayRef<Constant*> V) {
748 return ConstantAggregateZero::get(Ty);
751 assert(V[i]->getType() == Ty->getElementType() &&
754 LLVMContextImpl *pImpl = Ty->getContext().pImpl;
761 return UndefValue::get(Ty);
764 return ConstantAggregateZero::get(Ty);
836 return pImpl->ArrayConstants.getOrCreate(Ty, V);
1107 getWithOperands(ArrayRef<Constant*> Ops, Type *Ty) const {
1109 bool AnyChange = Ty != getType();
1129 return ConstantExpr::getCast(getOpcode(), Ops[0], Ty);
1158 bool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) {
1159 unsigned NumBits = Ty->getIntegerBitWidth(); // assert okay
1160 if (Ty->isIntegerTy(1))
1168 bool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) {
1169 unsigned NumBits = Ty->getIntegerBitWidth();
1170 if (Ty->isIntegerTy(1))
1179 bool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) {
1183 switch (Ty->getTypeID()) {
1230 ConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) {
1231 assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) &&
1234 ConstantAggregateZero *&Entry = Ty->getContext().pImpl->CAZConstants[Ty];
1236 Entry = new ConstantAggregateZero(Ty);
1313 ConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) {
1314 ConstantPointerNull *&Entry = Ty->getContext().pImpl->CPNConstants[Ty];
1316 Entry = new ConstantPointerNull(Ty);
1333 UndefValue *UndefValue::get(Type *Ty) {
1334 UndefValue *&Entry = Ty->getContext().pImpl->UVConstants[Ty];
1336 Entry = new UndefValue(Ty);
1429 Instruction::CastOps opc, Constant *C, Type *Ty) {
1430 assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
1432 if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
1435 LLVMContextImpl *pImpl = Ty->getContext().pImpl;
1440 return pImpl->ExprConstants.getOrCreate(Ty, Key);
1443 Constant *ConstantExpr::getCast(unsigned oc, Constant *C, Type *Ty) {
1446 assert(C && Ty && "Null arguments to getCast");
1447 assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!");
1452 case Instruction::Trunc: return getTrunc(C, Ty);
1453 case Instruction::ZExt: return getZExt(C, Ty);
1454 case Instruction::SExt: return getSExt(C, Ty);
1455 case Instruction::FPTrunc: return getFPTrunc(C, Ty);
1456 case Instruction::FPExt: return getFPExtend(C, Ty);
1457 case Instruction::UIToFP: return getUIToFP(C, Ty);
1458 case Instruction::SIToFP: return getSIToFP(C, Ty);
1459 case Instruction::FPToUI: return getFPToUI(C, Ty);
1460 case Instruction::FPToSI: return getFPToSI(C, Ty);
1461 case Instruction::PtrToInt: return getPtrToInt(C, Ty);
1462 case Instruction::IntToPtr: return getIntToPtr(C, Ty);
1463 case Instruction::BitCast: return getBitCast(C, Ty);
1467 Constant *ConstantExpr::getZExtOrBitCast(Constant *C, Type *Ty) {
1468 if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1469 return getBitCast(C, Ty);
1470 return getZExt(C, Ty);
1473 Constant *ConstantExpr::getSExtOrBitCast(Constant *C, Type *Ty) {
1474 if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1475 return getBitCast(C, Ty);
1476 return getSExt(C, Ty);
1479 Constant *ConstantExpr::getTruncOrBitCast(Constant *C, Type *Ty) {
1480 if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
1481 return getBitCast(C, Ty);
1482 return getTrunc(C, Ty);
1485 Constant *ConstantExpr::getPointerCast(Constant *S, Type *Ty) {
1487 assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
1490 if (Ty->isIntOrIntVectorTy())
1491 return getPtrToInt(S, Ty);
1492 return getBitCast(S, Ty);
1495 Constant *ConstantExpr::getIntegerCast(Constant *C, Type *Ty,
1498 Ty->isIntOrIntVectorTy() && "Invalid cast");
1500 unsigned DstBits = Ty->getScalarSizeInBits();
1505 return getCast(opcode, C, Ty);
1508 Constant *ConstantExpr::getFPCast(Constant *C, Type *Ty) {
1509 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1512 unsigned DstBits = Ty->getScalarSizeInBits();
1517 return getCast(opcode, C, Ty);
1520 Constant *ConstantExpr::getTrunc(Constant *C, Type *Ty) {
1523 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1527 assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral");
1528 assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
1531 return getFoldedCast(Instruction::Trunc, C, Ty);
1534 Constant *ConstantExpr::getSExt(Constant *C, Type *Ty) {
1537 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1541 assert(Ty->isIntOrIntVectorTy() && "SExt produces only integer");
1542 assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
1545 return getFoldedCast(Instruction::SExt, C, Ty);
1548 Constant *ConstantExpr::getZExt(Constant *C, Type *Ty) {
1551 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1555 assert(Ty->isIntOrIntVectorTy() && "ZExt produces only integer");
1556 assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
1559 return getFoldedCast(Instruction::ZExt, C, Ty);
1562 Constant *ConstantExpr::getFPTrunc(Constant *C, Type *Ty) {
1565 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1568 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1569 C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
1571 return getFoldedCast(Instruction::FPTrunc, C, Ty);
1574 Constant *ConstantExpr::getFPExtend(Constant *C, Type *Ty) {
1577 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1580 assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
1581 C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
1583 return getFoldedCast(Instruction::FPExt, C, Ty);
1586 Constant *ConstantExpr::getUIToFP(Constant *C, Type *Ty) {
1589 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1592 assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
1594 return getFoldedCast(Instruction::UIToFP, C, Ty);
1597 Constant *ConstantExpr::getSIToFP(Constant *C, Type *Ty) {
1600 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1603 assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() &&
1605 return getFoldedCast(Instruction::SIToFP, C, Ty);
1608 Constant *ConstantExpr::getFPToUI(Constant *C, Type *Ty) {
1611 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1614 assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
1616 return getFoldedCast(Instruction::FPToUI, C, Ty);
1619 Constant *ConstantExpr::getFPToSI(Constant *C, Type *Ty) {
1622 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1625 assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() &&
1627 return getFoldedCast(Instruction::FPToSI, C, Ty);
1742 Constant *ConstantExpr::getSizeOf(Type* Ty) {
1743 // sizeof is implemented as: (i64) gep (Ty*)null, 1
1745 Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
1747 Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
1749 Type::getInt64Ty(Ty->getContext()));
1752 Constant *ConstantExpr::getAlignOf(Type* Ty) {
1753 // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1
1756 StructType::get(Type::getInt1Ty(Ty->getContext()), Ty, NULL);
1758 Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0);
1759 Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
1763 Type::getInt64Ty(Ty->getContext()));
1771 Constant *ConstantExpr::getOffsetOf(Type* Ty, Constant *FieldNo) {
1772 // offsetof is implemented as: (i64) gep (Ty*)null, 0, FieldNo
1775 ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0),
1779 Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
1781 Type::getInt64Ty(Ty->getContext()));
1828 Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), Idxs);
1829 assert(Ty && "GEP indices invalid!");
1831 Type *ReqTy = Ty->getPointerTo(AS);
2106 Constant *ConstantExpr::getBinOpIdentity(unsigned Opcode, Type *Ty) {
2115 return Constant::getNullValue(Ty);
2118 return ConstantInt::get(Ty, 1);
2121 return Constant::getAllOnesValue(Ty);
2129 Constant *ConstantExpr::getBinOpAbsorber(unsigned Opcode, Type *Ty) {
2136 return Constant::getAllOnesValue(Ty);
2140 return Constant::getNullValue(Ty);
2187 bool ConstantDataSequential::isElementTypeCompatible(const Type *Ty) {
2188 if (Ty->isFloatTy() || Ty->isDoubleTy()) return true;
2189 if (const IntegerType *IT = dyn_cast<IntegerType>(Ty)) {
2234 Constant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) {
2235 assert(isElementTypeCompatible(Ty->getSequentialElementType()));
2239 return ConstantAggregateZero::get(Ty);
2243 Ty->getContext().pImpl->CDSConstants.GetOrCreateValue(Elements);
2252 if (Node->getType() == Ty)
2257 if (isa<ArrayType>(Ty))
2258 return *Entry = new ConstantDataArray(Ty, Slot.getKeyData());
2260 assert(isa<VectorType>(Ty));
2261 return *Entry = new ConstantDataVector(Ty, Slot.getKeyData());
2308 Type *Ty = ArrayType::get(Type::getInt8Ty(Context), Elts.size());
2310 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*1), Ty);
2313 Type *Ty = ArrayType::get(Type::getInt16Ty(Context), Elts.size());
2315 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*2), Ty);
2318 Type *Ty = ArrayType::get(Type::getInt32Ty(Context), Elts.size());
2320 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty);
2323 Type *Ty = ArrayType::get(Type::getInt64Ty(Context), Elts.size());
2325 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty);
2328 Type *Ty = ArrayType::get(Type::getFloatTy(Context), Elts.size());
2330 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty);
2333 Type *Ty = ArrayType::get(Type::getDoubleTy(Context), Elts.size());
2335 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty);
2361 Type *Ty = VectorType::get(Type::getInt8Ty(Context), Elts.size());
2363 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*1), Ty);
2366 Type *Ty = VectorType::get(Type::getInt16Ty(Context), Elts.size());
2368 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*2), Ty);
2371 Type *Ty = VectorType::get(Type::getInt32Ty(Context), Elts.size());
2373 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty);
2376 Type *Ty = VectorType::get(Type::getInt64Ty(Context), Elts.size());
2378 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty);
2381 Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size());
2383 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty);
2386 Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size());
2388 return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty);