diff options
30 files changed, 220 insertions, 167 deletions
diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h index 260aca6c89..3cf6788b75 100644 --- a/include/clang/AST/ASTContext.h +++ b/include/clang/AST/ASTContext.h @@ -872,9 +872,9 @@ public: /// \brief Determine whether the given types are equivalent after /// cvr-qualifiers have been removed. bool hasSameUnqualifiedType(QualType T1, QualType T2) { - T1 = getCanonicalType(T1); - T2 = getCanonicalType(T2); - return T1.getUnqualifiedType() == T2.getUnqualifiedType(); + CanQualType CT1 = getCanonicalType(T1); + CanQualType CT2 = getCanonicalType(T2); + return CT1.getUnqualifiedType() == CT2.getUnqualifiedType(); } /// \brief Retrieves the "canonical" declaration of diff --git a/include/clang/AST/CanonicalType.h b/include/clang/AST/CanonicalType.h index a53f2f48fd..9b1187770f 100644 --- a/include/clang/AST/CanonicalType.h +++ b/include/clang/AST/CanonicalType.h @@ -102,22 +102,22 @@ public: CanProxy<T> operator->() const; /// \brief Retrieve all qualifiers. - Qualifiers getQualifiers() const { return Stored.getQualifiers(); } + Qualifiers getQualifiers() const { return Stored.getLocalQualifiers(); } /// \brief Retrieve the const/volatile/restrict qualifiers. - unsigned getCVRQualifiers() const { return Stored.getCVRQualifiers(); } + unsigned getCVRQualifiers() const { return Stored.getLocalCVRQualifiers(); } /// \brief Determines whether this type has any qualifiers - bool hasQualifiers() const { return Stored.hasQualifiers(); } + bool hasQualifiers() const { return Stored.hasLocalQualifiers(); } bool isConstQualified() const { - return Stored.isConstQualified(); + return Stored.isLocalConstQualified(); } bool isVolatileQualified() const { - return Stored.isVolatileQualified(); + return Stored.isLocalVolatileQualified(); } bool isRestrictQualified() const { - return Stored.isRestrictQualified(); + return Stored.isLocalRestrictQualified(); } /// \brief Retrieve the unqualified form of this type. @@ -638,7 +638,7 @@ struct CanProxyAdaptor<ObjCObjectPointerType> //----------------------------------------------------------------------------// template<typename T> inline CanQual<T> CanQual<T>::getUnqualifiedType() const { - return CanQual<T>::CreateUnsafe(Stored.getUnqualifiedType()); + return CanQual<T>::CreateUnsafe(Stored.getLocalUnqualifiedType()); } template<typename T> diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h index e13792bc3a..66853b8c9a 100644 --- a/include/clang/AST/Type.h +++ b/include/clang/AST/Type.h @@ -396,10 +396,6 @@ class QualType { llvm::PointerIntPair<llvm::PointerUnion<const Type*,const ExtQuals*>, Qualifiers::FastWidth> Value; - bool hasExtQuals() const { - return Value.getPointer().is<const ExtQuals*>(); - } - const ExtQuals *getExtQualsUnsafe() const { return Value.getPointer().get<const ExtQuals*>(); } @@ -417,14 +413,14 @@ public: QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {} - unsigned getFastQualifiers() const { return Value.getInt(); } - void setFastQualifiers(unsigned Quals) { Value.setInt(Quals); } + unsigned getLocalFastQualifiers() const { return Value.getInt(); } + void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); } /// Retrieves a pointer to the underlying (unqualified) type. /// This should really return a const Type, but it's not worth /// changing all the users right now. Type *getTypePtr() const { - if (hasNonFastQualifiers()) + if (hasLocalNonFastQualifiers()) return const_cast<Type*>(getExtQualsUnsafe()->getBaseType()); return const_cast<Type*>(getTypePtrUnsafe()); } @@ -452,41 +448,99 @@ public: return Value.getPointer().isNull(); } + /// \brief Determine whether this particular QualType instance has the + /// "const" qualifier set, without looking through typedefs that may have + /// added "const" at a different level. + bool isLocalConstQualified() const { + return (getLocalFastQualifiers() & Qualifiers::Const); + } + + /// \brief Determine whether this type is const-qualified. bool isConstQualified() const { - return (getFastQualifiers() & Qualifiers::Const); + // FIXME: Look through sugar types. + return isLocalConstQualified(); + } + + /// \brief Determine whether this particular QualType instance has the + /// "restrict" qualifier set, without looking through typedefs that may have + /// added "restrict" at a different level. + bool isLocalRestrictQualified() const { + return (getLocalFastQualifiers() & Qualifiers::Restrict); } + + /// \brief Determine whether this type is restrict-qualified. bool isRestrictQualified() const { - return (getFastQualifiers() & Qualifiers::Restrict); + // FIXME: Look through sugar types. + return isLocalRestrictQualified(); + } + + /// \brief Determine whether this particular QualType instance has the + /// "volatile" qualifier set, without looking through typedefs that may have + /// added "volatile" at a different level. + bool isLocalVolatileQualified() const { + return (hasLocalNonFastQualifiers() && getExtQualsUnsafe()->hasVolatile()); } + + /// \brief Determine whether this type is volatile-qualified. bool isVolatileQualified() const { - return (hasNonFastQualifiers() && getExtQualsUnsafe()->hasVolatile()); + // FIXME: Look through sugar types. + return isLocalVolatileQualified(); + } + + /// \brief Determine whether this particular QualType instance has any + /// qualifiers, without looking through any typedefs that might add + /// qualifiers at a different level. + bool hasLocalQualifiers() const { + return getLocalFastQualifiers() || hasLocalNonFastQualifiers(); } - // Determines whether this type has any direct qualifiers. + /// \brief Determine whether this type has any qualifiers. bool hasQualifiers() const { - return getFastQualifiers() || hasNonFastQualifiers(); + // FIXME: Look for qualifiers at any level. + return hasLocalQualifiers(); } - - bool hasNonFastQualifiers() const { - return hasExtQuals(); + + /// \brief Determine whether this particular QualType instance has any + /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType + /// instance. + bool hasLocalNonFastQualifiers() const { + return Value.getPointer().is<const ExtQuals*>(); } - // Retrieves the set of qualifiers belonging to this type. - Qualifiers getQualifiers() const { + /// \brief Retrieve the set of qualifiers local to this particular QualType + /// instance, not including any qualifiers acquired through typedefs or + /// other sugar. + Qualifiers getLocalQualifiers() const { Qualifiers Quals; - if (hasNonFastQualifiers()) + if (hasLocalNonFastQualifiers()) Quals = getExtQualsUnsafe()->getQualifiers(); - Quals.addFastQualifiers(getFastQualifiers()); + Quals.addFastQualifiers(getLocalFastQualifiers()); return Quals; } - // Retrieves the CVR qualifiers of this type. - unsigned getCVRQualifiers() const { - unsigned CVR = getFastQualifiers(); - if (isVolatileQualified()) CVR |= Qualifiers::Volatile; + /// \brief Retrieve the set of qualifiers applied to this type. + Qualifiers getQualifiers() const { + // FIXME: Collect qualifiers from all levels. + return getLocalQualifiers(); + } + + /// \brief Retrieve the set of CVR (const-volatile-restrict) qualifiers + /// local to this particular QualType instance, not including any qualifiers + /// acquired through typedefs or other sugar. + unsigned getLocalCVRQualifiers() const { + unsigned CVR = getLocalFastQualifiers(); + if (isLocalVolatileQualified()) + CVR |= Qualifiers::Volatile; return CVR; } + /// \brief Retrieve the set of CVR (const-volatile-restrict) qualifiers + /// applied to this type. + unsigned getCVRQualifiers() const { + // FIXME: Collect qualifiers from all levels. + return getLocalCVRQualifiers(); + } + bool isConstant(ASTContext& Ctx) const { return QualType::isConstant(*this, Ctx); } @@ -508,6 +562,9 @@ public: Value.setInt(Value.getInt() | TQs); } + // FIXME: The remove* functions are semantically broken, because they might + // not remove a qualifier stored on a typedef. Most of the with* functions + // have the same problem. void removeConst(); void removeVolatile(); void removeRestrict(); @@ -540,8 +597,18 @@ public: return T; } - QualType getUnqualifiedType() const { return QualType(getTypePtr(), 0); } + /// \brief Return this type with all of the instance-specific qualifiers + /// removed, but without removing any qualifiers that may have been applied + /// through typedefs. + QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); } + /// \brief Return the unqualified form of the given type, which might be + /// desugared to eliminate qualifiers introduced via typedefs. + QualType getUnqualifiedType() const { + // FIXME: We may have to desugar the type to remove qualifiers. + return getLocalUnqualifiedType(); + } + bool isMoreQualifiedThan(QualType Other) const; bool isAtLeastAsQualifiedAs(QualType Other) const; QualType getNonReferenceType() const; @@ -2529,8 +2596,8 @@ public: /// Collect any qualifiers on the given type and return an /// unqualified type. const Type *strip(QualType QT) { - addFastQualifiers(QT.getFastQualifiers()); - if (QT.hasNonFastQualifiers()) { + addFastQualifiers(QT.getLocalFastQualifiers()); + if (QT.hasLocalNonFastQualifiers()) { const ExtQuals *EQ = QT.getExtQualsUnsafe(); Context = &EQ->getContext(); addQualifiers(EQ->getQualifiers()); @@ -2552,13 +2619,13 @@ public: inline bool QualType::isCanonical() const { const Type *T = getTypePtr(); - if (hasQualifiers()) + if (hasLocalQualifiers()) return T->isCanonicalUnqualified() && !isa<ArrayType>(T); return T->isCanonicalUnqualified(); } inline bool QualType::isCanonicalAsParam() const { - if (hasQualifiers()) return false; + if (hasLocalQualifiers()) return false; const Type *T = getTypePtr(); return T->isCanonicalUnqualified() && !isa<FunctionType>(T) && !isa<ArrayType>(T); @@ -2598,14 +2665,14 @@ inline void QualType::removeCVRQualifiers(unsigned Mask) { /// getAddressSpace - Return the address space of this type. inline unsigned QualType::getAddressSpace() const { - if (hasNonFastQualifiers()) { + if (hasLocalNonFastQualifiers()) { const ExtQuals *EQ = getExtQualsUnsafe(); if (EQ->hasAddressSpace()) return EQ->getAddressSpace(); } QualType CT = getTypePtr()->getCanonicalTypeInternal(); - if (CT.hasNonFastQualifiers()) { + if (CT.hasLocalNonFastQualifiers()) { const ExtQuals *EQ = CT.getExtQualsUnsafe(); if (EQ->hasAddressSpace()) return EQ->getAddressSpace(); @@ -2620,14 +2687,14 @@ inline unsigned QualType::getAddressSpace() const { /// getObjCGCAttr - Return the gc attribute of this type. inline Qualifiers::GC QualType::getObjCGCAttr() const { - if (hasNonFastQualifiers()) { + if (hasLocalNonFastQualifiers()) { const ExtQuals *EQ = getExtQualsUnsafe(); if (EQ->hasObjCGCAttr()) return EQ->getObjCGCAttr(); } QualType CT = getTypePtr()->getCanonicalTypeInternal(); - if (CT.hasNonFastQualifiers()) { + if (CT.hasLocalNonFastQualifiers()) { const ExtQuals *EQ = CT.getExtQualsUnsafe(); if (EQ->hasObjCGCAttr()) return EQ->getObjCGCAttr(); @@ -2705,28 +2772,26 @@ inline const ObjCInterfaceType *Type::getAsPointerToObjCInterfaceType() const { return 0; } -// NOTE: All of these methods use "getUnqualifiedType" to strip off address -// space qualifiers if present. inline bool Type::isFunctionType() const { - return isa<FunctionType>(CanonicalType.getUnqualifiedType()); + return isa<FunctionType>(CanonicalType); } inline bool Type::isPointerType() const { - return isa<PointerType>(CanonicalType.getUnqualifiedType()); + return isa<PointerType>(CanonicalType); } inline bool Type::isAnyPointerType() const { return isPointerType() || isObjCObjectPointerType(); } inline bool Type::isBlockPointerType() const { - return isa<BlockPointerType>(CanonicalType.getUnqualifiedType()); + return isa<BlockPointerType>(CanonicalType); } inline bool Type::isReferenceType() const { - return isa<ReferenceType>(CanonicalType.getUnqualifiedType()); + return isa<ReferenceType>(CanonicalType); } inline bool Type::isLValueReferenceType() const { - return isa<LValueReferenceType>(CanonicalType.getUnqualifiedType()); + return isa<LValueReferenceType>(CanonicalType); } inline bool Type::isRValueReferenceType() const { - return isa<RValueReferenceType>(CanonicalType.getUnqualifiedType()); + return isa<RValueReferenceType>(CanonicalType); } inline bool Type::isFunctionPointerType() const { if (const PointerType* T = getAs<PointerType>()) @@ -2735,7 +2800,7 @@ inline bool Type::isFunctionPointerType() const { return false; } inline bool Type::isMemberPointerType() const { - return isa<MemberPointerType>(CanonicalType.getUnqualifiedType()); + return isa<MemberPointerType>(CanonicalType); } inline bool Type::isMemberFunctionPointerType() const { if (const MemberPointerType* T = getAs<MemberPointerType>()) @@ -2744,37 +2809,37 @@ inline bool Type::isMemberFunctionPointerType() const { return false; } inline bool Type::isArrayType() const { - return isa<ArrayType>(CanonicalType.getUnqualifiedType()); + return isa<ArrayType>(CanonicalType); } inline bool Type::isConstantArrayType() const { - return isa<ConstantArrayType>(CanonicalType.getUnqualifiedType()); + return isa<ConstantArrayType>(CanonicalType); } inline bool Type::isIncompleteArrayType() const { - return isa<IncompleteArrayType>(CanonicalType.getUnqualifiedType()); + return isa<IncompleteArrayType>(CanonicalType); } inline bool Type::isVariableArrayType() const { - return isa<VariableArrayType>(CanonicalType.getUnqualifiedType()); + return isa<VariableArrayType>(CanonicalType); } inline bool Type::isDependentSizedArrayType() const { - return isa<DependentSizedArrayType>(CanonicalType.getUnqualifiedType()); + return isa<DependentSizedArrayType>(CanonicalType); } inline bool Type::isRecordType() const { - return isa<RecordType>(CanonicalType.getUnqualifiedType()); + return isa<RecordType>(CanonicalType); } inline bool Type::isAnyComplexType() const { - return isa<ComplexType>(CanonicalType.getUnqualifiedType()); + return isa<ComplexType>(CanonicalType); } inline bool Type::isVectorType() const { - return isa<VectorType>(CanonicalType.getUnqualifiedType()); + return isa<VectorType>(CanonicalType); } inline bool Type::isExtVectorType() const { - return isa<ExtVectorType>(CanonicalType.getUnqualifiedType()); + return isa<ExtVectorType>(CanonicalType); } inline bool Type::isObjCObjectPointerType() const { - return isa<ObjCObjectPointerType>(CanonicalType.getUnqualifiedType()); + return isa<ObjCObjectPointerType>(CanonicalType); } inline bool Type::isObjCInterfaceType() const { - return isa<ObjCInterfaceType>(CanonicalType.getUnqualifiedType()); + return isa<ObjCInterfaceType>(CanonicalType); } inline bool Type::isObjCQualifiedIdType() const { if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) @@ -2800,7 +2865,7 @@ inline bool Type::isObjCBuiltinType() const { return isObjCIdType() || isObjCClassType(); } inline bool Type::isTemplateTypeParmType() const { - return isa<TemplateTypeParmType>(CanonicalType.getUnqualifiedType()); + return isa<TemplateTypeParmType>(CanonicalType); } inline bool Type::isSpecificBuiltinType(unsigned K) const { diff --git a/include/clang/AST/TypeLoc.h b/include/clang/AST/TypeLoc.h index a06b9b82d0..8ac8c22a8e 100644 --- a/include/clang/AST/TypeLoc.h +++ b/include/clang/AST/TypeLoc.h @@ -58,7 +58,7 @@ public: : Ty(ty), Data(opaqueData) { } TypeLocClass getTypeLocClass() const { - if (getType().hasQualifiers()) return Qualified; + if (getType().hasLocalQualifiers()) return Qualified; return (TypeLocClass) getType()->getTypeClass(); } @@ -155,7 +155,7 @@ public: } static bool classof(const TypeLoc *TL) { - return !TL->getType().hasQualifiers(); + return !TL->getType().hasLocalQualifiers(); } static bool classof(const UnqualTypeLoc *TL) { return true; } }; @@ -200,7 +200,7 @@ public: } static bool classof(const TypeLoc *TL) { - return TL->getType().hasQualifiers(); + return TL->getType().hasLocalQualifiers(); } static bool classof(const QualifiedTypeLoc *TL) { return true; } }; diff --git a/include/clang/Frontend/PCHWriter.h b/include/clang/Frontend/PCHWriter.h index 22427eb671..b520f4be1d 100644 --- a/include/clang/Frontend/PCHWriter.h +++ b/include/clang/Frontend/PCHWriter.h @@ -52,7 +52,8 @@ struct UnsafeQualTypeDenseMapInfo { return QualType::getFromOpaquePtr((void*) 2); } static inline unsigned getHashValue(QualType T) { - assert(!T.getFastQualifiers() && "hash invalid for types with fast quals"); + assert(!T.getLocalFastQualifiers() && + "hash invalid for types with fast quals"); uintptr_t v = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr()); return (unsigned(v) >> 4) ^ (unsigned(v) >> 9); } diff --git a/include/clang/Frontend/TypeXML.def b/include/clang/Frontend/TypeXML.def index 6aca15a754..35f5debe5c 100644 --- a/include/clang/Frontend/TypeXML.def +++ b/include/clang/Frontend/TypeXML.def @@ -65,9 +65,9 @@ NODE_XML(QualType, "CvQualifiedType") ID_ATTRIBUTE_XML TYPE_ATTRIBUTE_XML(getTypePtr()) // the qualified type, e.g. for 'T* const' it's 'T*' - ATTRIBUTE_OPT_XML(isConstQualified(), "const") // boolean - ATTRIBUTE_OPT_XML(isVolatileQualified(), "volatile") // boolean - ATTRIBUTE_OPT_XML(isRestrictQualified(), "restrict") // boolean + ATTRIBUTE_OPT_XML(isLocalConstQualified(), "const") // boolean + ATTRIBUTE_OPT_XML(isLocalVolatileQualified(), "volatile") // boolean + ATTRIBUTE_OPT_XML(isLocalRestrictQualified(), "restrict") // boolean ATTRIBUTE_OPT_XML(getObjCGCAttr(), "objc_gc") // Qualifiers::GC ATTRIBUTE_OPT_XML(getAddressSpace(), "address_space") // unsigned END_NODE_XML diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp index 9850ad6f53..1b3e09291d 100644 --- a/lib/AST/ASTContext.cpp +++ b/lib/AST/ASTContext.cpp @@ -1186,7 +1186,7 @@ QualType ASTContext::getNoReturnType(QualType T) { } } - return getQualifiedType(ResultType, T.getQualifiers()); + return getQualifiedType(ResultType, T.getLocalQualifiers()); } /// getComplexType - Return the uniqued reference to the type for a complex @@ -2435,7 +2435,7 @@ ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) { const ArrayType *ASTContext::getAsArrayType(QualType T) { // Handle the non-qualified case efficiently. - if (!T.hasQualifiers()) { + if (!T.hasLocalQualifiers()) { // Handle the common positive case fast. if (const ArrayType *AT = dyn_cast<ArrayType>(T)) return AT; @@ -4204,8 +4204,8 @@ QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) { return LHS; // If the qualifiers are different, the types aren't compatible... mostly. - Qualifiers LQuals = LHSCan.getQualifiers(); - Qualifiers RQuals = RHSCan.getQualifiers(); + Qualifiers LQuals = LHSCan.getLocalQualifiers(); + Qualifiers RQuals = RHSCan.getLocalQualifiers(); if (LQuals != RQuals) { // If any of these qualifiers are different, we have a type // mismatch. diff --git a/lib/AST/CXXInheritance.cpp b/lib/AST/CXXInheritance.cpp index d4f6e87173..023bca4363 100644 --- a/lib/AST/CXXInheritance.cpp +++ b/lib/AST/CXXInheritance.cpp @@ -99,8 +99,8 @@ bool CXXRecordDecl::lookupInBases(BaseMatchesCallback *BaseMatches, for (base_class_const_iterator BaseSpec = bases_begin(), BaseSpecEnd = bases_end(); BaseSpec != BaseSpecEnd; ++BaseSpec) { // Find the record of the base class subobjects for this type. - QualType BaseType = Context.getCanonicalType(BaseSpec->getType()); - BaseType = BaseType.getUnqualifiedType(); + QualType BaseType = Context.getCanonicalType(BaseSpec->getType()) + .getUnqualifiedType(); // C++ [temp.dep]p3: // In the definition of a class template or a member of a class template, diff --git a/lib/AST/DeclCXX.cpp b/lib/AST/DeclCXX.cpp index 9867e5a880..bfa338b365 100644 --- a/lib/AST/DeclCXX.cpp +++ b/lib/AST/DeclCXX.cpp @@ -211,7 +211,7 @@ bool CXXRecordDecl::hasConstCopyAssignment(ASTContext &Context, if (!ArgType.isConstQualified()) AcceptsConst = false; } - if (Context.getCanonicalType(ArgType).getUnqualifiedType() != ClassType) + if (!Context.hasSameUnqualifiedType(ArgType, ClassType)) continue; MD = Method; // We have a single argument of type cv X or cv X&, i.e. we've found the @@ -276,7 +276,7 @@ void CXXRecordDecl::addedAssignmentOperator(ASTContext &Context, QualType ClassType = Context.getCanonicalType(Context.getTypeDeclType( const_cast<CXXRecordDecl*>(this))); - if (ClassType != Context.getCanonicalType(ArgType)) + if (!Context.hasSameUnqualifiedType(ClassType, ArgType)) return; // This is a copy assignment operator. diff --git a/lib/AST/TypePrinter.cpp b/lib/AST/TypePrinter.cpp index 234d38a59f..a482333782 100644 --- a/lib/AST/TypePrinter.cpp +++ b/lib/AST/TypePrinter.cpp @@ -63,7 +63,7 @@ void TypePrinter::Print(QualType T, std::string &S) { return; // Print qualifiers as appropriate. - Qualifiers Quals = T.getQualifiers(); + Qualifiers Quals = T.getLocalQualifiers(); if (!Quals.empty()) { std::string TQS; Quals.getAsStringInternal(TQS, Policy); @@ -550,7 +550,8 @@ void TypePrinter::PrintObjCObjectPointer(const ObjCObjectPointerType *T, ObjCQIString += '>'; } - T->getPointeeType().getQualifiers().getAsStringInternal(ObjCQIString, Policy); + T->getPointeeType().getLocalQualifiers().getAsStringInternal(ObjCQIString, + Policy); if (!T->isObjCIdType() && !T->isObjCQualifiedIdType()) ObjCQIString += " *"; // Don't forget the implicit pointer. diff --git a/lib/Analysis/CFRefCount.cpp b/lib/Analysis/CFRefCount.cpp index a0846b1abf..55e5f174cb 100644 --- a/lib/Analysis/CFRefCount.cpp +++ b/lib/Analysis/CFRefCount.cpp @@ -1537,7 +1537,7 @@ RetainSummaryManager::getCommonMethodSummary(const ObjCMethodDecl* MD, E = MD->param_end(); I != E; ++I, ++i) if (ParmVarDecl *PD = *I) { QualType Ty = Ctx.getCanonicalType(PD->getType()); - if (Ty.getUnqualifiedType() == Ctx.VoidPtrTy) + if (Ty.getLocalUnqualifiedType() == Ctx.VoidPtrTy) ScratchArgs = AF.Add(ScratchArgs, i, StopTracking); } } diff --git a/lib/Analysis/SValuator.cpp b/lib/Analysis/SValuator.cpp index 573cac315b..ac727b0ac6 100644 --- a/lib/Analysis/SValuator.cpp +++ b/lib/Analysis/SValuator.cpp @@ -62,8 +62,7 @@ SValuator::CastResult SValuator::EvalCast(SVal val, const GRState *state, ASTContext &C = ValMgr.getContext(); // For const casts, just propagate the value. - if (C.getCanonicalType(castTy).getUnqualifiedType() == - C.getCanonicalType(originalTy).getUnqualifiedType()) + if (C.hasSameUnqualifiedType(castTy, originalTy)) return CastResult(state, val); // Check for casts from pointers to integers. diff --git a/lib/Analysis/Store.cpp b/lib/Analysis/Store.cpp index afe2b4e7bd..2fd72ac0a1 100644 --- a/lib/Analysis/Store.cpp +++ b/lib/Analysis/Store.cpp @@ -64,7 +64,7 @@ const MemRegion *StoreManager::CastRegion(const MemRegion *R, QualType CastToTy) QualType CanonPointeeTy = Ctx.getCanonicalType(PointeeTy); // Handle casts to void*. We just pass the region through. - if (CanonPointeeTy.getUnqualifiedType() == Ctx.VoidTy) + if (CanonPointeeTy.getLocalUnqualifiedType() == Ctx.VoidTy) return R; // Handle casts from compatible types. @@ -199,9 +199,7 @@ SVal StoreManager::CastRetrievedVal(SVal V, const TypedRegion *R, if (castTy.isNull()) return V; - assert(Ctx.getCanonicalType(castTy).getUnqualifiedType() == - Ctx.getCanonicalType(R->getValueType(Ctx)).getUnqualifiedType()); - + assert(Ctx.hasSameUnqualifiedType(castTy, R->getValueType(Ctx))); return V; } diff --git a/lib/CodeGen/CGDebugInfo.cpp b/lib/CodeGen/CGDebugInfo.cpp index 41ffddd23a..0551667210 100644 --- a/lib/CodeGen/CGDebugInfo.cpp +++ b/lib/CodeGen/CGDebugInfo.cpp @@ -851,7 +851,7 @@ llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIType CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DICompileUnit Unit) { // Handle qualifiers, which recursively handles what they refer to. - if (Ty.hasQualifiers()) + if (Ty.hasLocalQualifiers()) return CreateQualifiedType(Ty, Unit); // Work out details of type. diff --git a/lib/CodeGen/Mangle.cpp b/lib/CodeGen/Mangle.cpp index 91e89fb711..0a7124de36 100644 --- a/lib/CodeGen/Mangle.cpp +++ b/lib/CodeGen/Mangle.cpp @@ -744,15 +744,15 @@ void CXXNameMangler::mangleType(QualType T) { // Only operate on the canonical type! T = Context.getASTContext().getCanonicalType(T); - bool IsSubstitutable = T.hasQualifiers() || !isa<BuiltinType>(T); + bool IsSubstitutable = T.hasLocalQualifiers() || !isa<BuiltinType>(T); if (IsSubstitutable && mangleSubstitution(T)) return; - if (Qualifiers Quals = T.getQualifiers()) { + if (Qualifiers Quals = T.getLocalQualifiers()) { mangleQualifiers(Quals); // Recurse: even if the qualified type isn't yet substitutable, // the unqualified type might be. - mangleType(T.getUnqualifiedType()); + mangleType(T.getLocalUnqualifiedType()); } else { switch (T->getTypeClass()) { #define ABSTRACT_TYPE(CLASS, PARENT) diff --git a/lib/Frontend/DocumentXML.cpp b/lib/Frontend/DocumentXML.cpp index d92d4cb7b8..0263c30bfd 100644 --- a/lib/Frontend/DocumentXML.cpp +++ b/lib/Frontend/DocumentXML.cpp @@ -135,7 +135,7 @@ void DocumentXML::finalize() { for (XML::IdMap<QualType>::iterator i = Types.begin(), e = Types.end(); i != e; ++i) { - if (i->first.hasQualifiers()) { + if (i->first.hasLocalQualifiers()) { writeTypeToXML(i->first); addAttribute("id", getPrefixedId(i->second, ID_NORMAL)); toParent(); @@ -205,7 +205,7 @@ void DocumentXML::addTypeRecursively(const QualType& pType) { addTypeRecursively(pType.getTypePtr()); // beautifier: a non-qualified type shall be transparent - if (!pType.hasQualifiers()) + if (!pType.hasLocalQualifiers()) { Types[pType] = BasicTypes[pType.getTypePtr()]; } diff --git a/lib/Frontend/PCHWriter.cpp b/lib/Frontend/PCHWriter.cpp index 2dcb8b0cee..8a45ebce1b 100644 --- a/lib/Frontend/PCHWriter.cpp +++ b/lib/Frontend/PCHWriter.cpp @@ -1248,9 +1248,9 @@ void PCHWriter::WriteType(QualType T) { // Emit the type's representation. PCHTypeWriter W(*this, Record); - if (T.hasNonFastQualifiers()) { - Qualifiers Qs = T.getQualifiers(); - AddTypeRef(T.getUnqualifiedType(), Record); + if (T.hasLocalNonFastQualifiers()) { + Qualifiers Qs = T.getLocalQualifiers(); + AddTypeRef(T.getLocalUnqualifiedType(), Record); Record.push_back(Qs.getAsOpaqueValue()); W.Code = pch::TYPE_EXT_QUAL; } else { @@ -2154,10 +2154,10 @@ void PCHWriter::AddTypeRef(QualType T, RecordData &Record) { return; } - unsigned FastQuals = T.getFastQualifiers(); + unsigned FastQuals = T.getLocalFastQualifiers(); T.removeFastQualifiers(); - if (T.hasNonFastQualifiers()) { + if (T.hasLocalNonFastQualifiers()) { pch::TypeID &ID = TypeIDs[T]; if (ID == 0) { // We haven't seen these qualifiers applied to this type before. @@ -2172,7 +2172,7 @@ void PCHWriter::AddTypeRef(QualType T, RecordData &Record) { return; } - assert(!T.hasQualifiers()); + assert(!T.hasLocalQualifiers()); |