From 7a0ca9263dbfeaad11ae68a64056c3d31a6cf56d Mon Sep 17 00:00:00 2001 From: Richard Smith Date: Wed, 24 Sep 2014 23:55:00 +0000 Subject: [PATCH] Fix handling of preincrement on bit-fields. This gives a bit-field in C++, but we were failing to find that bit-field when performing integer promotions. This brings us closer to following the standard, and closer to GCC. In C, this change is technically a regression: we get bit-field promotions completely wrong in C, promoting cases that are categorically not bit-field designators. This change makes us do so slightly more consistently, though. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@218428 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/AST/ASTContext.cpp | 30 +++++++++++++++++++++++------- lib/AST/Expr.cpp | 4 ++++ test/Sema/bitfield.c | 21 ++++++++++++++++++++- test/SemaCXX/bitfield.cpp | 32 ++++++++++++++++++++++++++++++++ 4 files changed, 79 insertions(+), 8 deletions(-) create mode 100644 test/SemaCXX/bitfield.cpp diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp index 718719a904..cafde32eb6 100644 --- a/lib/AST/ASTContext.cpp +++ b/lib/AST/ASTContext.cpp @@ -4421,7 +4421,11 @@ unsigned ASTContext::getIntegerRank(const Type *T) const { QualType ASTContext::isPromotableBitField(Expr *E) const { if (E->isTypeDependent() || E->isValueDependent()) return QualType(); - + + // FIXME: We should not do this unless E->refersToBitField() is true. This + // matters in C where getSourceBitField() will find bit-fields for various + // cases where the source expression is not a bit-field designator. + FieldDecl *Field = E->getSourceBitField(); // FIXME: conditional bit-fields? if (!Field) return QualType(); @@ -4430,9 +4434,20 @@ QualType ASTContext::isPromotableBitField(Expr *E) const { uint64_t BitWidth = Field->getBitWidthValue(*this); uint64_t IntSize = getTypeSize(IntTy); - // GCC extension compatibility: if the bit-field size is less than or equal - // to the size of int, it gets promoted no matter what its type is. - // For instance, unsigned long bf : 4 gets promoted to signed int. + // C++ [conv.prom]p5: + // A prvalue for an integral bit-field can be converted to a prvalue of type + // int if int can represent all the values of the bit-field; otherwise, it + // can be converted to unsigned int if unsigned int can represent all the + // values of the bit-field. If the bit-field is larger yet, no integral + // promotion applies to it. + // C11 6.3.1.1/2: + // [For a bit-field of type _Bool, int, signed int, or unsigned int:] + // If an int can represent all values of the original type (as restricted by + // the width, for a bit-field), the value is converted to an int; otherwise, + // it is converted to an unsigned int. + // + // FIXME: C does not permit promotion of a 'long : 3' bitfield to int. + // We perform that promotion here to match GCC and C++. if (BitWidth < IntSize) return IntTy; @@ -4440,9 +4455,10 @@ QualType ASTContext::isPromotableBitField(Expr *E) const { return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy; // Types bigger than int are not subject to promotions, and therefore act - // like the base type. - // FIXME: This doesn't quite match what gcc does, but what gcc does here - // is ridiculous. + // like the base type. GCC has some weird bugs in this area that we + // deliberately do not follow (GCC follows a pre-standard resolution to + // C's DR315 which treats bit-width as being part of the type, and this leaks + // into their semantics in some cases). return QualType(); } diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp index 523db1243d..0970d59c9c 100644 --- a/lib/AST/Expr.cpp +++ b/lib/AST/Expr.cpp @@ -3278,6 +3278,10 @@ FieldDecl *Expr::getSourceBitField() { return BinOp->getRHS()->getSourceBitField(); } + if (UnaryOperator *UnOp = dyn_cast(E)) + if (UnOp->isPrefix() && UnOp->isIncrementDecrementOp()) + return UnOp->getSubExpr()->getSourceBitField(); + return nullptr; } diff --git a/test/Sema/bitfield.c b/test/Sema/bitfield.c index ab05a7773d..a4629c6136 100644 --- a/test/Sema/bitfield.c +++ b/test/Sema/bitfield.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 %s -fsyntax-only -verify +// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c11 enum e0; // expected-note{{forward declaration of 'enum e0'}} struct a { @@ -54,3 +54,22 @@ void test4(struct Test4 *t) { (void) sizeof(t->var ? t->bitX : t->bitY); // not a bitfield designator in C (void) sizeof(t->var ? t->bitX : t->bitX); // not a bitfield designator in C } + +typedef unsigned Unsigned; +typedef signed Signed; + +struct Test5 { unsigned n : 2; } t5; +typedef __typeof__(t5.n) Unsigned; // Bitfield is unsigned +typedef __typeof__(+t5.n) Signed; // ... but promotes to signed. + +typedef __typeof__(t5.n + 0) Signed; // Arithmetic promotes. + +typedef __typeof__(+(t5.n = 0)) Signed; // FIXME: Assignment should not; the result +typedef __typeof__(+(t5.n += 0)) Signed; // is a non-bit-field lvalue of type unsigned. +typedef __typeof__(+(t5.n *= 0)) Signed; + +typedef __typeof__(+(++t5.n)) Signed; // FIXME: Increment is equivalent to compound-assignment. +typedef __typeof__(+(--t5.n)) Signed; // This should not promote to signed. + +typedef __typeof__(+(t5.n++)) Unsigned; // Post-increment is underspecified, but seems to +typedef __typeof__(+(t5.n--)) Unsigned; // also act like compound-assignment. diff --git a/test/SemaCXX/bitfield.cpp b/test/SemaCXX/bitfield.cpp new file mode 100644 index 0000000000..083c28ffbb --- /dev/null +++ b/test/SemaCXX/bitfield.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 %s -verify + +// expected-no-diagnostics + +namespace PromotionVersusMutation { + typedef unsigned Unsigned; + typedef signed Signed; + + struct T { unsigned n : 2; } t; + + typedef __typeof__(t.n) Unsigned; // Bitfield is unsigned + typedef __typeof__(+t.n) Signed; // ... but promotes to signed. + + typedef __typeof__(t.n + 0) Signed; // Arithmetic promotes. + + typedef __typeof__(t.n = 0) Unsigned; // Assignment produces an lvalue... + typedef __typeof__(t.n += 0) Unsigned; + typedef __typeof__(t.n *= 0) Unsigned; + typedef __typeof__(+(t.n = 0)) Signed; // ... which is a bit-field. + typedef __typeof__(+(t.n += 0)) Signed; + typedef __typeof__(+(t.n *= 0)) Signed; + + typedef __typeof__(++t.n) Unsigned; // Increment is equivalent to compound-assignment. + typedef __typeof__(--t.n) Unsigned; + typedef __typeof__(+(++t.n)) Signed; + typedef __typeof__(+(--t.n)) Signed; + + typedef __typeof__(t.n++) Unsigned; // Post-increment's result has the type + typedef __typeof__(t.n--) Unsigned; // of the operand... + typedef __typeof__(+(t.n++)) Unsigned; // ... and is not a bit-field (because + typedef __typeof__(+(t.n--)) Unsigned; // it's not a glvalue). +} -- 2.40.0