From f6278e545d9bc09fb5d7579d1123f0a455352627 Mon Sep 17 00:00:00 2001 From: Richard Trieu Date: Wed, 9 May 2012 21:08:22 +0000 Subject: [PATCH] Pull some cases of initialization with self-reference warnings out of -Wconditional-uninitialized into -Wuninitialized. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@156512 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Sema/AnalysisBasedWarnings.cpp | 58 +++++++++++++----------------- test/SemaCXX/uninitialized.cpp | 45 +++++++++++++++++++++-- 2 files changed, 67 insertions(+), 36 deletions(-) diff --git a/lib/Sema/AnalysisBasedWarnings.cpp b/lib/Sema/AnalysisBasedWarnings.cpp index a171a066d8..e602ef1a23 100644 --- a/lib/Sema/AnalysisBasedWarnings.cpp +++ b/lib/Sema/AnalysisBasedWarnings.cpp @@ -464,44 +464,36 @@ static bool SuggestInitializationFixit(Sema &S, const VarDecl *VD) { static bool DiagnoseUninitializedUse(Sema &S, const VarDecl *VD, const Expr *E, bool isAlwaysUninit, bool alwaysReportSelfInit = false) { - bool isSelfInit = false; if (const DeclRefExpr *DRE = dyn_cast(E)) { - if (isAlwaysUninit) { - // Inspect the initializer of the variable declaration which is - // being referenced prior to its initialization. We emit - // specialized diagnostics for self-initialization, and we - // specifically avoid warning about self references which take the - // form of: - // - // int x = x; - // - // This is used to indicate to GCC that 'x' is intentionally left - // uninitialized. Proven code paths which access 'x' in - // an uninitialized state after this will still warn. - // - // TODO: Should we suppress maybe-uninitialized warnings for - // variables initialized in this way? - if (const Expr *Initializer = VD->getInit()) { - if (!alwaysReportSelfInit && DRE == Initializer->IgnoreParenImpCasts()) - return false; - - ContainsReference CR(S.Context, DRE); - CR.Visit(const_cast(Initializer)); - isSelfInit = CR.doesContainReference(); - } - if (isSelfInit) { + // Inspect the initializer of the variable declaration which is + // being referenced prior to its initialization. We emit + // specialized diagnostics for self-initialization, and we + // specifically avoid warning about self references which take the + // form of: + // + // int x = x; + // + // This is used to indicate to GCC that 'x' is intentionally left + // uninitialized. Proven code paths which access 'x' in + // an uninitialized state after this will still warn. + if (const Expr *Initializer = VD->getInit()) { + if (!alwaysReportSelfInit && DRE == Initializer->IgnoreParenImpCasts()) + return false; + + ContainsReference CR(S.Context, DRE); + CR.Visit(const_cast(Initializer)); + if (CR.doesContainReference()) { S.Diag(DRE->getLocStart(), diag::warn_uninit_self_reference_in_init) - << VD->getDeclName() << VD->getLocation() << DRE->getSourceRange(); - } else { - S.Diag(DRE->getLocStart(), diag::warn_uninit_var) - << VD->getDeclName() << DRE->getSourceRange(); + << VD->getDeclName() << VD->getLocation() << DRE->getSourceRange(); + return true; } - } else { - S.Diag(DRE->getLocStart(), diag::warn_maybe_uninit_var) - << VD->getDeclName() << DRE->getSourceRange(); } + + S.Diag(DRE->getLocStart(), isAlwaysUninit ? diag::warn_uninit_var + : diag::warn_maybe_uninit_var) + << VD->getDeclName() << DRE->getSourceRange(); } else { const BlockExpr *BE = cast(E); if (VD->getType()->isBlockPointerType() && @@ -518,7 +510,7 @@ static bool DiagnoseUninitializedUse(Sema &S, const VarDecl *VD, // Report where the variable was declared when the use wasn't within // the initializer of that declaration & we didn't already suggest // an initialization fixit. - if (!isSelfInit && !SuggestInitializationFixit(S, VD)) + if (!SuggestInitializationFixit(S, VD)) S.Diag(VD->getLocStart(), diag::note_uninit_var_def) << VD->getDeclName(); diff --git a/test/SemaCXX/uninitialized.cpp b/test/SemaCXX/uninitialized.cpp index b3283c221d..a6045bd118 100644 --- a/test/SemaCXX/uninitialized.cpp +++ b/test/SemaCXX/uninitialized.cpp @@ -10,9 +10,6 @@ int far(const int& x); int a = a; // no-warning: used to signal intended lack of initialization. int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}} int c = (c + c); // expected-warning 2 {{variable 'c' is uninitialized when used within its own initialization}} -void test() { - int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}} -} int e = static_cast(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}} int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}} @@ -28,6 +25,48 @@ int l = k ? l : l; // expected-warning 2{{variable 'l' is uninitialized when us int m = 1 + (k ? m : m); // expected-warning 2{{variable 'm' is uninitialized when used within its own initialization}} int n = -n; // expected-warning {{variable 'n' is uninitialized when used within its own initialization}} +void test () { + int a = a; // no-warning: used to signal intended lack of initialization. + int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}} + int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}} + int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}} + int e = static_cast(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}} + int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}} + + // Thes don't warn as they don't require the value. + int g = sizeof(g); + void* ptr = &ptr; + int h = bar(&h); + int i = boo(i); + int j = far(j); + int k = __alignof__(k); + + int l = k ? l : l; // FIXME: warn here + int m = 1 + (k ? m : m); // FIXME: warn here + int n = -n; // expected-warning {{variable 'n' is uninitialized when used within its own initialization}} + + for (;;) { + int a = a; // no-warning: used to signal intended lack of initialization. + int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}} + int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}} + int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}} + int e = static_cast(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}} + int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}} + + // Thes don't warn as they don't require the value. + int g = sizeof(g); + void* ptr = &ptr; + int h = bar(&h); + int i = boo(i); + int j = far(j); + int k = __alignof__(k); + + int l = k ? l : l; // FIXME: warn here + int m = 1 + (k ? m : m); // FIXME: warn here + int n = -n; // expected-warning {{variable 'n' is uninitialized when used within its own initialization}} + } +} + // Test self-references with record types. class A { // Non-POD class. -- 2.40.0