llvm-svn: 58985

Implement RegionStoreManager::RemoveDeadBindings(). This prunes several false warning caused by removal of symbolic constraints. Currently we just mark all symbols live. Further optimization for dead binding removal needed.

llvm-svn: 58982

speeds up the compiler by ~8% at -emit-llvm -O0.

llvm-svn: 58977

1. emit proper debug info for forward decls of structs.
2. emit DW_TAG_member nodes around members of a field like llvm-gcc does.

This slows down debug info generation, but is required for correctness.

llvm-svn: 58973

using MachineModuleInfo.  This runs at about the same speed as the old
code, but fixes a bunch of bugs and is simpler and shorter.

llvm-svn: 58971

Print integer value instead of raw pointer. This is a hack to be fixed by migrating the output in analyzer to llvm::raw_ostream.

llvm-svn: 58965

llvm-svn: 58956

Introduce ScopedDecl::getLexicalDeclContext() which is different from ScopedDecl::getDeclContext() when there are nested-names.
e.g.:
  namespace A {
    void f(); // SemanticDC (getDeclContext) == LexicalDC (getLexicalDeclContext) == 'namespace A'
  }
  void A::f(); // SemanticDC == namespace 'A'
               // LexicalDC == global namespace

llvm-svn: 58948

When a tag has nested-name ('struct foo::bar'), use not 'CurContext' but the context of the nested-name ('foo::').

llvm-svn: 58945

-Use more of the non nested-name code path.
-Also use the ActOnTagStruct code path.

llvm-svn: 58944

llvm-svn: 58940

llvm-svn: 58916

No Sema functionality change, just the signatures of the Action/Sema methods.

llvm-svn: 58913

Introduce annotation tokens, a special kind of token, created and used only by the parser to replace a group of tokens with a single token encoding semantic information.
Will be fully utilized later for C++ nested-name-specifiers.

llvm-svn: 58911

Move named cast helpers out of Sema, as Chris requested. This requirse making a few functions public that weren't before.

llvm-svn: 58906

llvm-svn: 58904

llvm-svn: 58902

llvm-svn: 58892

 - Size/align are not effected by CVR qualifiers.

Support getCanonicalType: const Type* -> const Type*.

llvm-svn: 58891

generate the type of a member.

llvm-svn: 58889

llvm-svn: 58888

llvm-svn: 58886

Previously:

class C {
  int C;  // Declarator::SetConstructor was called here.
};

llvm-svn: 58880

llvm-svn: 58873

llvm-svn: 58870

-When parsing declarators, don't depend on "CurScope->isCXXClassScope() == true" for constructors/destructors
-For C++ member declarations, don't depend on "Declarator.getContext() == Declarator::MemberContext"

llvm-svn: 58866

functions in C++, e.g.,

  struct X {
    operator bool() const;
  };

Note that these conversions don't actually do anything, since we don't
yet have the ability to use them for implicit or explicit conversions.

llvm-svn: 58860

Assert that Parser::MaybeParseOperatorFunctionId is called when token is kw_operator, and replace ExpectAndConsume for the 'operator' token with a ConsumeToken.

llvm-svn: 58855

Separate the parsing of type-specifiers from other declaration specifiers, so that we can parse a C++ type-specifier-seq

llvm-svn: 58854

When allocating an array for ParamInfo, the "decl->getNumParams()" call was used, but this will return 0 since it checks ParamInfo (which isn't yet defined and is null).
The result was that ParamInfo got an array of zero length to hold the ParmVarDecls.

llvm-svn: 58850

void f() {
   int +; // crash here
}

llvm-svn: 58846

available, things get much simplified.

One addition is that CompoundLiteralExpr can appear both in rvalue and lvalue
context.

llvm-svn: 58837

llvm-svn: 58833

operators. For example, one can now write "x + y" where x or y is a
class or enumeration type, and Clang will perform overload resolution
for "+" based on the overloaded operators it finds.

The other kinds of overloadable operators in C++ will follow this same
approach. 

Three major issues remain:
  1) We don't find member operators
  2) Since we don't have user-defined conversion operators, we can't
  call any of the built-in overloaded operators in C++ [over.built].
  3) Once we've done the semantic checks, we drop the overloaded
  operator on the floor; it doesn't get into the AST at all.

llvm-svn: 58821

operators in C++. Overloaded operators can be called directly via
their operator-function-ids, e.g., "operator+(foo, bar)", but we don't
yet implement the semantics of operator overloading to handle, e.g.,
"foo + bar".

llvm-svn: 58817

llvm-svn: 58806

llvm-svn: 58804

llvm-svn: 58802

llvm-svn: 58771

llvm-svn: 58770