Commit Graph

53 Commits

Author SHA1 Message Date
Richard Smith c38498f046 PR23334: Perform semantic checking of lambda capture initialization in the right context.
Previously we'd try to perform checks on the captures from the middle of
parsing the lambda's body, at the point where we detected that a variable
needed to be captured. This was wrong in a number of subtle ways. In
PR23334, we couldn't correctly handle the list of potential odr-uses
resulting from the capture, and our attempt to recover from that resulted
in a use-after-free.

We now defer building the initialization expression until we leave the lambda
body and return to the enclosing context, where the initialization does the
right thing. This patch only covers lambda-expressions, but we should apply
the same change to blocks and captured statements too.

llvm-svn: 235921
2015-04-27 21:27:54 +00:00
Manuel Klimek 27ee25f738 Make -Wuninitialized warn on pointer-to-member and comma operators.
`isTrackedVar` has been updated to also track records.
`DeclRefExpr`s appearing on the left side of a comma operator are
ignored, while those appearing on the right side are classified as
`Use`.

Patch by Enrico Pertoso.

llvm-svn: 231068
2015-03-03 14:54:25 +00:00
Richard Trieu c321b931c0 When checking for uninitialized values, do not confuse "std::move" with every
other function named "move".

llvm-svn: 222863
2014-11-27 01:29:32 +00:00
Richard Trieu 3630c39972 Extend -Wuninitialized to warn when accessing uninitialized base classes in a
constructor.

llvm-svn: 222503
2014-11-21 03:10:30 +00:00
Richard Trieu 46847425c5 Fix a bug where -Wuninitialized would skip arguments to a function call.
llvm-svn: 221030
2014-11-01 00:46:54 +00:00
Richard Trieu d4a0136002 Have -Wuninitialized catch uninitalized use in overloaded operator arguments.
llvm-svn: 221000
2014-10-31 21:10:22 +00:00
Richard Trieu 277ace025d Disable the uninitialized field warning in uninstantiated classes.
If a templated class is not instantiated, then the AST for it could be missing
some things that would throw the field checker off.  Wait until specialization
before emitting these warnings.

llvm-svn: 220363
2014-10-22 02:52:00 +00:00
Richard Trieu fa1d0a7dbf Add support for initializer lists on field initializers for -Wuninitialized
llvm-svn: 220087
2014-10-17 20:56:10 +00:00
Richard Trieu 2d779b984c Improve -Wuninitialized warnings for fields that are record types.
Get the record handling code from SelfReferenceChecker into
UninitializedFieldVisitor as well as copying the testcases.

llvm-svn: 218740
2014-10-01 03:44:58 +00:00
Richard Trieu 438903d1b2 Update uninitialized tests to ensure that field initialization has the
same coverage as the global checker.

llvm-svn: 218720
2014-09-30 23:46:05 +00:00
Richard Trieu 9f8509f70d Update -Wuninitialized to be stricter on CK_NoOp casts.
llvm-svn: 218715
2014-09-30 23:04:37 +00:00
Richard Trieu 779c6f2573 Add back checking for condition of conditional operator for -Wuninitialized
llvm-svn: 218556
2014-09-26 23:48:30 +00:00
Richard Trieu 52b8b60d4c Add increment/decrement operators and compound assignment operators to the
uninitialized checkers that did not have them before.

llvm-svn: 218435
2014-09-25 01:15:40 +00:00
Richard Trieu 78dd725cde Fix an edge case with BinaryOperator's in -Wuninitialized. Add testcases for
the other visitors as well.

llvm-svn: 218366
2014-09-24 03:53:56 +00:00
Richard Trieu e396ba6bb0 Improve -Wuninitialized to take into account field ordering with initializer
lists.  Since the fields are inititalized one at a time, using a field with
lower index to initialize a higher indexed field should not be warned on.

llvm-svn: 218339
2014-09-23 22:52:42 +00:00
Richard Trieu 8a0c9e6247 Check delegating constructors for using uninitialized fields.
llvm-svn: 217716
2014-09-12 22:47:58 +00:00
Richard Trieu 2a07c96737 Stop double visiting some expressions during self reference checking.
Originally, self reference checking made a double pass over some expressions
to handle reference type checking.  Now, allow HandleValue to also check
reference types, and fallback to Visit for unhandled expressions.

llvm-svn: 217203
2014-09-04 23:19:34 +00:00
Richard Trieu 8d08a2770e During cross field uninitialized checking, when processing an assignment,
don't mark the field as initialized until the next initializer instead of
instantly.  Since this checker is AST based, statements are processed in tree
order instead of following code flow.  This can result in different warnings
from just reordering the code.  Also changed to use one checker per constructor
instead of creating a new checker per field.

class T {
  int x, y;

  // Already warns
  T(bool b) : x(!b ? (1 + y) : (y = 5)) {}

  // New warning added here, previously (1 + y) comes after (y = 5) in the AST
  // preventing the warning.
  T(bool b) : x(b ? (y = 5) : (1 + y)) {}

};

llvm-svn: 216641
2014-08-28 03:23:47 +00:00
Richard Trieu abf6ec45cd More -Wuninitialized updates
Fix r216438 to catch more complicated self-initialized in std::move.  For
instance, "Foo f = std::move(cond ? OtherFoo : (UNUSED_VALUE, f));"

Make sure that BinaryConditionalOperator, ConditionalOperator, BinaryOperator
with comma operator, and OpaqueValueExpr perform the correct usage forwarding
across the three uninitialized value checkers.

llvm-svn: 216627
2014-08-27 22:15:10 +00:00
Richard Trieu 11fd079b6e Passing a variable to std::move now counts as a use for -Wuninitialized
llvm-svn: 216438
2014-08-26 04:30:55 +00:00
Richard Trieu 4834ad2609 Improve -Wuninitialized to catch const classes being used in their own copy
constructors.

llvm-svn: 215471
2014-08-12 21:05:04 +00:00
Alp Toker f6a24ce40f Fix a tranche of comment, test and doc typos
llvm-svn: 196510
2013-12-05 16:25:25 +00:00
Richard Trieu ef64e94d5c Simplify and refactor the uninitialized field warning.
Change the uninitialized field warnings so that field initializers are checked
inside the constructor.  Previously, in class initializers were checked
separately.  Running one set of checks also simplifies the logic for preventing
duplicate warnings.  Added new checks to warn when an uninitialized field is
used in base class initialization.  Also fixed misspelling of uninitialized
and moved all code for this warning together.

llvm-svn: 193386
2013-10-25 00:56:00 +00:00
Richard Trieu 406e65c8d1 Modify the uninitialized field visitor to detect uninitialized use across the
fields in the class.  This allows a better checking of member intiailizers and
in class initializers in regards to initialization ordering.

For instance, this code will now produce warnings:

class A {
  int x;
  int y;
  A() : x(y) {}  // y is initialized after x, warn here
  A(int): y(x) {} // default initialization of leaves x uninitialized, warn here
};

Several test cases were updated with -Wno-uninitialized to silence this warning.

llvm-svn: 191068
2013-09-20 03:03:06 +00:00
Richard Trieu 1bc22c12cb Refactor the uninitialized field visitor. Also moved the calls to the visitor
later in the code so that the expressions will have addition processing first.
This catches a few additional cases of uninitialized uses of class fields.

llvm-svn: 190657
2013-09-13 03:20:53 +00:00
Richard Smith fa11fd669f PR15906: The body of a lambda is not an evaluated subexpression; don't visit it when visiting such subexpressions.
llvm-svn: 181046
2013-05-03 19:16:22 +00:00
Richard Trieu 8fbd91d445 Handle CXXOperatorCallExpr when checking self referrnce during initialization of
class types.

llvm-svn: 177987
2013-03-26 03:41:40 +00:00
Ted Kremenek a83b407c51 Reapply r172878 with test case.
llvm-svn: 172888
2013-01-19 04:33:14 +00:00
Ted Kremenek 7ba78c679c -Wuninitialized: warn about uninitialized values resulting from ?: that evaluate to lvalues (in C++).
llvm-svn: 172875
2013-01-19 00:25:06 +00:00
Richard Trieu 742c6ed9bf Change how the SelfReferenceChecker handles MemberExpr. Instead of treating
each one separately, process a stack of MemberExpr's as a single unit so that
static calls and member access will not be warned on.

llvm-svn: 165074
2012-10-03 00:41:36 +00:00
Richard Trieu 3267347cca Cleaning up the self initialization checker.
-Allow Sema to do more processing on the initial Expr before checking it.
-Remove the special conditions in HandleExpr()
-Move the code so that only one call site is needed.
-Removed the function from Sema and only call it locally.
-Warn on potentially evaluated reference variables, not just casts to r-values.
-Update tests.

llvm-svn: 164951
2012-10-01 17:39:51 +00:00
Hans Wennborg 61b2ffa60f Make warnings about uninitialized fields include the field name.
This makes the wording more informative, and consistent with the other
warnings about uninitialized variables.

Also, me and David who reviewed this couldn't figure out why we would
need to do a lookup to get the name of the variable; so just print the
name directly.

llvm-svn: 164366
2012-09-21 08:58:33 +00:00
Hans Wennborg 44fd70a3ad Warn about self references in in-class initializers.
This makes Clang warn about self references in in-class initializers,
for example:

  struct S {
    int a = a + 42;
  };

This basically just moves UninitializedFieldVisitor up a bit in
SemaDeclCXX.cpp, and adds a call to it from ActOnCXXInClassMemberInitializer.

llvm-svn: 164131
2012-09-18 15:58:06 +00:00
Hans Wennborg d799a2b3b9 Better wording for reference self-initialization warning.
llvm-svn: 162198
2012-08-20 08:52:22 +00:00
Hans Wennborg e1fdb059c6 Warn about self-initialization of references.
Initializing a reference with itself, e.g. "int &a = a;" seems like a
very bad idea.

llvm-svn: 162093
2012-08-17 10:12:33 +00:00
Richard Trieu b7ed89eb94 Check local static variables for self reference on initialization.
llvm-svn: 161909
2012-08-14 23:50:52 +00:00
Richard Trieu 43803f0951 For global record types, the self reference checker was called twice, resulting
in duplicate -Wuninitialized warnings.  Change so that only the check in
TryConstructorInitialization() will be used and a single warning be emitted.

llvm-svn: 161345
2012-08-06 21:09:23 +00:00
Ted Kremenek b50e716bac Refine CFG so that '&&' and '||' don't lead to extra confluence points when used in a branch, but
instead push the terminator for the branch down into the basic blocks of the subexpressions of '&&' and '||'
respectively.  This eliminates some artifical control-flow from the CFG and results in a more
compact CFG.

Note that this patch only alters the branches 'while', 'if' and 'for'.  This was complex enough for
one patch.  The remaining branches (e.g., do...while) can be handled in a separate patch, but they
weren't immediately tackled because they were less important.

It is possible that this patch introduces some subtle bugs, particularly w.r.t. to destructor placement.
I've tried to audit these changes, but it is also known that the destructor logic needs some refinement
in the area of '||' and '&&' regardless (i.e., their are known bugs).

llvm-svn: 160218
2012-07-14 05:04:10 +00:00
Richard Trieu 4fc853681f Use a proper visitor to recursively check for uninitialized use in constructors.
llvm-svn: 158477
2012-06-14 23:11:34 +00:00
Aaron Ballman f0b67b6f5c Removing the lambda extension warning concerning single return statements, as it no longer applies.
llvm-svn: 157943
2012-06-04 18:57:41 +00:00
Richard Trieu 43a2fc7b9e Pull some cases of initialization with self-reference warnings out of
-Wconditional-uninitialized into -Wuninitialized.

llvm-svn: 156512
2012-05-09 21:08:22 +00:00
Richard Trieu 64c51abf7f Update the SelfReferenceChecker. Refactored some of the visitor methods.
Added support for conditional operators and tightened the exclusion of the
unary operator from all operators to only the address of operator.

llvm-svn: 156450
2012-05-09 00:21:34 +00:00
Ted Kremenek 49a7ef5c23 Add -Wuninitialized test for C++11 lambdas.
llvm-svn: 154608
2012-04-12 20:03:47 +00:00
Ted Kremenek 213d05304e Fix broken CFG when an initializer is a statement expression that starts with a while loop (PR 12325).
llvm-svn: 153242
2012-03-22 05:57:43 +00:00
Richard Trieu 978dfc0d1e Fix -Wuninitialized to catch the case of a class being initialized with a call
to its own member function.

llvm-svn: 152276
2012-03-08 01:15:31 +00:00
Rafael Espindola 7c23b0891b Improvements to the uninitialized variable warning: Check if the constructor
call is elidable or if the constructor is trivial instead of checking if it
is user declared.

llvm-svn: 147652
2012-01-06 04:54:01 +00:00
Douglas Gregor 6c8f07ff46 Teach the CFG builder how to properly destroy temporaries who
lifetimes have been extended via reference binding. The type of the
reference and the type of the temporary are not necessarily the same,
which could cause a crash. Fixes <rdar://problem/10398199>.

llvm-svn: 144646
2011-11-15 15:29:30 +00:00
Richard Trieu aa5e256c20 Change the self-reference visitor (which gives the warning for self-reference oninitalization warning of -Wuninitialized) to exclude member variables that can decay into pointers. This will cause it to no longer warn on this code:
struct foo { char a[100], *e; } bar = { .e = bar.a };

llvm-svn: 139213
2011-09-07 00:58:53 +00:00
Richard Trieu a04ad1a1b9 Extend the self-reference warning to catch when a constructor references itself upon initialization, such as using itself within its own copy constructor.
struct S {};
S s(s);

llvm-svn: 138969
2011-09-01 21:44:13 +00:00
Chandler Carruth b5d4831f83 Fix PR9624 by explicitly disabling uninitialized warnings for direct self-init:
int x = x;

GCC disables its warnings on this construct as a way of indicating that
the programmer intentionally wants the variable to be uninitialized.
Only the warning on the initializer is turned off in this iteration.

This makes the code a lot more ugly, but starts commenting the
surprising behavior here. This is a WIP, I want to refactor it
substantially for clarity, and to determine whether subsequent warnings
should be suppressed or not.

llvm-svn: 128894
2011-04-05 17:41:31 +00:00