From: Chris Lattner Date: Mon, 16 Jul 2007 00:23:25 +0000 (+0000) Subject: Now that isPointerType can return a pointer type, avoid stripping off typedef X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=7a2e047c602d6ba28d6c434c990d4b9f7ef8c694;p=clang Now that isPointerType can return a pointer type, avoid stripping off typedef information in the common case. On this invalid code: typedef float float4 __attribute__((vector_size(16))); typedef int int4 __attribute__((vector_size(16))); void test(float4 a, int4 *result, int i) { result[i] = a; } we now generate: t.c:5:15: error: incompatible types assigning 'float4' to 'int4' instead of: t.c:5:15: error: incompatible types assigning 'float4' to 'int __attribute__((vector_size(16)))' This implements test/Sema/typedef-retain.c git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@39892 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/AST/Type.cpp b/AST/Type.cpp index 74e47936a9..0bc058f742 100644 --- a/AST/Type.cpp +++ b/AST/Type.cpp @@ -60,8 +60,12 @@ bool Type::isFunctionType() const { return isa(CanonicalType); } -PointerType *Type::isPointerType() const { - if (PointerType *PTy = dyn_cast(CanonicalType)) +const PointerType *Type::isPointerType() const { + // If this is directly a pointer type, return it. + if (const PointerType *PTy = dyn_cast(this)) + return PTy; + // If this is a typedef for a pointer type, strip the typedef off. + if (const PointerType *PTy = dyn_cast(CanonicalType)) return PTy; return 0; } @@ -90,6 +94,21 @@ bool Type::isUnionType() const { return false; } +bool Type::isComplexType() const { + return isa(CanonicalType); +} + +const VectorType *Type::isVectorType() const { + // Are we directly a vector type? + if (const VectorType *VTy = dyn_cast(this)) + return VTy; + // If this is a typedef for a vector type, strip the typedef off. + if (const VectorType *VTy = dyn_cast(CanonicalType)) + return VTy; + return 0; +} + + // C99 6.2.7p1: If both are complete types, then the following additional // requirements apply...FIXME (handle compatibility across source files). bool Type::tagTypesAreCompatible(QualType lhs, QualType rhs) { @@ -289,16 +308,6 @@ bool Type::isRealType() const { return false; } -bool Type::isComplexType() const { - return isa(CanonicalType); -} - -VectorType *Type::isVectorType() const { - if (VectorType *VTy = dyn_cast(CanonicalType)) - return VTy; - return 0; -} - bool Type::isArithmeticType() const { if (const BuiltinType *BT = dyn_cast(CanonicalType)) return BT->getKind() != BuiltinType::Void; diff --git a/Sema/SemaExpr.cpp b/Sema/SemaExpr.cpp index 088d3f1bdb..3a7635b252 100644 --- a/Sema/SemaExpr.cpp +++ b/Sema/SemaExpr.cpp @@ -294,17 +294,18 @@ ParseArraySubscriptExpr(ExprTy *Base, SourceLocation LLoc, // and index from the expression types. Expr *BaseExpr, *IndexExpr; QualType ResultType; - if (PointerType *PTy = LHSTy->isPointerType()) { + if (const PointerType *PTy = LHSTy->isPointerType()) { BaseExpr = LHSExp; IndexExpr = RHSExp; // FIXME: need to deal with const... ResultType = PTy->getPointeeType(); - } else if (PointerType *PTy = RHSTy->isPointerType()) { // uncommon: 123[Ptr] + } else if (const PointerType *PTy = RHSTy->isPointerType()) { + // Handle the uncommon case of "123[Ptr]". BaseExpr = RHSExp; IndexExpr = LHSExp; // FIXME: need to deal with const... ResultType = PTy->getPointeeType(); - } else if (VectorType *VTy = LHSTy->isVectorType()) { // vectors: V[123] + } else if (const VectorType *VTy = LHSTy->isVectorType()) { // vectors: V[123] BaseExpr = LHSExp; IndexExpr = RHSExp; // FIXME: need to deal with const... diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h index b2ca8eb5d7..ecce34c64e 100644 --- a/include/clang/AST/Type.h +++ b/include/clang/AST/Type.h @@ -230,11 +230,11 @@ public: bool isArithmeticType() const; // C99 6.2.5p18 (integer + floating) /// Vector types - VectorType *isVectorType() const; // GCC vector type. + const VectorType *isVectorType() const; // GCC vector type. /// Derived types (C99 6.2.5p20). isFunctionType() is also a derived type. bool isDerivedType() const; - PointerType *isPointerType() const; + const PointerType *isPointerType() const; bool isReferenceType() const; bool isArrayType() const; bool isStructureType() const;