Lines Matching refs:Base
230 bool ABIInfo::isHomogeneousAggregateSmallEnough(const Type *Base,
1416 for (const CXXBaseSpecifier &Base : RD->bases()) {
1417 if (!addBaseAndFieldSizes(Context, Base.getType()->getAsCXXRecordDecl(),
1475 const Type *Base = nullptr;
1479 isHomogeneousAggregate(RetTy, Base, NumElts)) {
1739 const Type *Base = nullptr;
1743 isHomogeneousAggregate(Ty, Base, NumElts)) {
1777 const Type *Base = nullptr;
1780 isHomogeneousAggregate(Ty, Base, NumElts)) {
3037 const auto *Base =
3047 OffsetBase + getContext().toBits(Layout.getBaseClassOffset(Base));
3303 const auto *Base =
3307 unsigned BaseOffset = Context.toBits(Layout.getBaseClassOffset(Base));
3349 // Base case if we find a float.
4148 const Type *Base = nullptr;
4152 isHomogeneousAggregate(Ty, Base, NumElts) && FreeSSERegs >= NumElts) {
4185 const Type *Base = nullptr;
4190 isHomogeneousAggregate(Ty, Base, NumElts)) {
5061 const Type *Base = nullptr;
5064 isAggregateTypeForABI(Ty) && isHomogeneousAggregate(Ty, Base, Members))
5065 AlignAsType = Base;
5089 /// aggregate. Base is set to the base element type, and Members is set
5091 bool ABIInfo::isHomogeneousAggregate(QualType Ty, const Type *&Base,
5097 if (!isHomogeneousAggregate(AT->getElementType(), Base, Members))
5115 if (!isHomogeneousAggregate(I.getType(), Base, FldMembers))
5140 if (!isHomogeneousAggregate(FD->getType(), Base, FldMembers))
5147 if (!Base)
5151 if (getContext().getTypeSize(Base) * Members !=
5169 if (!Base) {
5170 Base = TyPtr;
5173 if (const VectorType *VT = Base->getAs<VectorType>()) {
5177 Base = getContext()
5183 if (Base->isVectorType() != TyPtr->isVectorType() ||
5184 getContext().getTypeSize(Base) != getContext().getTypeSize(TyPtr))
5187 return Members > 0 && isHomogeneousAggregateSmallEnough(Base, Members);
5212 const Type *Base, uint64_t Members) const {
5217 Base->isFloat128Type()) ||
5218 Base->isVectorType()) ? 1
5219 : (getContext().getTypeSize(Base) + 63) / 64;
5256 const Type *Base = nullptr;
5259 isHomogeneousAggregate(Ty, Base, Members)) {
5260 llvm::Type *BaseTy = CGT.ConvertType(QualType(Base, 0));
5326 const Type *Base = nullptr;
5329 isHomogeneousAggregate(RetTy, Base, Members)) {
5330 llvm::Type *BaseTy = CGT.ConvertType(QualType(Base, 0));
5654 const Type *Base = nullptr;
5656 if (isHomogeneousAggregate(Ty, Base, Members)) {
5658 llvm::ArrayType::get(CGT.ConvertType(QualType(Base, 0)), Members));
5716 const Type *Base = nullptr;
5718 if (isHomogeneousAggregate(RetTy, Base, Members) &&
5795 bool AArch64ABIInfo::isHomogeneousAggregateSmallEnough(const Type *Base,
5928 const Type *Base = nullptr;
5930 bool IsHFA = isHomogeneousAggregate(Ty, Base, NumMembers);
5937 auto BaseTyInfo = getContext().getTypeInfoInChars(QualType(Base, 0));
5938 llvm::Type *BaseTy = CGF.ConvertType(QualType(Base, 0));
6072 const Type *Base = nullptr;
6074 IsIndirect = !isHomogeneousAggregate(Ty, Base, Members);
6153 ABIArgInfo classifyHomogeneousAggregate(QualType Ty, const Type *Base,
6351 const Type *Base,
6353 assert(Base && "Base class should be set for homogeneous aggregate");
6354 // Base can be a floating-point or a vector.
6355 if (const VectorType *VT = Base->getAs<VectorType>()) {
6374 // with a Base Type of a single- or double-precision floating-point type,
6412 const Type *Base = nullptr;
6414 if (isHomogeneousAggregate(Ty, Base, Members))
6415 return classifyHomogeneousAggregate(Ty, Base, Members);
6420 const Type *Base = nullptr;
6422 if (isHomogeneousAggregate(Ty, Base, Members)) {
6423 assert(Base && Members <= 4 && "unexpected homogeneous aggregate");
6425 llvm::ArrayType::get(CGT.ConvertType(QualType(Base, 0)), Members);
6638 const Type *Base = nullptr;
6640 if (isHomogeneousAggregate(RetTy, Base, Members))
6641 return classifyHomogeneousAggregate(RetTy, Base, Members);
6774 bool ARMABIInfo::isHomogeneousAggregateSmallEnough(const Type *Base,
6805 const Type *Base = nullptr;
6814 !isHomogeneousAggregate(Ty, Base, Members)) {
7236 QualType Base = I.getType();
7239 if (isEmptyRecord(getContext(), Base, true))
7244 Found = GetSingleElementType(Base);
8634 bool isHomogeneousAggregateSmallEnough(const Type *Base,
8691 const Type *Base, uint64_t Members) const {
8692 uint32_t NumRegs = (getContext().getTypeSize(Base) + 31) / 32;