llvm-svn: 59426

llvm-svn: 59425

llvm-svn: 59424

Eli please take a look, as I'm not sure if this gets the extension warning in the right place

llvm-svn: 59422

llvm-svn: 59421

llvm-svn: 59420

defined in a system header should be treated as system header tokens
even if they are instantiated in a different place.

llvm-svn: 59418

llvm-svn: 59411

llvm-svn: 59408

environment.

llvm-svn: 59407

llvm-svn: 59405

llvm-svn: 59404

 - RegionView and RegionViewMap is introduced to assist back-mapping from
   super region to subregions.
 - GDM is used to carry RegionView information.
 - AnonTypedRegion is added to represent a typed region introduced by pointer
   casting. Later AnonTypedRegion can be used in other similar cases, e.g.,
   malloc()'ed region.
 - The specific conversion is delegated to store manager.

llvm-svn: 59382

Patch by Fariborz!

llvm-svn: 59377

llvm-svn: 59375

llvm-svn: 59372

llvm-svn: 59371

llvm-svn: 59359

llvm-svn: 59358

llvm-svn: 59356

llvm-svn: 59354

Reverted part of r59335: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20081110/009243.html
In that patch I added a bogus type promotion for unary '!'.

The real bug was more fallout from edges cases with compound assignments and conjured symbolic values.  Now the conjured value has the type of the LHS expression, and we do a promotion to the computation type.  We also now correctly do a conversion from the computation type back to the LHS type.

llvm-svn: 59349

llvm-svn: 59348

llvm-svn: 59345

llvm-svn: 59343

Implement FIXME in GRExprEngine::VisitUnaryOperator() to handle implicit conversions caused by the '!' operator.  This required adding some logic to GRSimpleVals to reason about nonloc::LocAsInteger SVals.  This code appears to work fine, but it should eventually be cleaned up.

llvm-svn: 59335

llvm-svn: 59334

Thanks to Doug for the review. Actual effects of mutable to follow.

llvm-svn: 59331

Thanks to Sebastian for the suggestion.

llvm-svn: 59330

- Block-expression for 'ObjCForCollectionStmt' is not alive before it occurs
- Recursively visit 'element' expression for ObjCForCollectionStmt to get liveness for referenced block-level expressions and variables.

llvm-svn: 59316

Second attempt at implementation transfer function support for ObjCForCollectionStmt.  We now assume that the 'element' expression can be any lvalue.

llvm-svn: 59313

Flow-sensitive uninitialized values analysis: properly handle the 'element' expression of ObjCForCollectionStmt (can be anything).

llvm-svn: 59312

function call created in response to the use of operator syntax that
resolves to an overloaded operator in C++, e.g., "str1 +
str2" that resolves to std::operator+(str1, str2)". We now build a
CXXOperatorCallExpr in C++ when we pick an overloaded operator. (But
only for binary operators, where we actually implement overloading)

I decided *not* to refactor the current CallExpr to make it abstract
(with FunctionCallExpr and CXXOperatorCallExpr as derived
classes). Doing so would allow us to make CXXOperatorCallExpr a little
bit smaller, at the cost of making the argument and callee accessors
virtual. We won't know if this is going to be a win until we can parse
lots of C++ code to determine how much memory we'll save by making
this change vs. the performance penalty due to the extra virtual
calls.

llvm-svn: 59306

Don't require us to manually number the statements and expressions in StmtNodes.def. We don't need stable numbers yet, renumbering is a pain, and LAST_STMT had the wrong value anyway.

llvm-svn: 59300

llvm-svn: 59294

llvm-svn: 59290

Fix CFG construction for ObjCForCollectionStmt: 'element' expression can be anything that evaluates to an lvalue

llvm-svn: 59289

Update include files.

llvm-svn: 59284

candidates. Thanks to Chris for the review!

llvm-svn: 59260

1. In the top level of ParseStatementOrDeclaration, don't eat a } if we
   just parsed a statement if it list there.  Also, don't even bother
   emitting an error about a missing semicolon if the statement had a 
   bug (an rbrace is fine).
2. In do/while parsing, don't require a 'while' to be present if the do
   body didn't parse.

This allows us to generate a clean diagnostic for this code:

t.c:1:22: error: expected expression
void foo (void) { do . while (0); }
                     ^

Thanks to Neil for pointing this out.

llvm-svn: 59256