From: Jordan Rose Date: Mon, 4 Jun 2012 22:48:57 +0000 (+0000) Subject: Teach printf/scanf about enums with fixed underlying types. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=ee0259d308e72141982a85b40863e760a8447edf;p=clang Teach printf/scanf about enums with fixed underlying types. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@157961 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/Analysis/FormatString.cpp b/lib/Analysis/FormatString.cpp index f776c89cc5..caceeac113 100644 --- a/lib/Analysis/FormatString.cpp +++ b/lib/Analysis/FormatString.cpp @@ -241,6 +241,9 @@ bool ArgTypeResult::matchesType(ASTContext &C, QualType argTy) const { return true; case AnyCharTy: { + if (const EnumType *ETy = argTy->getAs()) + argTy = ETy->getDecl()->getIntegerType(); + if (const BuiltinType *BT = argTy->getAs()) switch (BT->getKind()) { default: @@ -255,7 +258,10 @@ bool ArgTypeResult::matchesType(ASTContext &C, QualType argTy) const { } case SpecificTy: { + if (const EnumType *ETy = argTy->getAs()) + argTy = ETy->getDecl()->getIntegerType(); argTy = C.getCanonicalType(argTy).getUnqualifiedType(); + if (T == argTy) return true; // Check for "compatible types". diff --git a/lib/Sema/SemaChecking.cpp b/lib/Sema/SemaChecking.cpp index e35f45b89d..0046b86f42 100644 --- a/lib/Sema/SemaChecking.cpp +++ b/lib/Sema/SemaChecking.cpp @@ -2396,17 +2396,26 @@ CheckPrintfHandler::HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier const analyze_printf::ArgTypeResult &ATR = FS.getArgType(S.Context, IsObjCLiteral); if (ATR.isValid() && !ATR.matchesType(S.Context, Ex->getType())) { - // Check if we didn't match because of an implicit cast from a 'char' - // or 'short' to an 'int'. This is done because printf is a varargs - // function. - if (const ImplicitCastExpr *ICE = dyn_cast(Ex)) - if (ICE->getType() == S.Context.IntTy || - ICE->getType() == S.Context.UnsignedIntTy) { - // All further checking is done on the subexpression. + // Look through argument promotions for our error message's reported type. + // This includes the integral and floating promotions, but excludes array + // and function pointer decay; seeing that an argument intended to be a + // string has type 'char [6]' is probably more confusing than 'char *'. + if (const ImplicitCastExpr *ICE = dyn_cast(Ex)) { + if (ICE->getCastKind() == CK_IntegralCast || + ICE->getCastKind() == CK_FloatingCast) { Ex = ICE->getSubExpr(); - if (ATR.matchesType(S.Context, Ex->getType())) - return true; + + // Check if we didn't match because of an implicit cast from a 'char' + // or 'short' to an 'int'. This is done because printf is a varargs + // function. + if (ICE->getType() == S.Context.IntTy || + ICE->getType() == S.Context.UnsignedIntTy) { + // All further checking is done on the subexpression. + if (ATR.matchesType(S.Context, Ex->getType())) + return true; + } } + } // We may be able to offer a FixItHint if it is a supported type. PrintfSpecifier fixedFS = FS; @@ -2415,7 +2424,7 @@ CheckPrintfHandler::HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier if (success) { // Get the fix string from the fixed format specifier - SmallString<128> buf; + SmallString<16> buf; llvm::raw_svector_ostream os(buf); fixedFS.toString(os); diff --git a/test/Sema/format-strings-enum-fixed-type.cpp b/test/Sema/format-strings-enum-fixed-type.cpp new file mode 100644 index 0000000000..8b6b237645 --- /dev/null +++ b/test/Sema/format-strings-enum-fixed-type.cpp @@ -0,0 +1,92 @@ +// RUN: %clang_cc1 -triple i386-apple-darwin9 -x c++ -std=c++11 -verify %s +// RUN: %clang_cc1 -triple i386-apple-darwin9 -x objective-c -verify %s +// RUN: %clang_cc1 -triple i386-apple-darwin9 -x objective-c++ -verify %s + +#ifdef __cplusplus +# define EXTERN_C extern "C" +#else +# define EXTERN_C extern +#endif + +EXTERN_C int printf(const char *,...); + +typedef enum : short { Constant = 0 } TestEnum; +// Note that in C (and Objective-C), the type of 'Constant' is 'short'. +// In C++ (and Objective-C++) it is 'TestEnum'. +// This is why we don't check for that in the expected output. + +void test(TestEnum input) { + printf("%hhd", input); // expected-warning{{format specifies type 'char' but the argument has type 'TestEnum'}} + printf("%hhd", Constant); // expected-warning{{format specifies type 'char'}} + + printf("%hd", input); // no-warning + printf("%hd", Constant); // no-warning + + // While these are less correct, they are still safe. + printf("%d", input); // no-warning + printf("%d", Constant); // no-warning + + printf("%lld", input); // expected-warning{{format specifies type 'long long' but the argument has type 'TestEnum'}} + printf("%lld", Constant); // expected-warning{{format specifies type 'long long'}} +} + + +typedef enum : unsigned long { LongConstant = ~0UL } LongEnum; + +void testLong(LongEnum input) { + printf("%u", input); // expected-warning{{format specifies type 'unsigned int' but the argument has type 'LongEnum'}} + printf("%u", LongConstant); // expected-warning{{format specifies type 'unsigned int'}} + + printf("%lu", input); + printf("%lu", LongConstant); +} + + +typedef short short_t; +typedef enum : short_t { ShortConstant = 0 } ShortEnum; + +void testUnderlyingTypedef(ShortEnum input) { + printf("%hhd", input); // expected-warning{{format specifies type 'char' but the argument has type 'ShortEnum'}} + printf("%hhd", ShortConstant); // expected-warning{{format specifies type 'char'}} + + printf("%hd", input); // no-warning + printf("%hd", ShortConstant); // no-warning + + // While these are less correct, they are still safe. + printf("%d", input); // no-warning + printf("%d", ShortConstant); // no-warning + + printf("%lld", input); // expected-warning{{format specifies type 'long long' but the argument has type 'ShortEnum'}} + printf("%lld", ShortConstant); // expected-warning{{format specifies type 'long long'}} +} + + +typedef ShortEnum ShortEnum2; + +void testTypedefChain(ShortEnum2 input) { + printf("%hhd", input); // expected-warning{{format specifies type 'char' but the argument has type 'ShortEnum2' (aka 'ShortEnum')}} + printf("%hd", input); // no-warning + printf("%d", input); // no-warning + printf("%lld", input); // expected-warning{{format specifies type 'long long' but the argument has type 'ShortEnum2' (aka 'ShortEnum')}} +} + + +typedef enum : char { CharConstant = 'a' } CharEnum; + +// %hhd is deliberately not required to be signed, because 'char' isn't either. +// This is a separate code path in FormatString.cpp. +void testChar(CharEnum input) { + printf("%hhd", input); // no-warning + printf("%hhd", CharConstant); // no-warning + + // This is not correct but it is safe. We warn because '%hd' shows intent. + printf("%hd", input); // expected-warning{{format specifies type 'short' but the argument has type 'CharEnum'}} + printf("%hd", CharConstant); // expected-warning{{format specifies type 'short'}} + + // This is not correct but it matches the promotion rules (and is safe). + printf("%d", input); // no-warning + printf("%d", CharConstant); // no-warning + + printf("%lld", input); // expected-warning{{format specifies type 'long long' but the argument has type 'CharEnum'}} + printf("%lld", CharConstant); // expected-warning{{format specifies type 'long long'}} +} diff --git a/test/Sema/format-strings-enum.c b/test/Sema/format-strings-enum.c new file mode 100644 index 0000000000..a6c27d0b6e --- /dev/null +++ b/test/Sema/format-strings-enum.c @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -verify %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -x c++ -verify %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -x c++ -std=c++11 -verify %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -x objective-c -verify %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -x objective-c++ -std=c++11 -verify %s + +#ifdef __cplusplus +# define EXTERN_C extern "C" +#else +# define EXTERN_C extern +#endif + +EXTERN_C int printf(const char *,...); + +typedef enum { Constant = 0 } TestEnum; +// Note that in C, the type of 'Constant' is 'int'. In C++ it is 'TestEnum'. +// This is why we don't check for that in the expected output. + +void test(TestEnum input) { + printf("%d", input); // no-warning + printf("%d", Constant); // no-warning + + printf("%lld", input); // expected-warning{{format specifies type 'long long' but the argument has type 'TestEnum'}} + printf("%lld", Constant); // expected-warning{{format specifies type 'long long'}} +} + + +typedef enum { LongConstant = ~0UL } LongEnum; + +void testLong(LongEnum input) { + printf("%u", input); // expected-warning{{format specifies type 'unsigned int' but the argument has type 'LongEnum'}} + printf("%u", LongConstant); // expected-warning{{format specifies type 'unsigned int'}} + + printf("%lu", input); + printf("%lu", LongConstant); +}