ahatanak updated this revision to Diff 58495. ahatanak added a comment. Address John's review comments.
http://reviews.llvm.org/D20407 Files: include/clang/AST/Type.h lib/AST/Type.cpp lib/CodeGen/CGObjC.cpp lib/Sema/SemaObjCProperty.cpp test/CodeGenObjC/property-atomic-bool.m test/SemaObjC/property-atomic-bool.m
Index: test/SemaObjC/property-atomic-bool.m =================================================================== --- /dev/null +++ test/SemaObjC/property-atomic-bool.m @@ -0,0 +1,61 @@ +// RUN: %clang_cc1 -triple x86_64-apple-macosx10.10 -ast-dump "%s" 2>&1 | FileCheck %s + +// CHECK: TypedefDecl {{.*}} referenced AtomicBool '_Atomic(_Bool)' +// CHECK: AtomicType {{.*}} '_Atomic(_Bool)' +// CHECK: BuiltinType {{.*}} '_Bool' +// CHECK: ObjCInterfaceDecl {{.*}} A0 +// CHECK: ObjCPropertyDecl {{.*}} p '_Atomic(_Bool)' {{.*}} nonatomic +// CHECK: ObjCMethodDecl {{.*}} implicit - p '_Bool' +// CHECK: ObjCMethodDecl {{.*}} implicit - setP: 'void' +// CHECK: ParmVarDecl {{.*}} p '_Bool' +// CHECK: ObjCInterfaceDecl {{.*}} A1 +// CHECK: ObjCPropertyDecl {{.*}} p 'AtomicBool':'_Atomic(_Bool)' {{.*}} nonatomic +// CHECK: ObjCMethodDecl {{.*}} implicit - p '_Bool' +// CHECK: ObjCMethodDecl {{.*}} implicit - setP: 'void' +// CHECK: ParmVarDecl {{.*}} p '_Bool' +// CHECK: ObjCInterfaceDecl {{.*}} A2 +// CHECK: ObjCIvarDecl {{.*}} p '_Atomic(_Bool)' protected +// CHECK: ObjCPropertyDecl {{.*}} p '_Atomic(_Bool)' +// CHECK: ObjCMethodDecl {{.*}} implicit - p '_Bool' +// CHECK: ObjCMethodDecl {{.*}} implicit - setP: 'void' +// CHECK: ParmVarDecl {{.*}} p '_Bool' +// CHECK: ObjCInterfaceDecl {{.*}} A3 +// CHECK: ObjCIvarDecl {{.*}} p 'AtomicBool':'_Atomic(_Bool)' protected +// CHECK: ObjCPropertyDecl {{.*}} p 'AtomicBool':'_Atomic(_Bool)' +// CHECK: ObjCMethodDecl {{.*}} implicit - p '_Bool' +// CHECK: ObjCMethodDecl {{.*}} implicit - setP: 'void' +// CHECK: ParmVarDecl {{.*}} p '_Bool' + +typedef _Atomic(_Bool) AtomicBool; + +@interface A0 +@property(nonatomic) _Atomic(_Bool) p; +@end +@implementation A0 +@end + +@interface A1 +@property(nonatomic) AtomicBool p; +@end +@implementation A1 +@end + +@interface A2 { + _Atomic(_Bool) p; +} +@property _Atomic(_Bool) p; +@end + +@implementation A2 +@synthesize p; +@end + +@interface A3 { + AtomicBool p; +} +@property AtomicBool p; +@end + +@implementation A3 +@synthesize p; +@end Index: test/CodeGenObjC/property-atomic-bool.m =================================================================== --- /dev/null +++ test/CodeGenObjC/property-atomic-bool.m @@ -0,0 +1,34 @@ +// RUN: %clang_cc1 -triple x86_64-apple-macosx10 -emit-llvm -x objective-c %s -o - | FileCheck %s + +// CHECK: define internal zeroext i1 @"\01-[A0 p]"( +// CHECK: %[[ATOMIC_LOAD:.*]] = load atomic i8, i8* %{{.*}} seq_cst +// CHECK: %[[TOBOOL:.*]] = trunc i8 %[[ATOMIC_LOAD]] to i1 +// CHECK: ret i1 %[[TOBOOL]] + +// CHECK: define internal void @"\01-[A0 setP:]"({{.*}} i1 zeroext {{.*}}) +// CHECK: store atomic i8 %{{.*}}, i8* %{{.*}} seq_cst +// CHECK: ret void + +// CHECK: define internal zeroext i1 @"\01-[A1 p]"( +// CHECK: %[[ATOMIC_LOAD:.*]] = load atomic i8, i8* %{{.*}} unordered +// CHECK: %[[TOBOOL:.*]] = trunc i8 %load to i1 +// CHECK: ret i1 %[[TOBOOL]] + +// CHECK: define internal void @"\01-[A1 setP:]"({{.*}} i1 zeroext %p) +// CHECK: store atomic i8 %{{.*}}, i8* %{{.*}} unordered +// CHECK: ret void + +@interface A0 +@property(nonatomic) _Atomic(_Bool) p; +@end +@implementation A0 +@end + +@interface A1 { + _Atomic(_Bool) p; +} +@property _Atomic(_Bool) p; +@end +@implementation A1 +@synthesize p; +@end Index: lib/Sema/SemaObjCProperty.cpp =================================================================== --- lib/Sema/SemaObjCProperty.cpp +++ lib/Sema/SemaObjCProperty.cpp @@ -1494,23 +1494,26 @@ return false; QualType GetterType = GetterMethod->getReturnType().getNonReferenceType(); QualType PropertyIvarType = property->getType().getNonReferenceType(); - bool compat = Context.hasSameType(PropertyIvarType, GetterType); + QualType AtomicUnquailifiedType = + PropertyIvarType.getAtomicUnqualifiedType(Context); + bool compat = Context.hasSameType(AtomicUnquailifiedType, GetterType); if (!compat) { const ObjCObjectPointerType *propertyObjCPtr = nullptr; const ObjCObjectPointerType *getterObjCPtr = nullptr; - if ((propertyObjCPtr = PropertyIvarType->getAs<ObjCObjectPointerType>()) && + if ((propertyObjCPtr = + AtomicUnquailifiedType->getAs<ObjCObjectPointerType>()) && (getterObjCPtr = GetterType->getAs<ObjCObjectPointerType>())) compat = Context.canAssignObjCInterfaces(getterObjCPtr, propertyObjCPtr); - else if (CheckAssignmentConstraints(Loc, GetterType, PropertyIvarType) + else if (CheckAssignmentConstraints(Loc, GetterType, AtomicUnquailifiedType) != Compatible) { Diag(Loc, diag::error_property_accessor_type) << property->getDeclName() << PropertyIvarType << GetterMethod->getSelector() << GetterType; Diag(GetterMethod->getLocation(), diag::note_declared_at); return true; } else { compat = true; - QualType lhsType =Context.getCanonicalType(PropertyIvarType).getUnqualifiedType(); + QualType lhsType = Context.getCanonicalType(AtomicUnquailifiedType); QualType rhsType =Context.getCanonicalType(GetterType).getUnqualifiedType(); if (lhsType != rhsType && lhsType->isArithmeticType()) compat = false; @@ -2204,8 +2207,11 @@ // for this class. SourceLocation Loc = property->getLocation(); + // The getter returns the declared property type with all qualifiers + // removed. + QualType resultTy = property->getType().getAtomicUnqualifiedType(Context); + // If the property is null_resettable, the getter returns nonnull. - QualType resultTy = property->getType(); if (property->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_null_resettable) { QualType modifiedTy = resultTy; @@ -2274,9 +2280,12 @@ ObjCMethodDecl::Optional : ObjCMethodDecl::Required); + // Remove all qualifiers from the setter's parameter type. + QualType paramTy = property->getType().getUnqualifiedType(); + paramTy = paramTy.getAtomicUnqualifiedType(Context); + // If the property is null_resettable, the setter accepts a // nullable value. - QualType paramTy = property->getType().getUnqualifiedType(); if (property->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_null_resettable) { QualType modifiedTy = paramTy; Index: lib/CodeGen/CGObjC.cpp =================================================================== --- lib/CodeGen/CGObjC.cpp +++ lib/CodeGen/CGObjC.cpp @@ -897,9 +897,8 @@ // Currently, all atomic accesses have to be through integer // types, so there's no point in trying to pick a prettier type. - llvm::Type *bitcastType = - llvm::Type::getIntNTy(getLLVMContext(), - getContext().toBits(strategy.getIvarSize())); + uint64_t ivarSize = getContext().toBits(strategy.getIvarSize()); + llvm::Type *bitcastType = llvm::Type::getIntNTy(getLLVMContext(), ivarSize); bitcastType = bitcastType->getPointerTo(); // addrspace 0 okay // Perform an atomic load. This does not impose ordering constraints. @@ -911,7 +910,16 @@ // Store that value into the return address. Doing this with a // bitcast is likely to produce some pretty ugly IR, but it's not // the *most* terrible thing in the world. - Builder.CreateStore(load, Builder.CreateBitCast(ReturnValue, bitcastType)); + llvm::Type *RetTy = ConvertType(getterMethod->getReturnType()); + uint64_t RetTySize = CGM.getDataLayout().getTypeSizeInBits(RetTy); + llvm::Value *IVarVal = load; + if (ivarSize > RetTySize) { + llvm::Type *NewTy = llvm::Type::getIntNTy(getLLVMContext(), RetTySize); + IVarVal = Builder.CreateTrunc(load, NewTy); + bitcastType = NewTy->getPointerTo(); + } + Builder.CreateStore(IVarVal, + Builder.CreateBitCast(ReturnValue, bitcastType)); // Make sure we don't do an autorelease. AutoreleaseResult = false; @@ -1010,7 +1018,6 @@ AutoreleaseResult = false; } - value = Builder.CreateBitCast(value, ConvertType(propType)); value = Builder.CreateBitCast( value, ConvertType(GetterMethodDecl->getReturnType())); } Index: lib/AST/Type.cpp =================================================================== --- lib/AST/Type.cpp +++ lib/AST/Type.cpp @@ -1274,6 +1274,12 @@ }); } +QualType QualType::getAtomicUnqualifiedType(const ASTContext &Ctx) const { + if (auto AT = getTypePtr()->getAs<AtomicType>()) + return AT->getValueType().getUnqualifiedType(); + return getUnqualifiedType(); +} + Optional<ArrayRef<QualType>> Type::getObjCSubstitutions( const DeclContext *dc) const { // Look through method scopes. Index: include/clang/AST/Type.h =================================================================== --- include/clang/AST/Type.h +++ include/clang/AST/Type.h @@ -1080,6 +1080,9 @@ /// Strip Objective-C "__kindof" types from the given type. QualType stripObjCKindOfType(const ASTContext &ctx) const; + /// Remove all qualifiers including _Atomic. + QualType getAtomicUnqualifiedType(const ASTContext &ctx) const; + private: // These methods are implemented in a separate translation unit; // "static"-ize them to avoid creating temporary QualTypes in the
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits