llvm-svn: 146476

llvm-svn: 146454

Necessary to parse Microsoft ATL code.

Example: 
  int array[] = {
    0, 
    __if_exists(CLASS::Type) {2, }
    3
  };

will declare an array of 2 or 3 elements depending on if CLASS::Type exists or not.

llvm-svn: 146447

inside a struct/union.

llvm-svn: 146444

Make CGRecordLayoutBuilder correctly switch over to a packed class when a class has a base whose alignment will break the class layout.  <rdar://problem/10551376>.

llvm-svn: 146443

The motivation here is a "clever" implementation of strncmp(), which peels the first few comparisons via chained conditional expressions which ensure that the input arrays are known at compile time to be sufficiently large.

llvm-svn: 146430

fields by just following what comment says.
// rdar://10513599

llvm-svn: 146414

conversions in constant expressions.

llvm-svn: 146406

the subdirectories to find headers in submodules.

llvm-svn: 146398

llvm-svn: 146395

actually a terribly good heuristic, and the world is too horrible for
it to work.

llvm-svn: 146393

llvm-svn: 146392

llvm-svn: 146390

llvm-svn: 146371

llvm-svn: 146367

llvm-svn: 146354

[analyzer] CStringChecker should not rely on the analyzer generating UndefOrUnknown value when it cannot reason about the expression.

We are now often generating expressions even if the solver is not known to be able to simplify it. This is another cleanup of the existing code, where the rest of the analyzer and checkers should not base their logic on knowing ahead of the time what the solver can reason about. 

In this case, CStringChecker is performing a check for overflow of 'left+right' operation. The overflow can be checked with either 'maxVal-left' or 'maxVal-right'. Previously, the decision was based on whether the expresion evaluated to undef or not. With this patch, we check if one of the arguments is a constant, in which case we know that 'maxVal-const' is easily simplified. (Another option is to use canReasonAbout() method of the solver here, however, it's currently is protected.)

This patch also contains 2 small bug fixes:
 - swap the order of operators inside SValBuilder::makeGenericVal.
 - handle a case when AddeVal is unknown in GenericTaintChecker::getPointedToSymbol.

llvm-svn: 146343

and offer fixits when there is a mismatch.

llvm-svn: 146326

llvm-svn: 146321

under ARC. Fixes <rdar://problem/10530209>.

llvm-svn: 146307

// rdar://10095131

llvm-svn: 146304

llvm-svn: 146303

template instantiation), and that expression might produce a
temporary, invoke MaybeBindToTemporary. Otherwise, we forget to
destroy objects, release objects, etc. Fixes <rdar://problem/10531073>.

llvm-svn: 146301

llvm-svn: 146291

C++11 ICE rules.

llvm-svn: 146290

whether an expression is a (core) constant expression as a side-effect of
evaluation. This takes us from accepting far too few expressions as ICEs to
accepting slightly too many -- fixes for the remaining cases are coming next.

The diagnostics produced when an expression is found to be non-constant are
currently quite poor (with generic wording but reasonable source locations),
and will be improved in subsequent commits.

llvm-svn: 146289

Add notes for suppressing and (if it's a zero-arg function returning bool) fixing the function-to-bool conversion warning.

llvm-svn: 146280

// rdar://10535245

llvm-svn: 146272

Provide a separate warning for weak vtables in explicit template instantiations. There's no (current) way to fix such templates to emit strong symbols/vtables, but perhaps users want to know about the cost being incurred anyway.

llvm-svn: 146265

in addition to underlying type.

llvm-svn: 146254

It should reset the length modifier (unless it's a wchar_t string).

llvm-svn: 146252

types are equivalent.

+ A taint test which tests bitwise operations and which was
triggering an assertion due to presence of the integer to integer cast.

llvm-svn: 146240

documentation) with one based on what GCC's __builtin_constant_p is actually
intended to do (discovered by asking a friendly GCC developer).

In particular, an expression which folds to a pointer is now only considered to
be a "constant" by this builtin if it refers to the first character in a string
literal.

This fixes a rather subtle wrong-code issue when building with glibc. Given:

const char cs[4] = "abcd";
int f(const char *p) { return strncmp(p, cs, 4); }

... the macro magic for strncmp produces a (potentially crashing) call to
strlen(cs), because it expands to an expression starting with:

  __builtin_constant_p(cs) && strlen(cs) < 4 ? /* ... */

Under the secret true meaning of __builtin_constant_p, this is guaranteed to be
safe!

llvm-svn: 146236

all of the headers below that particular directory. Use umbrella
directories as a clean way to deal with (1) directories/frameworks
that don't have an umbrella header, but don't want to enumerate all of
their headers, and (2) PrivateHeaders, which we never want to
enumerate and want to keep separate from the main umbrella header. 

This also eliminates a little more of the "magic" for private headers,
and frameworks in general.

llvm-svn: 146235

// rdar://10535640

llvm-svn: 146218

llvm-svn: 146210

+ random comments

llvm-svn: 146199

llvm-svn: 146189

llvm-svn: 146176

llvm-svn: 146174