vendor/clang/clang-r84119

694 files changed, 17634 insertions, 1407 deletions

diff --git a/test/Analysis/CFDateGC.m b/test/Analysis/CFDateGC.m
index dfc736627bfc..557e7e8f915c 100644
--- a/test/Analysis/CFDateGC.m
+++ b/test/Analysis/CFDateGC.m
@@ -1,6 +1,6 @@
-// RUN: clang-cc -analyze -checker-cfref -verify -fobjc-gc -analyzer-constraints=basic %s &&
-// RUN: clang-cc -analyze -checker-cfref -verify -fobjc-gc -analyzer-constraints=range %s &&
-// RUN: clang-cc -analyze -checker-cfref -verify -fobjc-gc -disable-free %s &&
+// RUN: clang-cc -analyze -checker-cfref -analyzer-store=basic -verify -fobjc-gc -analyzer-constraints=basic %s &&
+// RUN: clang-cc -analyze -checker-cfref -analyzer-store=basic -verify -fobjc-gc -analyzer-constraints=range %s &&
+// RUN: clang-cc -analyze -checker-cfref -analyzer-store=basic -verify -fobjc-gc -disable-free %s &&
 // RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -analyzer-constraints=basic -verify -fobjc-gc %s &&
 // RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -analyzer-constraints=range -verify -fobjc-gc %s
 
@@ -25,7 +25,7 @@ extern CFDateRef CFDateCreate(CFAllocatorRef allocator, CFAbsoluteTime at);
 extern CFAbsoluteTime CFDateGetAbsoluteTime(CFDateRef theDate);
 typedef struct objc_object {} *id;
 typedef signed char BOOL;
-static __inline__ __attribute__((always_inline)) id NSMakeCollectable(CFTypeRef cf) {}
+static __inline__ __attribute__((always_inline)) id NSMakeCollectable(CFTypeRef cf) { return 0; }
 @protocol NSObject  - (BOOL)isEqual:(id)object;
 - (oneway void)release;
 - (id)retain;
diff --git a/test/Analysis/CheckNSError.m b/test/Analysis/CheckNSError.m
index 779b865aff8c..5f92594f30d8 100644
--- a/test/Analysis/CheckNSError.m
+++ b/test/Analysis/CheckNSError.m
@@ -24,7 +24,7 @@ extern NSString * const NSXMLParserErrorDomain ;
 @end
 
 @implementation A
-- (void)myMethodWhichMayFail:(NSError **)error {   // expected-warning {{Method accepting NSError** should have a non-void return value to indicate whether or not an error occured.}}
+- (void)myMethodWhichMayFail:(NSError **)error {   // expected-warning {{Method accepting NSError** should have a non-void return value to indicate whether or not an error occurred}}
   *error = [NSError errorWithDomain:@"domain" code:1 userInfo:0]; // expected-warning {{Potential null dereference.}}
 }
 
@@ -37,7 +37,7 @@ extern NSString * const NSXMLParserErrorDomain ;
 struct __CFError {};
 typedef struct __CFError* CFErrorRef;
 
-void foo(CFErrorRef* error) { // expected-warning {{Function accepting CFErrorRef* should have a non-void return value to indicate whether or not an error occured.}}
+void foo(CFErrorRef* error) { // expected-warning {{Function accepting CFErrorRef* should have a non-void return value to indicate whether or not an error occurred}}
   *error = 0;  // expected-warning {{Potential null dereference.}}
 }
 
diff --git a/test/Analysis/NSPanel.m b/test/Analysis/NSPanel.m
index c4d4c22540f2..801620a181bf 100644
--- a/test/Analysis/NSPanel.m
+++ b/test/Analysis/NSPanel.m
@@ -28,7 +28,7 @@ typedef struct _NSZone NSZone;
 @end
 typedef float CGFloat;
 typedef struct _NSPoint {} NSRect;
-static __inline__ __attribute__((always_inline)) NSRect NSMakeRect(CGFloat x, CGFloat y, CGFloat w, CGFloat h) {}
+static __inline__ __attribute__((always_inline)) NSRect NSMakeRect(CGFloat x, CGFloat y, CGFloat w, CGFloat h) { NSRect r; return r; }
 typedef struct {} NSFastEnumerationState;
 @protocol NSFastEnumeration 
 - (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(id *)stackbuf count:(NSUInteger)len;
diff --git a/test/Analysis/NSString.m b/test/Analysis/NSString.m
index b707071990f8..0ba3cda6d580 100644
--- a/test/Analysis/NSString.m
+++ b/test/Analysis/NSString.m
@@ -1,9 +1,7 @@
 // RUN: clang-cc -triple i386-pc-linux-gnu -analyze -checker-cfref -analyzer-store=basic -analyzer-constraints=basic -verify %s &&
-// RUN: clang-cc -triple i386-pc-linux-gnu -analyze -checker-cfref -analyzer-store=basic -analyzer-constraints=range -verify %s
-
-
-// NOTWORK: clang-cc -triple i386-pc-linux-gnu -analyze -checker-cfref -analyzer-store=region -analyzer-constraints=basic -verify %s &&
-// NOTWORK: clang-cc -triple i386-pc-linux-gnu -analyze -checker-cfref -analyzer-store=region -analyzer-constraints=range -verify %s
+// RUN: clang-cc -triple i386-pc-linux-gnu -analyze -checker-cfref -analyzer-store=basic -analyzer-constraints=range -verify %s &&
+// RUN: clang-cc -triple i386-pc-linux-gnu -analyze -checker-cfref -analyzer-store=region -analyzer-constraints=basic -verify %s &&
+// RUN: clang-cc -triple i386-pc-linux-gnu -analyze -checker-cfref -analyzer-store=region -analyzer-constraints=range -verify %s
 
 //===----------------------------------------------------------------------===//
 // The following code is reduced using delta-debugging from
@@ -157,6 +155,7 @@ NSString* f11(CFDictionaryRef dict, const char* key) {
   if (s) {
     [s release];
   }
+  return 0;
 }
 
 // Test case for passing a tracked object by-reference to a function we
@@ -285,6 +284,12 @@ void testOSCompareAndSwap32Barrier() {
     [old release];
 }
 
+int testOSCompareAndSwap32Barrier_id(Class myclass, id xclass) {
+  if (OSAtomicCompareAndSwap32Barrier(0, (int32_t) myclass, (int32_t*) &xclass))
+    return 1;
+  return 0;
+}  
+
 void test_objc_atomicCompareAndSwap() {
   NSString *old = 0;
   NSString *s = [[NSString alloc] init]; // no-warning
diff --git a/test/Analysis/PR2978.m b/test/Analysis/PR2978.m
index 7bc90b8d03e0..0cb3dea8ea86 100644
--- a/test/Analysis/PR2978.m
+++ b/test/Analysis/PR2978.m
@@ -55,6 +55,7 @@
   [self setW:@"newW"]; // This will release '_W', but retain the new value
   self.O = 0; // no-warning  
   [super dealloc];
+  return 0;
 }
 
 @end
diff --git a/test/Analysis/PR3991.m b/test/Analysis/PR3991.m
index 20d4b5b96059..bbc1377b0415 100644
--- a/test/Analysis/PR3991.m
+++ b/test/Analysis/PR3991.m
@@ -43,6 +43,7 @@ typedef struct _NSZone NSZone;
 - (void)setCurrentPathComponentIndex:(unsigned int)aCurrentPathComponentIndex;
 - (NSURL *)folderFeedURL;
 @end  @implementation IHGoogleDocsAdapter    - (id)initWithUsername:(NSString *)inUsername password:(NSString *)inPassword owner:(NSObject <IHGoogleDocsAdapterDelegate> *)owner {
+  return 0;
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/test/Analysis/array-struct.c b/test/Analysis/array-struct.c
index da7df4b28e30..d6b6076a14b2 100644
--- a/test/Analysis/array-struct.c
+++ b/test/Analysis/array-struct.c
@@ -1,7 +1,5 @@
 // RUN: clang-cc -analyze -checker-cfref -analyzer-store=basic -analyzer-constraints=basic -verify %s &&
-// RUN: clang-cc -analyze -checker-cfref -analyzer-store=basic -analyzer-constraints=range -verify %s
-
-// RegionStore now has an infinite recursion with this test case.
+// RUN: clang-cc -analyze -checker-cfref -analyzer-store=basic -analyzer-constraints=range -verify %s &&
 // RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -analyzer-constraints=basic -verify %s &&
 // RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -analyzer-constraints=range -verify %s
 
@@ -145,7 +143,7 @@ void f15() {
   int a[10];
   bar(a);
   if (a[1]) // no-warning
-    1;
+    (void)1;
 }
 
 struct s3 p[1];
diff --git a/test/Analysis/casts.c b/test/Analysis/casts.c
index 5e4222bc84be..ae51ffb69aa5 100644
--- a/test/Analysis/casts.c
+++ b/test/Analysis/casts.c
@@ -1,9 +1,16 @@
-// RUN: clang-cc -analyze -checker-cfref -analyzer-store=region --verify %s
+// RUN: clang-cc -triple x86_64-apple-darwin9 -analyze -checker-cfref -analyzer-store=region --verify %s
 
 // Test if the 'storage' region gets properly initialized after it is cast to
 // 'struct sockaddr *'. 
 
-#include <sys/socket.h>
+typedef unsigned char __uint8_t;
+typedef unsigned int __uint32_t;
+typedef __uint32_t __darwin_socklen_t;
+typedef __uint8_t sa_family_t;
+typedef __darwin_socklen_t socklen_t;
+struct sockaddr { sa_family_t sa_family; };
+struct sockaddr_storage {};
+
 void f(int sock) {
   struct sockaddr_storage storage;
   struct sockaddr* sockaddr = (struct sockaddr*)&storage;
@@ -19,14 +26,14 @@ struct s {
   struct s *value;
 };
 
-int f1(struct s **pval) {
+void f1(struct s **pval) {
   int *tbool = ((void*)0);
   struct s *t = *pval;
   pval = &(t->value);
-  tbool = (int *)pval; // Should record the cast-to type here.
+  tbool = (int *)pval; // use the cast-to type 'int *' to create element region.
   char c = (unsigned char) *tbool; // Should use cast-to type to create symbol.
-  if (*tbool == -1)
-    3;
+  if (*tbool == -1) // here load the element region with the correct type 'int'
+    (void)3;
 }
 
 void f2(const char *str) {
diff --git a/test/Analysis/cfref_rdar6080742.c b/test/Analysis/cfref_rdar6080742.c
index 5d957615d0dd..9bbaf9b5ae06 100644
--- a/test/Analysis/cfref_rdar6080742.c
+++ b/test/Analysis/cfref_rdar6080742.c
@@ -44,15 +44,15 @@ Boolean         DebugDisplayOSStatusMsg(OSStatus status, const char *statusStr,
 #define AssertNoErr(err){ DebugDisplayOSStatusMsg((err), #err, __FILE__, __LINE__); }
 #define RequireNoErr(err, action){ if( DebugDisplayOSStatusMsg((err), #err, __FILE__, __LINE__) ) { action }}
 
-void DebugStop(const char *format,...);	/* Not an abort function. */
+void DebugStop(const char *format,...); /* Not an abort function. */
 
 int main(int argc, char *argv[]) {
-	CFStringRef     cfString;
-	OSStatus        status = noErr;
-	cfString = CFStringCreateWithCString(0, "hello", kCFStringEncodingUTF8);
-	RequireAction(cfString != 0, return memFullErr;) //no - warning
-        printf("cfstring %p\n", cfString);
-Exit:
-	CFRelease(cfString);
-	return 0;
+  CFStringRef     cfString;
+  OSStatus        status = noErr;
+  cfString = CFStringCreateWithCString(0, "hello", kCFStringEncodingUTF8);
+  RequireAction(cfString != 0, return memFullErr;) //no - warning
+    printf("cfstring %p\n", cfString);
+  Exit:
+  CFRelease(cfString);
+  return 0;
 }
diff --git a/test/Analysis/complex.c b/test/Analysis/complex.c
index cef624577a6d..3633b2148413 100644
--- a/test/Analysis/complex.c
+++ b/test/Analysis/complex.c
@@ -5,7 +5,7 @@
 
 #include <stdint.h>
 
-int f1(int * p) {
+void f1(int * p) {
   
   // This branch should be infeasible
   // because __imag__ p is 0.
diff --git a/test/Analysis/dead-stores.c b/test/Analysis/dead-stores.c
index 6d3b7e6f540d..c4ff7fa0e860 100644
--- a/test/Analysis/dead-stores.c
+++ b/test/Analysis/dead-stores.c
@@ -57,7 +57,7 @@ int f7(int *p) {
 
 int f8(int *p) {
   extern int *baz();
-  if (p = baz()) // expected-warning{{Although the value}}
+  if ((p = baz())) // expected-warning{{Although the value}}
     return 1;
   return 0;
 }
@@ -129,14 +129,15 @@ int f16(int x) {
 }
 
 // Self-assignments should not be flagged as dead stores.
-int f17() {
+void f17() {
   int x = 1;
   x = x; // no-warning
 }
 
 // <rdar://problem/6506065>
 // The values of dead stores are only "consumed" in an enclosing expression
-// what that value is actually used.  In other words, don't say "Although the value stored to 'x' is used...".
+// what that value is actually used.  In other words, don't say "Although the
+// value stored to 'x' is used...".
 int f18() {
    int x = 0; // no-warning
    if (1)
@@ -171,3 +172,167 @@ void f20(void) {
 #pragma unused(x)
 }
 
+void halt() __attribute__((noreturn));
+int f21() {
+  int x = 4;
+  
+  ++x; // expected-warning{{never read}}
+  if (1) {
+    halt();
+    (void)x;
+  }
+  return 1;
+}
+
+int j;
+void f22() {
+  int x = 4;
+  int y1 = 4;
+  int y2 = 4;
+  int y3 = 4;
+  int y4 = 4;
+  int y5 = 4;
+  int y6 = 4;
+  int y7 = 4;
+  int y8 = 4;
+  int y9 = 4;
+  int y10 = 4;
+  int y11 = 4;
+  int y12 = 4;
+  int y13 = 4;
+  int y14 = 4;
+  int y15 = 4;
+  int y16 = 4;
+  int y17 = 4;
+  int y18 = 4;
+  int y19 = 4;
+  int y20 = 4;
+
+  ++x; // expected-warning{{never read}}
+  ++y1;
+  ++y2;
+  ++y3;
+  ++y4;
+  ++y5;
+  ++y6;
+  ++y7;
+  ++y8;
+  ++y9;
+  ++y10;
+  ++y11;
+  ++y12;
+  ++y13;
+  ++y14;
+  ++y15;
+  ++y16;
+  ++y17;
+  ++y18;
+  ++y19;
+  ++y20;
+
+  switch (j) {
+  case 1:
+    if (0)
+      (void)x;
+    if (1) {
+      (void)y1;
+      return;
+    }
+    (void)x;
+    break;
+  case 2:
+    if (0)
+      (void)x;
+    else {
+      (void)y2;
+      return;
+    }
+    (void)x;
+    break;
+  case 3:
+    if (1) {
+      (void)y3;
+      return;
+    } else
+      (void)x;
+    (void)x;
+  break;
+  case 4:
+    0 ? : ((void)y4, ({ return; }));
+    (void)x;
+    break;
+  case 5:
+    1 ? : (void)x;
+    0 ? (void)x : ((void)y5, ({ return; }));
+    (void)x;
+    break;
+  case 6:
+    1 ? ((void)y6, ({ return; })) : (void)x;
+    (void)x;
+    break;
+  case 7:
+    (void)(0 && x);
+    (void)y7;
+    (void)(0 || (y8, ({ return; }), 1));
+    (void)x;
+    break;
+  case 8:
+    (void)(1 && (y9, ({ return; }), 1));
+    (void)x;
+    break;
+  case 9:
+    (void)(1 || x);
+    (void)y10;
+    break;
+  case 10:
+    while (0) {
+      (void)x;
+    }
+    (void)y11;
+    break;
+  case 11:
+    while (1) {
+      (void)y12;
+    }
+    (void)x;
+    break;
+  case 12:
+    do {
+      (void)y13;
+    } while (0);
+    (void)y14;
+    break;
+  case 13:
+    do {
+      (void)y15;
+    } while (1);
+    (void)x;
+    break;
+  case 14:
+    for (;;) {
+      (void)y16;
+    }
+    (void)x;    
+    break;
+  case 15:
+    for (;1;) {
+      (void)y17;
+    }
+    (void)x;
+    break;
+  case 16:
+    for (;0;) {
+      (void)x;
+    }
+    (void)y18;
+    break;
+  case 17:
+    __builtin_choose_expr(0, (void)x, ((void)y19, ({ return; })));
+    (void)x;
+    break;
+  case 19:
+    __builtin_choose_expr(1, ((void)y20, ({ return; })), (void)x);
+    (void)x;
+    break;
+  }
+}
diff --git a/test/Analysis/dead-stores.cpp b/test/Analysis/dead-stores.cpp
new file mode 100644
index 000000000000..9ddb7979ca69
--- /dev/null
+++ b/test/Analysis/dead-stores.cpp
@@ -0,0 +1,19 @@
+// RUN: clang-cc -analyze -warn-dead-stores -verify %s &&
+// RUN: clang-cc -analyze -checker-cfref -analyzer-store=basic -analyzer-constraints=basic -warn-dead-stores -verify %s &&
+// RUN: clang-cc -analyze -checker-cfref -analyzer-store=basic -analyzer-constraints=range -warn-dead-stores -verify %s &&
+// RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -analyzer-constraints=basic -warn-dead-stores -verify %s &&
+// RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -analyzer-constraints=range -warn-dead-stores -verify %s
+
+int j;
+void f1() {
+  int x = 4;
+
+  ++x; // expected-warning{{never read}}
+
+  switch (j) {
+  case 1:
+    throw 1;
+    (void)x;
+    break;
+  }
+}
diff --git a/test/Analysis/exercise-ps.c b/test/Analysis/exercise-ps.c
index c309349ab3a9..1e31b1888e1f 100644
--- a/test/Analysis/exercise-ps.c
+++ b/test/Analysis/exercise-ps.c
@@ -5,7 +5,7 @@
 // (i.e., no assertions or crashes).
 
 
-static const char * f1(const char *x, char *y) {
+static void f1(const char *x, char *y) {
   while (*x != 0) {
     *y++ = *x++;
   }
diff --git a/test/Analysis/misc-ps-basic-store.m b/test/Analysis/misc-ps-basic-store.m
index 1207f8663e90..c6ae20c86a36 100644
--- a/test/Analysis/misc-ps-basic-store.m
+++ b/test/Analysis/misc-ps-basic-store.m
@@ -19,3 +19,17 @@ void checkaccess_union() {
       ).__i))) & 0xff00) >> 8) == 1)
         ret = 1;
 }
+
+// BasicStore handles this case incorrectly because it doesn't reason about
+// the value pointed to by 'x' and thus creates different symbolic values
+// at the declarations of 'a' and 'b' respectively.  See the companion test
+// in 'misc-ps-region-store.m'.
+void test_trivial_symbolic_comparison_pointer_parameter(int *x) {
+  int a = *x;
+  int b = *x;
+  if (a != b) {
+    int *p = 0;
+    *p = 0xDEADBEEF;     // expected-warning{{null}}
+  }
+}
+
diff --git a/test/Analysis/misc-ps-region-store-i386.m b/test/Analysis/misc-ps-region-store-i386.m
new file mode 100644
index 000000000000..c2c4d5b9413c
--- /dev/null
+++ b/test/Analysis/misc-ps-region-store-i386.m
@@ -0,0 +1,14 @@
+// RUN: clang-cc -triple i386-apple-darwin9 -analyze -checker-cfref --analyzer-store=region --verify -fblocks %s
+
+// Here is a case where a pointer is treated as integer, invalidated as an
+// integer, and then used again as a pointer.   This test just makes sure
+// we don't crash.
+typedef unsigned uintptr_t;
+void test_pointer_invalidated_as_int_aux(uintptr_t* ptr);
+void test_pointer_invalidated_as_int() {
+  void *x;
+  test_pointer_invalidated_as_int_aux((uintptr_t*) &x);
+  // Here we have a pointer to integer cast.
+  uintptr_t y = (uintptr_t) x;
+}
+
diff --git a/test/Analysis/misc-ps-region-store-x86_64.m b/test/Analysis/misc-ps-region-store-x86_64.m
new file mode 100644
index 000000000000..154ffaf3a003
--- /dev/null
+++ b/test/Analysis/misc-ps-region-store-x86_64.m
@@ -0,0 +1,14 @@
+// RUN: clang-cc -triple x86_64-apple-darwin9 -analyze -checker-cfref --analyzer-store=region --verify -fblocks %s
+
+// Here is a case where a pointer is treated as integer, invalidated as an
+// integer, and then used again as a pointer.   This test just makes sure
+// we don't crash.
+typedef unsigned long uintptr_t;
+void test_pointer_invalidated_as_int_aux(uintptr_t* ptr);
+void test_pointer_invalidated_as_int() {
+  void *x;
+  test_pointer_invalidated_as_int_aux((uintptr_t*) &x);
+  // Here we have a pointer to integer cast.
+  uintptr_t y = (uintptr_t) x;
+}
+
diff --git a/test/Analysis/misc-ps-region-store.m b/test/Analysis/misc-ps-region-store.m
index 8c8815ea63eb..e849042b3d3d 100644
--- a/test/Analysis/misc-ps-region-store.m
+++ b/test/Analysis/misc-ps-region-store.m
@@ -1,4 +1,5 @@
-// RUN: clang-cc -analyze -checker-cfref --analyzer-store=region --verify -fblocks %s
+// RUN: clang-cc -triple i386-apple-darwin9 -analyze -checker-cfref --analyzer-store=region --verify -fblocks %s &&
+// RUN: clang-cc -triple x86_64-apple-darwin9 -analyze -checker-cfref --analyzer-store=region --verify -fblocks %s
 
 typedef struct objc_selector *SEL;
 typedef signed char BOOL;
@@ -31,10 +32,12 @@ extern NSString * const NSConnectionReplyMode;
 
 // PR 2948 (testcase; crash on VisitLValue for union types)
 // http://llvm.org/bugs/show_bug.cgi?id=2948
-
 void checkaccess_union() {
   int ret = 0, status;
-  if (((((__extension__ (((union {  // expected-warning {{ Branch condition evaluates to an uninitialized value.}}
+  // Since RegionStore doesn't handle unions yet,
+  // this branch condition won't be triggered
+  // as involving an uninitialized value.  
+  if (((((__extension__ (((union {  // no-warning
     __typeof (status) __in; int __i;}
     )
     {
@@ -43,7 +46,6 @@ void checkaccess_union() {
         ret = 1;
 }
 
-
 // Check our handling of fields being invalidated by function calls.
 struct test2_struct { int x; int y; char* s; };
 void test2_helper(struct test2_struct* p);
@@ -68,3 +70,236 @@ char test2() {
   return 'a';
 }
 
+// BasicStore handles this case incorrectly because it doesn't reason about
+// the value pointed to by 'x' and thus creates different symbolic values
+// at the declarations of 'a' and 'b' respectively.  RegionStore handles
+// it correctly. See the companion test in 'misc-ps-basic-store.m'.
+void test_trivial_symbolic_comparison_pointer_parameter(int *x) {
+  int a = *x;
+  int b = *x;
+  if (a != b) {
+    int *p = 0;
+    *p = 0xDEADBEEF;     // no-warning
+  }
+}
+
+// This is a modified test from 'misc-ps.m'.  Here we have the extra
+// NULL dereferences which are pruned out by RegionStore's symbolic reasoning
+// of fields.
+typedef struct _BStruct { void *grue; } BStruct;
+void testB_aux(void *ptr);
+
+void testB(BStruct *b) {
+  {
+    int *__gruep__ = ((int *)&((b)->grue));
+    int __gruev__ = *__gruep__;
+    int __gruev2__ = *__gruep__;
+    if (__gruev__ != __gruev2__) {
+      int *p = 0;
+      *p = 0xDEADBEEF; // no-warning
+    }
+
+    testB_aux(__gruep__);
+  }
+  {
+    int *__gruep__ = ((int *)&((b)->grue));
+    int __gruev__ = *__gruep__;
+    int __gruev2__ = *__gruep__;
+    if (__gruev__ != __gruev2__) {
+      int *p = 0;
+      *p = 0xDEADBEEF; // no-warning
+    }
+
+    if (~0 != __gruev__) {}
+  }
+}
+
+void testB_2(BStruct *b) {
+  {
+    int **__gruep__ = ((int **)&((b)->grue));
+    int *__gruev__ = *__gruep__;
+    testB_aux(__gruep__);
+  }
+  {
+    int **__gruep__ = ((int **)&((b)->grue));
+    int *__gruev__ = *__gruep__;
+    if ((int*)~0 != __gruev__) {}
+  }
+}
+
+// This test case is a reduced case of a caching bug discovered by an
+// assertion failure in RegionStoreManager::BindArray.  Essentially the
+// DeclStmt is evaluated twice, but on the second loop iteration the
+// engine caches out.  Previously a false transition would cause UnknownVal
+// to bind to the variable, firing an assertion failure.  This bug was fixed
+// in r76262.
+void test_declstmt_caching() {
+again:
+  {
+    const char a[] = "I like to crash";
+    goto again;
+  }
+}
+
+// Reduced test case from <rdar://problem/7114618>.
+// Basically a null check is performed on the field value, which is then
+// assigned to a variable and then checked again.
+struct s_7114618 { int *p; };
+void test_rdar_7114618(struct s_7114618 *s) {
+  if (s->p) {
+    int *p = s->p;
+    if (!p) {
+      // Infeasible
+      int *dead = 0;
+      *dead = 0xDEADBEEF; // no-warning
+    }
+  }
+}
+
+// Test pointers increment correctly.
+void f() {
+  int a[2];
+  a[1] = 3;
+  int *p = a;
+  p++;
+  if (*p != 3) {
+    int *q = 0;
+    *q = 3; // no-warning
+  }
+}
+
+// <rdar://problem/7185607>
+// Bit-fields of a struct should be invalidated when blasting the entire
+// struct with an integer constant.
+struct test_7185607 {
+  int x : 10;
+  int y : 22;
+};
+int rdar_test_7185607() {
+  struct test_7185607 s; // Uninitialized.
+  *((unsigned *) &s) = 0U;
+  return s.x; // no-warning
+}
+
+// <rdar://problem/7242006> [RegionStore] compound literal assignment with
+//  floats not honored
+// This test case is mirrored in misc-ps.m, but this case is a negative.
+typedef float CGFloat;
+typedef struct _NSSize {
+    CGFloat width;
+    CGFloat height;
+} NSSize;
+
+CGFloat rdar7242006_negative(CGFloat x) {
+  NSSize y;
+  return y.width; // expected-warning{{garbage}}
+}
+
+// <rdar://problem/7249340> - Allow binding of values to symbolic regions.
+// This test case shows how RegionStore tracks the value bound to 'x'
+// after the assignment.
+typedef int* ptr_rdar_7249340;
+void rdar_7249340(ptr_rdar_7249340 x) {
+  *x = 1;
+  if (*x)
+    return;
+  int *p = 0;   // This is unreachable.
+  *p = 0xDEADBEEF; // no-warning
+}
+
+// <rdar://problem/7249327> - This test case tests both value tracking of
+// array values and that we handle symbolic values that are casted
+// between different integer types.  Note the assignment 'n = *a++'; here
+// 'n' is and 'int' and '*a' is 'unsigned'.  Previously we got a false positive
+// at 'x += *b++' (undefined value) because we got a false path.
+int rdar_7249327_aux(void);
+
+void rdar_7249327(unsigned int A[2*32]) {
+  int B[2*32];
+  int *b;
+  unsigned int *a;
+  int x = 0;
+  
+  int n;
+  
+  a = A;
+  b = B;
+  
+  n = *a++;
+  if (n)
+    *b++ = rdar_7249327_aux();
+
+  a = A;
+  b = B;
+  
+  n = *a++;
+  if (n)
+    x += *b++; // no-warning
+}
+
+// <rdar://problem/6914474> - Check that 'x' is invalidated because its
+// address is passed in as a value to a struct.
+struct doodad_6914474 { int *v; };
+extern void prod_6914474(struct doodad_6914474 *d);
+int rdar_6914474(void) {
+  int x;
+  struct doodad_6914474 d;
+  d.v = &x;
+  prod_6914474(&d);
+  return x; // no-warning
+}
+
+// Test invalidation of a single field.
+struct s_test_field_invalidate {
+  int x;
+};
+extern void test_invalidate_field(int *x);
+int test_invalidate_field_test() {
+  struct s_test_field_invalidate y;
+  test_invalidate_field(&y.x);
+  return y.x; // no-warning
+}
+int test_invalidate_field_test_positive() {
+  struct s_test_field_invalidate y;
+  return y.x; // expected-warning{{garbage}}
+}
+
+// This test case illustrates how a typeless array of bytes casted to a
+// struct should be treated as initialized.  RemoveDeadBindings previously
+// had a bug that caused 'x' to lose its default symbolic value after the
+// assignment to 'p', thus causing 'p->z' to evaluate to "undefined".
+struct ArrayWrapper { unsigned char y[16]; };
+struct WrappedStruct { unsigned z; };
+
+int test_handle_array_wrapper() {
+  struct ArrayWrapper x;
+  test_handle_array_wrapper(&x);
+  struct WrappedStruct *p = (struct WrappedStruct*) x.y;
+  return p->z;  // no-warning
+}
+
+// <rdar://problem/7261075> [RegionStore] crash when 
+//   handling load: '*((unsigned int *)"????")'
+int rdar_7261075(void) {
+  unsigned int var = 0;
+  if (var == *((unsigned int *)"????"))
+    return 1;
+  return 0;
+}
+
+// <rdar://problem/7275774> false path due to limited pointer 
+//                          arithmetic constraints
+void rdar_7275774(void *data, unsigned n) {
+  if (!(data || n == 0))
+    return;
+  
+  unsigned short *p = (unsigned short*) data;
+  unsigned short *q = p + (n / 2);
+
+  if (p < q) {
+    // If we reach here, 'p' cannot be null.  If 'p' is null, then 'n' must
+    // be '0', meaning that this branch is not feasible.
+    *p = *q; // no-warning
+  }
+}
+
diff --git a/test/Analysis/misc-ps.m b/test/Analysis/misc-ps.m
index ea41b5bb2f35..10e5823c206c 100644
--- a/test/Analysis/misc-ps.m
+++ b/test/Analysis/misc-ps.m
@@ -1,24 +1,43 @@
-// RUN: clang-cc -analyze -checker-cfref --analyzer-store=basic -analyzer-constraints=basic --verify -fblocks %s &&
+// NOTE: Use '-fobjc-gc' to test the analysis being run twice, and multiple reports are not issued.
+// RUN: clang-cc -analyze -checker-cfref --analyzer-store=basic -fobjc-gc -analyzer-constraints=basic --verify -fblocks %s &&
 // RUN: clang-cc -analyze -checker-cfref --analyzer-store=basic -analyzer-constraints=range --verify -fblocks %s &&
 // RUN: clang-cc -analyze -checker-cfref --analyzer-store=region -analyzer-constraints=basic --verify -fblocks %s &&
 // RUN: clang-cc -analyze -checker-cfref --analyzer-store=region -analyzer-constraints=range --verify -fblocks %s
 
+typedef struct objc_ivar *Ivar;
 typedef struct objc_selector *SEL;
 typedef signed char BOOL;
 typedef int NSInteger;
 typedef unsigned int NSUInteger;
 typedef struct _NSZone NSZone;
-@class NSInvocation, NSMethodSignature, NSCoder, NSString, NSEnumerator;
-@protocol NSObject  - (BOOL)isEqual:(id)object; @end
-@protocol NSCopying  - (id)copyWithZone:(NSZone *)zone; @end
+@class NSInvocation, NSArray, NSMethodSignature, NSCoder, NSString, NSEnumerator;
+@protocol NSObject
+- (BOOL)isEqual:(id)object;
+- (id)autorelease;
+@end
+@protocol NSCopying
+- (id)copyWithZone:(NSZone *)zone;
+@end
 @protocol NSMutableCopying  - (id)mutableCopyWithZone:(NSZone *)zone; @end
-@protocol NSCoding  - (void)encodeWithCoder:(NSCoder *)aCoder; @end
-@interface NSObject <NSObject> {} - (id)init; @end
+@protocol NSCoding
+- (void)encodeWithCoder:(NSCoder *)aCoder;
+@end
+@interface NSObject <NSObject> {}
+- (id)init;
++ (id)allocWithZone:(NSZone *)zone;
+@end
 extern id NSAllocateObject(Class aClass, NSUInteger extraBytes, NSZone *zone);
 @interface NSString : NSObject <NSCopying, NSMutableCopying, NSCoding>
 - (NSUInteger)length;
 + (id)stringWithUTF8String:(const char *)nullTerminatedCString;
 @end extern NSString * const NSBundleDidLoadNotification;
+@interface NSValue : NSObject <NSCopying, NSCoding>
+- (void)getValue:(void *)value;
+@end
+@interface NSNumber : NSValue
+- (char)charValue;
+- (id)initWithBool:(BOOL)value;
+@end
 @interface NSAssertionHandler : NSObject {}
 + (NSAssertionHandler *)currentHandler;
 - (void)handleFailureInMethod:(SEL)selector object:(id)object file:(NSString *)fileName lineNumber:(NSInteger)line description:(NSString *)format,...;
@@ -144,7 +163,7 @@ void pr3422() {
 }
 
 // PR 3543 (handle empty statement expressions)
-int pr_3543(void) {
+void pr_3543(void) {
   ({});
 }
 
@@ -295,4 +314,381 @@ void rdar_7027684(int x, int y) {
   (rdar_7027684_aux() ? rdar_7027684_aux_2() : (void) 0);
 }
 
+// Test that we handle casts of string literals to arbitrary types.
+unsigned const char *string_literal_test1() {
+  return (const unsigned char*) "hello";
+}
+
+const float *string_literal_test2() {
+  return (const float*) "hello";
+}
+
+// Test that we handle casts *from* incomplete struct types.
+extern const struct _FooAssertStruct _cmd;
+void test_cast_from_incomplete_struct_aux(volatile const void *x);
+void test_cast_from_incomplete_struct() {
+  test_cast_from_incomplete_struct_aux(&_cmd);
+}
+
+// Test for <rdar://problem/7034511> 
+//  "ValueManager::makeIntVal(uint64_t X, QualType T) should return a 'Loc' 
+//   when 'T' is a pointer"
+//
+// Previously this case would crash.
+void test_rdar_7034511(NSArray *y) {
+  NSObject *x;
+  for (x in y) {}
+  if (x == ((void*) 0)) {}
+}
+
+// Handle casts of function pointers (CodeTextRegions) to arbitrary pointer
+// types. This was previously causing a crash in CastRegion.
+void handle_funcptr_voidptr_casts() {
+  void **ptr;
+  typedef void *PVOID;
+  typedef void *PCHAR;  
+  typedef long INT_PTR, *PINT_PTR;
+  typedef INT_PTR (*FARPROC)();
+  FARPROC handle_funcptr_voidptr_casts_aux();
+  PVOID handle_funcptr_voidptr_casts_aux_2(PVOID volatile *x);
+  PVOID handle_funcptr_voidptr_casts_aux_3(PCHAR volatile *x);  
+  
+  ptr = (void**) handle_funcptr_voidptr_casts_aux();
+  handle_funcptr_voidptr_casts_aux_2(ptr);
+  handle_funcptr_voidptr_casts_aux_3(ptr);
+}
+
+// RegionStore::Retrieve previously crashed on this example.  This example
+// was previously in the test file 'xfail_regionstore_wine_crash.c'.
+void testA() {
+  long x = 0;
+  char *y = (char *) &x;
+  if (!*y)
+    return;
+}
+
+// RegionStoreManager previously crashed on this example.  The problem is that
+// the value bound to the field of b->grue after the call to testB_aux is
+// a symbolic region.  The second '*__gruep__' involves performing a load
+// from a 'int*' that really is a 'void**'.  The loaded location must be
+// implicitly converted to an integer that wraps a location.  Previosly we would
+// get a crash here due to an assertion failure.
+typedef struct _BStruct { void *grue; } BStruct;
+void testB_aux(void *ptr);
+void testB(BStruct *b) {
+  {
+    int *__gruep__ = ((int *)&((b)->grue));
+    int __gruev__ = *__gruep__;
+    testB_aux(__gruep__);
+  }
+  {
+    int *__gruep__ = ((int *)&((b)->grue));
+    int __gruev__ = *__gruep__;
+    if (~0 != __gruev__) {}
+  }
+}
+
+void test_trivial_symbolic_comparison(int *x) {
+  int test_trivial_symbolic_comparison_aux();
+  int a = test_trivial_symbolic_comparison_aux();
+  int b = a;
+  if (a != b) {
+    int *p = 0;
+    *p = 0xDEADBEEF;     // no-warning
+  }
+  
+  a = a == 1;
+  b = b == 1;
+  if (a != b) {
+    int *p = 0;
+    *p = 0xDEADBEEF;     // no-warning
+  }
+}
+
+// Test for:
+//  <rdar://problem/7062158> false positive null dereference due to
+//   BasicStoreManager not tracking *static* globals
+//
+// This just tests the proper tracking of symbolic values for globals (both 
+// static and non-static).
+//
+static int* x_rdar_7062158;
+void rdar_7062158() {
+  int *current = x_rdar_7062158;
+  if (current == x_rdar_7062158)
+    return;
+    
+  int *p = 0;
+  *p = 0xDEADBEEF; // no-warning  
+}
+
+int* x_rdar_7062158_2;
+void rdar_7062158_2() {
+  int *current = x_rdar_7062158_2;
+  if (current == x_rdar_7062158_2)
+    return;
+    
+  int *p = 0;
+  *p = 0xDEADBEEF; // no-warning  
+}
+
+// This test reproduces a case for a crash when analyzing ClamAV using
+// RegionStoreManager (the crash doesn't exhibit in BasicStoreManager because
+// it isn't doing anything smart about arrays).  The problem is that on the
+// second line, 'p = &p[i]', p is assigned an ElementRegion whose index
+// is a 16-bit integer.  On the third line, a new ElementRegion is created
+// based on the previous region, but there the region uses a 32-bit integer,
+// resulting in a clash of values (an assertion failure at best).  We resolve
+// this problem by implicitly converting index values to 'int' when the
+// ElementRegion is created.
+unsigned char test_array_index_bitwidth(const unsigned char *p) {
+  unsigned short i = 0;
+  for (i = 0; i < 2; i++) p = &p[i];  
+  return p[i+1];
+}
+
+// This case tests that CastRegion handles casts involving BlockPointerTypes.
+// It should not crash.
+void test_block_cast() {
+  id test_block_cast_aux();
+  (void (^)(void *))test_block_cast_aux(); // expected-warning{{expression result unused}}
+}
+
+// Test comparison of 'id' instance variable to a null void* constant after
+// performing an OSAtomicCompareAndSwap32Barrier.
+// This previously was a crash in RegionStoreManager.
+@interface TestIdNull {
+  id x;
+}
+-(int)foo;
+@end
+@implementation TestIdNull
+-(int)foo {
+  OSAtomicCompareAndSwap32Barrier(0, (signed)2, (signed*)&x);  
+  if (x == (void*) 0) { return 0; }
+  return 1;
+}
+@end
+
+// PR 4594 - This was a crash when handling casts in SimpleSValuator.
+void PR4594() {
+  char *buf[1];
+  char **foo = buf;
+  *foo = "test";
+}
+
+// Test invalidation logic where an integer is casted to an array with a
+// different sign and then invalidated.
+void test_invalidate_cast_int() {
+  void test_invalidate_cast_int_aux(unsigned *i);
+  signed i;  
+  test_invalidate_cast_int_aux((unsigned*) &i);
+  if (i < 0)
+    return;
+}
+
+// Reduced from a crash involving the cast of an Objective-C symbolic region to
+// 'char *'
+static NSNumber *test_ivar_offset(id self, SEL _cmd, Ivar inIvar) {
+  return [[[NSNumber allocWithZone:((void*)0)] initWithBool:*(_Bool *)((char *)self + ivar_getOffset(inIvar))] autorelease];
+}
+
+// Reduced from a crash in StoreManager::CastRegion involving a divide-by-zero.
+// This resulted from not properly handling region casts to 'const void*'.
+void test_cast_const_voidptr() {
+  char x[10];
+  char *p = &x[1];
+  const void* q = p;
+}
+
+// Reduced from a crash when analyzing Wine.  This test handles loads from
+// function addresses.
+typedef long (*FARPROC)();
+FARPROC test_load_func(FARPROC origfun) {
+  if (!*(unsigned char*) origfun)
+    return origfun;
+  return 0;
+}
+
+// Test passing-by-value an initialized struct variable.
+struct test_pass_val {
+  int x;
+  int y;
+};
+void test_pass_val_aux(struct test_pass_val s);
+void test_pass_val() {
+  struct test_pass_val s;
+  s.x = 1;
+  s.y = 2;
+  test_pass_val_aux(s);
+}
+
+// This is a reduced test case of a false positive that previously appeared
+// in RegionStoreManager.  Previously the array access resulted in dereferencing
+// an undefined value.
+int test_array_compound(int *q, int *r, int *z) {
+  int *array[] = { q, r, z };
+  int j = 0;
+  for (unsigned i = 0; i < 3 ; ++i)
+    if (*array[i]) ++j; // no-warning
+  return j;
+}
+
+// This test case previously crashed with -analyzer-store=basic because the
+// symbolic value stored in 'x' wouldn't be implicitly casted to a signed value
+// during the comparison.
+int rdar_7124210(unsigned int x) {
+  enum { SOME_CONSTANT = 123 };
+  int compare = ((signed) SOME_CONSTANT) == *((signed *) &x);
+  return compare ? 0 : 1; // Forces the evaluation of the symbolic constraint.
+}
+
+void pr4781(unsigned long *raw1) {
+  unsigned long *cook, *raw0;
+  unsigned long dough[32];
+  int i;
+  cook = dough;
+  for( i = 0; i < 16; i++, raw1++ ) {
+    raw0 = raw1++;
+    *cook = (*raw0 & 0x00fc0000L) << 6;
+    *cook |= (*raw0 & 0x00000fc0L) << 10;
+  }
+}
+
+// <rdar://problem/7185647> - 'self' should be treated as being non-null
+// upon entry to an objective-c method.
+@interface RDar7185647
+- (id)foo;
+@end
+@implementation RDar7185647
+- (id) foo {
+  if (self)
+    return self;
+  *((int *) 0x0) = 0xDEADBEEF; // no-warning
+  return self;
+}
+@end
+
+// Test reasoning of __builtin_offsetof;
+struct test_offsetof_A {
+  int x;
+  int y;
+};
+struct test_offsetof_B {
+  int w;
+  int z;
+};
+void test_offsetof_1() {
+  if (__builtin_offsetof(struct test_offsetof_A, x) ==
+      __builtin_offsetof(struct test_offsetof_B, w))
+    return;
+  int *p = 0;
+  *p = 0xDEADBEEF; // no-warning
+}
+void test_offsetof_2() {
+  if (__builtin_offsetof(struct test_offsetof_A, y) ==
+      __builtin_offsetof(struct test_offsetof_B, z))
+    return;
+  int *p = 0;
+  *p = 0xDEADBEEF; // no-warning
+}
+void test_offsetof_3() {
+  if (__builtin_offsetof(struct test_offsetof_A, y) -
+      __builtin_offsetof(struct test_offsetof_A, x)
+      ==
+      __builtin_offsetof(struct test_offsetof_B, z) -
+      __builtin_offsetof(struct test_offsetof_B, w))
+    return;
+  int *p = 0;
+  *p = 0xDEADBEEF; // no-warning
+}
+void test_offsetof_4() {
+  if (__builtin_offsetof(struct test_offsetof_A, y) ==
+      __builtin_offsetof(struct test_offsetof_B, w))
+    return;
+  int *p = 0;
+  *p = 0xDEADBEEF; // expected-warning{{Dereference of null pointer}}
+}
+
+// <rdar://problem/6829164> "nil receiver" false positive: make tracking 
+// of the MemRegion for 'self' path-sensitive
+@interface RDar6829164 : NSObject {
+  double x; int y;
+}
+- (id) init;
+@end
+
+id rdar_6829164_1();
+double rdar_6829164_2();
+
+@implementation RDar6829164
+- (id) init {
+  if((self = [super init]) != 0) {
+    id z = rdar_6829164_1();
+    y = (z != 0);
+    if (y)
+      x = rdar_6829164_2();
+  }
+  return self;
+}
+@end
+
+// <rdar://problem/7242015> - Invalidate values passed-by-reference
+// to functions when the pointer to the value is passed as an integer.
+void test_7242015_aux(unsigned long);
+int rdar_7242015() {
+  int x;
+  test_7242015_aux((unsigned long) &x); // no-warning
+  return x; // Previously we return and uninitialized value when
+            // using RegionStore.
+}
+
+// <rdar://problem/7242006> [RegionStore] compound literal assignment with
+//  floats not honored
+CGFloat rdar7242006(CGFloat x) {
+  NSSize y = (NSSize){x, 10};
+  return y.width; // no-warning
+}
+
+// PR 4988 - This test exhibits a case where a function can be referenced
+//  when not explicitly used in an "lvalue" context (as far as the analyzer is
+//  concerned). This previously triggered a crash due to an invalid assertion.
+void pr_4988(void) {
+  pr_4988; // expected-warning{{expression result unused}}
+}
+
+// <rdar://problem/7152418> - A 'signed char' is used as a flag, which is
+//  implicitly converted to an int.
+void *rdar7152418_bar();
+@interface RDar7152418 {
+  signed char x;
+}
+-(char)foo;
+@end;
+@implementation RDar7152418
+-(char)foo {
+  char *p = 0;
+  void *result = 0;
+  if (x) {
+    result = rdar7152418_bar();
+    p = "hello";
+  }
+  if (!result) {
+    result = rdar7152418_bar();
+    if (result && x)
+      return *p; // no-warning
+  }
+  return 1;
+}
+
+// Test constant-folding of symbolic values, automatically handling type
+// conversions of the symbol as necessary.  Previously this would crash
+// once we started eagerly evaluating symbols whose values were constrained
+// to a single value.
+void test_constant_symbol(signed char x) {
+  while (1) {
+    if (x == ((signed char) 0)) {}
+  }
+}
+
 
diff --git a/test/Analysis/nil-receiver-undefined-larger-than-voidptr-ret.m b/test/Analysis/nil-receiver-undefined-larger-than-voidptr-ret.m
index 9a64b3001e16..87faab6bfbac 100644
--- a/test/Analysis/nil-receiver-undefined-larger-than-voidptr-ret.m
+++ b/test/Analysis/nil-receiver-undefined-larger-than-voidptr-ret.m
@@ -1,4 +1,5 @@
-// RUN: clang-cc -triple i386-apple-darwin9 -analyze -checker-cfref -analyzer-constraints=basic -analyzer-store=basic %s -verify
+// RUN: clang-cc -triple i386-apple-darwin9 -analyze -checker-cfref -analyzer-constraints=basic -analyzer-store=basic %s -verify &&
+// RUN: clang-cc -triple i386-apple-darwin9 -analyze -checker-cfref -analyzer-constraints=basic -analyzer-store=region %s -verify
 
 @interface MyClass {}
 - (void *)voidPtrM;
diff --git a/test/Analysis/no-outofbounds.c b/test/Analysis/no-outofbounds.c
new file mode 100644
index 000000000000..94052806f0aa
--- /dev/null
+++ b/test/Analysis/no-outofbounds.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc -checker-cfref -analyze -analyzer-store=basic -verify %s &&
+// RUN: clang-cc -checker-cfref -analyze -analyzer-store=region -verify %s
+
+//===----------------------------------------------------------------------===//
+// This file tests cases where we should not flag out-of-bounds warnings.
+//===----------------------------------------------------------------------===//
+
+void f() {
+  long x = 0;
+  char *y = (char*) &x;
+  char c = y[0] + y[1] + y[2]; // no-warning
+}
diff --git a/test/Analysis/null-deref-ps.c b/test/Analysis/null-deref-ps.c
index 6e2074146c30..f37b4416f2a1 100644
--- a/test/Analysis/null-deref-ps.c
+++ b/test/Analysis/null-deref-ps.c
@@ -1,10 +1,16 @@
-// RUN: clang-cc -analyze -std=gnu99 -checker-cfref -verify %s -analyzer-constraints=basic -analyzer-store=basic &&
-// RUN: clang-cc -analyze -std=gnu99 -checker-cfref -verify %s -analyzer-constraints=range -analyzer-store=basic &&
-// RUN: clang-cc -analyze -std=gnu99 -checker-cfref -analyzer-store=region -analyzer-constraints=range -analyzer-purge-dead=false -verify %s &&
-// RUN: clang-cc -analyze -std=gnu99 -checker-cfref -analyzer-store=region -analyzer-constraints=range -verify %s
+// RUN: clang-cc -triple i386-apple-darwin10 -analyze -std=gnu99 -checker-cfref -verify %s -analyzer-constraints=basic -analyzer-store=basic &&
+// RUN: clang-cc -triple i386-apple-darwin10 -analyze -std=gnu99 -checker-cfref -verify %s -analyzer-constraints=range -analyzer-store=basic &&
+// RUN: clang-cc -triple i386-apple-darwin10 -analyze -std=gnu99 -checker-cfref -analyzer-store=region -analyzer-constraints=range -analyzer-purge-dead=false -verify %s &&
+// RUN: clang-cc -triple i386-apple-darwin10 -analyze -std=gnu99 -checker-cfref -analyzer-store=region -analyzer-constraints=range -verify %s
 
-#include<stdint.h>
-#include <assert.h>
+typedef unsigned uintptr_t;
+
+extern void __assert_fail (__const char *__assertion, __const char *__file,
+    unsigned int __line, __const char *__function)
+     __attribute__ ((__noreturn__));
+
+#define assert(expr) \
+  ((expr)  ? (void)(0)  : __assert_fail (#expr, __FILE__, __LINE__, __func__))
 
 void f1(int *p) {  
   if (p) *p = 1;
@@ -72,6 +78,7 @@ int f4_b() {
   else return; // expected-warning {{non-void function 'f4_b' should return a value}}
 
   *p += 10; // expected-warning{{Dereference of null pointer}}
+  return 0;
 }
 
 
@@ -102,6 +109,15 @@ int f6c(int *p, int *q) {
              : bar3(p, 2, q); // no-warning
 }
 
+void f6d(int *p) {
+  bar(p, 0);
+  // At this point, 'p' cannot be null.
+  if (!p) {
+    int *q = 0;
+    *q = 0xDEADBEEF; // no-warning    
+  }  
+}
+
 int* qux();
 
 int f7(int x) {
@@ -160,7 +176,7 @@ int* f7c2(int *x) {
 }
 
 
-int f8(int *p, int *q) {
+void f8(int *p, int *q) {
   if (!p)
     if (p)
       *p = 1; // no-warning
@@ -262,4 +278,13 @@ void f13() {
   if (((((int) x) << 2) + 1) >> 1) *x = 1; // no-warning
 }
 
+// PR 4759 - Attribute non-null checking by the analyzer was not correctly
+// handling pointer values that were undefined.
+void pr4759_aux(int *p) __attribute__((nonnull));
+
+void pr4759() {
+  int *p;
+  pr4759_aux(p); // expected-warning{{undefined}}
+}
+
 
diff --git a/test/Analysis/outofbound.c b/test/Analysis/outofbound.c
index 527a311d2b7d..568f14329e9b 100644
--- a/test/Analysis/outofbound.c
+++ b/test/Analysis/outofbound.c
@@ -1,4 +1,5 @@
 // RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -verify %s
+// XFAIL
 
 char f1() {
   char* s = "abcd";
diff --git a/test/Analysis/pr4209.m b/test/Analysis/pr4209.m
index 7d7d8fc5a157..991d0d68f704 100644
--- a/test/Analysis/pr4209.m
+++ b/test/Analysis/pr4209.m
@@ -1,4 +1,4 @@
-// RUN: clang-cc -triple i386-apple-darwin9 -analyze -checker-cfref -verify %s &&
+// RUN: clang-cc -triple i386-apple-darwin9 -analyze -checker-cfref -analyzer-store=basic -verify %s &&
 // RUN: clang-cc -triple i386-apple-darwin9 -analyze -checker-cfref -analyzer-store=region -verify %s
 
 // This test case was crashing due to how CFRefCount.cpp resolved the
@@ -56,6 +56,7 @@ CMProfileLocation;
 - (GSEbayCategory *) parent;
 - (GSEbayCategory*) subcategoryWithID:(int) inID;
 @end   @implementation GBCategoryChooserPanelController  + (int) chooseCategoryIDFromCategories:(NSArray*) inCategories        searchRequest:(GBSearchRequest*)inRequest         parentWindow:(NSWindow*) inParent {
+  return 0;
 }
 - (void) addCategory:(EBayCategoryType*)inCategory toRootTreeCategory:(NSMutableArray*)inRootTreeCategories {
   GSEbayCategory *category = [rootCategory subcategoryWithID:[[inCategory categoryID] intValue]];
diff --git a/test/Analysis/rdar-6442306-1.m b/test/Analysis/rdar-6442306-1.m
index 15d349884093..bfda115360e4 100644
--- a/test/Analysis/rdar-6442306-1.m
+++ b/test/Analysis/rdar-6442306-1.m
@@ -28,4 +28,5 @@ __Beeble_check__Request__SetPortalSize_t(__attribute__((__unused__)) __Request__
     }
     while (0);
   }
+  return 0;
 }
diff --git a/test/Analysis/rdar-6540084.m b/test/Analysis/rdar-6540084.m
index 18ab038f6e2e..cfe522074ed3 100644
--- a/test/Analysis/rdar-6540084.m
+++ b/test/Analysis/rdar-6540084.m
@@ -32,5 +32,6 @@ typedef struct {} TazVersion;
       }
     }
   }
+  while (1) {}
 }
 @end
diff --git a/test/Analysis/rdar-6541136-region.c b/test/Analysis/rdar-6541136-region.c
index 1e7a2d974bc4..e2779e8d914f 100644
--- a/test/Analysis/rdar-6541136-region.c
+++ b/test/Analysis/rdar-6541136-region.c
@@ -13,7 +13,10 @@ void foo( void )
   struct load_wine *cmd = (void*) &wonky[1];
   cmd = cmd;
   char *p = (void*) &wonky[1];
-  *p = 1; 
+  *p = 1;  // no-warning
   kernel_tea_cheese_t *q = &wonky[1];
-  kernel_tea_cheese_t r = *q; // expected-warning{{out-of-bound memory position}}
+  // This test case tests both the RegionStore logic (doesn't crash) and
+  // the out-of-bounds checking.  We don't expect the warning for now since
+  // out-of-bound checking is temporarily disabled.
+  kernel_tea_cheese_t r = *q; // eventually-warning{{out-of-bound memory position}}
 }
diff --git a/test/Analysis/rdar-6562655.m b/test/Analysis/rdar-6562655.m
index 581d6eacf085..3c1c281a830d 100644
--- a/test/Analysis/rdar-6562655.m
+++ b/test/Analysis/rdar-6562655.m
@@ -1,4 +1,5 @@
-// RUN: clang-cc -analyze -checker-cfref -analyzer-constraints=basic -analyzer-store=basic -verify %s
+// RUN: clang-cc -analyze -checker-cfref -analyzer-constraints=basic -analyzer-store=basic -verify %s &&
+// RUN: clang-cc -analyze -checker-cfref -analyzer-constraints=basic -analyzer-store=region -verify %s
 //
 // This test case mainly checks that the retain/release checker doesn't crash
 // on this file.
@@ -51,7 +52,7 @@ typedef struct _NSRunArrayItem {
 @end
 @implementation Bar
 static Baz Qux = 0;
-- (id)copyWithZone:(NSZone *)zone {}
+- (id)copyWithZone:(NSZone *)zone { return 0; }
 - (void)encodeWithCoder:(NSCoder *)coder {}
 @end
 @implementation Bar (BarBotnet)
@@ -59,5 +60,6 @@ static Baz Qux = 0;
   if (!(*(BarAuxiliary **)&self->_support)->auxCFlags.botnetIsSet) {
     _cFlags.botnet = [self _initialBotnetZorg];
   }
+  while (1) {}
 }
 @end
diff --git a/test/Analysis/rdar-6600344-nil-receiver-undefined-struct-ret.m b/test/Analysis/rdar-6600344-nil-receiver-undefined-struct-ret.m
index 5d1fa37c46a8..49ef7c381545 100644
--- a/test/Analysis/rdar-6600344-nil-receiver-undefined-struct-ret.m
+++ b/test/Analysis/rdar-6600344-nil-receiver-undefined-struct-ret.m
@@ -1,4 +1,5 @@
-// RUN: clang-cc -analyze -checker-cfref -analyzer-constraints=basic -analyzer-store=basic %s -verify
+// RUN: clang-cc -analyze -checker-cfref -analyzer-constraints=basic -analyzer-store=basic %s -verify &&
+// RUN: clang-cc -analyze -checker-cfref -analyzer-constraints=basic -analyzer-store=region %s -verify
 
 typedef struct Foo { int x; } Bar;
 
diff --git a/test/Analysis/rdar-7168531.m b/test/Analysis/rdar-7168531.m
new file mode 100644
index 000000000000..bdbd22d24e2c
--- /dev/null
+++ b/test/Analysis/rdar-7168531.m
@@ -0,0 +1,19 @@
+// RUN: clang-cc -analyze -checker-cfref -triple i386-apple-darwin10 -analyzer-store=region &&
+// RUN: clang-cc -analyze -checker-cfref -triple i386-apple-darwin10 -analyzer-store=basic
+
+// Note that the target triple is important for this test case.  It specifies that we use the
+// fragile Objective-C ABI.
+
+@interface Foo {
+  int x;
+}
+@end
+
+@implementation Foo
+static Foo* bar(Foo *p) {
+  if (p->x)
+   return ++p;  // This is only valid for the fragile ABI.
+
+  return p;
+}
+@end
diff --git a/test/Analysis/region-1.m b/test/Analysis/region-1.m
index ed172e431e99..68a375b7126c 100644
--- a/test/Analysis/region-1.m
+++ b/test/Analysis/region-1.m
@@ -79,6 +79,7 @@ typedef NSUInteger JabaSourceLanguage;
 Dos_CharacterRangeType = 0,     Dos_LineRangeType = 1 }
   DosTextRangeType;
 @implementation JabaSCSharedDiagramViewController  + (NSImage *)findImageNamed:(NSString *)name {
+  return 0;
 }
 - (void)revealSourceInEditor:(JabasectItem *)sectItem duperGesture:(BOOL)duperGesture {
   id <EcoNamedElement> selectedElement = [sectItem representedObject];
diff --git a/test/Analysis/region-only-test.c b/test/Analysis/region-only-test.c
index 64d3fcd57b2a..8908adb1057c 100644
--- a/test/Analysis/region-only-test.c
+++ b/test/Analysis/region-only-test.c
@@ -9,5 +9,5 @@ void foo(int* p) {
   if (p[0] == 1)
     x = &a;
   if (p[0] == 1)
-    *x; // no-warning
+    (void)*x; // no-warning
 }
diff --git a/test/Analysis/retain-release-gc-only.m b/test/Analysis/retain-release-gc-only.m
index ec33a57d3303..2833b02f0771 100644
--- a/test/Analysis/retain-release-gc-only.m
+++ b/test/Analysis/retain-release-gc-only.m
@@ -1,16 +1,26 @@
-// RUN: clang-cc -analyze -checker-cfref -verify -fobjc-gc-only %s &&
+// RUN: clang-cc -analyze -checker-cfref -analyzer-store=basic -verify -fobjc-gc-only %s &&
 // RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -fobjc-gc-only -verify %s
 
 //===----------------------------------------------------------------------===//
 // Header stuff.
 //===----------------------------------------------------------------------===//
 
-typedef struct objc_class *Class;
-
 typedef unsigned int __darwin_natural_t;
-typedef struct {} div_t;
-typedef unsigned long UInt32;
+typedef unsigned long uintptr_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+typedef unsigned int UInt32;
 typedef signed long CFIndex;
+typedef struct {
+    CFIndex location;
+    CFIndex length;
+} CFRange;
+static __inline__ __attribute__((always_inline)) CFRange CFRangeMake(CFIndex loc, CFIndex len) {
+    CFRange range;
+    range.location = loc;
+    range.length = len;
+    return range;
+}
 typedef const void * CFTypeRef;
 typedef const struct __CFString * CFStringRef;
 typedef const struct __CFAllocator * CFAllocatorRef;
@@ -26,7 +36,17 @@ typedef struct __CFArray * CFMutableArrayRef;
 extern CFMutableArrayRef CFArrayCreateMutable(CFAllocatorRef allocator, CFIndex capacity, const CFArrayCallBacks *callBacks);
 extern const void *CFArrayGetValueAtIndex(CFArrayRef theArray, CFIndex idx);
 extern void CFArrayAppendValue(CFMutableArrayRef theArray, const void *value);
+typedef struct {
+}
+CFDictionaryKeyCallBacks;
+extern const CFDictionaryKeyCallBacks kCFTypeDictionaryKeyCallBacks;
+typedef struct {
+}
+CFDictionaryValueCallBacks;
+extern const CFDictionaryValueCallBacks kCFTypeDictionaryValueCallBacks;
 typedef const struct __CFDictionary * CFDictionaryRef;
+typedef struct __CFDictionary * CFMutableDictionaryRef;
+extern CFMutableDictionaryRef CFDictionaryCreateMutable(CFAllocatorRef allocator, CFIndex capacity, const CFDictionaryKeyCallBacks *keyCallBacks, const CFDictionaryValueCallBacks *valueCallBacks);
 typedef UInt32 CFStringEncoding;
 enum {
 kCFStringEncodingMacRoman = 0,     kCFStringEncodingWindowsLatin1 = 0x0500,     kCFStringEncodingISOLatin1 = 0x0201,     kCFStringEncodingNextStepLatin = 0x0B01,     kCFStringEncodingASCII = 0x0600,     kCFStringEncodingUnicode = 0x0100,     kCFStringEncodingUTF8 = 0x08000100,     kCFStringEncodingNonLossyASCII = 0x0BFF      ,     kCFStringEncodingUTF16 = 0x0100,     kCFStringEncodingUTF16BE = 0x10000100,     kCFStringEncodingUTF16LE = 0x14000100,      kCFStringEncodingUTF32 = 0x0c000100,     kCFStringEncodingUTF32BE = 0x18000100,     kCFStringEncodingUTF32LE = 0x1c000100  };
@@ -40,44 +60,96 @@ extern CFAbsoluteTime CFDateGetAbsoluteTime(CFDateRef theDate);
 typedef __darwin_natural_t natural_t;
 typedef natural_t mach_port_name_t;
 typedef mach_port_name_t mach_port_t;
-typedef struct {
-}
-CFRunLoopObserverContext;
+typedef int kern_return_t;
+typedef kern_return_t mach_error_t;
+enum {
+kCFNumberSInt8Type = 1,     kCFNumberSInt16Type = 2,     kCFNumberSInt32Type = 3,     kCFNumberSInt64Type = 4,     kCFNumberFloat32Type = 5,     kCFNumberFloat64Type = 6,      kCFNumberCharType = 7,     kCFNumberShortType = 8,     kCFNumberIntType = 9,     kCFNumberLongType = 10,     kCFNumberLongLongType = 11,     kCFNumberFloatType = 12,     kCFNumberDoubleType = 13,      kCFNumberCFIndexType = 14,      kCFNumberNSIntegerType = 15,     kCFNumberCGFloatType = 16,     kCFNumberMaxType = 16    };
+typedef CFIndex CFNumberType;
+typedef const struct __CFNumber * CFNumberRef;
+extern CFNumberRef CFNumberCreate(CFAllocatorRef allocator, CFNumberType theType, const void *valuePtr);
+typedef const struct __CFAttributedString *CFAttributedStringRef;
+typedef struct __CFAttributedString *CFMutableAttributedStringRef;
+extern CFAttributedStringRef CFAttributedStringCreate(CFAllocatorRef alloc, CFStringRef str, CFDictionaryRef attributes) ;
+extern CFMutableAttributedStringRef CFAttributedStringCreateMutableCopy(CFAllocatorRef alloc, CFIndex maxLength, CFAttributedStringRef aStr) ;
+extern void CFAttributedStringSetAttribute(CFMutableAttributedStringRef aStr, CFRange range, CFStringRef attrName, CFTypeRef value) ;
 typedef signed char BOOL;
-typedef unsigned int NSUInteger;
+typedef unsigned long NSUInteger;
 @class NSString, Protocol;
 extern void NSLog(NSString *format, ...) __attribute__((format(__NSString__, 1, 2)));
 typedef struct _NSZone NSZone;
 @class NSInvocation, NSMethodSignature, NSCoder, NSString, NSEnumerator;
-@protocol NSObject  - (BOOL)isEqual:(id)object;
+@protocol NSObject
+- (BOOL)isEqual:(id)object;
 - (id)retain;
 - (oneway void)release;
 - (id)autorelease;
+- (Class)class;
 @end  @protocol NSCopying  - (id)copyWithZone:(NSZone *)zone;
 @end  @protocol NSMutableCopying  - (id)mutableCopyWithZone:(NSZone *)zone;
 @end  @protocol NSCoding  - (void)encodeWithCoder:(NSCoder *)aCoder;
 @end
 @interface NSObject <NSObject> {}
-- (Class)class;
-+ (id)alloc;
 + (id)allocWithZone:(NSZone *)zone;
-@end   typedef float CGFloat;
++ (id)alloc;
+- (void)dealloc;
+@end
+@interface NSObject (NSCoderMethods)
+- (id)awakeAfterUsingCoder:(NSCoder *)aDecoder;
+@end
+extern id NSAllocateObject(Class aClass, NSUInteger extraBytes, NSZone *zone);
+typedef struct {
+}
+NSFastEnumerationState;
+@protocol NSFastEnumeration  - (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(id *)stackbuf count:(NSUInteger)len;
+@end           @class NSString, NSDictionary;
+@interface NSValue : NSObject <NSCopying, NSCoding>  - (void)getValue:(void *)value;
+@end  @interface NSNumber : NSValue  - (char)charValue;
+- (id)initWithInt:(int)value;
+@end   @class NSString;
+@interface NSArray : NSObject <NSCopying, NSMutableCopying, NSCoding, NSFastEnumeration>  - (NSUInteger)count;
+@end  @interface NSArray (NSArrayCreation)  + (id)array;
+@end       @interface NSAutoreleasePool : NSObject {
+}
+- (void)drain;
+@end extern NSString * const NSBundleDidLoadNotification;
+typedef double NSTimeInterval;
+@interface NSDate : NSObject <NSCopying, NSCoding>  - (NSTimeInterval)timeIntervalSinceReferenceDate;
+@end            typedef unsigned short unichar;
 @interface NSString : NSObject <NSCopying, NSMutableCopying, NSCoding>    - (NSUInteger)length;
-- (const char *)UTF8String;
+- ( const char *)UTF8String;
 - (id)initWithUTF8String:(const char *)nullTerminatedCString;
 + (id)stringWithUTF8String:(const char *)nullTerminatedCString;
-- (id)init;
-- (void)dealloc;
-@end   extern NSString * const NSCurrentLocaleDidChangeNotification ;
-@protocol NSLocking  - (void)lock;
-@end  extern NSString * const NSUndoManagerCheckpointNotification;
-typedef enum {
-ACL_READ_DATA = (1<<1),  ACL_LIST_DIRECTORY = (1<<1),  ACL_WRITE_DATA = (1<<2),  ACL_ADD_FILE = (1<<2),  ACL_EXECUTE = (1<<3),  ACL_SEARCH = (1<<3),  ACL_DELETE = (1<<4),  ACL_APPEND_DATA = (1<<5),  ACL_ADD_SUBDIRECTORY = (1<<5),  ACL_DELETE_CHILD = (1<<6),  ACL_READ_ATTRIBUTES = (1<<7),  ACL_WRITE_ATTRIBUTES = (1<<8),  ACL_READ_EXTATTRIBUTES = (1<<9),  ACL_WRITE_EXTATTRIBUTES = (1<<10),  ACL_READ_SECURITY = (1<<11),  ACL_WRITE_SECURITY = (1<<12),  ACL_CHANGE_OWNER = (1<<13) }
-acl_entry_id_t;
-typedef int kern_return_t;
-typedef kern_return_t mach_error_t;
+@end        @class NSString, NSURL, NSError;
+@interface NSData : NSObject <NSCopying, NSMutableCopying, NSCoding>  - (NSUInteger)length;
++ (id)dataWithBytesNoCopy:(void *)bytes length:(NSUInteger)length;
++ (id)dataWithBytesNoCopy:(void *)bytes length:(NSUInteger)length freeWhenDone:(BOOL)b;
+@end   @class NSLocale, NSDate, NSCalendar, NSTimeZone, NSError, NSArray, NSMutableDictionary;
+@interface NSDictionary : NSObject <NSCopying, NSMutableCopying, NSCoding, NSFastEnumeration>  - (NSUInteger)count;
+@end    @interface NSMutableDictionary : NSDictionary  - (void)removeObjectForKey:(id)aKey;
+- (void)setObject:(id)anObject forKey:(id)aKey;
+@end  @interface NSMutableDictionary (NSMutableDictionaryCreation)  + (id)dictionaryWithCapacity:(NSUInteger)numItems;
+@end  typedef double CGFloat;
+struct CGSize {
+};
+typedef struct CGSize CGSize;
+struct CGRect {
+};
+typedef struct CGRect CGRect;
 typedef mach_port_t io_object_t;
+typedef char io_name_t[128];
+typedef io_object_t io_iterator_t;
 typedef io_object_t io_service_t;
+typedef struct IONotificationPort * IONotificationPortRef;
+typedef void (*IOServiceMatchingCallback)(  void * refcon,  io_iterator_t iterator );
+io_service_t IOServiceGetMatchingService(  mach_port_t masterPort,  CFDictionaryRef matching );
+kern_return_t IOServiceGetMatchingServices(  mach_port_t masterPort,  CFDictionaryRef matching,  io_iterator_t * existing );
+kern_return_t IOServiceAddNotification(  mach_port_t masterPort,  const io_name_t notificationType,  CFDictionaryRef matching,  mach_port_t wakePort,  uintptr_t reference,  io_iterator_t * notification ) __attribute__((deprecated));
+kern_return_t IOServiceAddMatchingNotification(  IONotificationPortRef notifyPort,  const io_name_t notificationType,  CFDictionaryRef matching,         IOServiceMatchingCallback callback,         void * refCon,  io_iterator_t * notification );
+CFMutableDictionaryRef IOServiceMatching(  const char * name );
+CFMutableDictionaryRef IOServiceNameMatching(  const char * name );
+CFMutableDictionaryRef IOBSDNameMatching(  mach_port_t masterPort,  uint32_t options,  const char * bsdName );
+CFMutableDictionaryRef IOOpenFirmwarePathMatching(  mach_port_t masterPort,  uint32_t options,  const char * path );
+CFMutableDictionaryRef IORegistryEntryIDMatching(  uint64_t entryID );
 typedef struct __DASession * DASessionRef;
 extern DASessionRef DASessionCreate( CFAllocatorRef allocator );
 typedef struct __DADisk * DADiskRef;
@@ -85,23 +157,62 @@ extern DADiskRef DADiskCreateFromBSDName( CFAllocatorRef allocator, DASessionRef
 extern DADiskRef DADiskCreateFromIOMedia( CFAllocatorRef allocator, DASessionRef session, io_service_t media );
 extern CFDictionaryRef DADiskCopyDescription( DADiskRef disk );
 extern DADiskRef DADiskCopyWholeDisk( DADiskRef disk );
+@interface NSTask : NSObject - (id)init;
+@end                    typedef struct CGColorSpace *CGColorSpaceRef;
+typedef struct CGImage *CGImageRef;
+typedef struct CGLayer *CGLayerRef;
 @interface NSResponder : NSObject <NSCoding> {
 }
-@end  @class NSColor, NSFont, NSNotification;
-typedef struct __CFlags {
+@end    @protocol NSAnimatablePropertyContainer      - (id)animator;
+@end  extern NSString *NSAnimationTriggerOrderIn ;
+@interface NSView : NSResponder  <NSAnimatablePropertyContainer>  {
 }
-_CFlags;
+@end @protocol NSValidatedUserInterfaceItem - (SEL)action;
+@end   @protocol NSUserInterfaceValidations - (BOOL)validateUserInterfaceItem:(id <NSValidatedUserInterfaceItem>)anItem;
+@end  @class NSDate, NSDictionary, NSError, NSException, NSNotification;
+@interface NSApplication : NSResponder <NSUserInterfaceValidations> {
+}
+@end   enum {
+NSTerminateCancel = 0,         NSTerminateNow = 1,         NSTerminateLater = 2 };
+typedef NSUInteger NSApplicationTerminateReply;
+@protocol NSApplicationDelegate <NSObject> @optional        - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender;
+@end  @class NSAttributedString, NSEvent, NSFont, NSFormatter, NSImage, NSMenu, NSText, NSView, NSTextView;
 @interface NSCell : NSObject <NSCopying, NSCoding> {
 }
-@end  @class NSDate, NSDictionary, NSError, NSException, NSNotification;
-@interface NSManagedObjectContext : NSObject <NSCoding, NSLocking> {
+@end @class NSTextField, NSPanel, NSArray, NSWindow, NSImage, NSButton, NSError;
+typedef struct {
+}
+CVTimeStamp;
+@interface CIImage : NSObject <NSCoding, NSCopying> {
 }
-@end enum {
+typedef int CIFormat;
+@end  enum {
 kDAReturnSuccess = 0,     kDAReturnError = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x01,     kDAReturnBusy = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x02,     kDAReturnBadArgument = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x03,     kDAReturnExclusiveAccess = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x04,     kDAReturnNoResources = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x05,     kDAReturnNotFound = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x06,     kDAReturnNotMounted = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x07,     kDAReturnNotPermitted = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x08,     kDAReturnNotPrivileged = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x09,     kDAReturnNotReady = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0A,     kDAReturnNotWritable = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0B,     kDAReturnUnsupported = (((0x3e)&0x3f)<<26) | (((0x368)&0xfff)<<14) | 0x0C };
 typedef mach_error_t DAReturn;
 typedef const struct __DADissenter * DADissenterRef;
 extern DADissenterRef DADissenterCreate( CFAllocatorRef allocator, DAReturn status, CFStringRef string );
-
+@interface CIContext: NSObject {
+}
+- (CGImageRef)createCGImage:(CIImage *)im fromRect:(CGRect)r;
+- (CGImageRef)createCGImage:(CIImage *)im fromRect:(CGRect)r     format:(CIFormat)f colorSpace:(CGColorSpaceRef)cs;
+- (CGLayerRef)createCGLayerWithSize:(CGSize)size info:(CFDictionaryRef)d;
+@end extern NSString* const QCRendererEventKey;
+@protocol QCCompositionRenderer - (NSDictionary*) attributes;
+@end   @interface QCRenderer : NSObject <QCCompositionRenderer> {
+}
+- (id) createSnapshotImageOfType:(NSString*)type;
+@end  extern NSString* const QCViewDidStartRenderingNotification;
+@interface QCView : NSView <QCCompositionRenderer> {
+}
+- (id) createSnapshotImageOfType:(NSString*)type;
+@end    enum {
+ICEXIFOrientation1 = 1,     ICEXIFOrientation2 = 2,     ICEXIFOrientation3 = 3,     ICEXIFOrientation4 = 4,     ICEXIFOrientation5 = 5,     ICEXIFOrientation6 = 6,     ICEXIFOrientation7 = 7,     ICEXIFOrientation8 = 8, };
+@class ICDevice;
+@protocol ICDeviceDelegate <NSObject>  @required      - (void)didRemoveDevice:(ICDevice*)device;
+@end extern NSString *const ICScannerStatusWarmingUp;
+@class ICScannerDevice;
+@protocol ICScannerDeviceDelegate <ICDeviceDelegate>  @optional       - (void)scannerDeviceDidBecomeAvailable:(ICScannerDevice*)scanner;
+@end
 CFTypeRef CFMakeCollectable(CFTypeRef cf) ;
 
 static __inline__ __attribute__((always_inline)) id NSMakeCollectable(CFTypeRef 
@@ -198,6 +309,19 @@ void f5b() {
 @end
 
 //===----------------------------------------------------------------------===//
+// <rdar://problem/7174400> 'ciContext createCGImage:outputImage fromRect:' returns a retained CF object (not GC'ed)//===----------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+
+void rdar_7174400(QCView *view, QCRenderer *renderer, CIContext *context,
+                  NSString *str, CIImage *img, CGRect rect,
+                  CIFormat form, CGColorSpaceRef cs) {
+  [view createSnapshotImageOfType:str]; // no-warning
+  [renderer createSnapshotImageOfType:str]; // no-warning
+  [context createCGImage:img fromRect:rect]; // expected-warning{{leak}}
+  [context createCGImage:img fromRect:rect format:form colorSpace:cs]; // expected-warning{{leak}}
+}
+
+//===----------------------------------------------------------------------===//
 // Tests of ownership attributes.
 //===----------------------------------------------------------------------===//
 
diff --git a/test/Analysis/retain-release-region-store.m b/test/Analysis/retain-release-region-store.m
index 66950e2190ed..7a696833f92d 100644
--- a/test/Analysis/retain-release-region-store.m
+++ b/test/Analysis/retain-release-region-store.m
@@ -1,4 +1,5 @@
 // RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -verify %s
+// XFAIL
 
 //===----------------------------------------------------------------------===//
 // The following code is reduced using delta-debugging from
@@ -115,4 +116,27 @@ CFAbsoluteTime f4() {
 }
 @end
 
+//===----------------------------------------------------------------------===//
+// <rdar://problem/7257223> - False positive due to not invalidating the
+// reference count of a tracked region that was itself invalidated.
+//===----------------------------------------------------------------------===//
+
+typedef struct __rdar_7257223 { CFDateRef x; } RDar7257223;
+void rdar_7257223_aux(RDar7257223 *p);
+
+// THIS CASE CURRENTLY FAILS.
+CFDateRef rdar7257223_Create(void) {
+  RDar7257223 s;
+  CFAbsoluteTime t = CFAbsoluteTimeGetCurrent();
+  s.x = CFDateCreate(0, t); // no-warning
+  rdar_7257223_aux(&s);
+  return s.x;
+}
+
+CFDateRef rdar7257223_Create_2(void) {
+  RDar7257223 s;
+  CFAbsoluteTime t = CFAbsoluteTimeGetCurrent();
+  s.x = CFDateCreate(0, t); // no-warning
+  return s.x;
+}
 
diff --git a/test/Analysis/retain-release.m b/test/Analysis/retain-release.m
index da0ae801dac6..7076bb294254 100644
--- a/test/Analysis/retain-release.m
+++ b/test/Analysis/retain-release.m
@@ -1,6 +1,12 @@
-//>>SLICER
-// RUN: clang-cc -analyze -checker-cfref -verify %s &&
-// RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -verify %s
+// RUN: clang-cc -triple x86_64-apple-darwin10 -analyze -checker-cfref -analyzer-store=basic -verify %s &&
+// RUN: clang-cc -triple x86_64-apple-darwin10 -analyze -checker-cfref -analyzer-store=region -verify %s
+
+#if __has_feature(attribute_ns_returns_retained)
+#define NS_RETURNS_RETAINED __attribute__((ns_returns_retained))
+#endif
+#if __has_feature(attribute_cf_returns_retained)
+#define CF_RETURNS_RETAINED __attribute__((cf_returns_retained))
+#endif
 
 //===----------------------------------------------------------------------===//
 // The following code is reduced using delta-debugging from Mac OS X headers:
@@ -21,6 +27,16 @@ typedef unsigned int uint32_t;
 typedef unsigned long long uint64_t;
 typedef unsigned int UInt32;
 typedef signed long CFIndex;
+typedef struct {
+    CFIndex location;
+    CFIndex length;
+} CFRange;
+static __inline__ __attribute__((always_inline)) CFRange CFRangeMake(CFIndex loc, CFIndex len) {
+    CFRange range;
+    range.location = loc;
+    range.length = len;
+    return range;
+}
 typedef const void * CFTypeRef;
 typedef const struct __CFString * CFStringRef;
 typedef const struct __CFAllocator * CFAllocatorRef;
@@ -36,8 +52,17 @@ typedef struct __CFArray * CFMutableArrayRef;
 extern CFMutableArrayRef CFArrayCreateMutable(CFAllocatorRef allocator, CFIndex capacity, const CFArrayCallBacks *callBacks);
 extern const void *CFArrayGetValueAtIndex(CFArrayRef theArray, CFIndex idx);
 extern void CFArrayAppendValue(CFMutableArrayRef theArray, const void *value);
+typedef struct {
+}
+CFDictionaryKeyCallBacks;
+extern const CFDictionaryKeyCallBacks kCFTypeDictionaryKeyCallBacks;
+typedef struct {
+}
+CFDictionaryValueCallBacks;
+extern const CFDictionaryValueCallBacks kCFTypeDictionaryValueCallBacks;
 typedef const struct __CFDictionary * CFDictionaryRef;
 typedef struct __CFDictionary * CFMutableDictionaryRef;
+extern CFMutableDictionaryRef CFDictionaryCreateMutable(CFAllocatorRef allocator, CFIndex capacity, const CFDictionaryKeyCallBacks *keyCallBacks, const CFDictionaryValueCallBacks *valueCallBacks);
 typedef UInt32 CFStringEncoding;
 enum {
 kCFStringEncodingMacRoman = 0,     kCFStringEncodingWindowsLatin1 = 0x0500,     kCFStringEncodingISOLatin1 = 0x0201,     kCFStringEncodingNextStepLatin = 0x0B01,     kCFStringEncodingASCII = 0x0600,     kCFStringEncodingUnicode = 0x0100,     kCFStringEncodingUTF8 = 0x08000100,     kCFStringEncodingNonLossyASCII = 0x0BFF      ,     kCFStringEncodingUTF16 = 0x0100,     kCFStringEncodingUTF16BE = 0x10000100,     kCFStringEncodingUTF16LE = 0x14000100,      kCFStringEncodingUTF32 = 0x0c000100,     kCFStringEncodingUTF32BE = 0x18000100,     kCFStringEncodingUTF32LE = 0x1c000100  };
@@ -53,29 +78,48 @@ typedef natural_t mach_port_name_t;
 typedef mach_port_name_t mach_port_t;
 typedef int kern_return_t;
 typedef kern_return_t mach_error_t;
+enum {
+kCFNumberSInt8Type = 1,     kCFNumberSInt16Type = 2,     kCFNumberSInt32Type = 3,     kCFNumberSInt64Type = 4,     kCFNumberFloat32Type = 5,     kCFNumberFloat64Type = 6,      kCFNumberCharType = 7,     kCFNumberShortType = 8,     kCFNumberIntType = 9,     kCFNumberLongType = 10,     kCFNumberLongLongType = 11,     kCFNumberFloatType = 12,     kCFNumberDoubleType = 13,      kCFNumberCFIndexType = 14,      kCFNumberNSIntegerType = 15,     kCFNumberCGFloatType = 16,     kCFNumberMaxType = 16    };
+typedef CFIndex CFNumberType;
+typedef const struct __CFNumber * CFNumberRef;
+extern CFNumberRef CFNumberCreate(CFAllocatorRef allocator, CFNumberType theType, const void *valuePtr);
+typedef const struct __CFAttributedString *CFAttributedStringRef;
+typedef struct __CFAttributedString *CFMutableAttributedStringRef;
+extern CFAttributedStringRef CFAttributedStringCreate(CFAllocatorRef alloc, CFStringRef str, CFDictionaryRef attributes) ;
+extern CFMutableAttributedStringRef CFAttributedStringCreateMutableCopy(CFAllocatorRef alloc, CFIndex maxLength, CFAttributedStringRef aStr) ;
+extern void CFAttributedStringSetAttribute(CFMutableAttributedStringRef aStr, CFRange range, CFStringRef attrName, CFTypeRef value) ;
 typedef signed char BOOL;
 typedef unsigned long NSUInteger;
 @class NSString, Protocol;
 extern void NSLog(NSString *format, ...) __attribute__((format(__NSString__, 1, 2)));
 typedef struct _NSZone NSZone;
 @class NSInvocation, NSMethodSignature, NSCoder, NSString, NSEnumerator;
-@protocol NSObject  - (BOOL)isEqual:(id)object;
+@protocol NSObject
+- (BOOL)isEqual:(id)object;
 - (id)retain;
 - (oneway void)release;
 - (id)autorelease;
 @end  @protocol NSCopying  - (id)copyWithZone:(NSZone *)zone;
 @end  @protocol NSMutableCopying  - (id)mutableCopyWithZone:(NSZone *)zone;
 @end  @protocol NSCoding  - (void)encodeWithCoder:(NSCoder *)aCoder;
-@end    @interface NSObject <NSObject> {
-}
+@end
+@interface NSObject <NSObject> {}
 + (id)allocWithZone:(NSZone *)zone;
 + (id)alloc;
 - (void)dealloc;
-@end      extern id NSAllocateObject(Class aClass, NSUInteger extraBytes, NSZone *zone);
+@end
+@interface NSObject (NSCoderMethods)
+- (id)awakeAfterUsingCoder:(NSCoder *)aDecoder;
+@end
+extern id NSAllocateObject(Class aClass, NSUInteger extraBytes, NSZone *zone);
 typedef struct {
 }
 NSFastEnumerationState;
 @protocol NSFastEnumeration  - (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(id *)stackbuf count:(NSUInteger)len;
+@end           @class NSString, NSDictionary;
+@interface NSValue : NSObject <NSCopying, NSCoding>  - (void)getValue:(void *)value;
+@end  @interface NSNumber : NSValue  - (char)charValue;
+- (id)initWithInt:(int)value;
 @end   @class NSString;
 @interface NSArray : NSObject <NSCopying, NSMutableCopying, NSCoding, NSFastEnumeration>  - (NSUInteger)count;
 @end  @interface NSArray (NSArrayCreation)  + (id)array;
@@ -90,11 +134,11 @@ typedef double NSTimeInterval;
 - ( const char *)UTF8String;
 - (id)initWithUTF8String:(const char *)nullTerminatedCString;
 + (id)stringWithUTF8String:(const char *)nullTerminatedCString;
-@end       @class NSString, NSData;
+@end        @class NSString, NSURL, NSError;
 @interface NSData : NSObject <NSCopying, NSMutableCopying, NSCoding>  - (NSUInteger)length;
 + (id)dataWithBytesNoCopy:(void *)bytes length:(NSUInteger)length;
 + (id)dataWithBytesNoCopy:(void *)bytes length:(NSUInteger)length freeWhenDone:(BOOL)b;
-@end             @class NSString;
+@end   @class NSLocale, NSDate, NSCalendar, NSTimeZone, NSError, NSArray, NSMutableDictionary;
 @interface NSDictionary : NSObject <NSCopying, NSMutableCopying, NSCoding, NSFastEnumeration>  - (NSUInteger)count;
 @end    @interface NSMutableDictionary : NSDictionary  - (void)removeObjectForKey:(id)aKey;
 - (void)setObject:(id)anObject forKey:(id)aKey;
@@ -106,9 +150,6 @@ typedef struct CGSize CGSize;
 struct CGRect {
 };
 typedef struct CGRect CGRect;
-@protocol NSLocking  - (void)lock;
-- (id)init;
-@end @class NSURLAuthenticationChallenge;
 typedef mach_port_t io_object_t;
 typedef char io_name_t[128];
 typedef io_object_t io_iterator_t;
@@ -131,37 +172,32 @@ extern DADiskRef DADiskCreateFromBSDName( CFAllocatorRef allocator, DASessionRef
 extern DADiskRef DADiskCreateFromIOMedia( CFAllocatorRef allocator, DASessionRef session, io_service_t media );
 extern CFDictionaryRef DADiskCopyDescription( DADiskRef disk );
 extern DADiskRef DADiskCopyWholeDisk( DADiskRef disk );
-typedef struct CGColorSpace *CGColorSpaceRef;
+@interface NSTask : NSObject - (id)init;
+@end                    typedef struct CGColorSpace *CGColorSpaceRef;
 typedef struct CGImage *CGImageRef;
-  typedef struct CGLayer *CGLayerRef;
-           @class NSArray, NSError, NSEvent, NSMenu, NSUndoManager, NSWindow;
+typedef struct CGLayer *CGLayerRef;
 @interface NSResponder : NSObject <NSCoding> {
 }
 @end    @protocol NSAnimatablePropertyContainer      - (id)animator;
 @end  extern NSString *NSAnimationTriggerOrderIn ;
 @interface NSView : NSResponder  <NSAnimatablePropertyContainer>  {
-struct __VFlags2 {
-}
-_vFlags2;
-}
-@end   extern NSString * const NSFullScreenModeAllScreens;
-@protocol NSChangeSpelling - (void)changeSpelling:(id)sender;
-@end      @protocol NSIgnoreMisspelledWords - (void)ignoreSpelling:(id)sender;
-@end  @class NSColor, NSFont, NSNotification;
-@interface NSText : NSView <NSChangeSpelling, NSIgnoreMisspelledWords> {
 }
 @end @protocol NSValidatedUserInterfaceItem - (SEL)action;
 @end   @protocol NSUserInterfaceValidations - (BOOL)validateUserInterfaceItem:(id <NSValidatedUserInterfaceItem>)anItem;
-@end @class NSArray, NSError, NSImage, NSView, NSNotificationCenter, NSURL, NSScreen, NSRunningApplication;
+@end  @class NSDate, NSDictionary, NSError, NSException, NSNotification;
 @interface NSApplication : NSResponder <NSUserInterfaceValidations> {
 }
 @end   enum {
 NSTerminateCancel = 0,         NSTerminateNow = 1,         NSTerminateLater = 2 };
 typedef NSUInteger NSApplicationTerminateReply;
 @protocol NSApplicationDelegate <NSObject> @optional        - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender;
-@end    enum {
+@end  @class NSAttributedString, NSEvent, NSFont, NSFormatter, NSImage, NSMenu, NSText, NSView, NSTextView;
+@interface NSCell : NSObject <NSCopying, NSCoding> {
 }
-_CFlags;
+@end @class NSTextField, NSPanel, NSArray, NSWindow, NSImage, NSButton, NSError;
+typedef struct {
+}
+CVTimeStamp;
 @interface CIImage : NSObject <NSCoding, NSCopying> {
 }
 typedef int CIFormat;
@@ -175,7 +211,7 @@ extern DADissenterRef DADissenterCreate( CFAllocatorRef allocator, DAReturn stat
 - (CGImageRef)createCGImage:(CIImage *)im fromRect:(CGRect)r;
 - (CGImageRef)createCGImage:(CIImage *)im fromRect:(CGRect)r     format:(CIFormat)f colorSpace:(CGColorSpaceRef)cs;
 - (CGLayerRef)createCGLayerWithSize:(CGSize)size info:(CFDictionaryRef)d;
-@end @class NSURL;
+@end extern NSString* const QCRendererEventKey;
 @protocol QCCompositionRenderer - (NSDictionary*) attributes;
 @end   @interface QCRenderer : NSObject <QCCompositionRenderer> {
 }
@@ -188,11 +224,34 @@ extern DADissenterRef DADissenterCreate( CFAllocatorRef allocator, DAReturn stat
 ICEXIFOrientation1 = 1,     ICEXIFOrientation2 = 2,     ICEXIFOrientation3 = 3,     ICEXIFOrientation4 = 4,     ICEXIFOrientation5 = 5,     ICEXIFOrientation6 = 6,     ICEXIFOrientation7 = 7,     ICEXIFOrientation8 = 8, };
 @class ICDevice;
 @protocol ICDeviceDelegate <NSObject>  @required      - (void)didRemoveDevice:(ICDevice*)device;
-@end  @class ICCameraDevice;
+@end extern NSString *const ICScannerStatusWarmingUp;
 @class ICScannerDevice;
 @protocol ICScannerDeviceDelegate <ICDeviceDelegate>  @optional       - (void)scannerDeviceDidBecomeAvailable:(ICScannerDevice*)scanner;
 @end
-  
+
+typedef long unsigned int __darwin_size_t;
+typedef __darwin_size_t size_t;
+typedef unsigned long CFTypeID;
+struct CGPoint {
+  CGFloat x;
+  CGFloat y;
+};
+typedef struct CGPoint CGPoint;
+typedef struct CGGradient *CGGradientRef;
+typedef uint32_t CGGradientDrawingOptions;
+extern CFTypeID CGGradientGetTypeID(void);
+extern CGGradientRef CGGradientCreateWithColorComponents(CGColorSpaceRef
+  space, const CGFloat components[], const CGFloat locations[], size_t count);
+extern CGGradientRef CGGradientCreateWithColors(CGColorSpaceRef space,
+  CFArrayRef colors, const CGFloat locations[]);
+extern CGGradientRef CGGradientRetain(CGGradientRef gradient);
+extern void CGGradientRelease(CGGradientRef gradient);
+typedef struct CGContext *CGContextRef;
+extern void CGContextDrawLinearGradient(CGContextRef context,
+    CGGradientRef gradient, CGPoint startPoint, CGPoint endPoint,
+    CGGradientDrawingOptions options);
+extern CGColorSpaceRef CGColorSpaceCreateDeviceRGB(void);
+
 //===----------------------------------------------------------------------===//
 // Test cases.
 //===----------------------------------------------------------------------===//
@@ -371,6 +430,7 @@ CFMutableArrayRef f13_autorelease_d() {
   [(id) A autorelease]; 
   CFMutableArrayRef B = CFArrayCreateMutable(0, 10, &kCFTypeArrayCallBacks); // expected-warning{{Object sent -autorelease too many times}}
   CFRelease(B); // no-warning
+  while (1) {}
 }
 
 
@@ -389,6 +449,18 @@ void f15() {
   CFRelease(*B);  // no-warning
 }
 
+// Test when we pass NULL to CFRetain/CFRelease.
+void f16(int x, CFTypeRef p) {
+  if (p)
+    return;
+
+  if (x) {
+    CFRelease(p); // expected-warning{{Null pointer argument in call to CFRelease}}
+  }
+  else {
+    CFRetain(p); // expected-warning{{Null pointer argument in call to CFRetain}}
+  }
+}
 
 // Test basic tracking of ivars associated with 'self'.  For the retain/release
 // checker we currently do not want to flag leaks associated with stores
@@ -559,7 +631,7 @@ void rdar6704930(unsigned char *s, unsigned int length) {
 int rdar_6257780_Case1() {
   NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
   NSArray *array = [NSArray array];
-  [array release]; // expected-warning{{Incorrect decrement of the reference count of an object is not owned at this point by the caller}}
+  [array release]; // expected-warning{{Incorrect decrement of the reference count of an object that is not owned at this point by the caller}}
   [pool drain];
   return 0;
 }
@@ -603,7 +675,8 @@ typedef CFTypeRef OtherRef;
 @end
 
 //===----------------------------------------------------------------------===//
-//<rdar://problem/6320065> false positive - init method returns an object owned by caller
+//<rdar://problem/6320065> false positive - init method returns an object
+// owned by caller
 //===----------------------------------------------------------------------===//
 
 @interface RDar6320065 : NSObject {
@@ -646,7 +719,21 @@ int RDar6320065_test() {
 }
 
 //===----------------------------------------------------------------------===//
-// <rdar://problem/6859457> [NSData dataWithBytesNoCopy] does not return a retained object
+// <rdar://problem/7129086> -awakeAfterUsingCoder: returns an owned object 
+//  and claims the receiver
+//===----------------------------------------------------------------------===//
+
+@interface RDar7129086 : NSObject {} @end
+@implementation RDar7129086
+- (id)awakeAfterUsingCoder:(NSCoder *)aDecoder {
+  [self release]; // no-warning
+  return [NSString alloc];  // no-warning
+}
+@end
+
+//===----------------------------------------------------------------------===//
+// <rdar://problem/6859457> [NSData dataWithBytesNoCopy] does not return a
+//  retained object
 //===----------------------------------------------------------------------===//
 
 @interface RDar6859457 : NSObject {}
@@ -750,7 +837,7 @@ void IOServiceNameMatching_wrapper(const char * name) {
   IOServiceNameMatching(name); // expected-warning{{leak}}
 }
 
-__attribute__((cf_returns_retained)) CFDictionaryRef CreateDict();
+CF_RETURNS_RETAINED CFDictionaryRef CreateDict();
 
 void IOServiceAddNotification_wrapper(mach_port_t masterPort, const io_name_t notificationType,
   mach_port_t wakePort, uintptr_t reference, io_iterator_t * notification ) {
@@ -791,19 +878,241 @@ void IOServiceAddMatchingNotification_wrapper(IONotificationPortRef notifyPort,
 }
 
 //===----------------------------------------------------------------------===//
+// Test of handling objects whose references "escape" to containers.
+//===----------------------------------------------------------------------===//
+
+// <rdar://problem/6539791>
+void rdar_6539791(CFMutableDictionaryRef y, void* key, void* val_key) {
+  CFMutableDictionaryRef x = CFDictionaryCreateMutable(kCFAllocatorDefault, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+  CFDictionaryAddValue(y, key, x);
+  CFRelease(x); // the dictionary keeps a reference, so the object isn't deallocated yet
+  signed z = 1;
+  CFNumberRef value = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &z);
+  if (value) {
+    CFDictionaryAddValue(x, val_key, value); // no-warning
+    CFRelease(value);
+    CFDictionaryAddValue(y, val_key, value); // no-warning
+  }
+}
+
+// <rdar://problem/6560661>
+// Same issue, except with "AppendValue" functions.
+void rdar_6560661(CFMutableArrayRef x) {
+  signed z = 1;
+  CFNumberRef value = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &z);
+  // CFArrayAppendValue keeps a reference to value.
+  CFArrayAppendValue(x, value);
+  CFRelease(value);
+  CFRetain(value);
+  CFRelease(value); // no-warning
+}
+
+// <rdar://problem/7152619>
+// Same issue, excwept with "CFAttributeStringSetAttribute".
+void rdar_7152619(CFStringRef str) {
+  CFAttributedStringRef string = CFAttributedStringCreate(kCFAllocatorDefault, str, 0);
+  CFMutableAttributedStringRef attrString = CFAttributedStringCreateMutableCopy(kCFAllocatorDefault, 100, string);
+  CFRelease(string);
+  NSNumber *number = [[NSNumber alloc] initWithInt:5]; // expected-warning{{leak}}
+  CFAttributedStringSetAttribute(attrString, CFRangeMake(0, 1), str, number);
+  [number release];
+  [number retain];
+  CFRelease(attrString);  
+}
+
+//===----------------------------------------------------------------------===//
+// Test of handling CGGradientXXX functions.
+//===----------------------------------------------------------------------===//
+
+void rdar_7184450(CGContextRef myContext, CGFloat x, CGPoint myStartPoint,
+                  CGPoint myEndPoint) {
+  size_t num_locations = 6;
+  CGFloat locations[6] = { 0.0, 0.265, 0.28, 0.31, 0.36, 1.0 };
+  CGFloat components[28] = { 239.0/256.0, 167.0/256.0, 170.0/256.0,
+     x,  // Start color
+    207.0/255.0, 39.0/255.0, 39.0/255.0, x,
+    147.0/255.0, 21.0/255.0, 22.0/255.0, x,
+    175.0/255.0, 175.0/255.0, 175.0/255.0, x,
+    255.0/255.0,255.0/255.0, 255.0/255.0, x,
+    255.0/255.0,255.0/255.0, 255.0/255.0, x
+  }; // End color
+  
+  CGGradientRef myGradient =
+    CGGradientCreateWithColorComponents(CGColorSpaceCreateDeviceRGB(), // expected-warning{{leak}}
+      components, locations, num_locations);
+
+  CGContextDrawLinearGradient(myContext, myGradient, myStartPoint, myEndPoint,
+                              0);
+  CGGradientRelease(myGradient);
+}
+
+void rdar_7184450_pos(CGContextRef myContext, CGFloat x, CGPoint myStartPoint,
+                  CGPoint myEndPoint) {
+  size_t num_locations = 6;
+  CGFloat locations[6] = { 0.0, 0.265, 0.28, 0.31, 0.36, 1.0 };
+  CGFloat components[28] = { 239.0/256.0, 167.0/256.0, 170.0/256.0,
+     x,  // Start color
+    207.0/255.0, 39.0/255.0, 39.0/255.0, x,
+    147.0/255.0, 21.0/255.0, 22.0/255.0, x,
+    175.0/255.0, 175.0/255.0, 175.0/255.0, x,
+    255.0/255.0,255.0/255.0, 255.0/255.0, x,
+    255.0/255.0,255.0/255.0, 255.0/255.0, x
+  }; // End color
+  
+  CGGradientRef myGradient =
+   CGGradientCreateWithColorComponents(CGColorSpaceCreateDeviceRGB(), components, locations, num_locations); // expected-warning 2 {{leak}}
+
+  CGContextDrawLinearGradient(myContext, myGradient, myStartPoint, myEndPoint,
+                              0);
+}
+
+//===----------------------------------------------------------------------===//
+// <rdar://problem/7299394> clang false positive: retained instance passed to
+//                          thread in pthread_create marked as leak
+//
+// Until we have full IPA, the analyzer should stop tracking the reference
+// count of objects passed to pthread_create.
+//
+//===----------------------------------------------------------------------===//
+
+struct _opaque_pthread_t {};
+struct _opaque_pthread_attr_t {};
+typedef struct _opaque_pthread_t *__darwin_pthread_t;
+typedef struct _opaque_pthread_attr_t __darwin_pthread_attr_t;
+typedef __darwin_pthread_t pthread_t;
+typedef __darwin_pthread_attr_t pthread_attr_t;
+
+int pthread_create(pthread_t * restrict, const pthread_attr_t * restrict,
+                   void *(*)(void *), void * restrict);
+
+void *rdar_7299394_start_routine(void *p) {
+  [((id) p) release];
+  return 0;
+}
+void rdar_7299394(pthread_attr_t *attr, pthread_t *thread, void *args) {
+  NSNumber *number = [[NSNumber alloc] initWithInt:5]; // no-warning
+  pthread_create(thread, attr, rdar_7299394_start_routine, number);
+}
+void rdar_7299394_positive(pthread_attr_t *attr, pthread_t *thread) {
+  NSNumber *number = [[NSNumber alloc] initWithInt:5]; // expected-warning{{leak}}
+}
+
+//===----------------------------------------------------------------------===//
+// <rdar://problem/7283567> False leak associated with call to 
+//                          CVPixelBufferCreateWithBytes ()
+//
+// According to the Core Video Reference (ADC), CVPixelBufferCreateWithBytes and
+// CVPixelBufferCreateWithPlanarBytes can release (via a callback) the
+// pixel buffer object.  These test cases show how the analyzer stops tracking
+// the reference count for the objects passed for this argument.  This
+// could be made smarter.
+//===----------------------------------------------------------------------===//
+
+typedef int int32_t;
+typedef UInt32 FourCharCode;
+typedef FourCharCode OSType;
+typedef uint64_t CVOptionFlags;
+typedef int32_t CVReturn;
+typedef struct __CVBuffer *CVBufferRef;
+typedef CVBufferRef CVImageBufferRef;
+typedef CVImageBufferRef CVPixelBufferRef;
+typedef void (*CVPixelBufferReleaseBytesCallback)( void *releaseRefCon, const void *baseAddress );
+
+extern CVReturn CVPixelBufferCreateWithBytes(CFAllocatorRef allocator,
+            size_t width,
+            size_t height,
+            OSType pixelFormatType,
+            void *baseAddress,
+            size_t bytesPerRow,
+            CVPixelBufferReleaseBytesCallback releaseCallback,
+            void *releaseRefCon,
+            CFDictionaryRef pixelBufferAttributes,
+                   CVPixelBufferRef *pixelBufferOut) ;
+
+typedef void (*CVPixelBufferReleasePlanarBytesCallback)( void *releaseRefCon, const void *dataPtr, size_t dataSize, size_t numberOfPlanes, const void *planeAddresses[] );
+
+extern CVReturn CVPixelBufferCreateWithPlanarBytes(CFAllocatorRef allocator,
+        size_t width,
+        size_t height,
+        OSType pixelFormatType,
+        void *dataPtr,
+        size_t dataSize,
+        size_t numberOfPlanes,
+        void *planeBaseAddress[],
+        size_t planeWidth[],
+        size_t planeHeight[],
+        size_t planeBytesPerRow[],
+        CVPixelBufferReleasePlanarBytesCallback releaseCallback,
+        void *releaseRefCon,
+        CFDictionaryRef pixelBufferAttributes,
+        CVPixelBufferRef *pixelBufferOut) ;
+
+extern CVReturn CVPixelBufferCreateWithBytes(CFAllocatorRef allocator,
+            size_t width,
+            size_t height,
+            OSType pixelFormatType,
+            void *baseAddress,
+            size_t bytesPerRow,
+            CVPixelBufferReleaseBytesCallback releaseCallback,
+            void *releaseRefCon,
+            CFDictionaryRef pixelBufferAttributes,
+                   CVPixelBufferRef *pixelBufferOut) ;
+
+CVReturn rdar_7283567(CFAllocatorRef allocator, size_t width, size_t height,
+                      OSType pixelFormatType, void *baseAddress,
+                      size_t bytesPerRow,
+                      CVPixelBufferReleaseBytesCallback releaseCallback,
+                      CFDictionaryRef pixelBufferAttributes,
+                      CVPixelBufferRef *pixelBufferOut) {
+
+  // For the allocated object, it doesn't really matter what type it is
+  // for the purpose of this test.  All we want to show is that
+  // this is freed later by the callback.
+  NSNumber *number = [[NSNumber alloc] initWithInt:5]; // no-warning
+  
+  return CVPixelBufferCreateWithBytes(allocator, width, height, pixelFormatType,
+                                baseAddress, bytesPerRow, releaseCallback,
+                                number, // potentially released by callback
+                                pixelBufferAttributes, pixelBufferOut) ;
+}
+
+CVReturn rdar_7283567_2(CFAllocatorRef allocator, size_t width, size_t height,
+        OSType pixelFormatType, void *dataPtr, size_t dataSize,
+        size_t numberOfPlanes, void *planeBaseAddress[],
+        size_t planeWidth[], size_t planeHeight[], size_t planeBytesPerRow[],
+        CVPixelBufferReleasePlanarBytesCallback releaseCallback,
+        CFDictionaryRef pixelBufferAttributes,
+        CVPixelBufferRef *pixelBufferOut) {
+    
+    // For the allocated object, it doesn't really matter what type it is
+    // for the purpose of this test.  All we want to show is that
+    // this is freed later by the callback.
+    NSNumber *number = [[NSNumber alloc] initWithInt:5]; // no-warning
+
+    return CVPixelBufferCreateWithPlanarBytes(allocator,
+              width, height, pixelFormatType, dataPtr, dataSize,
+              numberOfPlanes, planeBaseAddress, planeWidth,
+              planeHeight, planeBytesPerRow, releaseCallback,
+              number, // potentially released by callback
+              pixelBufferAttributes, pixelBufferOut) ;
+}
+
+//===----------------------------------------------------------------------===//
 // Tests of ownership attributes.
 //===----------------------------------------------------------------------===//
 
 typedef NSString* MyStringTy;
 
+@protocol FooP;
+
 @interface TestOwnershipAttr : NSObject
-- (NSString*) returnsAnOwnedString  __attribute__((ns_returns_retained)); // no-warning
-- (NSString*) returnsAnOwnedCFString  __attribute__((cf_returns_retained)); // no-warning
-- (MyStringTy) returnsAnOwnedTypedString __attribute__((ns_returns_retained)); // no-warning
-- (int) returnsAnOwnedInt __attribute__((ns_returns_retained)); // expected-warning{{'ns_returns_retained' attribute only applies to functions or methods that return a pointer or Objective-C object}}
+- (NSString*) returnsAnOwnedString  NS_RETURNS_RETAINED; // no-warning
+- (NSString*) returnsAnOwnedCFString  CF_RETURNS_RETAINED; // no-warning
+- (MyStringTy) returnsAnOwnedTypedString NS_RETURNS_RETAINED; // no-warning
+- (int) returnsAnOwnedInt NS_RETURNS_RETAINED; // expected-warning{{'ns_returns_retained' attribute only applies to functions or methods that return a pointer or Objective-C object}}
 @end
 
-static int ownership_attribute_doesnt_go_here __attribute__((ns_returns_retained)); // expected-warning{{'ns_returns_retained' attribute only applies to function or method types}}
+static int ownership_attribute_doesnt_go_here NS_RETURNS_RETAINED; // expected-warning{{'ns_returns_retained' attribute only applies to function or method types}}
 
 void test_attr_1(TestOwnershipAttr *X) {
   NSString *str = [X returnsAnOwnedString]; // expected-warning{{leak}}
@@ -814,12 +1123,14 @@ void test_attr_1b(TestOwnershipAttr *X) {
 }
 
 @interface MyClassTestCFAttr : NSObject {}
-- (NSDate*) returnsCFRetained __attribute__((cf_returns_retained));
+- (NSDate*) returnsCFRetained CF_RETURNS_RETAINED;
+- (CFDateRef) returnsCFRetainedAsCF CF_RETURNS_RETAINED;
 - (NSDate*) alsoReturnsRetained;
-- (NSDate*) returnsNSRetained __attribute__((ns_returns_retained));
+- (CFDateRef) alsoReturnsRetainedAsCF;
+- (NSDate*) returnsNSRetained NS_RETURNS_RETAINED;
 @end
 
-__attribute__((cf_returns_retained))
+CF_RETURNS_RETAINED
 CFDateRef returnsRetainedCFDate()  {
   return CFDateCreate(0, CFAbsoluteTimeGetCurrent());
 }
@@ -829,14 +1140,58 @@ CFDateRef returnsRetainedCFDate()  {
   return (NSDate*) returnsRetainedCFDate(); // No leak.
 }
 
+- (CFDateRef) returnsCFRetainedAsCF {
+  return returnsRetainedCFDate(); // No leak.
+}
+
+
 - (NSDate*) alsoReturnsRetained {
   return (NSDate*) returnsRetainedCFDate(); // expected-warning{{leak}}
 }
 
+- (CFDateRef) alsoReturnsRetainedAsCF {
+  return returnsRetainedCFDate(); // expected-warning{{leak}}
+}
+
+
 - (NSDate*) returnsNSRetained {
   return (NSDate*) returnsRetainedCFDate(); // no-warning
 }
 @end
 
+//===----------------------------------------------------------------------===//
+// Test that leaks post-dominated by "panic" functions are not reported.
+//
+// <rdar://problem/5905851> do not report a leak when post-dominated by a call
+// to a noreturn or panic function
+//===----------------------------------------------------------------------===//
+
+void panic() __attribute__((noreturn));
+
+void test_panic_negative() {
+  signed z = 1;
+  CFNumberRef value = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &z);  // expected-warning{{leak}}
+}
+
+void test_panic_positive() {
+  signed z = 1;
+  CFNumberRef value = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &z); // no-warning
+  panic();
+}
 
+void test_panic_neg_2(int x) {
+  signed z = 1;
+  CFNumberRef value = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &z); // expected-warning{{leak}}
+  if (x)
+    panic();
+}
+
+void test_panic_pos_2(int x) {
+  signed z = 1;
+  CFNumberRef value = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &z); // no-warning
+  if (x)
+    panic();  
+  if (!x)
+    panic();
+}
 
diff --git a/test/Analysis/security-syntax-checks.m b/test/Analysis/security-syntax-checks.m
new file mode 100644
index 000000000000..ebd7d172b5b4
--- /dev/null
+++ b/test/Analysis/security-syntax-checks.m
@@ -0,0 +1,91 @@
+// RUN: clang-cc -triple i386-apple-darwin10 -analyze -warn-security-syntactic %s -verify
+
+// <rdar://problem/6336718> rule request: floating point used as loop 
+//  condition (FLP30-C, FLP-30-CPP)
+//
+// For reference: https://www.securecoding.cert.org/confluence/display/seccode/FLP30-C.+Do+not+use+floating+point+variables+as+loop+counters
+//
+void test_float_condition() {
+  for (float x = 0.1f; x <= 1.0f; x += 0.1f) {} // expected-warning{{Variable 'x' with floating point type 'float'}}
+  for (float x = 100000001.0f; x <= 100000010.0f; x += 1.0f) {} // expected-warning{{Variable 'x' with floating point type 'float'}}
+  for (float x = 100000001.0f; x <= 100000010.0f; x++ ) {} // expected-warning{{Variable 'x' with floating point type 'float'}}
+  for (double x = 100000001.0; x <= 100000010.0; x++ ) {} // expected-warning{{Variable 'x' with floating point type 'double'}}
+  for (double x = 100000001.0; ((x)) <= 100000010.0; ((x))++ ) {} // expected-warning{{Variable 'x' with floating point type 'double'}}
+  
+  for (double x = 100000001.0; 100000010.0 >= x; x = x + 1.0 ) {} // expected-warning{{Variable 'x' with floating point type 'double'}}
+  
+  int i = 0;
+  for (double x = 100000001.0; ((x)) <= 100000010.0; ((x))++, ++i ) {} // expected-warning{{Variable 'x' with floating point type 'double'}}
+  
+  typedef float FooType;
+  for (FooType x = 100000001.0f; x <= 100000010.0f; x++ ) {} // expected-warning{{Variable 'x' with floating point type 'FooType'}}
+}
+
+// <rdar://problem/6335715> rule request: gets() buffer overflow
+// Part of recommendation: 300-BSI (buildsecurityin.us-cert.gov)
+char* gets(char *buf);
+
+void test_gets() {
+  char buff[1024];
+  gets(buff); // expected-warning{{Call to function 'gets' is extremely insecure as it can always result in a buffer overflow}}
+}
+
+// <rdar://problem/6337132> CWE-273: Failure to Check Whether Privileges Were
+//  Dropped Successfully
+typedef unsigned int __uint32_t;
+typedef __uint32_t __darwin_uid_t;
+typedef __uint32_t __darwin_gid_t;
+typedef __darwin_uid_t uid_t;
+typedef __darwin_gid_t gid_t;
+int setuid(uid_t);
+int setregid(gid_t, gid_t);
+int setreuid(uid_t, uid_t);
+extern void check(int);
+
+void test_setuid() 
+{
+  setuid(2); // expected-warning{{The return value from the call to 'setuid' is not checked.  If an error occurs in 'setuid', the following code may execute with unexpected privileges}}
+  setuid(0); // expected-warning{{The return value from the call to 'setuid' is not checked.  If an error occurs in 'setuid', the following code may execute with unexpected privileges}}
+  if (setuid (2) != 0)
+    abort();
+
+  // Currently the 'setuid' check is not flow-sensitive, and only looks
+  // at whether the function was called in a compound statement.  This
+  // will lead to false negatives, but there should be no false positives.
+  int t = setuid(2);  // no-warning
+  (void)setuid (2); // no-warning
+
+  check(setuid (2)); // no-warning
+
+  setreuid(2,2); // expected-warning{{The return value from the call to 'setreuid' is not checked.  If an error occurs in 'setreuid', the following code may execute with unexpected privileges}}
+  setregid(2,2); // expected-warning{{The return value from the call to 'setregid' is not checked.  If an error occurs in 'setregid', the following code may execute with unexpected privileges}}
+}
+
+// <rdar://problem/6337100> CWE-338: Use of cryptographically weak prng
+int      rand(void);
+double   drand48(void);
+double   erand48(unsigned short[3]);
+long     jrand48(unsigned short[3]);
+void     lcong48(unsigned short[7]);
+long     lrand48(void);
+long     mrand48(void);
+long     nrand48(unsigned short[3]);
+long     random(void);
+int      rand_r(unsigned *);
+
+void test_rand()
+{
+  unsigned short a[7];
+  unsigned b;
+  
+  rand();	// expected-warning{{Function 'rand' is obsolete because it implements a poor random number generator.  Use 'arc4random' instead}}
+  drand48();	// expected-warning{{Function 'drand48' is obsolete because it implements a poor random number generator.  Use 'arc4random' instead}}
+  erand48(a);	// expected-warning{{Function 'erand48' is obsolete because it implements a poor random number generator.  Use 'arc4random' instead}}
+  jrand48(a);	// expected-warning{{Function 'jrand48' is obsolete because it implements a poor random number generator.  Use 'arc4random' instead}}
+  lcong48(a);	// expected-warning{{Function 'lcong48' is obsolete because it implements a poor random number generator.  Use 'arc4random' instead}}
+  lrand48();	// expected-warning{{Function 'lrand48' is obsolete because it implements a poor random number generator.  Use 'arc4random' instead}}
+  mrand48();	// expected-warning{{Function 'mrand48' is obsolete because it implements a poor random number generator.  Use 'arc4random' instead}}
+  nrand48(a);	// expected-warning{{Function 'nrand48' is obsolete because it implements a poor random number generator.  Use 'arc4random' instead}}
+  rand_r(&b);	// expected-warning{{Function 'rand_r' is obsolete because it implements a poor random number generator.  Use 'arc4random' instead}}
+  random();	// expected-warning{{The 'random' function produces a sequence of values that an adversary may be able to predict.  Use 'arc4random' instead}}
+}
diff --git a/test/Analysis/uninit-vals-ps-region.c b/test/Analysis/uninit-vals-ps-region.c
index 32f787db4aeb..1561f11c9937 100644
--- a/test/Analysis/uninit-vals-ps-region.c
+++ b/test/Analysis/uninit-vals-ps-region.c
@@ -15,3 +15,21 @@ void f4() {
   if (global.data == 0) // When the true branch is feasible 'a = 3'.
     g(a); // no-warning
 }
+
+
+// Test uninitialized value due to part of the structure being uninitialized.
+struct TestUninit { int x; int y; };
+struct TestUninit test_uninit_aux();
+void test_uninit_pos() {
+  struct TestUninit v1 = { 0, 0 };
+  struct TestUninit v2 = test_uninit_aux();
+  int z;
+  v1.y = z;
+  test_unit_aux2(v2.x + v1.y);  // expected-warning{{The right operand of '+' is a garbage value}}
+}
+void test_uninit_neg() {
+  struct TestUninit v1 = { 0, 0 };
+  struct TestUninit v2 = test_uninit_aux();
+  test_unit_aux2(v2.x + v1.y); // no-warning
+}
+
diff --git a/test/Analysis/uninit-vals-ps.c b/test/Analysis/uninit-vals-ps.c
index 41771265367a..759c7edbcc57 100644
--- a/test/Analysis/uninit-vals-ps.c
+++ b/test/Analysis/uninit-vals-ps.c
@@ -1,4 +1,4 @@
-// RUN: clang-cc -analyze -checker-cfref -verify %s &&
+// RUN: clang-cc -analyze -checker-cfref -analyzer-store=basic -verify %s &&
 // RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -verify %s
 
 struct FPRec {
@@ -22,7 +22,7 @@ int f2() {
   
   int x;
   
-  if (x+1)  // expected-warning{{Branch}}
+  if (x+1)  // expected-warning{{The left operand of '+' is a garbage value}}
     return 1;
     
   return 2;  
@@ -31,13 +31,13 @@ int f2() {
 int f2_b() {
   int x;
   
-  return ((x+1)+2+((x))) + 1 ? 1 : 2; // expected-warning{{Branch}}
+  return ((1+x)+2+((x))) + 1 ? 1 : 2; // expected-warning{{The right operand of '+' is a garbage value}}
 }
 
 int f3(void) {
   int i;
   int *p = &i;
-  if (*p > 0) // expected-warning{{Branch condition evaluates to an uninitialized value}}
+  if (*p > 0) // expected-warning{{The left operand of '>' is a garbage value}}
     return 0;
   else
     return 1;
@@ -61,7 +61,7 @@ int f5(void) {
 int ret_uninit() {
   int i;
   int *p = &i;
-  return *p;  // expected-warning{{Uninitialized or undefined value returned to caller.}}
+  return *p;  // expected-warning{{Undefined or garbage value returned to caller}}
 }
 
 // <rdar://problem/6451816>
@@ -83,3 +83,43 @@ CFStringRef rdar_6451816(CFNumberRef nr) {
   return CFStringConvertEncodingToIANACharSetName(encoding); // no-warning
 }
 
+// PR 4630 - false warning with nonnull attribute
+//  This false positive (due to a regression) caused the analyzer to falsely
+//  flag a "return of uninitialized value" warning in the first branch due to
+//  the nonnull attribute.
+void pr_4630_aux(char *x, int *y) __attribute__ ((nonnull (1)));
+void pr_4630_aux_2(char *x, int *y);
+int pr_4630(char *a, int y) {
+  int x;
+  if (y) {
+    pr_4630_aux(a, &x);
+    return x;   // no-warning
+  }
+  else {
+    pr_4630_aux_2(a, &x);
+    return x;   // no-warning
+  }
+}
+
+// PR 4631 - False positive with union initializer
+//  Previously the analyzer didn't examine the compound initializers of unions,
+//  resulting in some false positives for initializers with side-effects.
+union u_4631 { int a; };
+struct s_4631 { int a; };
+int pr4631_f2(int *p);
+int pr4631_f3(void *q);
+int pr4631_f1(void)
+{
+  int x;
+  union u_4631 m = { pr4631_f2(&x) };
+  pr4631_f3(&m); // tell analyzer that we use m
+  return x;  // no-warning
+}
+int pr4631_f1_b(void)
+{
+  int x;
+  struct s_4631 m = { pr4631_f2(&x) };
+  pr4631_f3(&m); // tell analyzer that we use m
+  return x;  // no-warning
+}
+
diff --git a/test/Analysis/uninit-vals.c b/test/Analysis/uninit-vals.c
index d69250b65c0b..8428ca4f81cd 100644
--- a/test/Analysis/uninit-vals.c
+++ b/test/Analysis/uninit-vals.c
@@ -23,7 +23,7 @@ int f4(int x) {
   return y; // expected-warning {{use of uninitialized variable}}
 }
 
-int f5() {
+void f5() {
   int a;
   a = 30; // no-warning
 }
diff --git a/test/Analysis/unions-region.m b/test/Analysis/unions-region.m
new file mode 100644
index 000000000000..be4f1852bf02
--- /dev/null
+++ b/test/Analysis/unions-region.m
@@ -0,0 +1,41 @@
+// RUN: clang-cc -analyze -checker-cfref -analyzer-store=region -analyzer-constraints=range %s -verify
+
+//===-- unions-region.m ---------------------------------------------------===//
+//
+// This file tests the analyzer's reasoning about unions.
+//
+//===----------------------------------------------------------------------===//
+
+// [testA] When using RegionStore, this test case previously had a
+// false positive of a 'pass-by-value argument is uninitialized'
+// warning at the call to 'testA_aux' and 'testA_aux_2'.
+union u_testA {
+  unsigned i;
+  float f;
+};
+ 
+float testA(float f) {
+  int testA_aux(unsigned x);
+  int testA_aux_2(union u_testA z);
+  
+  union u_testA swap;
+  swap.f = f;
+
+  if (testA_aux(swap.i))  // no-warning
+    swap.i = ((swap.i & 0xffff0000) >> 16) | ((swap.i & 0x0000fffff) << 16);
+
+  testA_aux_2(swap); // no-warning
+
+  return swap.f;  
+}
+
+// [testB] When using RegionStore, this test case previously had a
+// false positive of a 'pass-by-value argument is uninitialized'
+// warning at the call to 'testB_aux'.
+void testB(int i) {
+  void testB_aux(short z);
+  union { short x[2]; unsigned y; } val;  
+  val.y = 10;
+  testB_aux(val.x[1]); // no-warning
+}
+
diff --git a/test/Analysis/unused-ivars.m b/test/Analysis/unused-ivars.m
index 632b395c3e08..aacd44e7e677 100644
--- a/test/Analysis/unused-ivars.m
+++ b/test/Analysis/unused-ivars.m
@@ -1,10 +1,45 @@
-// RUN: clang-cc -analyze -warn-objc-unused-ivars %s -verify
+// RUN: clang-cc -triple x86_64-apple-darwin10 -analyze -warn-objc-unused-ivars %s -verify
 
-@interface A
-{
-  @private int x; // expected-warning {{Instance variable 'x' in class 'A' is never used}}
+//===--- BEGIN: Delta-debugging reduced headers. --------------------------===//
+
+@protocol NSObject
+- (id)retain;
+- (oneway void)release;
+@end
+@interface NSObject <NSObject> {}
+- (id)init;
++ (id)alloc;
+@end
+
+//===--- END: Delta-debugging reduced headers. ----------------------------===//
+
+// This test case tests the basic functionality of the unused ivar test.
+@interface TestA {
+@private
+  int x; // expected-warning {{Instance variable 'x' in class 'TestA' is never used}}
 }
 @end
+@implementation TestA @end
 
-@implementation A @end
+// This test case tests whether the unused ivar check handles blocks that
+// reference an instance variable. (<rdar://problem/7075531>)
+@interface TestB : NSObject {
+@private
+  id _ivar; // no-warning
+}
+@property (readwrite,retain) id ivar;
+@end
+
+@implementation TestB
+- (id)ivar {
+  __attribute__((__blocks__(byref))) id value = ((void*)0);
+  void (^b)() = ^{ value = _ivar; };
+  b();
+  return value;
+}
 
+- (void)setIvar:(id)newValue {
+  void (^b)() = ^{ [_ivar release]; _ivar = [newValue retain]; };
+  b();
+}
+@end
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index d5e23278729b..2a7f132fb5df 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,5 +1,6 @@
 set(CLANG_TEST_DIRECTORIES
   "Analysis"
+  "CodeCompletion"
   "CodeGen"
   "CodeGenCXX"
   "CodeGenObjC"
@@ -24,37 +25,59 @@ set(CLANG_TEST_DIRECTORIES
 include(FindPythonInterp)
 if(PYTHONINTERP_FOUND)
   get_target_property(LLVM_TOOLS_PATH clang RUNTIME_OUTPUT_DIRECTORY)
-  set(TESTING_EXTRA_PATHS
-      "${LLVM_TOOLS_PATH}/${CMAKE_CFG_INTDIR}:${LLVM_SOURCE_DIR}/test/Scripts")
+  get_target_property(LLVM_LIBS_PATH clang LIBRARY_OUTPUT_DIRECTORY)
   set(CLANG_TEST_EXTRA_ARGS)
   if (MSVC OR XCODE)
     set(CLANG_TEST_EXTRA_ARGS "--no-progress-bar")
   endif()
-  set(all_testdirs)
- foreach(testdir ${CLANG_TEST_DIRECTORIES})
-   add_custom_target(clang-test-${testdir} 
-      ${PYTHON_EXECUTABLE} 
-      ${LLVM_SOURCE_DIR}/tools/clang/utils/test/MultiTestRunner.py
-     "--path=${TESTING_EXTRA_PATHS}"
-      -s ${CLANG_TEST_EXTRA_ARGS}
-      --clang=${LLVM_TOOLS_PATH}/${CMAKE_CFG_INTDIR}/clang
-      --clang-cc=${LLVM_TOOLS_PATH}/${CMAKE_CFG_INTDIR}/clang-cc
-     ${CMAKE_CURRENT_SOURCE_DIR}/${testdir}/
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-      COMMENT "Running Clang regression tests in ${testdir}")
 
-    list(APPEND all_testdirs ${CMAKE_CURRENT_SOURCE_DIR}/${testdir}/)
+  foreach(testdir ${CLANG_TEST_DIRECTORIES})
+    add_custom_target(clang-test-${testdir} 
+      COMMAND sed -e "s#\@LLVM_SOURCE_DIR\@#${LLVM_MAIN_SRC_DIR}#"
+                  -e "s#\@LLVM_BINARY_DIR\@#${LLVM_BINARY_DIR}#"
+                  -e "s#\@LLVM_TOOLS_DIR\@#${LLVM_TOOLS_PATH}/${CMAKE_CFG_INTDIR}#"
+                  -e "s#\@LLVM_LIBS_DIR\@#${LLVM_LIBS_PATH}/${CMAKE_CFG_INTDIR}#"
+                  -e "s#\@CLANG_SOURCE_DIR\@#${CMAKE_CURRENT_SOURCE_DIR}/..#"
+                  -e "s#\@CLANG_BINARY_DIR\@#${CMAKE_CURRENT_BINARY_DIR}/..#"
+                  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in >
+                  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+      COMMAND ${PYTHON_EXECUTABLE} 
+                  ${LLVM_SOURCE_DIR}/utils/lit/lit.py
+                  -sv ${CLANG_TEST_EXTRA_ARGS}
+                  ${CMAKE_CURRENT_BINARY_DIR}/${testdir}
+                  DEPENDS clang clang-cc index-test
+                  COMMENT "Running Clang regression tests in ${testdir}")
   endforeach()
 
   add_custom_target(clang-test
-    ${PYTHON_EXECUTABLE} 
-    ${LLVM_SOURCE_DIR}/tools/clang/utils/test/MultiTestRunner.py
-    "--path=${TESTING_EXTRA_PATHS}"
-    -s ${CLANG_TEST_EXTRA_ARGS}
-    --clang=${LLVM_TOOLS_PATH}/${CMAKE_CFG_INTDIR}/clang
-    --clang-cc=${LLVM_TOOLS_PATH}/${CMAKE_CFG_INTDIR}/clang-cc
-    ${all_testdirs}
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    DEPENDS clang clang-cc index-test
-    COMMENT "Running Clang regression tests")
+    COMMAND sed -e "s#\@LLVM_SOURCE_DIR\@#${LLVM_MAIN_SRC_DIR}#"
+                -e "s#\@LLVM_BINARY_DIR\@#${LLVM_BINARY_DIR}#"
+                -e "s#\@LLVM_TOOLS_DIR\@#${LLVM_TOOLS_PATH}/${CMAKE_CFG_INTDIR}#"
+                -e "s#\@LLVM_LIBS_DIR\@#${LLVM_LIBS_PATH}/${CMAKE_CFG_INTDIR}#"
+                -e "s#\@CLANG_SOURCE_DIR\@#${CMAKE_CURRENT_SOURCE_DIR}/..#"
+                -e "s#\@CLANG_BINARY_DIR\@#${CMAKE_CURRENT_BINARY_DIR}/..#"
+                ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in >
+                ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+    COMMAND ${PYTHON_EXECUTABLE} 
+                ${LLVM_SOURCE_DIR}/utils/lit/lit.py
+                -sv ${CLANG_TEST_EXTRA_ARGS}
+                ${CMAKE_CURRENT_BINARY_DIR}
+                DEPENDS clang clang-cc index-test
+                COMMENT "Running Clang regression tests")
+
+  add_custom_target(clang-c++tests
+    COMMAND sed -e "s#\@LLVM_SOURCE_DIR\@#${LLVM_MAIN_SRC_DIR}#"
+                -e "s#\@LLVM_BINARY_DIR\@#${LLVM_BINARY_DIR}#"
+                -e "s#\@LLVM_TOOLS_DIR\@#${LLVM_TOOLS_PATH}/${CMAKE_CFG_INTDIR}#"
+                -e "s#\@LLVM_LIBS_DIR\@#${LLVM_LIBS_PATH}/${CMAKE_CFG_INTDIR}#"
+                -e "s#\@CLANG_SOURCE_DIR\@#${CMAKE_CURRENT_SOURCE_DIR}/..#"
+                -e "s#\@CLANG_BINARY_DIR\@#${CMAKE_CURRENT_BINARY_DIR}/..#"
+                ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in >
+                ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+    COMMAND ${PYTHON_EXECUTABLE} 
+                ${LLVM_SOURCE_DIR}/utils/lit/lit.py
+                -sv ${CLANG_TEST_EXTRA_ARGS}
+                ${CMAKE_CURRENT_SOURCE_DIR}/../utils/C++Tests
+                DEPENDS clang clang-cc index-test
+                COMMENT "Running Clang regression tests")
 endif()  
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2-template-id.cpp b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2-template-id.cpp
new file mode 100644
index 000000000000..e2c76f918336
--- /dev/null
+++ b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2-template-id.cpp
@@ -0,0 +1,27 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+namespace N1 {
+  struct X { };
+  int& f(void*);
+}
+
+namespace N2 {
+  template<typename T> struct Y { };
+}
+
+namespace N3 {
+  void test() {
+    int &ir = f((N2::Y<N1::X>*)0);
+  }
+}
+
+int g(void *);
+long g(N1::X);
+
+namespace N1 {
+  void h(int (*)(void *));
+}
+
+void test() {
+  h((&g));
+}
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2.cpp b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2.cpp
new file mode 100644
index 000000000000..677df8284a72
--- /dev/null
+++ b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2.cpp
@@ -0,0 +1,73 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+namespace N {
+  struct X { };
+  
+  X operator+(X, X);
+
+  void f(X);
+  void g(X); // expected-note{{candidate function}}
+
+  void test_multiadd(X x) {
+    (void)(x + x);
+  }
+}
+
+namespace M {
+  struct Y : N::X { };
+}
+
+void f();
+
+void test_operator_adl(N::X x, M::Y y) {
+  (void)(x + x);
+  (void)(y + y);
+}
+
+void test_func_adl(N::X x, M::Y y) {
+  f(x);
+  f(y);
+  (f)(x); // expected-error{{too many arguments to function call}}
+  ::f(x); // expected-error{{too many arguments to function call}}
+}
+
+namespace N {
+  void test_multiadd2(X x) {
+    (void)(x + x);
+  }
+}
+
+
+void test_func_adl_only(N::X x) {
+  g(x);
+}
+
+namespace M {
+  int g(N::X); // expected-note{{candidate function}}
+
+  void test(N::X x) {
+    g(x); // expected-error{{call to 'g' is ambiguous; candidates are:}}
+    int i = (g)(x);
+
+    int g(N::X);
+    g(x); // okay; calls locally-declared function, no ADL
+  }
+}
+
+
+void test_operator_name_adl(N::X x) {
+  (void)operator+(x, x);
+}
+
+struct Z { };
+int& f(Z);
+
+namespace O {
+  char &f();
+  void test_global_scope_adl(Z z) {
+    {
+      int& ir = f(z);
+    }
+  }
+}
+
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp
new file mode 100644
index 000000000000..8f0bed8789fe
--- /dev/null
+++ b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp
@@ -0,0 +1,42 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+namespace A {
+  class A {
+    friend void func(A);
+    friend A operator+(A,A);
+  };
+}
+
+namespace B {
+  class B {
+    static void func(B);
+  };
+  B operator+(B,B);
+}
+
+namespace D {
+  class D {};
+}
+
+namespace C {
+  class C {};
+  void func(C);
+  C operator+(C,C);
+  D::D operator+(D::D,D::D);
+}
+
+namespace D {
+  using namespace C;
+}
+
+namespace Test {
+  void test() {
+    func(A::A());
+    func(B::B()); // expected-error {{ no matching function for call to 'func' }}
+    func(C::C());
+    A::A() + A::A();
+    B::B() + B::B();
+    C::C() + C::C();
+    D::D() + D::D(); // expected-error {{ invalid operands to binary expression ('D::D' and 'D::D') }}
+  }
+}
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.elab/templateid.cpp b/test/CXX/basic/basic.lookup/basic.lookup.elab/templateid.cpp
new file mode 100644
index 000000000000..cb9d942ba6f6
--- /dev/null
+++ b/test/CXX/basic/basic.lookup/basic.lookup.elab/templateid.cpp
@@ -0,0 +1,18 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// elaborated-type-specifier:
+//   class-key '::'? nested-name-specifier? 'template'? simple-template-id
+// Tests that this form is accepted by the compiler but does not follow
+// the elaborated lookup rules of [basic.lookup.elab].
+
+template <typename> class Ident {}; // expected-note {{previous use is here}}
+
+namespace A {
+  template <typename> void Ident();
+
+  class Ident<int> AIdent; // expected-error {{refers to a function template}}
+  class ::Ident<int> AnotherIdent;
+}
+
+class Ident<int> GlobalIdent;
+union Ident<int> GlobalIdent; // expected-error {{ tag type that does not match }}
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp
new file mode 100644
index 000000000000..b32948b4a608
--- /dev/null
+++ b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp
@@ -0,0 +1,65 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+namespace Ints {
+  int zero = 0; // expected-note {{candidate found by name lookup is 'Ints::zero'}}
+  void f(int); // expected-note 3 {{candidate function}}
+  void g(int);
+}
+
+namespace Floats {
+  float zero = 0.0f; // expected-note {{candidate found by name lookup is 'Floats::zero'}}
+  void f(float); // expected-note 3 {{candidate function}}
+  void g(float);
+}
+
+namespace Numbers {
+  using namespace Ints;
+  using namespace Floats;
+}
+
+void test() {
+  int i = Ints::zero;
+  Ints::f(i);
+  
+  float f = Floats::zero;
+  Floats::f(f);
+  
+  double n = Numbers::zero; // expected-error {{reference to 'zero' is ambiguous}}
+  Numbers::f(n); // expected-error{{call to 'f' is ambiguous}}
+  Numbers::f(i);
+  Numbers::f(f);
+}
+
+namespace Numbers {
+  struct Number {
+    explicit Number(double d) : d(d) {}
+    double d;
+  };
+  Number zero(0.0f);
+  void g(Number);
+}
+
+void test2() {
+  Numbers::Number n = Numbers::zero;
+  Numbers::f(n); // expected-error {{no matching function for call to 'f'}}
+  Numbers::g(n);
+}
+
+namespace Numbers2 {
+  using Numbers::f;
+  using Numbers::g;
+}
+
+void test3() {
+  Numbers::Number n = Numbers::zero;
+  Numbers2::f(n); // expected-error {{no matching function for call to 'f'}}
+  Numbers2::g(n);
+
+  int i = Ints::zero;
+  Numbers2::f(i);
+  Numbers2::g(i); // expected-error {{incompatible type passing 'int'}}
+
+  float f = Floats::zero;
+  Numbers2::f(f);
+  Numbers2::g(f); // expected-error {{incompatible type passing 'float'}}
+}
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p3.cpp b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p3.cpp
new file mode 100644
index 000000000000..7a51a7bb1df0
--- /dev/null
+++ b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p3.cpp
@@ -0,0 +1,41 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// This is basically paraphrased from the standard.
+
+namespace Root {
+  int i = 0;
+  void f();
+}
+
+namespace A {
+  using namespace Root;
+}
+
+namespace B {
+  using namespace Root;
+}
+
+namespace AB {
+  using namespace A;
+  using namespace B;
+}
+
+void test() {
+  if (AB::i)
+    AB::f();
+}
+
+namespace C {
+  using Root::i;
+  using Root::f;
+}
+
+namespace AC {
+  using namespace A;
+  using namespace C;
+}
+
+void test2() {
+  if (AC::i)
+    AC::f();
+}
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p4.cpp b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p4.cpp
new file mode 100644
index 000000000000..2c0ce80d8ce6
--- /dev/null
+++ b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p4.cpp
@@ -0,0 +1,25 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+namespace A {
+  int a;
+}
+
+namespace C {
+  int c;
+}
+
+namespace B {
+  using namespace C;
+  int b;
+}
+
+namespace C {
+  using namespace B;
+  using namespace A;
+}
+
+void test() {
+  C::a++;
+  C::b++;
+  C::c++;
+}
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p5.cpp b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p5.cpp
new file mode 100644
index 000000000000..78af521c9103
--- /dev/null
+++ b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p5.cpp
@@ -0,0 +1,35 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+namespace A {
+  struct x {}; // expected-note {{candidate found by name lookup is 'A::x'}}
+  int x; // expected-note {{candidate found by name lookup is 'A::x'}}
+
+  struct y {}; // expected-note {{type declaration hidden}}
+
+  struct z;
+  void z(float);
+}
+
+namespace B {
+  struct x {}; // expected-note {{candidate found by name lookup is 'B::x'}}
+  float x; // expected-note {{candidate found by name lookup is 'B::x'}}
+
+  float y; // expected-note {{declaration hides type}}
+
+  void z(int);
+}
+
+namespace AB {
+  using namespace A;
+  using namespace B;
+}
+
+void test() {
+  struct AB::x foo; // expected-error {{reference to 'x' is ambiguous}}
+  int i = AB::x; // expected-error {{reference to 'x' is ambiguous}}
+
+  struct AB::y bar;
+  float f = AB::y; // expected-error {{a type named 'y' is hidden by a declaration in a different namespace}}
+  AB::z(i);
+  AB::z(f);
+}
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.unqual/p3.cpp b/test/CXX/basic/basic.lookup/basic.lookup.unqual/p3.cpp
index 1daf0ddec6c0..7fd1b53c2cb0 100644
--- a/test/CXX/basic/basic.lookup/basic.lookup.unqual/p3.cpp
+++ b/test/CXX/basic/basic.lookup/basic.lookup.unqual/p3.cpp
@@ -1,9 +1,7 @@
 // RUN: clang-cc -fsyntax-only -verify %s
-// XFAIL
 
-// FIXME: This part is here to demonstrate the failure in looking up 'f', it can
-// be removed once the whole test passes.
 typedef int f; 
+
 namespace N0 {
   struct A { 
     friend void f(); 
diff --git a/test/CXX/basic/basic.start/basic.start.main/p2a.cpp b/test/CXX/basic/basic.start/basic.start.main/p2a.cpp
new file mode 100644
index 000000000000..a6a758798949
--- /dev/null
+++ b/test/CXX/basic/basic.start/basic.start.main/p2a.cpp
@@ -0,0 +1,8 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+typedef int Int;
+typedef char Char;
+typedef Char* Carp;
+
+Int main(Int argc, Carp argv[]) {
+}
diff --git a/test/CXX/basic/basic.start/basic.start.main/p2b.cpp b/test/CXX/basic/basic.start/basic.start.main/p2b.cpp
new file mode 100644
index 000000000000..caecf6060881
--- /dev/null
+++ b/test/CXX/basic/basic.start/basic.start.main/p2b.cpp
@@ -0,0 +1,8 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+typedef int Int;
+typedef char Char;
+typedef Char* Carp;
+
+Int main(Int argc, Carp argv[], Char *env[]) {
+}
diff --git a/test/CXX/basic/basic.start/basic.start.main/p2c.cpp b/test/CXX/basic/basic.start/basic.start.main/p2c.cpp
new file mode 100644
index 000000000000..8587d8cec791
--- /dev/null
+++ b/test/CXX/basic/basic.start/basic.start.main/p2c.cpp
@@ -0,0 +1,4 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+int main() {
+}
diff --git a/test/CXX/basic/basic.start/basic.start.main/p2d.cpp b/test/CXX/basic/basic.start/basic.start.main/p2d.cpp
new file mode 100644
index 000000000000..777b5ceb743a
--- /dev/null
+++ b/test/CXX/basic/basic.start/basic.start.main/p2d.cpp
@@ -0,0 +1,4 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+static int main() { // expected-error {{'main' is not allowed to be declared static}}
+}
diff --git a/test/CXX/basic/basic.start/basic.start.main/p2e.cpp b/test/CXX/basic/basic.start/basic.start.main/p2e.cpp
new file mode 100644
index 000000000000..087cf77476ad
--- /dev/null
+++ b/test/CXX/basic/basic.start/basic.start.main/p2e.cpp
@@ -0,0 +1,4 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+inline int main() { // expected-error {{'main' is not allowed to be declared inline}}
+}
diff --git a/test/CXX/basic/basic.start/basic.start.main/p2f.cpp b/test/CXX/basic/basic.start/basic.start.main/p2f.cpp
new file mode 100644
index 000000000000..b7845b13e9a4
--- /dev/null
+++ b/test/CXX/basic/basic.start/basic.start.main/p2f.cpp
@@ -0,0 +1,7 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+void  // expected-error {{error: 'main' must return 'int'}}
+main( // expected-error {{error: first argument of 'main' should be of type 'int'}}
+     float a
+) {
+}
diff --git a/test/CXX/basic/basic.start/basic.start.main/p2g.cpp b/test/CXX/basic/basic.start/basic.start.main/p2g.cpp
new file mode 100644
index 000000000000..4cedcdb91657
--- /dev/null
+++ b/test/CXX/basic/basic.start/basic.start.main/p2g.cpp
@@ -0,0 +1,4 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+int main(int argc, const char* const* argv) {
+}
diff --git a/test/CXX/basic/basic.stc/basic.stc.dynamic/p2-nodef.cpp b/test/CXX/basic/basic.stc/basic.stc.dynamic/p2-nodef.cpp
new file mode 100644
index 000000000000..ff653d5fef08
--- /dev/null
+++ b/test/CXX/basic/basic.stc/basic.stc.dynamic/p2-nodef.cpp
@@ -0,0 +1,7 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+int *use_new(int N) {
+  return new int [N];
+}
+
+int std = 17;
diff --git a/test/CXX/basic/basic.stc/basic.stc.dynamic/p2.cpp b/test/CXX/basic/basic.stc/basic.stc.dynamic/p2.cpp
new file mode 100644
index 000000000000..f3499e4286bc
--- /dev/null
+++ b/test/CXX/basic/basic.stc/basic.stc.dynamic/p2.cpp
@@ -0,0 +1,25 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+int *use_new(int N) {
+  if (N == 1)
+    return new int;
+  
+  return new int [N];
+}
+
+void use_delete(int* ip, int N) {
+  if (N == 1)
+    delete ip;
+  else
+    delete [] ip;
+}
+
+namespace std {
+  class bad_alloc { };
+  
+  typedef __SIZE_TYPE__ size_t;
+}
+
+void* operator new(std::size_t) throw(std::bad_alloc); 
+void* operator new[](std::size_t) throw(std::bad_alloc); 
+void operator delete(void*) throw(); 
+void operator delete[](void*) throw();
diff --git a/test/CXX/class.derived/class.virtual/p12.cpp b/test/CXX/class.derived/class.virtual/p12.cpp
new file mode 100644
index 000000000000..b5974a021180
--- /dev/null
+++ b/test/CXX/class.derived/class.virtual/p12.cpp
@@ -0,0 +1,19 @@
+// RUN: clang-cc -ast-print %s | FileCheck %s
+
+// CHECK: test12_A::foo()
+struct test12_A {
+  virtual void foo();
+  
+  void bar() {
+    test12_A::foo();
+  }
+};
+
+// CHECK: xp->test24_B::wibble()
+struct test24_B {
+  virtual void wibble();
+};
+
+void foo(test24_B *xp) {
+  xp->test24_B::wibble();
+}
diff --git a/test/CXX/class/class.friend/p1-ambiguous.cpp b/test/CXX/class/class.friend/p1-ambiguous.cpp
new file mode 100644
index 000000000000..a02bc5337522
--- /dev/null
+++ b/test/CXX/class/class.friend/p1-ambiguous.cpp
@@ -0,0 +1,37 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// Make sure that friend declarations don't introduce ambiguous
+// declarations.
+
+// Test case courtesy of Shantonu Sen.
+// Bug 4784.
+
+class foo;
+
+extern "C" {
+  int c_func(foo *a);
+};
+int cpp_func(foo *a);
+
+class foo {
+public:
+  friend int c_func(foo *a);
+  friend int cpp_func(foo *a);
+  int caller();
+private:
+  int x;
+};
+
+int c_func(foo *a) {
+  return a->x;
+}
+
+int cpp_func(foo *a) {
+  return a->x;
+}
+
+int foo::caller() {
+    c_func(this);
+    cpp_func(this);
+    return 0;
+}
diff --git a/test/CXX/class/class.friend/p1.cpp b/test/CXX/class/class.friend/p1.cpp
new file mode 100644
index 000000000000..7065a7e917fd
--- /dev/null
+++ b/test/CXX/class/class.friend/p1.cpp
@@ -0,0 +1,76 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+struct Outer {
+  struct Inner {
+    int intfield;
+  };
+};
+
+struct Base {
+  void base_member();
+  
+  typedef int Int;
+  Int typedeffed_member();
+};
+
+struct Derived : public Base {
+};
+
+int myglobal;
+
+void global_function();
+extern "C" {
+  void global_c_function();
+}
+
+class A {
+  class AInner {
+  };
+
+  friend class PreDeclared;
+  friend class Outer::Inner;
+  friend int Outer::Inner::intfield; // expected-error {{ friends can only be classes or functions }}
+  friend int Outer::Inner::missing_field; //expected-error {{ friends can only be classes or functions }}
+  friend int myoperation(float); // okay
+  friend int myglobal;   // expected-error {{ friends can only be classes or functions }}
+
+  friend void global_function();
+  friend void global_c_function();
+
+  friend class UndeclaredSoFar;
+  UndeclaredSoFar x; // expected-error {{ unknown type name 'UndeclaredSoFar' }}
+
+  void a_member();
+  friend void A::a_member(); // expected-error {{ friends cannot be members of the declaring class }}
+  friend void a_member(); // okay (because we ignore class scopes when looking up friends)
+  friend class A::AInner; // this is okay as an extension
+  friend class AInner; // okay, refers to ::AInner
+
+  friend void Derived::missing_member(); // expected-error {{ no function named 'missing_member' with type 'void ()' was found in the specified scope }}
+
+  friend void Derived::base_member(); // expected-error {{ no function named 'base_member' with type 'void ()' was found in the specified scope }}
+
+  friend int Base::typedeffed_member(); // okay: should look through typedef
+
+  // These test that the friend is properly not being treated as a
+  // member function.
+  friend A operator|(const A& l, const A& r); // okay
+  friend A operator|(const A& r); // expected-error {{ overloaded 'operator|' must be a binary operator (has 1 parameter) }}
+
+  friend operator bool() const; // expected-error {{ must use a qualified name when declaring a conversion operator as a friend }}
+
+  typedef void ftypedef();
+  friend ftypedef typedeffed_function; // okay (because it's not declared as a member)
+
+  class facet;
+  friend class facet;  // should not assert
+  class facet {};
+};
+
+A::UndeclaredSoFar y; // expected-error {{no type named 'UndeclaredSoFar' in 'class A'}}
+
+class PreDeclared;
+
+int myoperation(float f) {
+  return (int) f;
+}
diff --git a/test/CXX/class/class.friend/p2.cpp b/test/CXX/class/class.friend/p2.cpp
new file mode 100644
index 000000000000..98be2049e756
--- /dev/null
+++ b/test/CXX/class/class.friend/p2.cpp
@@ -0,0 +1,10 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+struct B0;
+
+class A {
+  friend class B {}; // expected-error {{cannot define a type in a friend declaration}}
+  friend int; // expected-error {{friends can only be classes or functions}}
+  friend B0; // expected-error {{must specify 'struct' to befriend}}
+  friend class C; // okay
+};
diff --git a/test/CXX/class/class.friend/p6.cpp b/test/CXX/class/class.friend/p6.cpp
new file mode 100644
index 000000000000..2e8153c6c047
--- /dev/null
+++ b/test/CXX/class/class.friend/p6.cpp
@@ -0,0 +1,10 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+class A {
+  friend static class B; // expected-error {{'static' is invalid in friend declarations}}
+  friend extern class C; // expected-error {{'extern' is invalid in friend declarations}}
+  friend auto class D; // expected-error {{'auto' is invalid in friend declarations}}
+  friend register class E; // expected-error {{'register' is invalid in friend declarations}}
+  friend mutable class F; // expected-error {{'mutable' is invalid in friend declarations}}
+  friend typedef class G; // expected-error {{'typedef' is invalid in friend declarations}}
+};
diff --git a/test/CXX/class/class.local/p3.cpp b/test/CXX/class/class.local/p3.cpp
index d888a6d93633..9c625d18c95c 100644
--- a/test/CXX/class/class.local/p3.cpp
+++ b/test/CXX/class/class.local/p3.cpp
@@ -27,4 +27,4 @@ void f3(int a) { // expected-note{{'a' declared here}}
       int f() { return a; } // expected-error{{reference to local variable 'a' declared in enclosed function 'f3'}}
     };
   };
-}
\ No newline at end of file
+}
diff --git a/test/CXX/class/class.local/p4.cpp b/test/CXX/class/class.local/p4.cpp
index 40702ad96899..f2432ec97393 100644
--- a/test/CXX/class/class.local/p4.cpp
+++ b/test/CXX/class/class.local/p4.cpp
@@ -7,4 +7,4 @@ void f() {
     
     static void f() { }
   };
-}
\ No newline at end of file
+}
diff --git a/test/CXX/class/class.nest/p1.cpp b/test/CXX/class/class.nest/p1.cpp
new file mode 100644
index 000000000000..bbc49f9e95e7
--- /dev/null
+++ b/test/CXX/class/class.nest/p1.cpp
@@ -0,0 +1,14 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+class Outer {
+  int x;
+  static int sx;
+
+  // C++0x will likely relax this rule in this specific case, but
+  // we'll still need to enforce it in C++03 mode.  See N2253 (or
+  // successor).
+  class Inner {
+    static char a[sizeof(x)]; // expected-error {{ invalid use of nonstatic data member 'x' }}
+    static char b[sizeof(sx)]; // okay
+  };
+};
diff --git a/test/CXX/class/class.nested.type/p1.cpp b/test/CXX/class/class.nested.type/p1.cpp
index 33bf4b4473e5..61ccd281ca93 100644
--- a/test/CXX/class/class.nested.type/p1.cpp
+++ b/test/CXX/class/class.nested.type/p1.cpp
@@ -1,3 +1,5 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
 class X {
 public:
   typedef int I;
@@ -8,4 +10,4 @@ public:
 I b; // expected-error{{unknown type name 'I'}}
 Y c; // expected-error{{unknown type name 'Y'}}
 X::Y d;
-X::I e;
\ No newline at end of file
+X::I e;
diff --git a/test/CXX/class/class.union/p1.cpp b/test/CXX/class/class.union/p1.cpp
new file mode 100644
index 000000000000..15c263467367
--- /dev/null
+++ b/test/CXX/class/class.union/p1.cpp
@@ -0,0 +1,105 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+void abort() __attribute__((noreturn));
+
+class Okay {
+  int a_;
+};
+
+class Virtual {
+  virtual void foo() { abort(); } // expected-note 3 {{because type 'class Virtual' has a virtual member function}}
+};
+
+class VirtualBase : virtual Okay { // expected-note 3 {{because type 'class VirtualBase' has a virtual base class}}
+};
+
+class Ctor {
+  Ctor() { abort(); } // expected-note 3 {{because type 'class Ctor' has a user-declared constructor}}
+};
+
+class CopyCtor {
+  CopyCtor(CopyCtor &cc) { abort(); } // expected-note 3 {{because type 'class CopyCtor' has a user-declared copy constructor}}
+};
+
+// FIXME: this should eventually trigger on the operator's declaration line
+class CopyAssign { // expected-note 3 {{because type 'class CopyAssign' has a user-declared copy assignment operator}}
+  CopyAssign& operator=(CopyAssign& CA) { abort(); }
+};
+
+class Dtor {
+  ~Dtor() { abort(); } // expected-note 3 {{because type 'class Dtor' has a user-declared destructor}}
+};
+
+union U1 {
+  Virtual v; // expected-error {{union member 'v' has a non-trivial copy constructor}}
+  VirtualBase vbase; // expected-error {{union member 'vbase' has a non-trivial copy constructor}}
+  Ctor ctor; // expected-error {{union member 'ctor' has a non-trivial constructor}}
+  CopyCtor copyctor; // expected-error {{union member 'copyctor' has a non-trivial copy constructor}}
+  CopyAssign copyassign; // expected-error {{union member 'copyassign' has a non-trivial copy assignment operator}}
+  Dtor dtor; // expected-error {{union member 'dtor' has a non-trivial destructor}}
+  Okay okay;
+};
+
+union U2 {
+  struct {
+    Virtual v; // expected-note {{because type 'struct U2::<anonymous>' has a member with a non-trivial copy constructor}}
+  } m1; // expected-error {{union member 'm1' has a non-trivial copy constructor}}
+  struct {
+    VirtualBase vbase; // expected-note {{because type 'struct U2::<anonymous>' has a member with a non-trivial copy constructor}}
+  } m2; // expected-error {{union member 'm2' has a non-trivial copy constructor}}
+  struct {
+    Ctor ctor; // expected-note {{because type 'struct U2::<anonymous>' has a member with a non-trivial constructor}}
+  } m3; // expected-error {{union member 'm3' has a non-trivial constructor}}
+  struct {
+    CopyCtor copyctor; // expected-note {{because type 'struct U2::<anonymous>' has a member with a non-trivial copy constructor}}
+  } m4; // expected-error {{union member 'm4' has a non-trivial copy constructor}}
+  struct {
+    CopyAssign copyassign; // expected-note {{because type 'struct U2::<anonymous>' has a member with a non-trivial copy assignment operator}}
+  } m5; // expected-error {{union member 'm5' has a non-trivial copy assignment operator}}
+  struct {
+    Dtor dtor; // expected-note {{because type 'struct U2::<anonymous>' has a member with a non-trivial destructor}}
+  } m6; // expected-error {{union member 'm6' has a non-trivial destructor}}
+  struct {
+    Okay okay;
+  } m7;
+};
+
+union U3 {
+  struct s1 : Virtual { // expected-note {{because type 'struct U3::s1' has a base class with a non-trivial copy constructor}}
+  } m1; // expected-error {{union member 'm1' has a non-trivial copy constructor}}
+  struct s2 : VirtualBase { // expected-note {{because type 'struct U3::s2' has a base class with a non-trivial copy constructor}}
+  } m2; // expected-error {{union member 'm2' has a non-trivial copy constructor}}
+  struct s3 : Ctor { // expected-note {{because type 'struct U3::s3' has a base class with a non-trivial constructor}}
+  } m3; // expected-error {{union member 'm3' has a non-trivial constructor}}
+  struct s4 : CopyCtor { // expected-note {{because type 'struct U3::s4' has a base class with a non-trivial copy constructor}}
+  } m4; // expected-error {{union member 'm4' has a non-trivial copy constructor}}
+  struct s5 : CopyAssign { // expected-note {{because type 'struct U3::s5' has a base class with a non-trivial copy assignment operator}}
+  } m5; // expected-error {{union member 'm5' has a non-trivial copy assignment operator}}
+  struct s6 : Dtor { // expected-note {{because type 'struct U3::s6' has a base class with a non-trivial destructor}}
+  } m6; // expected-error {{union member 'm6' has a non-trivial destructor}}
+  struct s7 : Okay {
+  } m7;
+};
+
+template <class A, class B> struct Either {
+  bool tag;
+  union {
+    A a;
+    B b;
+  };
+
+  Either(A& a) : tag(true), a(a) {}
+  Either(B& b) : tag(false), b(b) {}
+};
+
+/* FIXME: this should work, but crashes in template code.
+void fred() {
+  Either<int,Virtual> virt(0);
+  Either<int,VirtualBase> vbase(0);
+  Either<int,Ctor> ctor(0);
+  Either<int,CopyCtor> copyctor(0);
+  Either<int,CopyAssign> copyassign(0);
+  Either<int,Dtor> dtor(0);
+  Either<int,Okay> okay(0);
+}
+ */
diff --git a/test/CXX/dcl.dcl/basic.namespace/namespace.def/namespace.memdef/p3.cpp b/test/CXX/dcl.dcl/basic.namespace/namespace.def/namespace.memdef/p3.cpp
new file mode 100644
index 000000000000..2ca7165aad48
--- /dev/null
+++ b/test/CXX/dcl.dcl/basic.namespace/namespace.def/namespace.memdef/p3.cpp
@@ -0,0 +1,15 @@
+// RUN: clang-cc -fsyntax-only %s
+
+template<typename T> struct X0 { };
+struct X1 { };
+
+struct Y {
+  template<typename T> union X0;
+  template<typename T> friend union X0;
+  
+  union X1;
+  friend union X1;
+};
+
+
+// FIXME: Woefully inadequate for testing
diff --git a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p3-cxx0x.cpp b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p3-cxx0x.cpp
new file mode 100644
index 000000000000..d701f885fba1
--- /dev/null
+++ b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p3-cxx0x.cpp
@@ -0,0 +1,20 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+// C++0x N2914.
+
+struct B {
+  void f(char);
+  void g(char);
+  enum E { e };
+  union { int x; };
+};
+
+class C {
+  int g();
+};
+
+class D2 : public B {
+  using B::f;
+  using B::e;
+  using B::x;
+  using C::g; // expected-error{{using declaration refers into 'C::', which is not a base class of 'D2'}}
+};
diff --git a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p5-cxx0x.cpp b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p5-cxx0x.cpp
new file mode 100644
index 000000000000..63e5c3cd27b0
--- /dev/null
+++ b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p5-cxx0x.cpp
@@ -0,0 +1,12 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+// C++0x N2914.
+
+struct A {
+  template<class T> void f(T);
+  template<class T> struct X { };
+};
+
+struct B : A {
+  using A::f<double>; // expected-error{{using declaration can not refer to template specialization}}
+  using A::X<int>; // expected-error{{using declaration can not refer to template specialization}}
+};
\ No newline at end of file
diff --git a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p6-cxx0x.cpp b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p6-cxx0x.cpp
new file mode 100644
index 000000000000..f86f8fb57907
--- /dev/null
+++ b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p6-cxx0x.cpp
@@ -0,0 +1,8 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+// C++0x N2914.
+
+namespace A {
+  namespace B { }
+}
+
+using A::B; // expected-error{{using declaration can not refer to namespace}}
diff --git a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8-cxx0x.cpp b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8-cxx0x.cpp
new file mode 100644
index 000000000000..59137eb8c9d8
--- /dev/null
+++ b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8-cxx0x.cpp
@@ -0,0 +1,15 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+// C++0x N2914.
+
+struct X {
+  int i;
+  static int a;
+};
+
+using X::i; // expected-error{{using declaration can not refer to class member}}
+using X::s; // expected-error{{using declaration can not refer to class member}}
+
+void f() {
+  using X::i; // expected-error{{using declaration can not refer to class member}}
+  using X::s; // expected-error{{using declaration can not refer to class member}}
+}
diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p9.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p9.cpp
index 5d9f9e7a51c5..907a91a86ec4 100644
--- a/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p9.cpp
+++ b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p9.cpp
@@ -2,11 +2,11 @@
 
 struct S; // expected-note {{forward declaration of 'struct S'}}
 extern S a;
-extern S f();
+extern S f(); // expected-note {{'f' declared here}}
 extern void g(S a); // expected-note {{candidate function}}
 
 void h() {
   // FIXME: This diagnostic could be better.
   g(a); // expected-error {{no matching function for call to 'g'}}
-  f(); // expected-error {{return type of called function ('struct S') is incomplete}}
+  f(); // expected-error {{calling 'f' with incomplete return type 'struct S'}}
 }
diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p3.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p3.cpp
new file mode 100644
index 000000000000..6bdea20df6bd
--- /dev/null
+++ b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p3.cpp
@@ -0,0 +1,10 @@
+// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x
+void f() {
+  auto a = a; // expected-error{{variable 'a' declared with 'auto' type cannot appear in its own initializer}}
+}
+
+void g() {
+  auto a; // expected-error{{declaration of variable 'a' with type 'auto' requires an initializer}}
+  
+  auto *b; // expected-error{{declaration of variable 'b' with type 'auto *' requires an initializer}}
+}
diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p5.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p5.cpp
new file mode 100644
index 000000000000..fa3101c6736c
--- /dev/null
+++ b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p5.cpp
@@ -0,0 +1,13 @@
+// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x
+void f() {
+  auto a = a; // expected-error{{variable 'a' declared with 'auto' type cannot appear in its own initializer}}
+}
+
+struct S { auto a; }; // expected-error{{'auto' not allowed in struct member}}
+
+void f(auto a) // expected-error{{'auto' not allowed in function prototype}}
+{
+  try { } catch (auto a) {  } // expected-error{{'auto' not allowed in exception declaration}}
+}
+
+template <auto a = 10> class C { }; // expected-error{{'auto' not allowed in template parameter}}
diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp
new file mode 100644
index 000000000000..b9cdb52f11a1
--- /dev/null
+++ b/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/p3.cpp
@@ -0,0 +1,60 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+class A {}; // expected-note 3 {{previous use is here}}
+
+void a1(struct A);
+void a2(class A);
+void a3(union A); // expected-error {{use of 'A' with tag type that does not match previous declaration}}
+void a4(enum A); // expected-error {{use of 'A' with tag type that does not match previous declaration}}
+
+class A1 {
+  friend struct A;
+  friend class A;
+  friend union A; // expected-error {{use of 'A' with tag type that does not match previous declaration}}
+
+  friend enum A; // expected-error {{ISO C++ forbids forward references to 'enum' types}} \
+                 // expected-error {{enum types cannot be friends}}
+};
+
+template <class T> struct B { // expected-note {{previous use is here}}
+  class Member {}; // expected-note 2 {{previous use is here}}
+};
+
+template <> class B<int> {
+  // no type Member
+};
+
+template <> struct B<A> {
+  // FIXME: the error here should be associated with the use at "void foo..."
+  union Member { // expected-note 4 {{previous use is here}} expected-error {{tag type that does not match previous declaration}}
+    void* a;
+  };
+};
+
+void b1(struct B<float>);
+void b2(class B<float>);
+void b3(union B<float>); // expected-error {{use of 'B<float>' with tag type that does not match previous declaration}}
+//void b4(enum B<float>); // this just doesn't parse; you can't template an enum directly
+
+void c1(struct B<float>::Member);
+void c2(class B<float>::Member);
+void c3(union B<float>::Member); // expected-error {{use of 'Member' with tag type that does not match previous declaration}}
+void c4(enum B<float>::Member); // expected-error {{use of 'Member' with tag type that does not match previous declaration}}
+
+void d1(struct B<int>::Member); // expected-error {{'Member' does not name a tag member in the specified scope}}
+void d2(class B<int>::Member); // expected-error {{'Member' does not name a tag member in the specified scope}}
+void d3(union B<int>::Member); // expected-error {{'Member' does not name a tag member in the specified scope}}
+void d4(enum B<int>::Member); // expected-error {{'Member' does not name a tag member in the specified scope}}
+
+void e1(struct B<A>::Member); // expected-error {{use of 'Member' with tag type that does not match previous declaration}}
+void e2(class B<A>::Member); // expected-error {{use of 'Member' with tag type that does not match previous declaration}}
+void e3(union B<A>::Member);
+void e4(enum B<A>::Member); // expected-error {{use of 'Member' with tag type that does not match previous declaration}}
+
+template <class T> struct C {
+  void foo(class B<T>::Member); // expected-error{{no type named 'Member' in 'B<int>'}}
+};
+
+C<float> f1;
+C<int> f2; // expected-note {{in instantiation of template class}}
+C<A> f3; // expected-note {{in instantiation of template class}}
diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p10.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p10.cpp
new file mode 100644
index 000000000000..82f526745dc6
--- /dev/null
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p10.cpp
@@ -0,0 +1,16 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+struct A { 
+  virtual void f(int a = 7);
+}; 
+
+struct B : public A {
+  void f(int a);
+}; 
+
+void m() {
+  B* pb = new B; 
+  A* pa = pb; 
+  pa->f(); // OK, calls pa->B::f(7) 
+  pb->f(); // expected-error{{too few arguments}}
+}
diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p2.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p2.cpp
new file mode 100644
index 000000000000..143a0caf82b2
--- /dev/null
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p2.cpp
@@ -0,0 +1,9 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+void point(int = 3, int = 4);
+
+void test_point() {
+  point(1,2); 
+  point(1); 
+  point();
+}
diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p3.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p3.cpp
new file mode 100644
index 000000000000..ea16f641dba0
--- /dev/null
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p3.cpp
@@ -0,0 +1,13 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+void nondecl(int (*f)(int x = 5)) // {expected-error {{default arguments can only be specified}}}
+{
+  void (*f2)(int = 17)  // {expected-error {{default arguments can only be specified}}}
+  = (void (*)(int = 42))f; // {expected-error {{default arguments can only be specified}}}
+}
+
+struct X0 {
+  int (*f)(int = 17); // expected-error{{default arguments can only be specified for parameters in a function declaration}}
+  
+  void mem8(int (*fp)(int) = (int (*)(int = 17))0); // expected-error{{default arguments can only be specified for parameters in a function declaration}}  
+};
diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p4.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p4.cpp
new file mode 100644
index 000000000000..bbfaf909392a
--- /dev/null
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p4.cpp
@@ -0,0 +1,55 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+void f0(int i, int j, int k = 3);
+void f0(int i, int j, int k);
+void f0(int i, int j = 2, int k);
+void f0(int i, int j, int k);
+void f0(int i = 1, // expected-note{{previous definition}}
+        int j, int k);
+void f0(int i, int j, int k);
+
+namespace N0 {
+  void f0(int, int, int); // expected-note{{candidate}}
+
+  void test_f0_inner_scope() {
+    f0(); // expected-error{{no matching}}
+  }
+}
+
+void test_f0_outer_scope() {
+  f0(); // okay
+}
+
+void f0(int i = 1, // expected-error{{redefinition of default argument}}
+        int, int); 
+
+template<typename T> void f1(T); // expected-note{{previous}}
+
+template<typename T>
+void f1(T = T()); // expected-error{{cannot be added}}
+
+
+namespace N1 {
+  // example from C++03 standard
+  // FIXME: make these "f2"s into "f"s, then fix our scoping issues
+  void f2(int, int); 
+  void f2(int, int = 7); 
+  void h() {
+    f2(3); // OK, calls f(3, 7) 
+    void f(int = 1, int);	// expected-error{{missing default argument}}
+  }
+  
+  void m()
+  {
+    void f(int, int); // expected-note{{candidate}}
+    f(4);  // expected-error{{no matching}}
+    void f(int, int = 5); // expected-note{{previous definition}}
+    f(4); // okay
+    void f(int, int = 5); // expected-error{{redefinition of default argument}}
+  }
+  
+  void n()
+  {
+    f2(6); // okay
+  }
+}
\ No newline at end of file
diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p5.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p5.cpp
new file mode 100644
index 000000000000..894c9b5a877a
--- /dev/null
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p5.cpp
@@ -0,0 +1,18 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+float global_f;
+
+void f0(int *ip = &global_f); // expected-error{{incompatible}}
+
+// Example from C++03 standard
+int a = 1; 
+int f(int); 
+int g(int x = f(a));
+
+void h() { 
+  a = 2;
+  {
+    int *a = 0;
+    g(); // FIXME: check that a is called with a value of 2
+  }
+}
diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p6.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p6.cpp
new file mode 100644
index 000000000000..ef00e7b70534
--- /dev/null
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p6.cpp
@@ -0,0 +1,32 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+class C { 
+  void f(int i = 3); // expected-note{{here}}
+  void g(int i, int j = 99);
+};
+
+void C::f(int i = 3) { } // expected-error{{redefinition of default argument}}
+
+void C::g(int i = 88, int j) { }
+
+void test_C(C c) {
+  c.f();
+  c.g();
+}
+
+template<typename T>
+struct X0 {
+  void f(int);
+  
+  struct Inner {
+    void g(int);
+  };
+};
+
+// DR217
+template<typename T>
+void X0<T>::f(int = 17) { } // expected-error{{cannot be added}}
+
+// DR217 + DR205 (reading tea leaves)
+template<typename T>
+void X0<T>::Inner::g(int = 17) { } // expected-error{{cannot be added}}
diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p7.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p7.cpp
new file mode 100644
index 000000000000..9c1d3a91c9bd
--- /dev/null
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p7.cpp
@@ -0,0 +1,7 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+void h()
+{
+  int i;
+  extern void h2(int x = sizeof(i)); // expected-error {{default argument references local variable 'i' of enclosing function}}
+}
diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p8.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p8.cpp
new file mode 100644
index 000000000000..574237ee557d
--- /dev/null
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p8.cpp
@@ -0,0 +1,4 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+class A { 
+  void f(A* p = this) { }	// expected-error{{invalid use of 'this'}}
+};
diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p3.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p3.cpp
new file mode 100644
index 000000000000..6f71978c4e46
--- /dev/null
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p3.cpp
@@ -0,0 +1,3 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+void f(int) { } // expected-note {{previous definition is here}}
+void f(const int) { } // expected-error {{redefinition of 'f'}}
\ No newline at end of file
diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.mptr/p3.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.mptr/p3.cpp
new file mode 100644
index 000000000000..101d75fc0f48
--- /dev/null
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.mptr/p3.cpp
@@ -0,0 +1,26 @@
+// RUN: clang-cc -fsyntax-only -verify %t
+class A { 
+public:
+  int& i; 
+
+  A(int& i) : i(i) { }
+  
+  static int s;
+}; 
+
+template<typename T> void ft(T& t) {
+  t.*&T::i = 10; // expected-error{{cannot form a pointer-to-member to member 'i' of reference type 'int &'}}
+}
+
+void f() {
+  int b;
+  A a(b); 
+  
+  int A::*ip = &A::s; // expected-error {{incompatible type initializing 'int *', expected 'int class A::*'}}
+  a.*&A::s = 10; // expected-error{{right hand operand to .* has non pointer-to-member type 'int *'}}
+  
+  a.*&A::i = 10; // expected-error{{cannot form a pointer-to-member to member 'i' of reference type 'int &'}}
+  ft(a); // expected-note{{in instantiation of function template specialization 'ft' requested here}}
+  
+  void A::*p = 0; // expected-error{{'p' declared as a member pointer to void}}
+}
diff --git a/test/CXX/expr/p3.cpp b/test/CXX/expr/p3.cpp
new file mode 100644
index 000000000000..40fe052f6342
--- /dev/null
+++ b/test/CXX/expr/p3.cpp
@@ -0,0 +1,15 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+double operator +(double, double); // expected-error{{overloaded 'operator+' must have at least one parameter of class or enumeration type}}
+
+struct A
+{
+  operator int();
+};
+
+int main()
+{
+  A a, b;
+  int i0 = a + 1;
+  int i1 = a + b;
+}
diff --git a/test/CXX/expr/p8.cpp b/test/CXX/expr/p8.cpp
new file mode 100644
index 000000000000..4f02497486c8
--- /dev/null
+++ b/test/CXX/expr/p8.cpp
@@ -0,0 +1,18 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+int a0;
+const volatile int a1;
+int a2[16];
+int a3();
+
+void f0(int);
+void f1(int *);
+void f2(int (*)());
+
+int main()
+{
+  f0(a0);
+  f0(a1);
+  f1(a2);
+  f2(a3);
+}
diff --git a/test/CXX/expr/p9.cpp b/test/CXX/expr/p9.cpp
new file mode 100644
index 000000000000..1eec3cf0b9f9
--- /dev/null
+++ b/test/CXX/expr/p9.cpp
@@ -0,0 +1,50 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// floating-point overloads
+
+__typeof__(0 + 0.0L) ld0;
+long double &ldr = ld0;
+
+__typeof__(0 + 0.0) d0;
+double &dr = d0;
+
+__typeof__(0 + 0.0f) f0;
+float &fr = f0;
+
+// integral promotions
+
+signed char c0;
+__typeof__(c0 + c0) c1;
+int &cr = c1;
+
+unsigned char uc0;
+__typeof__(uc0 + uc0) uc1;
+int &ucr = uc1;
+
+short s0;
+__typeof__(s0 + s0) s1;
+int &sr = s1;
+
+unsigned short us0;
+__typeof__(us0 + us0) us1;
+int &usr = us1;
+
+// integral overloads
+
+__typeof__(0 + 0UL) ul0;
+unsigned long &ulr = ul0;
+
+template<bool T> struct selector;
+template<> struct selector<true> { typedef long type; };
+template<> struct selector<false> {typedef unsigned long type; };
+__typeof__(0U + 0L) ui_l0;
+selector<(sizeof(long) > sizeof(unsigned int))>::type &ui_lr = ui_l0;
+
+__typeof__(0 + 0L) l0;
+long &lr = l0;
+
+__typeof__(0 + 0U) u0;
+unsigned &ur = u0;
+
+__typeof__(0 + 0) i0;
+int &ir = i0;
diff --git a/test/CXX/lex/lex.trigraph/p1.cpp b/test/CXX/lex/lex.trigraph/p1.cpp
new file mode 100644
index 000000000000..2a9a34b87eed
--- /dev/null
+++ b/test/CXX/lex/lex.trigraph/p1.cpp
@@ -0,0 +1,19 @@
+// RUN: clang-cc -fsyntax-only -trigraphs -Wtrigraphs -verify %s
+
+??=pragma // expected-warning {{trigraph converted to '#' character}}
+
+int a = '??/0'; // expected-warning {{trigraph converted to '\' character}}
+
+int b = 1 ??' 0; // expected-warning {{trigraph converted to '^' character}}
+
+int c ??(1]; // expected-warning {{trigraph converted to '[' character}}
+
+int d [1??); // expected-warning {{trigraph converted to ']' character}}
+
+int e = 1 ??! 0; // expected-warning {{trigraph converted to '|' character}}
+
+void f() ??<} // expected-warning {{trigraph converted to '{' character}}
+
+void g() {??> // expected-warning {{trigraph converted to '}' character}}
+
+int h = ??- 0; // expected-warning {{trigraph converted to '~' character}}
diff --git a/test/CXX/lex/lex.trigraph/p2.cpp b/test/CXX/lex/lex.trigraph/p2.cpp
new file mode 100644
index 000000000000..5be2d46b9189
--- /dev/null
+++ b/test/CXX/lex/lex.trigraph/p2.cpp
@@ -0,0 +1,3 @@
+// RUN: clang-cc -fsyntax-only -trigraphs -Wtrigraphs -verify %s
+
+??=define arraycheck(a,b) a??(b??) ??!??! b??(a??) // expected-warning {{trigraph converted to '#' character}} expected-warning {{trigraph converted to '[' character}} expected-warning {{trigraph converted to ']' character}} expected-warning {{trigraph converted to '|' character}} expected-warning {{trigraph converted to '|' character}} expected-warning {{trigraph converted to '[' character}} expected-warning {{trigraph converted to ']' character}}
diff --git a/test/CXX/lex/lex.trigraph/p3.cpp b/test/CXX/lex/lex.trigraph/p3.cpp
new file mode 100644
index 000000000000..f32af49994af
--- /dev/null
+++ b/test/CXX/lex/lex.trigraph/p3.cpp
@@ -0,0 +1,8 @@
+// RUN: clang-cc -fsyntax-only -trigraphs -Wtrigraphs -verify %s
+
+char a[] =
+"?? ??\"??#??$??%??&??*??+??,??.??0??1??2??3??4??5??6"
+"??7??8??9??:??;?????@??A??B??C??D??E??F??G??H??I??J"
+"??K??L??M??N??O??P??Q??R??S??T??U??V??W??X??Y??Z??["
+"??\\??]??^??_??`??a??b??c??d??e??f??g??h??i??j??k??l"
+"??m??n??o??p??q??r??s??t??u??v??w??x??y??z??{??|??}??~";
diff --git a/test/CXX/over/over.match/over.match.best/p1.cpp b/test/CXX/over/over.match/over.match.best/p1.cpp
new file mode 100644
index 000000000000..df5198357d7b
--- /dev/null
+++ b/test/CXX/over/over.match/over.match.best/p1.cpp
@@ -0,0 +1,16 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T> int &f0(T*, int);
+float &f0(void*, int);
+
+void test_f0(int* ip, void *vp) {
+  // One argument is better...
+  int &ir = f0(ip, 0);
+  
+  // Prefer non-templates to templates
+  float &fr = f0(vp, 0);
+}
+
+// Partial ordering of function template specializations will be tested 
+// elsewhere
+// FIXME: Initialization by user-defined conversion is tested elsewhere
diff --git a/test/CXX/over/over.over/p1.cpp b/test/CXX/over/over.over/p1.cpp
new file mode 100644
index 000000000000..e7f7d18c69e3
--- /dev/null
+++ b/test/CXX/over/over.over/p1.cpp
@@ -0,0 +1,94 @@
+// RUN: clang-cc -fsyntax-only %s
+
+template<typename T> T f0(T);
+int f0(int);
+
+// -- an object or reference being initialized 
+struct S {
+  int (*f0)(int);
+  float (*f1)(float);
+};
+
+void test_init_f0() {
+  int (*f0a)(int) = f0;
+  int (*f0b)(int) = &f0;
+  int (*f0c)(int) = (f0);
+  float (*f0d)(float) = f0;
+  float (*f0e)(float) = &f0;
+  float (*f0f)(float) = (f0);
+  int (&f0g)(int) = f0;
+  int (&f0h)(int) = (f0);
+  float (&f0i)(float) = f0;
+  float (&f0j)(float) = (f0);
+  S s = { f0, f0 };
+}
+
+// -- the left side of an assignment (5.17),
+void test_assign_f0() {
+  int (*f0a)(int) = 0;
+  float (*f0b)(float) = 0;
+  
+  f0a = f0;
+  f0a = &f0;
+  f0a = (f0);
+  f0b = f0;
+  f0b = &f0;
+  f0b = (f0);  
+}
+
+// -- a parameter of a function (5.2.2),
+void eat_f0(int a(int), float (*b)(float), int (&c)(int), float (&d)(float));
+
+void test_pass_f0() {
+  eat_f0(f0, f0, f0, f0);
+  eat_f0(&f0, &f0, (f0), (f0));
+}
+
+// -- a parameter of a user-defined operator (13.5),
+struct X { };
+void operator+(X, int(int));
+void operator-(X, float(*)(float));
+void operator*(X, int (&)(int));
+void operator/(X, float (&)(float));
+
+void test_operator_pass_f0(X x) {
+  x + f0;
+  x + &f0;
+  x - f0;
+  x - &f0;
+  x * f0;
+  x * (f0);
+  x / f0;
+  x / (f0);
+}
+
+// -- the return value of a function, operator function, or conversion (6.6.3),
+int (*test_return_f0_a())(int) { return f0; }
+int (*test_return_f0_b())(int) { return &f0; }
+int (*test_return_f0_c())(int) { return (f0); }
+float (*test_return_f0_d())(float) { return f0; }
+float (*test_return_f0_e())(float) { return &f0; }
+float (*test_return_f0_f())(float) { return (f0); }
+
+// -- an explicit type conversion (5.2.3, 5.2.9, 5.4), or
+void test_convert_f0() {
+  (void)((int (*)(int))f0);
+  (void)((int (*)(int))&f0);
+  (void)((int (*)(int))(f0));
+  (void)((float (*)(float))f0);
+  (void)((float (*)(float))&f0);
+  (void)((float (*)(float))(f0));
+}
+
+// -- a non-type template-parameter(14.3.2).
+template<int(int)> struct Y0 { };
+template<float(float)> struct Y1 { };
+template<int (&)(int)> struct Y2 { };
+template<float (&)(float)> struct Y3 { };
+
+Y0<f0> y0;
+Y0<&f0> y0a;
+Y1<f0> y1;
+Y1<&f0> y1a;
+Y2<f0> y2;
+Y3<f0> y3;
diff --git a/test/CXX/over/over.over/p2.cpp b/test/CXX/over/over.over/p2.cpp
new file mode 100644
index 000000000000..9ab026061893
--- /dev/null
+++ b/test/CXX/over/over.over/p2.cpp
@@ -0,0 +1,10 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T> T f0(T, T);
+
+void test_f0() {
+  int (*f0a)(int, int) = f0;
+  int (*f0b)(int, int) = &f0;
+  int (*f0c)(int, float) = f0; // expected-error{{incompatible type}}
+  // FIXME: poor error message above!
+}
diff --git a/test/CXX/over/over.over/p4.cpp b/test/CXX/over/over.over/p4.cpp
new file mode 100644
index 000000000000..a05dbaebb71d
--- /dev/null
+++ b/test/CXX/over/over.over/p4.cpp
@@ -0,0 +1,23 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T> T f0(T);
+int f0(int); // expected-note{{candidate function}}
+
+void test_f0() {
+  int (*fp0)(int) = f0;
+  int (*fp1)(int) = &f0;
+  float (*fp2)(float) = &f0;
+}
+
+namespace N {
+  int f0(int); // expected-note{{candidate function}}
+}
+
+int f0(int);
+
+void test_f0_2() {
+  using namespace N;
+  int (*fp0)(int) = f0; // expected-error{{ambiguous}} \ 
+                        // expected-error{{initializing}}
+  float (*fp1)(float) = f0;
+}
diff --git a/test/CXX/temp/temp.decls/temp.class.spec/p6.cpp b/test/CXX/temp/temp.decls/temp.class.spec/p6.cpp
new file mode 100644
index 000000000000..afe6ab2b968e
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.class.spec/p6.cpp
@@ -0,0 +1,20 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T>
+struct X0 {
+  template<typename U> struct Inner0 {
+    static const unsigned value = 0;
+  };
+  
+  template<typename U> struct Inner0<U*> { 
+    static const unsigned value = 1;
+  };
+};
+
+template<typename T> template<typename U>
+struct X0<T>::Inner0<const U*> {
+  static const unsigned value = 2;
+};
+
+// FIXME: Test instantiation of these partial specializations (once they are
+// implemented).
diff --git a/test/CXX/temp/temp.decls/temp.class.spec/temp.class.order/p2.cpp b/test/CXX/temp/temp.decls/temp.class.spec/temp.class.order/p2.cpp
new file mode 100644
index 000000000000..b3b7635106c5
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.class.spec/temp.class.order/p2.cpp
@@ -0,0 +1,16 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+template<int I, int J, class T> class X { 
+  static const int value = 0;
+};
+
+template<int I, int J> class X<I, J, int> { 
+  static const int value = 1;
+};
+
+template<int I> class X<I, I, int> { 
+  static const int value = 2;
+};
+
+int array0[X<0, 0, float>::value == 0? 1 : -1];
+int array1[X<0, 1, int>::value == 1? 1 : -1];
+int array2[X<0, 0, int>::value == 2? 1 : -1];
diff --git a/test/CXX/temp/temp.decls/temp.class.spec/temp.class.spec.mfunc/p1-neg.cpp b/test/CXX/temp/temp.decls/temp.class.spec/temp.class.spec.mfunc/p1-neg.cpp
new file mode 100644
index 000000000000..47cf8379c319
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.class.spec/temp.class.spec.mfunc/p1-neg.cpp
@@ -0,0 +1,25 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T, int N>
+struct A;
+
+template<typename T> // expected-note{{previous template declaration}}
+struct A<T*, 2> {
+  void f0();
+  void f1();
+  void f2();
+};
+
+template<>
+struct A<int, 1> {
+  void g0();
+};
+
+// FIXME: We should probably give more precise diagnostics here, but the
+// diagnostics we give aren't terrible.
+// FIXME: why not point to the first parameter that's "too many"?
+template<typename T, int N> // expected-error{{too many template parameters}}
+void A<T*, 2>::f0() { }
+
+template<typename T, int N>
+void A<T, N>::f1() { } // expected-error{{out-of-line definition}}
diff --git a/test/CXX/temp/temp.decls/temp.class.spec/temp.class.spec.mfunc/p1.cpp b/test/CXX/temp/temp.decls/temp.class.spec/temp.class.spec.mfunc/p1.cpp
new file mode 100644
index 000000000000..b63c56c40fe8
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.class.spec/temp.class.spec.mfunc/p1.cpp
@@ -0,0 +1,26 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T, int N>
+struct A;
+
+template<typename T>
+struct A<T*, 2> {
+  A(T);
+  ~A();
+  
+  void f(T*);
+  
+  operator T*();
+  
+  static T value;
+};
+
+template<class X> void A<X*, 2>::f(X*) { }
+
+template<class X> X A<X*, 2>::value;
+
+template<class X> A<X*, 2>::A(X) { value = 0; }
+
+template<class X> A<X*, 2>::~A() { }
+
+template<class X> A<X*, 2>::operator X*() { return 0; }
diff --git a/test/CXX/temp/temp.decls/temp.class/temp.mem.class/p1.cpp b/test/CXX/temp/temp.decls/temp.class/temp.mem.class/p1.cpp
new file mode 100644
index 000000000000..bc4bb5da4011
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.class/temp.mem.class/p1.cpp
@@ -0,0 +1,27 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T, typename U>
+struct X0 {
+  struct Inner;
+};
+
+template<typename T, typename U>
+struct X0<T, U>::Inner {
+  T x;
+  U y;
+  
+  void f() { x = y; } // expected-error{{incompatible}}
+};
+
+
+void test(int i, float f) {
+  X0<int, float>::Inner inner;
+  inner.x = 5;
+  inner.y = 3.4;
+  inner.f();
+  
+  X0<int*, float *>::Inner inner2;
+  inner2.x = &i;
+  inner2.y = &f;
+  inner2.f(); // expected-note{{instantiation}}
+}
diff --git a/test/CXX/temp/temp.decls/temp.class/temp.mem.func/p1-retmem.cpp b/test/CXX/temp/temp.decls/temp.class/temp.mem.func/p1-retmem.cpp
new file mode 100644
index 000000000000..fd3fb0bc7a7d
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.class/temp.mem.func/p1-retmem.cpp
@@ -0,0 +1,28 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T> struct X1 { };
+
+template<typename T>
+struct X0 {
+  typedef int size_type;
+  typedef T value_type;
+  
+  size_type f0() const;
+  value_type *f1();
+  X1<value_type*> f2();
+};
+
+template<typename T>
+typename X0<T>::size_type X0<T>::f0() const { 
+  return 0;
+}
+
+template<typename U>
+typename X0<U>::value_type *X0<U>::f1() { 
+  return 0;
+};
+
+template<typename U>
+X1<typename X0<U>::value_type*> X0<U>::f2() { 
+  return 0;
+};
diff --git a/test/CXX/temp/temp.decls/temp.class/temp.mem.func/p1.cpp b/test/CXX/temp/temp.decls/temp.class/temp.mem.func/p1.cpp
new file mode 100644
index 000000000000..725b61c27162
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.class/temp.mem.func/p1.cpp
@@ -0,0 +1,68 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T, typename U> // expected-note{{previous template}}
+class X0 {
+public:
+  typedef int size_type;
+  
+  X0(int);
+  ~X0();
+  
+  void f0(const T&, const U&);
+  
+  T& operator[](int i) const;
+  
+  void f1(size_type) const;
+  void f2(size_type) const;
+  void f3(size_type) const;
+  void f4() ;
+  
+  operator T*() const;
+  
+  T value;
+};
+
+template<typename T, typename U>
+void X0<T, U>::f0(const T&, const U&) { // expected-note{{previous definition}}
+}
+
+template<class X, class Y>
+X& X0<X, Y>::operator[](int i) const {
+  (void)i;
+  return value;
+}
+
+template<class X, class Y>
+void X0<X, Y>::f1(int) const { }
+
+template<class X, class Y>
+void X0<X, Y>::f2(size_type) const { }
+
+template<class X, class Y, class Z> // expected-error{{too many template parameters}}
+void X0<X, Y>::f3(size_type) const {
+}
+
+template<class X, class Y> 
+void X0<Y, X>::f4() { } // expected-error{{does not refer}}
+
+// FIXME: error message should probably say, "redefinition of 'X0<T, U>::f0'"
+// rather than just "redefinition of 'f0'"
+template<typename T, typename U>
+void X0<T, U>::f0(const T&, const U&) { // expected-error{{redefinition}}
+}
+
+// Test out-of-line constructors, destructors
+template<typename T, typename U>
+X0<T, U>::X0(int x) : value(x) { }
+
+template<typename T, typename U>
+X0<T, U>::~X0() { }
+
+// Test out-of-line conversion functions.
+template<typename T, typename U>
+X0<T, U>::operator T*() const {
+  return &value;
+}
+
+namespace N { template <class X> class A {void a();}; }
+namespace N { template <class X> void A<X>::a() {} }
diff --git a/test/CXX/temp/temp.decls/temp.class/temp.mem.func/p1inst.cpp b/test/CXX/temp/temp.decls/temp.class/temp.mem.func/p1inst.cpp
new file mode 100644
index 000000000000..a09d0efa297f
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.class/temp.mem.func/p1inst.cpp
@@ -0,0 +1,17 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+// Test instantiation of member functions of class templates defined out-of-line
+template<typename T, typename U>
+struct X0 {
+  void f(T *t, const U &u);
+  void f(T *);
+};
+
+template<typename T, typename U>
+void X0<T, U>::f(T *t, const U &u) {
+  *t = u; // expected-error{{not assignable}}
+}
+
+void test_f(X0<float, int> xfi, X0<void, int> xvi, float *fp, void *vp, int i) {
+  xfi.f(fp, i);
+  xvi.f(vp, i); // expected-note{{instantiation}}
+}
diff --git a/test/CXX/temp/temp.decls/temp.class/temp.mem.func/pr5056.cpp b/test/CXX/temp/temp.decls/temp.class/temp.mem.func/pr5056.cpp
new file mode 100644
index 000000000000..602fd374c2ab
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.class/temp.mem.func/pr5056.cpp
@@ -0,0 +1,17 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+extern "C" void * malloc(int);
+
+template <typename T> struct A {
+  void *malloc(int);
+};
+
+template <typename T>
+inline void *A<T>::malloc(int)
+{
+  return 0;
+}
+
+void f() {
+  malloc(10);
+}
diff --git a/test/CXX/temp/temp.decls/temp.class/temp.static/p1-inst.cpp b/test/CXX/temp/temp.decls/temp.class/temp.static/p1-inst.cpp
new file mode 100644
index 000000000000..2ddb8eac6c0a
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.class/temp.static/p1-inst.cpp
@@ -0,0 +1,28 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// Test instantiation of static data members declared out-of-line.
+
+template<typename T>
+struct X {
+  static T value;
+};
+
+template<typename T> 
+  T X<T>::value = 17; // expected-error{{initialize}}
+
+struct InitOkay {
+  InitOkay(int) { }
+};
+
+struct CannotInit { };
+
+int &returnInt() { return X<int>::value; }
+float &returnFloat() { return X<float>::value; }
+
+InitOkay &returnInitOkay() { return X<InitOkay>::value; }
+
+unsigned long sizeOkay() { return sizeof(X<CannotInit>::value); }
+  
+CannotInit &returnError() {
+  return X<CannotInit>::value; // expected-note{{instantiation}}
+}
diff --git a/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp b/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp
new file mode 100644
index 000000000000..949a8b0a72c7
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp
@@ -0,0 +1,26 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T>
+struct X0 {
+  static T value;
+};
+
+template<typename T>
+T X0<T>::value = 0; // expected-error{{initialize}}
+
+struct X1 { 
+  X1(int);
+};
+
+struct X2 { };
+
+int& get_int() { return X0<int>::value; }
+X1& get_X1() { return X0<X1>::value; }
+
+double*& get_double_ptr() { return X0<int*>::value; } // expected-error{{initialized}}
+
+X2& get_X2() { 
+  return X0<X2>::value; // expected-note{{instantiation}}
+}
+  
+template<typename T> T x; // expected-error{{variable 'x' declared as a template}}
diff --git a/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p4.cpp b/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p4.cpp
new file mode 100644
index 000000000000..fe42ba41d81e
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p4.cpp
@@ -0,0 +1,23 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<class T> struct A { A(); };
+template<class T> int &f(T); 
+template<class T> float &f(T*); 
+template<class T> double &f(const T*);
+
+template<class T> void g(T); // expected-note{{candidate}}
+template<class T> void g(T&); // expected-note{{candidate}}
+
+template<class T> int &h(const T&); 
+template<class T> float &h(A<T>&);
+
+void m() { 
+  const int *p; 
+  double &dr1 = f(p); 
+  float x; 
+  g(x); // expected-error{{ambiguous}}
+  A<int> z; 
+  float &fr1 = h(z);
+  const A<int> z2; 
+  int &ir1 = h(z2);
+}
diff --git a/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p5.cpp b/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p5.cpp
new file mode 100644
index 000000000000..27e4426b9082
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p5.cpp
@@ -0,0 +1,12 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+template<class T> int &f(T); 
+template<class T> float &f(T*, int=1); 
+
+template<class T> int &g(T); 
+template<class T> float &g(T*, ...);
+
+int main() { 
+  int* ip; 
+  float &fr1 = f(ip); 
+  float &fr2 = g(ip);
+}
diff --git a/test/CXX/temp/temp.decls/temp.fct/temp.over.link/p4-neg.cpp b/test/CXX/temp/temp.decls/temp.fct/temp.over.link/p4-neg.cpp
index b482955818cb..399dcc4bed76 100644
--- a/test/CXX/temp/temp.decls/temp.fct/temp.over.link/p4-neg.cpp
+++ b/test/CXX/temp/temp.decls/temp.fct/temp.over.link/p4-neg.cpp
@@ -17,11 +17,11 @@ template<typename T>
 struct MetaFun;
 
 template<typename T>
-  typename MetaFun<T*>::type f0(const T&) { } // expected-note{{previous}}
+  typename MetaFun<T*>::type f0(const T&) { while (1) {} } // expected-note{{previous}}
 template<class U>
-  typename MetaFun<U*>::type f0(const U&) { } // expected-error{{redefinition}}
+  typename MetaFun<U*>::type f0(const U&) { while (1) {} } // expected-error{{redefinition}}
 
 // FIXME: We need canonicalization of expressions for this to work
 // template<int> struct A { };
 // template<int I> void f0(A<I>) { } // Xpected-note{{previous}}
-// template<int J> void f0(A<J>) { } // Xpected-error{{redefinition}}
\ No newline at end of file
+// template<int J> void f0(A<J>) { } // Xpected-error{{redefinition}}
diff --git a/test/CXX/temp/temp.decls/temp.fct/temp.over.link/p6.cpp b/test/CXX/temp/temp.decls/temp.fct/temp.over.link/p6.cpp
new file mode 100644
index 000000000000..2571e45c5cde
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.fct/temp.over.link/p6.cpp
@@ -0,0 +1,16 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<int N, int M>
+struct A0 {
+  void g0();
+};
+
+template<int X, int Y> void f0(A0<X, Y>) { } // expected-note{{previous}}
+template<int N, int M> void f0(A0<M, N>) { }
+template<int V1, int V2> void f0(A0<V1, V2>) { } // expected-error{{redefinition}}
+
+template<int X, int Y> void f1(A0<0, (X + Y)>) { } // expected-note{{previous}}
+template<int X, int Y> void f1(A0<0, (X - Y)>) { }
+template<int A, int B> void f1(A0<0, (A + B)>) { } // expected-error{{redefinition}}
+
+template<int X, int Y> void A0<X, Y>::g0() { }
diff --git a/test/CXX/temp/temp.decls/temp.friend/p1.cpp b/test/CXX/temp/temp.decls/temp.friend/p1.cpp
new file mode 100644
index 000000000000..fc392da00acf
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.friend/p1.cpp
@@ -0,0 +1,56 @@
+// RUN: clang-cc -emit-llvm-only %s
+
+template <typename T> struct Num {
+  T value_;
+
+public:
+  Num(T value) : value_(value) {}
+  T get() const { return value_; }
+
+  template <typename U> struct Rep {
+    U count_;
+    Rep(U count) : count_(count) {}
+
+    friend Num operator*(const Num &a, const Rep &n) {
+      Num x = 0;
+      for (U count = n.count_; count; --count)
+        x += a;
+      return x;
+    } 
+  };
+
+  friend Num operator+(const Num &a, const Num &b) {
+    return a.value_ + b.value_;
+  }
+
+  Num& operator+=(const Num& b) {
+    value_ += b.value_;
+    return *this;
+  }
+
+  class Representation {};
+  friend class Representation;
+};
+
+class A {
+  template <typename T> friend bool iszero(const A &a) throw();
+};
+
+template <class T> class B_iterator;
+template <class T> class B {
+  friend class B_iterator<T>;
+};
+
+int calc1() {
+  Num<int> left = -1;
+  Num<int> right = 1;
+  Num<int> result = left + right;
+  return result.get();
+}
+
+int calc2() {
+  Num<int> x = 3;
+  Num<int>::Rep<char> n = (char) 10;
+  Num<int> result = x * n;
+  return result.get();
+}
diff --git a/test/CXX/temp/temp.decls/temp.friend/p3.cpp b/test/CXX/temp/temp.decls/temp.friend/p3.cpp
new file mode 100644
index 000000000000..4615bebe711f
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.friend/p3.cpp
@@ -0,0 +1,13 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template <class T> class A {
+  typedef int Member;
+};
+
+class B {
+  template <class T> friend class A;
+  template <class T> friend class Undeclared;
+  
+  // FIXME: Diagnostic below could be (and was) better.
+  template <class T> friend typename A<T>::Member; // expected-error {{classes or functions}}
+};
diff --git a/test/CXX/temp/temp.decls/temp.friend/p5.cpp b/test/CXX/temp/temp.decls/temp.friend/p5.cpp
new file mode 100644
index 000000000000..f1142a4129b2
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.friend/p5.cpp
@@ -0,0 +1,11 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template <class T> class A {
+  class Member {
+  };
+};
+
+class B {
+  template <class T> friend class A<T>::Member;
+};
+
diff --git a/test/CXX/temp/temp.decls/temp.mem/p1.cpp b/test/CXX/temp/temp.decls/temp.mem/p1.cpp
new file mode 100644
index 000000000000..80b18467a364
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.mem/p1.cpp
@@ -0,0 +1,16 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template <class T> struct A {
+  static T cond;
+  
+  template <class U> struct B {
+    static T twice(U value) {
+      return (cond ? value + value : value);
+    }
+  };
+};
+
+int foo() {
+  A<bool>::cond = true;
+  return A<bool>::B<int>::twice(4);
+}
diff --git a/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p3.cpp b/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p3.cpp
index f4970b89f693..01030b2a8a20 100644
--- a/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p3.cpp
+++ b/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p3.cpp
@@ -8,4 +8,4 @@ void g() {
   f<int>("aa",3.0);       // Y is deduced to be char*, and
                           // Z is deduced to be double 
   f("aa",3.0); // expected-error{{no matching}}
-}
\ No newline at end of file
+}
diff --git a/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/p3.cpp b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/p3.cpp
index c014c663598c..dbe2ff3e18fb 100644
--- a/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/p3.cpp
+++ b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/p3.cpp
@@ -1,4 +1,4 @@
-// RUN: clang-cc -fsyntax-only %s
+// RUN: clang-cc -fsyntax-only -verify %s
 
 template<typename T> struct A { };
 
@@ -57,4 +57,32 @@ void test_f3(int ***ip, volatile int ***vip) {
   A<volatile int> a1 = f3(vip);
 }
                              
-// FIXME: the next bullet requires a lot of effort.
+//   - If P is a class, and P has the form template-id, then A can be a 
+//     derived class of the deduced A. Likewise, if P is a pointer to a class
+//     of the form template-id, A can be a pointer to a derived class pointed 
+//     to by the deduced A.
+template<typename T, int I> struct C { };
+
+struct D : public C<int, 1> { };
+struct E : public D { };
+struct F : A<float> { };
+struct G : A<float>, C<int, 1> { };
+
+template<typename T, int I>
+  C<T, I> *f4a(const C<T, I>&);
+template<typename T, int I>
+  C<T, I> *f4b(C<T, I>);
+template<typename T, int I>
+  C<T, I> *f4c(C<T, I>*);
+int *f4c(...);
+
+void test_f4(D d, E e, F f, G g) {
+  C<int, 1> *ci1a = f4a(d);
+  C<int, 1> *ci2a = f4a(e);
+  C<int, 1> *ci1b = f4b(d);
+  C<int, 1> *ci2b = f4b(e);
+  C<int, 1> *ci1c = f4c(&d);
+  C<int, 1> *ci2c = f4c(&e);
+  C<int, 1> *ci3c = f4c(&g);
+  int       *ip1 = f4c(&f);
+}
diff --git a/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p2.cpp b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p2.cpp
new file mode 100644
index 000000000000..7d175781c2d9
--- /dev/null
+++ b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p2.cpp
@@ -0,0 +1,36 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// FIXME: [temp.deduct.conv]p2 bullets 1 and 2 can't actually happen without
+// references?
+// struct ConvertibleToArray {
+//   //  template<typename T, unsigned N>
+//   //  operator T(()[]) const;
+
+// private:
+//   typedef int array[17];
+
+//   operator array() const;
+// };
+
+// void test_array(ConvertibleToArray cta) {
+//   int *ip = cta;
+//   ip = cta;
+//   const float *cfp = cta;
+// }
+
+// bullet 2
+// struct ConvertibleToFunction {
+//   template<typename T, typename A1, typename A2>
+//   operator T(A1, A2) const ()  { };
+// };
+
+// bullet 3
+struct ConvertibleToCVQuals {
+  template<typename T>
+  operator T* const() const;
+};
+
+void test_cvqual_conv(ConvertibleToCVQuals ctcv) {
+  int *ip = ctcv;
+  const int *icp = ctcv;
+}
diff --git a/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p3.cpp b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p3.cpp
new file mode 100644
index 000000000000..95bd7fe12159
--- /dev/null
+++ b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p3.cpp
@@ -0,0 +1,30 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+struct AnyPtr {
+  template<typename T>
+  operator T*() const;
+};
+
+// If A is a cv-qualified type, the top level cv-qualifiers of A's type
+// are ignored for type deduction.
+void test_cvquals(AnyPtr ap) {
+  int* const ip = ap;
+  const float * const volatile fp = ap;
+}
+
+// If A is a reference type, the type referred to by A is used for
+// type deduction.
+void test_ref_arg(AnyPtr ap) {
+  const int* const &ip = ap;
+  double * const &dp = ap;
+}
+
+struct AnyRef {
+  template<typename T>
+  operator T&() const;
+};
+
+void test_ref_param(AnyRef ar) {
+  int &ir = ar;
+  const float &fr = ar;
+  int i = ar;
+}
diff --git a/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p4.cpp b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p4.cpp
new file mode 100644
index 000000000000..50d31fb2f851
--- /dev/null
+++ b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p4.cpp
@@ -0,0 +1,44 @@
+// RUN: clang-cc -fsyntax-only %s
+
+struct AnyT {
+  template<typename T>
+  operator T();
+};
+
+void test_cvqual_ref(AnyT any) {
+  const int &cir = any;  
+}
+
+struct AnyThreeLevelPtr {
+  template<typename T>
+  operator T***() const
+  {
+    T x = 0;
+    // FIXME: looks like we get this wrong, too!
+    // x = 0; // will fail if T is deduced to a const type
+           // (EDG and GCC get this wrong)
+    return 0;
+  }
+};
+
+struct X { };
+
+void test_deduce_with_qual(AnyThreeLevelPtr a3) {
+  int * const * const * const ip = a3;
+}
+
+struct AnyPtrMem {
+  template<typename Class, typename T>
+  operator T Class::*() const
+  {
+    T x = 0;
+    // FIXME: looks like we get this wrong, too!
+    // x = 0; // will fail if T is deduced to a const type.
+           // (EDG and GCC get this wrong)
+    return 0;
+  }
+};
+
+void test_deduce_ptrmem_with_qual(AnyPtrMem apm) {
+  const float X::* pm = apm;
+}
diff --git a/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.funcaddr/p1.cpp b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.funcaddr/p1.cpp
new file mode 100644
index 000000000000..86a34500ad41
--- /dev/null
+++ b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.funcaddr/p1.cpp
@@ -0,0 +1,22 @@
+// RUN: clang-cc -fsyntax-only %s
+
+template<typename T>
+  T f0(T, int);
+
+void test_f0() {
+  int (*f0a)(int, int) = f0;
+  int (*f0b)(int, int) = &f0;
+  float (*f0c)(float, int) = &f0;
+}
+
+template<typename T> T f1(T, int);
+template<typename T> T f1(T);
+
+void test_f1() {
+  float (*f1a)(float, int) = f1;
+  float (*f1b)(float, int) = &f1;
+  float (*f1c)(float) = f1;
+  float (*f1d)(float) = (f1);
+  float (*f1e)(float) = &f1;
+  float (*f1f)(float) = (&f1);
+}
diff --git a/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.partial/p11.cpp b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.partial/p11.cpp
new file mode 100644
index 000000000000..072789c7d579
--- /dev/null
+++ b/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.partial/p11.cpp
@@ -0,0 +1,22 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template <class T> T* f(int);	// #1 
+template <class T, class U> T& f(U); // #2 
+
+void g() {
+  int *ip = f<int>(1);	// calls #1
+}
+
+template<typename T>
+struct identity {
+  typedef T type;
+};
+
+template <class T> 
+  T* f2(int, typename identity<T>::type = 0); // expected-note{{candidate}}
+template <class T, class U> 
+  T& f2(U, typename identity<T>::type = 0); // expected-note{{candidate}}
+
+void g2() {
+  f2<int>(1); // expected-error{{ambiguous}}
+}
diff --git a/test/CXX/temp/temp.param/p1.cpp b/test/CXX/temp/temp.param/p1.cpp
index 488c3a07429a..a6638b4f60f2 100644
--- a/test/CXX/temp/temp.param/p1.cpp
+++ b/test/CXX/temp/temp.param/p1.cpp
@@ -1 +1,4 @@
+// Suppress 'no run line' failure.
+// RUN: true
+
 // Paragraph 1 is descriptive, and therefore requires no tests.
diff --git a/test/CXX/temp/temp.res/temp.dep/p3.cpp b/test/CXX/temp/temp.res/temp.dep/p3.cpp
new file mode 100644
index 000000000000..d47f0d683514
--- /dev/null
+++ b/test/CXX/temp/temp.res/temp.dep/p3.cpp
@@ -0,0 +1,43 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+struct A0 {
+  struct K { };
+};
+
+template <typename T> struct B0: A0 {
+  static void f() {
+    K k;
+  }
+};
+
+namespace E1 {
+  typedef double A; 
+
+  template<class T> class B {
+    typedef int A; 
+  };
+
+  template<class T> 
+  struct X : B<T> {
+    A* blarg(double *dp) {
+      return dp;
+    }
+  };
+}
+
+namespace E2 {
+  struct A { 
+    struct B;
+    int *a;
+    int Y;
+  };
+    
+  int a;
+  template<class T> struct Y : T { 
+    struct B { /* ... */ };
+    B b; 
+    void f(int i) { a = i; } 
+    Y* p;
+  }; 
+  
+  Y<A> ya;
+}
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p1.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p1.cpp
new file mode 100644
index 000000000000..239b8aeb04e4
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p1.cpp
@@ -0,0 +1,99 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// This test creates cases where implicit instantiations of various entities
+// would cause a diagnostic, but provides expliict specializations for those
+// entities that avoid the diagnostic. The intent is to verify that 
+// implicit instantiations do not occur (because the explicit specialization 
+// is used instead).
+struct NonDefaultConstructible {
+  NonDefaultConstructible(int);
+};
+
+
+// C++ [temp.expl.spec]p1:
+//   An explicit specialization of any of the following:
+
+//     -- function template
+template<typename T> void f0(T) {
+  T t;
+}
+
+template<> void f0(NonDefaultConstructible) { }
+
+void test_f0(NonDefaultConstructible NDC) {
+  f0(NDC);
+}
+
+//     -- class template
+template<typename T>
+struct X0 {
+  static T member;
+  
+  void f1(T t) {
+    t = 17;
+  }
+  
+  struct Inner : public T { };
+  
+  template<typename U>
+  struct InnerTemplate : public T { };
+  
+  template<typename U>
+  void ft1(T t, U u);
+};
+
+template<typename T> 
+template<typename U>
+void X0<T>::ft1(T t, U u) {
+  t = u;
+}
+
+template<typename T> T X0<T>::member;
+
+template<> struct X0<void> { };
+X0<void> test_X0;
+  
+
+//     -- member function of a class template
+template<> void X0<void*>::f1(void *) { }
+
+void test_spec(X0<void*> xvp, void *vp) {
+  xvp.f1(vp);
+}
+
+//     -- static data member of a class template
+template<> 
+NonDefaultConstructible X0<NonDefaultConstructible>::member = 17;
+
+NonDefaultConstructible &get_static_member() {
+  return X0<NonDefaultConstructible>::member;
+}
+
+//    -- member class of a class template
+template<>
+struct X0<void*>::Inner { };
+
+X0<void*>::Inner inner0;
+
+//    -- member class template of a class template
+template<>
+template<>
+struct X0<void*>::InnerTemplate<int> { };
+
+X0<void*>::InnerTemplate<int> inner_template0;
+
+//    -- member function template of a class template
+template<>
+template<>
+void X0<void*>::ft1(void*, const void*) { }
+
+void test_func_template(X0<void *> xvp, void *vp, const void *cvp) {
+  xvp.ft1(vp, cvp);
+}
+
+// example from the standard:
+template<class T> class stream;
+template<> class stream<char> { /* ... */ };
+template<class T> class Array { /* ... */ }; 
+template<class T> void sort(Array<T>& v) { /* ... */ }
+template<> void sort<char*>(Array<char*>&) ;
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p10.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p10.cpp
new file mode 100644
index 000000000000..61f1710a6b9e
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p10.cpp
@@ -0,0 +1,7 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<class T> class X; 
+template<> class X<int>; // expected-note{{forward}}
+X<int>* p; 
+
+X<int> x; // expected-error{{incomplete type}}
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p11.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p11.cpp
new file mode 100644
index 000000000000..e794e67a5ef3
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p11.cpp
@@ -0,0 +1,8 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<class T> class Array { /* ... */ }; 
+template<class T> void sort(Array<T>& v);
+
+// explicit specialization for sort(Array<int>&) 
+// with deduced template-argument of type int 
+template<> void sort(Array<int>&);
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p13.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p13.cpp
new file mode 100644
index 000000000000..63cf9f5e50d1
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p13.cpp
@@ -0,0 +1,6 @@
+// RUN: clang-cc -fsyntax-only %s
+
+template<typename T> void f(T);
+
+template<> void f(int) { }
+void f(int) { }
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p14.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p14.cpp
new file mode 100644
index 000000000000..a5d5b9e3c41e
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p14.cpp
@@ -0,0 +1,42 @@
+// RUN: clang-cc -emit-llvm -o - %s | FileCheck %s 
+
+template<class T> void f(T) { /* ... */ }
+template<class T> inline void g(T) { /* ... */ }
+
+// CHECK: define void @_Z1gIiEvT_
+template<> void g<>(int) { /* ... */ }
+
+template<class T>
+struct X {
+  void f() { }
+  void g();
+  void h();
+};
+
+template<class T>
+void X<T>::g() {
+}
+
+template<class T>
+inline void X<T>::h() {
+}
+
+// CHECK: define void @_ZN1XIiE1fEv
+template<> void X<int>::f() { }
+
+// CHECK: define void @_ZN1XIiE1hEv
+template<> void X<int>::h() { }
+
+// CHECK: define linkonce_odr void @_Z1fIiEvT_
+template<> inline void f<>(int) { /* ... */ } 
+
+// CHECK: define linkonce_odr void @_ZN1XIiE1gEv
+template<> inline void X<int>::g() { }
+
+void test(X<int> xi) {
+  f(17);
+  g(17);
+  xi.f();
+  xi.g();
+  xi.h();
+}
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p15.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p15.cpp
new file mode 100644
index 000000000000..840f566362ed
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p15.cpp
@@ -0,0 +1,22 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+struct NonDefaultConstructible {
+  NonDefaultConstructible(const NonDefaultConstructible&);
+};
+
+template<typename T, typename U>
+struct X {
+  static T member;
+};
+
+template<typename T, typename U>
+T X<T, U>::member; // expected-error{{no matching constructor}}
+
+// Okay; this is a declaration, not a definition.
+template<>
+NonDefaultConstructible X<NonDefaultConstructible, long>::member;
+
+NonDefaultConstructible &test(bool b) {
+  return b? X<NonDefaultConstructible, int>::member // expected-note{{instantiation}}
+          : X<NonDefaultConstructible, long>::member;
+}
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p16.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p16.cpp
new file mode 100644
index 000000000000..ce40afd40225
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p16.cpp
@@ -0,0 +1,26 @@
+// RUN: clang-cc -fsyntax-only %s
+template<class T> struct A { 
+  void f(T);
+  template<class X1> void g1(T, X1); 
+  template<class X2> void g2(T, X2); 
+  void h(T) { }
+};
+
+// specialization 
+template<> void A<int>::f(int);
+
+// out of class member template definition 
+template<class T> template<class X1> void A<T>::g1(T, X1) { }
+
+// member template specialization 
+template<> template<class X1> void A<int>::g1(int, X1);
+
+// member template specialization 
+template<> template<>
+  void A<int>::g1(int, char);	// X1 deduced as char 
+
+template<> template<>
+  void A<int>::g2<char>(int, char); // X2 specified as char 
+                                    // member specialization even if defined in class definition
+
+template<> void A<int>::h(int) { }
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p17.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p17.cpp
new file mode 100644
index 000000000000..883cb71d5686
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p17.cpp
@@ -0,0 +1,12 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+template<class T1> 
+class A {
+  template<class T2> class B {
+    void mf();
+  };
+};
+
+template<> template<> class A<int>::B<double>; 
+template<> template<> void A<char>::B<char>::mf();
+
+template<> void A<char>::B<int>::mf(); // expected-error{{requires 'template<>'}}
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p18.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p18.cpp
new file mode 100644
index 000000000000..a5877d281d74
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p18.cpp
@@ -0,0 +1,20 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+template<class T1> class A { 
+  template<class T2> class B {
+    template<class T3> void mf1(T3); 
+    void mf2();
+  };
+}; 
+
+template<> template<class X>
+class A<long>::B { }; 
+
+template<> template<> template<class T>
+  void A<int>::B<double>::mf1(T t) { } 
+
+template<> template<> template<class T>
+void A<long>::B<double>::mf1(T t) { } // expected-error{{does not match}}
+
+// FIXME: This diagnostic could probably be better.
+template<class Y> template<>
+  void A<Y>::B<double>::mf2() { } // expected-error{{does not refer}}
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p19.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p19.cpp
new file mode 100644
index 000000000000..1f38e5a2c17d
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p19.cpp
@@ -0,0 +1,30 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T>
+struct X {
+  template<typename U> struct Inner { };
+  
+  template<typename U> void f(T, U) { }
+};
+
+template<> template<typename U>
+struct X<int>::Inner {
+  U member;
+};
+
+template<> template<typename U>
+void X<int>::f(int x, U y) { 
+  x = y; // expected-error{{incompatible type}}
+}
+
+void test(X<int> xi, X<long> xl, float *fp) {
+  X<int>::Inner<float*> xii;
+  xii.member = fp;
+  xi.f(17, 25);
+  xi.f(17, 3.14159);
+  xi.f(17, fp); // expected-note{{instantiation}}
+  X<long>::Inner<float*> xli;
+  
+  xli.member = fp; // expected-error{{no member}}
+  xl.f(17, fp); // okay
+}
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p2.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p2.cpp
new file mode 100644
index 000000000000..64856605a0a7
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p2.cpp
@@ -0,0 +1,239 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// This test creates cases where implicit instantiations of various entities
+// would cause a diagnostic, but provides expliict specializations for those
+// entities that avoid the diagnostic. The specializations are alternately
+// declarations and definitions, and the intent of this test is to verify
+// that we allow specializations only in the appropriate namespaces (and
+// nowhere else).
+struct NonDefaultConstructible {
+  NonDefaultConstructible(int);
+};
+
+
+// C++ [temp.expl.spec]p1:
+//   An explicit specialization of any of the following:
+
+//     -- function template
+namespace N0 {
+  template<typename T> void f0(T) { // expected-note{{here}}
+    T t;
+  }
+
+  template<> void f0(NonDefaultConstructible) { }
+
+  void test_f0(NonDefaultConstructible NDC) {
+    f0(NDC);
+  }
+  
+  template<> void f0(int);
+  template<> void f0(long);
+}
+
+template<> void N0::f0(int) { } // okay
+
+namespace N1 {
+  template<> void N0::f0(long) { } // expected-error{{not in a namespace enclosing}}
+}
+
+template<> void N0::f0(double) { } // expected-error{{originally be declared}}
+
+struct X1 {
+  template<typename T> void f(T);
+  
+  template<> void f(int); // expected-error{{in class scope}}
+};
+
+//     -- class template
+namespace N0 {
+  
+template<typename T>
+struct X0 { // expected-note 2{{here}}
+  static T member; // expected-note{{here}}
+  
+  void f1(T t) { // expected-note{{explicitly specialized declaration is here}}
+    t = 17;
+  }
+  
+  struct Inner : public T { }; // expected-note 3{{here}}
+  
+  template<typename U>
+  struct InnerTemplate : public T { }; // expected-note 2{{explicitly specialized}} \
+   // expected-error{{base specifier}}
+  
+  template<typename U>
+  void ft1(T t, U u); // expected-note{{explicitly specialized}}
+};
+
+}
+
+template<typename T> 
+template<typename U>
+void N0::X0<T>::ft1(T t, U u) {
+  t = u;
+}
+
+template<typename T> T N0::X0<T>::member;
+
+template<> struct N0::X0<void> { }; // expected-error{{originally}}
+N0::X0<void> test_X0;
+
+namespace N1 {
+  template<> struct N0::X0<const void> { }; // expected-error{{originally}}
+}
+
+namespace N0 {
+  template<> struct X0<volatile void>;
+}
+
+template<> struct N0::X0<volatile void> { 
+  void f1(void *);
+};
+
+//     -- member function of a class template
+template<> void N0::X0<void*>::f1(void *) { } // expected-error{{member function specialization}}
+
+void test_spec(N0::X0<void*> xvp, void *vp) {
+  xvp.f1(vp);
+}
+
+namespace N0 {
+  template<> void X0<volatile void>::f1(void *) { } // expected-error{{no function template matches}}
+
+  template<> void X0<const volatile void*>::f1(const volatile void*);
+}
+
+void test_x0_cvvoid(N0::X0<const volatile void*> x0, const volatile void *cvp) {
+  x0.f1(cvp); // okay: we've explicitly specialized
+}
+
+//     -- static data member of a class template
+namespace N0 {
+  // This actually tests p15; the following is a declaration, not a definition.
+  template<> 
+  NonDefaultConstructible X0<NonDefaultConstructible>::member;
+  
+  template<> long X0<long>::member = 17;
+
+  template<> float X0<float>::member;
+  
+  template<> double X0<double>::member;
+}
+
+NonDefaultConstructible &get_static_member() {
+  return N0::X0<NonDefaultConstructible>::member;
+}
+
+template<> int N0::X0<int>::member;  // expected-error{{originally}}
+
+template<> float N0::X0<float>::member = 3.14f;
+
+namespace N1 {
+  template<> double N0::X0<double>::member = 3.14; // expected-error{{not in a namespace enclosing}}
+}
+
+//    -- member class of a class template
+namespace N0 {
+  
+  template<>
+  struct X0<void*>::Inner { };
+
+  template<>
+  struct X0<int>::Inner { };
+
+  template<>
+  struct X0<unsigned>::Inner;
+
+  template<>
+  struct X0<float>::Inner;
+
+  template<>
+  struct X0<double>::Inner; // expected-note{{forward declaration}}
+}
+
+template<>
+struct N0::X0<long>::Inner { }; // expected-error{{originally}}
+
+template<>
+struct N0::X0<float>::Inner { };
+
+namespace N1 {
+  template<>
+  struct N0::X0<unsigned>::Inner { }; // expected-error{{member class specialization}}
+
+  template<>
+  struct N0::X0<unsigned long>::Inner { }; // expected-error{{member class specialization}}
+};
+
+N0::X0<void*>::Inner inner0;
+N0::X0<int>::Inner inner1;
+N0::X0<long>::Inner inner2;
+N0::X0<float>::Inner inner3;
+N0::X0<double>::Inner inner4; // expected-error{{incomplete}}
+
+//    -- member class template of a class template
+namespace N0 {
+  template<>
+  template<>
+  struct X0<void*>::InnerTemplate<int> { };
+  
+  template<> template<>
+  struct X0<int>::InnerTemplate<int>; // expected-note{{forward declaration}}
+
+  template<> template<>
+  struct X0<int>::InnerTemplate<long>;
+
+  template<> template<>
+  struct X0<int>::InnerTemplate<double>;
+}
+
+template<> template<>
+struct N0::X0<int>::InnerTemplate<long> { }; // okay
+
+template<> template<>
+struct N0::X0<int>::InnerTemplate<float> { }; // expected-error{{class template specialization}}
+
+namespace N1 {
+  template<> template<>
+  struct N0::X0<int>::InnerTemplate<double> { }; // expected-error{{enclosing}}
+}
+
+N0::X0<void*>::InnerTemplate<int> inner_template0;
+N0::X0<int>::InnerTemplate<int> inner_template1; // expected-error{{incomplete}}
+N0::X0<int>::InnerTemplate<long> inner_template2;
+N0::X0<int>::InnerTemplate<unsigned long> inner_template3; // expected-note{{instantiation}}
+
+//    -- member function template of a class template
+namespace N0 {
+  template<>
+  template<>
+  void X0<void*>::ft1(void*, const void*) { }
+  
+  template<> template<>
+  void X0<void*>::ft1(void *, int);
+
+  template<> template<>
+  void X0<void*>::ft1(void *, unsigned);
+
+  template<> template<>
+  void X0<void*>::ft1(void *, long);
+}
+
+template<> template<>
+void N0::X0<void*>::ft1(void *, unsigned) { } // okay
+
+template<> template<>
+void N0::X0<void*>::ft1(void *, float) { } // expected-error{{function template specialization}}
+
+namespace N1 {
+  template<> template<>
+  void N0::X0<void*>::ft1(void *, long) { } // expected-error{{enclosing}}
+}
+
+
+void test_func_template(N0::X0<void *> xvp, void *vp, const void *cvp,
+                        int i, unsigned u) {
+  xvp.ft1(vp, cvp);
+  xvp.ft1(vp, i);
+  xvp.ft1(vp, u);
+}
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p20.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p20.cpp
new file mode 100644
index 000000000000..d270b8167a16
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p20.cpp
@@ -0,0 +1,14 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+template<typename T>
+void f(T);
+
+template<typename T>
+struct A { };
+
+struct X {
+  template<> friend void f<int>(int); // expected-error{{in class scope}}
+  template<> friend class A<int>; // expected-error{{cannot be a friend}}
+  
+  friend void f<float>(float); // okay
+  friend class A<float>; // okay
+};
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p21.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p21.cpp
new file mode 100644
index 000000000000..9dae3eb5190b
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p21.cpp
@@ -0,0 +1,30 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T>
+struct X {
+  void mf1(T);
+  template<typename U> void mf2(T, U); // expected-note{{previous}}
+};
+
+template<>
+void X<int>::mf1(int i = 17) // expected-error{{default}}
+{
+}
+
+template<> template<>
+void X<int>::mf2(int, int = 17) // expected-error{{default}}
+{ }
+
+template<> template<typename U> 
+void X<int>::mf2(int, U = U()) // expected-error{{default}}
+{
+}
+
+template<>
+struct X<float> {
+  void mf1(float);
+};
+
+void X<float>::mf1(float = 3.14f)  // okay
+{
+}
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p3.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p3.cpp
new file mode 100644
index 000000000000..2bd1400faefb
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p3.cpp
@@ -0,0 +1,14 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+namespace N {
+  template<class T> class X;
+}
+
+// FIXME: this diagnostic is terrible (PR3844).
+template<> class X<int> { /* ... */ };	// expected-error {{unqualified-id}}
+
+namespace N {
+  
+template<> class X<char*> { /* ... */ };	// OK: X is a template
+  
+}
\ No newline at end of file
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p4.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p4.cpp
new file mode 100644
index 000000000000..8d91068f9b99
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p4.cpp
@@ -0,0 +1,59 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+struct IntHolder { // expected-note{{here}}
+  IntHolder(int);
+};
+
+template<typename T, typename U>
+struct X { // expected-note{{here}}
+  void f() { 
+    T t; // expected-error{{no matching}}
+  }
+
+  void g() { }
+  
+  struct Inner { 
+    T value; 	// expected-note {{member is declared here}}
+  };
+  
+  static T value;
+};
+
+template<typename T, typename U>
+T X<T, U>::value; // expected-error{{no matching constructor}}
+
+IntHolder &test_X_IntHolderInt(X<IntHolder, int> xih) {
+  xih.g(); // okay
+  xih.f(); // expected-note{{instantiation}}
+  
+  // FIXME: diagnostic here has incorrect reason (PR5154)
+  X<IntHolder, int>::Inner inner; // expected-error{{implicit default}}
+  
+  return X<IntHolder, int>::value; // expected-note{{instantiation}}
+}
+
+// Explicitly specialize the members of X<IntHolder, long> to not cause
+// problems with instantiation.
+template<>
+void X<IntHolder, long>::f() { }
+
+template<>
+struct X<IntHolder, long>::Inner {
+  Inner() : value(17) { }
+  IntHolder value;
+};
+
+template<>
+IntHolder X<IntHolder, long>::value = 17;
+
+IntHolder &test_X_IntHolderInt(X<IntHolder, long> xih) {
+  xih.g(); // okay
+  xih.f(); // okay, uses specialization
+  
+  X<IntHolder, long>::Inner inner; // okay, uses specialization
+  
+  return X<IntHolder, long>::value; // okay, uses specialization
+}
+
+template<>
+X<IntHolder, long>::X() { } // expected-error{{instantiated member}}
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p5.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p5.cpp
new file mode 100644
index 000000000000..58682c786f95
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p5.cpp
@@ -0,0 +1,61 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+struct IntHolder {
+  IntHolder(int);
+};
+
+template<typename T, typename U>
+struct X {
+  void f() { 
+    T t;
+  }
+  
+  void g() { }
+  
+  struct Inner { 
+    T value; 
+  };
+  
+  static T value;
+};
+
+template<typename T, typename U>
+T X<T, U>::value;
+
+// Explicitly specialize the members of X<IntHolder, long> to not cause
+// problems with instantiation, but only provide declarations (not definitions).
+template<>
+void X<IntHolder, long>::f();
+
+template<>
+struct X<IntHolder, long>::Inner; // expected-note{{forward declaration}}
+
+template<>
+IntHolder X<IntHolder, long>::value;
+
+IntHolder &test_X_IntHolderInt(X<IntHolder, long> xih) {
+  xih.g(); // okay
+  xih.f(); // okay, uses specialization
+  
+  X<IntHolder, long>::Inner inner; // expected-error {{incomplete}}
+  
+  return X<IntHolder, long>::value; // okay, uses specialization
+}
+
+
+template<class T> struct A {
+  void f(T) { /* ... */ }
+};
+
+template<> struct A<int> { 
+  void f(int);
+};
+
+void h() {
+  A<int> a; 
+  a.f(16); // A<int>::f must be defined somewhere
+}
+
+// explicit specialization syntax not used for a member of 
+// explicitly specialized class template specialization 
+void A<int>::f(int) { /* ... */ }
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p6.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p6.cpp
new file mode 100644
index 000000000000..e92d3f0a8883
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p6.cpp
@@ -0,0 +1,56 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T>
+struct X0 {
+  void f();
+  
+  template<typename U>
+  void g(U);
+  
+  struct Nested {
+  };
+  
+  static T member;
+};
+
+int &use_X0_int(X0<int> x0i,  // expected-note{{implicit instantiation first required here}}
+                int i) {
+  x0i.f(); // expected-note{{implicit instantiation first required here}}
+  x0i.g(i); // expected-note{{implicit instantiation first required here}}
+  X0<int>::Nested nested; // expected-note{{implicit instantiation first required here}}
+  return X0<int>::member; // expected-note{{implicit instantiation first required here}}
+}
+
+template<>
+void X0<int>::f() { // expected-error{{after instantiation}}
+}
+
+template<> template<>
+void X0<int>::g(int) { // expected-error{{after instantiation}}
+}
+
+template<>
+struct X0<int>::Nested { }; // expected-error{{after instantiation}}
+
+template<>
+int X0<int>::member = 17; // expected-error{{after instantiation}}
+
+template<>
+struct X0<int> { }; // expected-error{{after instantiation}}
+
+// Example from the standard
+template<class T> class Array { /* ... */ }; 
+
+template<class T> void sort(Array<T>& v) { /* ... */ }
+
+struct String {};
+
+void f(Array<String>& v) {
+  
+  sort(v); // expected-note{{required}}
+           // use primary template 
+           // sort(Array<T>&), T is String
+}
+
+template<> void sort<String>(Array<String>& v); // // expected-error{{after instantiation}}
+template<> void sort<>(Array<char*>& v);	// OK: sort<char*> not yet used
diff --git a/test/CXX/temp/temp.spec/temp.expl.spec/p9.cpp b/test/CXX/temp/temp.spec/temp.expl.spec/p9.cpp
new file mode 100644
index 000000000000..49481d2e6d7a
--- /dev/null
+++ b/test/CXX/temp/temp.spec/temp.expl.spec/p9.cpp
@@ -0,0 +1,14 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+namespace N { 
+  template<class T> class X { /* ... */ }; 
+  template<class T> class Y { /* ... */ };
+  template<> class X<int> { /* ... */ }; 
+  template<> class Y<double>;
+  
+  const unsigned NumElements = 17;
+} 
+
+template<> class N::Y<double> { 
+  int array[NumElements];
+};
diff --git a/test/CodeCompletion/call.cpp b/test/CodeCompletion/call.cpp
new file mode 100644
index 000000000000..90bf82bff307
--- /dev/null
+++ b/test/CodeCompletion/call.cpp
@@ -0,0 +1,28 @@
+// Note: the run lines follow their respective tests, since line/column
+// matter in this test.
+void f(float x, float y);
+void f(int i, int j, int k);
+struct X { };
+void f(X);
+namespace N {
+  struct Y { 
+    Y(int = 0); 
+    
+    operator int() const;
+  };
+  void f(Y y, int ZZ);
+}
+typedef N::Y Y;
+void f();
+
+void test() {
+  f(Y(), 0, 0);
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:19:9 %s -o - | FileCheck -check-prefix=CC1 %s &&
+  // CHECK-CC1: f(struct N::Y y, <#int ZZ#>)
+  // CHECK-CC1-NEXT: f(int i, <#int j#>, int k)
+  // CHECK-CC1-NEXT: f(float x, <#float y#>)
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:19:13 %s -o - | FileCheck -check-prefix=CC2 %s &&
+  // CHECK-CC2-NOT: f(struct N::Y y, int ZZ)
+  // CHECK-CC2: f(int i, int j, <#int k#>)
+  // RUN: true
+}
diff --git a/test/CodeCompletion/enum-switch-case-qualified.cpp b/test/CodeCompletion/enum-switch-case-qualified.cpp
new file mode 100644
index 000000000000..223aca8b9323
--- /dev/null
+++ b/test/CodeCompletion/enum-switch-case-qualified.cpp
@@ -0,0 +1,33 @@
+namespace M {
+  
+namespace N {
+  struct C {
+    enum Color {
+      Red,
+      Orange,
+      Yellow,
+      Green,
+      Blue,
+      Indigo,
+      Violet
+    };
+  };
+}
+  
+}
+
+namespace M {
+  
+void test(enum N::C::Color color) {
+  switch (color) {
+  case 
+    // RUN: clang-cc -fsyntax-only -code-completion-at=%s:23:8 %s -o - | FileCheck -check-prefix=CC1 %s &&
+    // RUN: true
+    // CHECK-CC1: Blue : 0 : N::C::Blue
+    // CHECK-CC1-NEXT: Green : 0 : N::C::Green
+    // CHECK-CC1-NEXT: Indigo : 0 : N::C::Indigo
+    // CHECK-CC1-NEXT: Orange : 0 : N::C::Orange
+    // CHECK-CC1-NEXT: Red : 0 : N::C::Red
+    // CHECK-CC1-NEXT: Violet : 0 : N::C::Violet
+    // CHECK-CC1: Yellow : 0 : N::C::Yellow
+      
diff --git a/test/CodeCompletion/enum-switch-case.c b/test/CodeCompletion/enum-switch-case.c
new file mode 100644
index 000000000000..d8bb5e8ca474
--- /dev/null
+++ b/test/CodeCompletion/enum-switch-case.c
@@ -0,0 +1,29 @@
+enum Color {
+  Red,
+  Orange,
+  Yellow,
+  Green,
+  Blue,
+  Indigo,
+  Violet
+};
+
+void test(enum Color color) {
+  switch (color) {
+    case Red:
+      break;
+      
+    case Yellow:
+      break;
+
+    case Green:
+      break;
+      
+    // RUN: clang-cc -fsyntax-only -code-completion-at=%s:19:10 %s -o - | FileCheck -check-prefix=CC1 %s &&
+    // CHECK-CC1: Blue : 0
+    // CHECK-CC1-NEXT: Green : 0
+    // CHECK-CC1-NEXT: Indigo : 0
+    // CHECK-CC1-NEXT: Orange : 0
+    // CHECK-CC1-NEXT: Violet : 0
+    // RUN: true
+      
diff --git a/test/CodeCompletion/enum-switch-case.cpp b/test/CodeCompletion/enum-switch-case.cpp
new file mode 100644
index 000000000000..7a388fce0e39
--- /dev/null
+++ b/test/CodeCompletion/enum-switch-case.cpp
@@ -0,0 +1,29 @@
+namespace N {
+  enum Color {
+    Red,
+    Orange,
+    Yellow,
+    Green,
+    Blue,
+    Indigo,
+    Violet
+  };
+}
+
+void test(enum N::Color color) {
+  switch (color) {
+  case N::Red:
+    break;
+    
+  case N::Yellow:
+    break;
+    
+  case 
+    // RUN: clang-cc -fsyntax-only -code-completion-at=%s:21:8 %s -o - | FileCheck -check-prefix=CC1 %s &&
+    // CHECK-CC1: Blue : 0 : N::Blue
+    // CHECK-CC1-NEXT: Green : 0 : N::Green
+    // CHECK-CC1-NEXT: Indigo : 0 : N::Indigo
+    // CHECK-CC1-NEXT: Orange : 0 : N::Orange
+    // CHECK-CC1-NEXT: Violet : 0 : N::Violet
+    
+    // RUN: true
diff --git a/test/CodeCompletion/function-templates.cpp b/test/CodeCompletion/function-templates.cpp
new file mode 100644
index 000000000000..52cba71bd2f9
--- /dev/null
+++ b/test/CodeCompletion/function-templates.cpp
@@ -0,0 +1,15 @@
+namespace std {
+  template<typename RandomAccessIterator>
+  void sort(RandomAccessIterator first, RandomAccessIterator last);
+  
+  template<class X, class Y>
+  X* dyn_cast(Y *Val);
+}
+
+void f() {
+  std::  
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:10:8 %s -o - | FileCheck -check-prefix=CC1 %s &&
+  // CHECK-CC1: dyn_cast<<#class X#>>(<#Y *Val#>)
+  // CHECK-CC1: sort(<#RandomAccessIterator first#>, <#RandomAccessIterator last#>)
+  // RUN: true
+  
diff --git a/test/CodeCompletion/functions.cpp b/test/CodeCompletion/functions.cpp
new file mode 100644
index 000000000000..2e1bc6edf8c4
--- /dev/null
+++ b/test/CodeCompletion/functions.cpp
@@ -0,0 +1,9 @@
+void f(int i, int j = 2, int k = 5);
+void f(float x, float y...);
+       
+void test() {
+  ::
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:5:5 %s -o - | FileCheck -check-prefix=CC1 %s &&
+  // CHECK-CC1: f(<#int i#>{#, <#int j#>{#, <#int k#>#}#})
+  // CHECK-CC1: f(<#float x#>, <#float y#><#, ...#>)
+  // RUN: true
diff --git a/test/CodeCompletion/member-access.c b/test/CodeCompletion/member-access.c
new file mode 100644
index 000000000000..1e8e5630981f
--- /dev/null
+++ b/test/CodeCompletion/member-access.c
@@ -0,0 +1,13 @@
+struct Point {
+  float x;
+  float y;
+  float z;
+};
+
+void test(struct Point *p) {
+  p->
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:8:6 %s -o - | FileCheck -check-prefix=CC1 %s &&
+  // CHECK-CC1: x
+  // CHECK-CC1: y
+  // CHECK-CC1: z
+  // RUN: true
diff --git a/test/CodeCompletion/member-access.cpp b/test/CodeCompletion/member-access.cpp
new file mode 100644
index 000000000000..b810366209f5
--- /dev/null
+++ b/test/CodeCompletion/member-access.cpp
@@ -0,0 +1,43 @@
+struct Base1 {
+  int member1;
+  float member2;
+};
+
+struct Base2 {
+  int member1;
+  double member3;
+  void memfun1(int);
+};
+
+struct Base3 : Base1, Base2 {
+  void memfun1(float);
+  void memfun1(double);
+  void memfun2(int);
+};
+
+struct Derived : Base3 {
+  int member4;
+  int memfun3(int);
+};
+
+class Proxy {
+public:
+  Derived *operator->() const;
+};
+
+void test(const Proxy &p) {
+  p->
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:29:6 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s &&
+  // CHECK-CC1: member1 : 0 : [#Base1::#]member1
+  // CHECK-CC1: member1 : 0 : [#Base2::#]member1
+  // CHECK-CC1: member2 : 0 : [#Base1::#]member2
+  // CHECK-CC1: member3 : 0
+  // CHECK-CC1: member4 : 0
+  // CHECK-CC1: memfun1 : 0 : [#Base3::#]memfun1(<#float#>)
+  // CHECK-CC1: memfun1 : 0 : [#Base3::#]memfun1(<#double#>)
+  // CHECK-CC1: memfun2 : 0 : [#Base3::#]memfun2(<#int#>)
+  // CHECK-CC1: memfun3 : 0 : memfun3(<#int#>)
+  // CHECK-CC1: Base1 : 0 : Base1::
+  // CHECK-CC1: memfun1 : 0 (Hidden) : Base2::memfun1(<#int#>)
+  // RUN: true
+  
diff --git a/test/CodeCompletion/namespace-alias.cpp b/test/CodeCompletion/namespace-alias.cpp
new file mode 100644
index 000000000000..0fa2ec20209c
--- /dev/null
+++ b/test/CodeCompletion/namespace-alias.cpp
@@ -0,0 +1,21 @@
+namespace N4 {
+  namespace N3 { }
+}
+
+class N3;
+
+namespace N2 {
+  namespace I1 { }
+  namespace I4 = I1;
+  namespace I5 { }
+  namespace I1 { }
+  
+  namespace New =
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:13:18 %s -o - | FileCheck -check-prefix=CC1 %s &&
+  // CHECK-CC1: I1 : 1
+  // CHECK-CC1: I4 : 1
+  // CHECK-CC1: I5 : 1
+  // CHECK-CC1: N2 : 3
+  // CHECK-CC1-NEXT: N4 : 3
+  // RUN: true
+  
diff --git a/test/CodeCompletion/namespace.cpp b/test/CodeCompletion/namespace.cpp
new file mode 100644
index 000000000000..d4ed639f8a05
--- /dev/null
+++ b/test/CodeCompletion/namespace.cpp
@@ -0,0 +1,15 @@
+namespace N3 {
+}
+
+namespace N2 {
+  namespace I1 { }
+  namespace I4 = I1;
+  namespace I5 { }
+  namespace I1 { }
+  
+  namespace
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:10:12 %s -o - | FileCheck -check-prefix=CC1 %s &&
+  // CHECK-CC1: I1 : 0
+  // CHECK-CC1-NEXT: I5 : 0
+  // RUN: true
+  
diff --git a/test/CodeCompletion/nested-name-specifier.cpp b/test/CodeCompletion/nested-name-specifier.cpp
new file mode 100644
index 000000000000..0cc5a19421c7
--- /dev/null
+++ b/test/CodeCompletion/nested-name-specifier.cpp
@@ -0,0 +1,18 @@
+namespace N {
+  struct A { };
+  namespace M { 
+    struct C { };
+  };
+}
+
+namespace N {
+  struct B { };
+}
+
+N::
+// RUN: clang-cc -fsyntax-only -code-completion-at=%s:12:4 %s -o - | FileCheck -check-prefix=CC1 %s &&
+// CHECK-CC1: A : 0
+// CHECK-CC1: B : 0
+// CHECK-CC1: M : 0
+// RUN: true
+
diff --git a/test/CodeCompletion/operator.cpp b/test/CodeCompletion/operator.cpp
new file mode 100644
index 000000000000..a3950f6b8913
--- /dev/null
+++ b/test/CodeCompletion/operator.cpp
@@ -0,0 +1,18 @@
+class T { };
+
+typedef int Integer;
+
+namespace N { }
+
+void f() {
+  typedef float Float;
+  
+  operator
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:10:11 %s -o - | FileCheck -check-prefix=CC1 %s &&
+  // CHECK-CC1: Float : 0
+  // CHECK-CC1: + : 0
+  // CHECK-CC1: short : 0
+  // CHECK-CC1: Integer : 2
+  // CHECK-CC1: T : 2
+  // CHECK-CC1: N : 6
+  // RUN: true
diff --git a/test/CodeCompletion/ordinary-name.c b/test/CodeCompletion/ordinary-name.c
new file mode 100644
index 000000000000..586e2b371bd7
--- /dev/null
+++ b/test/CodeCompletion/ordinary-name.c
@@ -0,0 +1,12 @@
+struct X { int x; };
+
+typedef struct t TYPEDEF;
+
+void foo() {
+  int y;
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:6:9 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s &&
+  // CHECK-CC1: y : 0
+  // CHECK-CC1: foo : 2
+  // CHECK-NOT-CC1: y : 2
+  // CHECK-CC1-NEXT: TYPEDEF : 2
+  // RUN: true
diff --git a/test/CodeCompletion/property.m b/test/CodeCompletion/property.m
new file mode 100644
index 000000000000..7f2321ee1395
--- /dev/null
+++ b/test/CodeCompletion/property.m
@@ -0,0 +1,29 @@
+// Note: the run lines follow their respective tests, since line/column
+// matter in this test.
+
+@interface Foo  {
+  void *isa;
+}
+@property(copy) Foo *myprop;
+@property(retain, nonatomic) id xx;
+// RUN: clang-cc -fsyntax-only -code-completion-at=%s:7:11 %s -o - | FileCheck -check-prefix=CC1 %s &&
+// CC1: assign
+// CC1-NEXT: copy
+// CC1-NEXT: getter
+// CC1-NEXT: nonatomic
+// CC1-NEXT: readonly
+// CC1-NEXT: readwrite
+// CC1-NEXT: retain
+// CC1-NEXT: setter
+// RUN: clang-cc -fsyntax-only -code-completion-at=%s:8:18 %s -o - | FileCheck -check-prefix=CC2 %s
+// CC2: assign
+// CC2-NEXT: copy
+// CC2-NEXT: getter
+// CC2-NEXT: nonatomic
+// CC2-NEXT: readonly
+// CC2-NEXT: readwrite
+// CC2-NEXT: setter
+@end
+
+
+
diff --git a/test/CodeCompletion/tag.c b/test/CodeCompletion/tag.c
new file mode 100644
index 000000000000..e7250f540c4f
--- /dev/null
+++ b/test/CodeCompletion/tag.c
@@ -0,0 +1,13 @@
+enum X { x };
+enum Y { y };
+struct Z { };
+
+void X();
+
+void test() {
+  enum X { x };
+  enum
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:9:7 %s -o - | FileCheck -check-prefix=CC1 %s &&
+  // CHECK-CC1: X : 0
+  // CHECK-CC1: Y : 2
+  // RUN: true
diff --git a/test/CodeCompletion/tag.cpp b/test/CodeCompletion/tag.cpp
new file mode 100644
index 000000000000..b00ff1fabdaa
--- /dev/null
+++ b/test/CodeCompletion/tag.cpp
@@ -0,0 +1,26 @@
+class X { };
+struct Y { };
+
+namespace N {
+  template<typename> class Z;
+}
+
+namespace M {
+  class A;
+}
+using M::A;
+
+namespace N {
+  class Y;
+  
+  void test() {
+    class
+    // RUN: clang-cc -fsyntax-only -code-completion-at=%s:17:10 %s -o - | FileCheck -check-prefix=CC1 %s &&
+    // CHECK-CC1: Y : 2
+    // CHECK-CC1: Z : 2
+    // CHECK-CC1: A : 4
+    // CHECK-CC1: X : 4
+    // CHECK-CC1: Y : 4
+    // CHECK-CC1: M : 9 : M::
+    // CHECK-CC1: N : 9 : N::
+    // RUN: true
diff --git a/test/CodeCompletion/templates.cpp b/test/CodeCompletion/templates.cpp
new file mode 100644
index 000000000000..22cca65bea98
--- /dev/null
+++ b/test/CodeCompletion/templates.cpp
@@ -0,0 +1,17 @@
+namespace std {
+  template<typename T>
+  class allocator;
+  
+  template<typename T, typename Alloc = std::allocator<T> >
+  class vector;
+}
+
+void f() {
+  std::
+  // RUN: clang-cc -fsyntax-only -code-completion-at=%s:10:8 %s -o - | FileCheck -check-prefix=CC1 %s &&
+  // CHECK-CC1: allocator<<#typename T#>>
+  // CHECK-CC1: vector<<#typename T#>{#, <#typename Alloc#>#}>
+  // RUN: true
+  
+  
+
diff --git a/test/CodeCompletion/truncation.c b/test/CodeCompletion/truncation.c
new file mode 100644
index 000000000000..b72aa7facf79
--- /dev/null
+++ b/test/CodeCompletion/truncation.c
@@ -0,0 +1,12 @@
+#include "truncation.c.h"
+
+struct 
+
+// RUN: clang-cc -fsyntax-only -code-completion-at=%s.h:4:8 -o - %s | FileCheck -check-prefix=CC1 %s &&
+// CHECK-CC1: X : 1
+// CHECK-CC1-NEXT: Y : 1
+// RUN: clang-cc -fsyntax-only -code-completion-at=%s:3:8 -o - %s | FileCheck -check-prefix=CC2 %s &&
+// CHECK-CC2: X : 1
+// CHECK-CC2: Xa : 1
+// CHECK-CC2: Y : 1
+// RUN: true
diff --git a/test/CodeCompletion/truncation.c.h b/test/CodeCompletion/truncation.c.h
new file mode 100644
index 000000000000..a5ebbacb3442
--- /dev/null
+++ b/test/CodeCompletion/truncation.c.h
@@ -0,0 +1,5 @@
+struct X { };
+struct Y { };
+
+struct Xa { };
+
diff --git a/test/CodeCompletion/using-namespace.cpp b/test/CodeCompletion/using-namespace.cpp
new file mode 100644
index 000000000000..a332b880074e
--- /dev/null
+++ b/test/CodeCompletion/using-namespace.cpp
@@ -0,0 +1,21 @@
+namespace N4 {
+  namespace N3 { }
+}
+
+class N3;
+
+namespace N2 {
+  namespace I1 { }
+  namespace I4 = I1;
+  namespace I5 { }
+  namespace I1 { }
+  
+  void foo() {
+    using namespace
+    // RUN: clang-cc -fsyntax-only -code-completion-at=%s:14:20 %s -o - | FileCheck -check-prefix=CC1 %s &&
+    // CHECK-CC1: I1 : 2
+    // CHECK-CC1: I4 : 2
+    // CHECK-CC1: I5 : 2
+    // CHECK-CC1: N2 : 4
+    // CHECK-CC1-NEXT: N4 : 4
+    // RUN: true
diff --git a/test/CodeCompletion/using.cpp b/test/CodeCompletion/using.cpp
new file mode 100644
index 000000000000..57b3aa7880a2
--- /dev/null
+++ b/test/CodeCompletion/using.cpp
@@ -0,0 +1,25 @@
+namespace N4 {
+  namespace N3 { }
+}
+
+class N3;
+
+namespace N2 {
+  namespace I1 { }
+  namespace I4 = I1;
+  namespace I5 { }
+  namespace I1 { }
+  
+  void foo() {
+    int N3;
+    
+    using
+    // RUN: clang-cc -fsyntax-only -code-completion-at=%s:16:10 %s -o - | FileCheck -check-prefix=CC1 %s &&
+    // CHECK-CC1: I1 : 2
+    // CHECK-CC1: I4 : 2
+    // CHECK-CC1: I5 : 2
+    // CHECK-CC1: N2 : 4
+    // CHECK-CC1: N3 : 4
+    // CHECK-CC1-NEXT: N4 : 4
+    // RUN: true
+
diff --git a/test/CodeGen/2008-07-17-no-emit-on-error.c b/test/CodeGen/2008-07-17-no-emit-on-error.c
index 89aeb18d9d13..51ba2b45d063 100644
--- a/test/CodeGen/2008-07-17-no-emit-on-error.c
+++ b/test/CodeGen/2008-07-17-no-emit-on-error.c
@@ -1,5 +1,5 @@
-// RUN: rm -f %t1.bc 
-// RUN: not clang-cc %s -emit-llvm-bc -o %t1.bc
+// RUN: rm -f %t1.bc &&
+// RUN: not clang-cc %s -emit-llvm-bc -o %t1.bc &&
 // RUN: not test -f %t1.bc
 
 void f() {
diff --git a/test/CodeGen/2008-07-22-bitfield-init-after-zero-len-array.c b/test/CodeGen/2008-07-22-bitfield-init-after-zero-len-array.c
index 19bf9a2b078e..348ea75ea295 100644
--- a/test/CodeGen/2008-07-22-bitfield-init-after-zero-len-array.c
+++ b/test/CodeGen/2008-07-22-bitfield-init-after-zero-len-array.c
@@ -1,5 +1,4 @@
-// RUN: clang-cc --emit-llvm -o %t %s &&
-// RUN: grep "i8 52" %t | count 1
+// RUN: clang-cc -triple=i686-apple-darwin9 --emit-llvm -o - %s | FileCheck %s
 
 struct et7 {
   float lv7[0];
@@ -9,3 +8,5 @@ struct et7 {
   52, 
 };
 
+// CHECK: @yv7 = global 
+// CHECK: i8 52,
\ No newline at end of file
diff --git a/test/CodeGen/2008-07-29-override-alias-decl.c b/test/CodeGen/2008-07-29-override-alias-decl.c
index 43f4e3ecedae..4a36e0f13d5c 100644
--- a/test/CodeGen/2008-07-29-override-alias-decl.c
+++ b/test/CodeGen/2008-07-29-override-alias-decl.c
@@ -1,6 +1,6 @@
 // RUN: clang-cc -emit-llvm -o - %s | grep -e "^@f" | count 1
 
-int x() {}
+int x() { return 1; }
 
 int f() __attribute__((weak, alias("x")));
 
diff --git a/test/CodeGen/2009-01-21-invalid-debug-info.m b/test/CodeGen/2009-01-21-invalid-debug-info.m
index 9a955a1c0d95..2662b922a03c 100644
--- a/test/CodeGen/2009-01-21-invalid-debug-info.m
+++ b/test/CodeGen/2009-01-21-invalid-debug-info.m
@@ -10,7 +10,7 @@
 @interface I1 @end
 
 @implementation I1
--im0 {}
+-im0 { return 0; }
 @end
 
 I1 *f1(void) { return 0; }
diff --git a/test/CodeGen/2009-04-23-dbg.c b/test/CodeGen/2009-04-23-dbg.c
index 4be6dab7ea2b..c6b179126e03 100644
--- a/test/CodeGen/2009-04-23-dbg.c
+++ b/test/CodeGen/2009-04-23-dbg.c
@@ -1,4 +1,4 @@
-// RUN: clang-cc -g -o %t  %s -emit-llvm-bc && llc %t -f -o %t.s
+// RUN: clang-cc -g -o %t  %s -emit-llvm-bc && llc %t -o %t.s
 # 1 "a.c"
 # 1 "a.c" 1
 # 1 "<built-in>" 1
diff --git a/test/CodeGen/2009-06-01-addrofknr.c b/test/CodeGen/2009-06-01-addrofknr.c
index 16a5bbffc3af..d51a4a47b478 100644
--- a/test/CodeGen/2009-06-01-addrofknr.c
+++ b/test/CodeGen/2009-06-01-addrofknr.c
@@ -2,20 +2,20 @@
 // PR4289
 
 struct funcptr {
-    int (*func)();
+  int (*func)();
 };
 
 static int func(f)
-        void *f;
+  void *f;
 {
+  return 0;
 }
 
 int
 main(int argc, char *argv[])
 {
-        struct funcptr fp;
+  struct funcptr fp;
 
-        fp.func = &func;
-        fp.func = func;
+  fp.func = &func;
+  fp.func = func;
 }
-
diff --git a/test/CodeGen/2009-07-31-DbgDeclare.c b/test/CodeGen/2009-07-31-DbgDeclare.c
new file mode 100644
index 000000000000..da49afedbc7a
--- /dev/null
+++ b/test/CodeGen/2009-07-31-DbgDeclare.c
@@ -0,0 +1,5 @@
+// RUN: clang-cc -S -g -o %t.s %s
+void foo() {
+     int i = 0;
+     i = 42;
+}
diff --git a/test/CodeGen/2009-08-14-vararray-crash.c b/test/CodeGen/2009-08-14-vararray-crash.c
new file mode 100644
index 000000000000..40e071bd19a0
--- /dev/null
+++ b/test/CodeGen/2009-08-14-vararray-crash.c
@@ -0,0 +1,11 @@
+// RUN: clang-cc -emit-llvm < %s
+
+void sum1(int rb) {
+  typedef unsigned char imgrow[rb];
+  typedef imgrow img[rb];
+
+  const img *br;
+  int y;
+
+  (*br)[y];
+}
diff --git a/test/CodeGen/PR3613-static-decl.c b/test/CodeGen/PR3613-static-decl.c
index 365b9b2be05e..208358130000 100644
--- a/test/CodeGen/PR3613-static-decl.c
+++ b/test/CodeGen/PR3613-static-decl.c
@@ -1,5 +1,5 @@
 // RUN: clang-cc -triple i386-unknown-unknown -emit-llvm -o %t %s &&
-// RUN: grep '@g0 = internal global .struct.s0 <{ i32 3 }>' %t | count 1
+// RUN: grep '@g0 = internal global %.truct.s0 { i32 3 }' %t | count 1
 
 struct s0 {
   int a;
diff --git a/test/CodeGen/PR4611-bitfield-layout.c b/test/CodeGen/PR4611-bitfield-layout.c
new file mode 100644
index 000000000000..83ce4ffdbd6d
--- /dev/null
+++ b/test/CodeGen/PR4611-bitfield-layout.c
@@ -0,0 +1,6 @@
+// RUN: clang-cc -triple i386-unknown-unknown %s -emit-llvm -o %t &&
+// RUN: grep "struct.object_entry = type { i8, \[2 x i8\], i8 }" %t
+
+struct object_entry {
+       unsigned int type:3, pack_id:16, depth:13;
+} entries;
diff --git a/test/CodeGen/PR5060-align.c b/test/CodeGen/PR5060-align.c
new file mode 100644
index 000000000000..5d864084b012
--- /dev/null
+++ b/test/CodeGen/PR5060-align.c
@@ -0,0 +1,13 @@
+// RUN: clang-cc -emit-llvm %s -o - -verify | FileCheck %s
+
+// CHECK: @foo.p = internal global i8 0, align 32
+char *foo(void) {
+  static char p __attribute__((aligned(32)));
+  return &p;
+}
+
+void bar(long n) {
+  // CHECK: align 32
+  char p[n] __attribute__((aligned(32)));
+}
+
diff --git a/test/CodeGen/address-space-compound-literal.c b/test/CodeGen/address-space-compound-literal.c
new file mode 100644
index 000000000000..79d19ed6b6ba
--- /dev/null
+++ b/test/CodeGen/address-space-compound-literal.c
@@ -0,0 +1,5 @@
+// RUN: clang-cc -emit-llvm < %s | grep "internal addrspace(1) global i32 1"
+
+typedef int a __attribute__((address_space(1)));
+a* x = &(a){1};
+
diff --git a/test/CodeGen/address-space-field1.c b/test/CodeGen/address-space-field1.c
new file mode 100644
index 000000000000..f8ec83ca71cf
--- /dev/null
+++ b/test/CodeGen/address-space-field1.c
@@ -0,0 +1,39 @@
+// RUN: clang-cc -emit-llvm < %s -o - | FileCheck %s
+// CHECK:%struct.S = type { i32, i32 }
+// CHECK:define void @test_addrspace(%struct.S addrspace(1)* %p1, %struct.S addrspace(2)* %p2) nounwind
+// CHECK:entry:
+// CHECK:  %p1.addr = alloca %struct.S addrspace(1)*       ; <%struct.S addrspace(1)**> [#uses=3]
+// CHECK:  %p2.addr = alloca %struct.S addrspace(2)*       ; <%struct.S addrspace(2)**> [#uses=3]
+// CHECK:  store %struct.S addrspace(1)* %p1, %struct.S addrspace(1)** %p1.addr
+// CHECK:  store %struct.S addrspace(2)* %p2, %struct.S addrspace(2)** %p2.addr
+// CHECK:  %tmp = load %struct.S addrspace(2)** %p2.addr   ; <%struct.S addrspace(2)*> [#uses=1]
+// CHECK:  %tmp1 = getelementptr inbounds %struct.S addrspace(2)* %tmp, i32 0, i32 1 ; <i32 addrspace(2)*> [#uses=1]
+// CHECK:  %tmp2 = load i32 addrspace(2)* %tmp1            ; <i32> [#uses=1]
+// CHECK:  %tmp3 = load %struct.S addrspace(1)** %p1.addr  ; <%struct.S addrspace(1)*> [#uses=1]
+// CHECK:  %tmp4 = getelementptr inbounds %struct.S addrspace(1)* %tmp3, i32 0, i32 0 ; <i32 addrspace(1)*> [#uses=1]
+// CHECK:  store i32 %tmp2, i32 addrspace(1)* %tmp4
+// CHECK:  %tmp5 = load %struct.S addrspace(2)** %p2.addr  ; <%struct.S addrspace(2)*> [#uses=1]
+// CHECK:  %tmp6 = getelementptr inbounds %struct.S addrspace(2)* %tmp5, i32 0, i32 0 ; <i32 addrspace(2)*> [#uses=1]
+// CHECK:  %tmp7 = load i32 addrspace(2)* %tmp6            ; <i32> [#uses=1]
+// CHECK:  %tmp8 = load %struct.S addrspace(1)** %p1.addr  ; <%struct.S addrspace(1)*> [#uses=1]
+// CHECK:  %tmp9 = getelementptr inbounds %struct.S addrspace(1)* %tmp8, i32 0, i32 1 ; <i32 addrspace(1)*> [#uses=1]
+// CHECK:  store i32 %tmp7, i32 addrspace(1)* %tmp9
+// CHECK:  ret void
+// CHECK:}
+
+// Check that we don't lose the address space when accessing a member
+// of a structure.
+
+#define __addr1    __attribute__((address_space(1)))
+#define __addr2    __attribute__((address_space(2)))
+
+typedef struct S {
+  int a;
+  int b;
+} S;
+
+void test_addrspace(__addr1 S* p1, __addr2 S*p2) {
+  // swap
+  p1->a = p2->b;
+  p1->b = p2->a;
+}
diff --git a/test/CodeGen/address-space-field2.c b/test/CodeGen/address-space-field2.c
new file mode 100644
index 000000000000..5576e55b63fa
--- /dev/null
+++ b/test/CodeGen/address-space-field2.c
@@ -0,0 +1,50 @@
+// RUN: clang-cc -emit-llvm %s -o - | FileCheck %s
+// CHECK: addrspace(1)
+// CHECK: addrspace(2)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+
+// Check that we don't lose the address space when accessing an array element
+// inside a structure.
+
+#define __addr1    __attribute__((address_space(1)))
+#define __addr2    __attribute__((address_space(2)))
+
+typedef struct S {
+  int arr[ 3 ];
+} S;
+
+void test_addrspace(__addr1 S* p1, __addr2 S*p2, int* val, int n) {
+  for (int i=0; i < 3; ++i) {
+    int t = val[i];
+    p1->arr[i] = t;
+    for (int j=0; j < n; ++j)
+      p2[j].arr[i] = t;
+  }
+}
diff --git a/test/CodeGen/address-space-field3.c b/test/CodeGen/address-space-field3.c
new file mode 100644
index 000000000000..567757fe6670
--- /dev/null
+++ b/test/CodeGen/address-space-field3.c
@@ -0,0 +1,46 @@
+// RUN: clang-cc -emit-llvm %s -o - | FileCheck %s
+// CHECK: addrspace(1)
+// CHECK: addrspace(2)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+
+// Check that we don't lose the address space when accessing an array element
+// inside a structure.
+
+#define __addr1    __attribute__((address_space(1)))
+#define __addr2    __attribute__((address_space(2)))
+
+typedef struct S {
+  int arr[ 3 ];
+} S;
+
+void test_addrspace(__addr1 S* p1, __addr2 S*p2, int* val, int n) {
+  for (int i=0; i < 3; ++i) {
+    int t = val[i];
+    p1->arr[i] = p2->arr[i];
+  }
+}
diff --git a/test/CodeGen/address-space-field4.c b/test/CodeGen/address-space-field4.c
new file mode 100644
index 000000000000..31df018206b5
--- /dev/null
+++ b/test/CodeGen/address-space-field4.c
@@ -0,0 +1,61 @@
+// RUN: clang-cc -emit-llvm %s -o - | FileCheck %s
+// CHECK: addrspace(2)
+// CHECK: addrspace(3)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(3)
+// CHECK: addrspace(3)
+// CHECK: addrspace(1)
+// CHECK: addrspace(3)
+// CHECK: addrspace(3)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(1)
+// CHECK: addrspace(2)
+// CHECK: addrspace(1)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+// CHECK: addrspace(2)
+
+// Check the load and store are using the correct address space to access
+// the variables.
+
+#define __addr1    __attribute__((address_space(1)))
+#define __addr2    __attribute__((address_space(2)))
+#define __addr3    __attribute__((address_space(3)))
+
+typedef struct Pair {
+  __addr2 int* a;
+  __addr3 int* b;
+} Pair;
+
+typedef struct S {
+  Pair arr[ 3 ];
+} S;
+
+void test_addrspace(__addr1 S* p1, __addr1 S* p2) {
+  *p1->arr[0].a = *p2->arr[1].b;
+}
diff --git a/test/CodeGen/arm-arguments.c b/test/CodeGen/arm-arguments.c
new file mode 100644
index 000000000000..c43ede2ca05e
--- /dev/null
+++ b/test/CodeGen/arm-arguments.c
@@ -0,0 +1,94 @@
+// RUN: clang-cc -triple armv7-apple-darwin9 -target-abi=apcs-gnu -emit-llvm -w -o - %s | FileCheck -check-prefix=APCS-GNU %s &&
+// RUN: clang-cc -triple armv7-apple-darwin9 -target-abi=aapcs -emit-llvm -w -o - %s | FileCheck -check-prefix=AAPCS %s
+
+// APCS-GNU: define arm_apcscc signext i8 @f0()
+// AAPCS: define arm_aapcscc signext i8 @f0()
+char f0(void) {
+  return 0;
+}
+
+// APCS-GNU: define arm_apcscc i8 @f1()
+// AAPCS: define arm_aapcscc i8 @f1()
+struct s1 { char f0; };
+struct s1 f1(void) {}
+
+// APCS-GNU: define arm_apcscc i16 @f2()
+// AAPCS: define arm_aapcscc i16 @f2()
+struct s2 { short f0; };
+struct s2 f2(void) {}
+
+// APCS-GNU: define arm_apcscc i32 @f3()
+// AAPCS: define arm_aapcscc i32 @f3()
+struct s3 { int f0; };
+struct s3 f3(void) {}
+
+// APCS-GNU: define arm_apcscc i32 @f4()
+// AAPCS: define arm_aapcscc i32 @f4()
+struct s4 { struct s4_0 { int f0; } f0; };
+struct s4 f4(void) {}
+
+// APCS-GNU: define arm_apcscc void @f5(
+// APCS-GNU: struct.s5* noalias sret
+// AAPCS: define arm_aapcscc i32 @f5()
+struct s5 { struct { } f0; int f1; };
+struct s5 f5(void) {}
+
+// APCS-GNU: define arm_apcscc void @f6(
+// APCS-GNU: struct.s6* noalias sret
+// AAPCS: define arm_aapcscc i32 @f6()
+struct s6 { int f0[1]; };
+struct s6 f6(void) {}
+
+// APCS-GNU: define arm_apcscc void @f7()
+// AAPCS: define arm_aapcscc void @f7()
+struct s7 { struct { int : 0; } f0; };
+struct s7 f7(void) {}
+
+// APCS-GNU: define arm_apcscc void @f8(
+// APCS-GNU: struct.s8* noalias sret
+// AAPCS: define arm_aapcscc void @f8()
+struct s8 { struct { int : 0; } f0[1]; };
+struct s8 f8(void) {}
+
+// APCS-GNU: define arm_apcscc i32 @f9()
+// AAPCS: define arm_aapcscc i32 @f9()
+struct s9 { int f0; int : 0; };
+struct s9 f9(void) {}
+
+// APCS-GNU: define arm_apcscc i32 @f10()
+// AAPCS: define arm_aapcscc i32 @f10()
+struct s10 { int f0; int : 0; int : 0; };
+struct s10 f10(void) {}
+
+// APCS-GNU: define arm_apcscc void @f11(
+// APCS-GNU: struct.s10* noalias sret
+// AAPCS: define arm_aapcscc i32 @f11()
+struct s11 { int : 0; int f0; };
+struct s11 f11(void) {}
+
+// APCS-GNU: define arm_apcscc i32 @f12()
+// AAPCS: define arm_aapcscc i32 @f12()
+union u12 { char f0; short f1; int f2; };
+union u12 f12(void) {}
+
+// APCS-GNU: define arm_apcscc void @f13(
+// APCS-GNU: struct.s13* noalias sret
+
+// FIXME: This should return a float.
+// AAPCS-FIXME: define arm_aapcscc float @f13()
+struct s13 { float f0; };
+struct s13 f13(void) {}
+
+// APCS-GNU: define arm_apcscc void @f14(
+// APCS-GNU: struct.s13* noalias sret
+// AAPCS: define arm_aapcscc i32 @f14()
+union u14 { float f0; };
+union u14 f14(void) {}
+
+// APCS-GNU: define arm_apcscc void @f15()
+// AAPCS: define arm_aapcscc void @f15()
+void f15(struct s7 a0) {}
+
+// APCS-GNU: define arm_apcscc void @f16()
+// AAPCS: define arm_aapcscc void @f16()
+void f16(struct s8 a0) {}
diff --git a/test/CodeGen/arm_asm_clobber.c b/test/CodeGen/arm_asm_clobber.c
new file mode 100644
index 000000000000..34e2517aefab
--- /dev/null
+++ b/test/CodeGen/arm_asm_clobber.c
@@ -0,0 +1,21 @@
+// RUN: clang -ccc-host-triple armv6-unknown-unknown -emit-llvm -S -o %t %s
+
+void test0(void) {
+	asm volatile("mov r0, r0" :: );
+}
+void test1(void) {
+	asm volatile("mov r0, r0" :::
+				 "cc", "memory" );
+}
+void test2(void) {
+	asm volatile("mov r0, r0" :::
+				 "r0", "r1", "r2", "r3");
+	asm volatile("mov r0, r0" :::
+				 "r4", "r5", "r6", "r8");
+}
+void test3(void) {
+	asm volatile("mov r0, r0" :::
+				 "a1", "a2", "a3", "a4");
+	asm volatile("mov r0, r0" :::
+				 "v1", "v2", "v3", "v5");
+}
diff --git a/test/CodeGen/array.c b/test/CodeGen/array.c
index 5bcc26ecf38b..294dabfbbb5d 100644
--- a/test/CodeGen/array.c
+++ b/test/CodeGen/array.c
@@ -1,11 +1,11 @@
 // RUN: clang-cc -emit-llvm %s -o %t
 
-int f() {
+void f() {
  int a[2];
  a[0] = 0;
 }
 
-int f2() {
+void f2() {
   int x = 0;
   int y = 1;
   int a[10] = { y, x, 2, 3};
diff --git a/test/CodeGen/asm-inout.c b/test/CodeGen/asm-inout.c
new file mode 100644
index 000000000000..0d8dbdfb9d38
--- /dev/null
+++ b/test/CodeGen/asm-inout.c
@@ -0,0 +1,18 @@
+// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm %s -o %t &&
+// RUN: grep "load i8\*\*\* %p.addr"  %t | count 1
+// XFAIL
+
+// PR3800
+void f(void **p)
+{
+    __asm__ volatile("" :"+m"(*p));
+}
+
+#if 0
+// FIXME: Once this works again, we must verify that the code below behaves as expected
+// See PR4677.
+void f() {
+  unsigned _data = 42;
+  __asm__("bswap   %0":"+r"(_data));
+}
+#endif
diff --git a/test/CodeGen/asm.c b/test/CodeGen/asm.c
index 58373fc4c96e..52afc9152748 100644
--- a/test/CodeGen/asm.c
+++ b/test/CodeGen/asm.c
@@ -15,7 +15,7 @@ void t4() {
   unsigned long long a;
   struct reg { unsigned long long a, b; } b;
 
-	__asm__ volatile ("":: "m"(a), "m"(b));
+  __asm__ volatile ("":: "m"(a), "m"(b));
 }
 
 // PR3417
@@ -33,7 +33,7 @@ void t7(int a) {
   __asm__ volatile("T7 NAMED: %[input]" : "+r"(a): [input] "i" (4));
 }
 
-// RUN: grep "T8 NAMED MODIFIER: \${0:c}" %t
+// RUN: grep "T8 NAMED MODIFIER: \${0:c}" %t &&
 void t8() {
   __asm__ volatile("T8 NAMED MODIFIER: %c[input]" :: [input] "i" (4));
 }
@@ -101,3 +101,12 @@ void t14(struct S *P) {
 }
 
 
+// PR4938
+int t16() {
+  int a,b;
+  asm ( "nop;"
+       :"=%c" (a)
+       : "r" (b)
+       );
+  return 0;
+}
diff --git a/test/CodeGen/attr-cleanup.c b/test/CodeGen/attr-cleanup.c
index 03dde3341e6c..9105ededa20c 100644
--- a/test/CodeGen/attr-cleanup.c
+++ b/test/CodeGen/attr-cleanup.c
@@ -3,6 +3,6 @@
 // <rdar://problem/6827047>
 void f(void* arg);
 void g() {
-	__attribute__((cleanup(f))) void *g;
+  __attribute__((cleanup(f))) void *g;
 }
 
diff --git a/test/CodeGen/attributes.c b/test/CodeGen/attributes.c
index 8f157f3d314b..d539e033a7e9 100644
--- a/test/CodeGen/attributes.c
+++ b/test/CodeGen/attributes.c
@@ -1,69 +1,77 @@
-// RUN: clang-cc -emit-llvm -o %t %s &&
-// RUN: grep 't1.*noreturn' %t &&
-// RUN: grep 't2.*nounwind' %t &&
-// RUN: grep 'weak.*t3' %t &&
-// RUN: grep 'hidden.*t4' %t &&
-// RUN: grep 't5.*weak' %t &&
-// RUN: grep 't6.*protected' %t &&
-// RUN: grep 't7.*noreturn' %t &&
-// RUN: grep 't7.*nounwind' %t &&
-// RUN: grep 't9.*alias.*weak.*t8' %t &&
-// RUN: grep '@t10().*section "SECT"' %t &&
-// RUN: grep '@t11().*section "SECT"' %t &&
-// RUN: grep '@t12 =.*section "SECT"' %t &&
-// RUN: grep '@t13 =.*section "SECT"' %t &&
-// RUN: grep '@t14.x =.*section "SECT"' %t
-// RUN: grep 'declare extern_weak i32 @t15()' %t &&
-// RUN: grep '@t16 = extern_weak global i32' %t &&
+// RUN: clang-cc -emit-llvm -triple i386-linux-gnu -o %t %s &&
+// RUN: FileCheck --input-file=%t %s
 
-void t1() __attribute__((noreturn));
-void t1() {}
+// CHECK: @t5 = weak global i32 2
+int t5 __attribute__((weak)) = 2;
 
-void t2() __attribute__((nothrow));
-void t2() {}
+// CHECK: @t13 = global %0 zeroinitializer, section "SECT"
+struct s0 { int x; };
+struct s0 t13 __attribute__((section("SECT"))) = { 0 };
 
-void t3() __attribute__((weak));
-void t3() {}
+// CHECK: @t14.x = internal global i32 0, section "SECT"
+void t14(void) {
+  static int x __attribute__((section("SECT"))) = 0;
+}
 
-void t4() __attribute__((visibility("hidden")));
-void t4() {}
+// CHECK: @t18 = global i32 1, align 4
+extern int t18 __attribute__((weak_import));
+int t18 = 1;
 
-int t5 __attribute__((weak)) = 2;
+// CHECK: @t16 = extern_weak global i32
+extern int t16 __attribute__((weak_import));
 
+// CHECK: @t6 = common protected global i32 0
 int t6 __attribute__((visibility("protected")));
 
-void t7() __attribute__((noreturn, nothrow));
-void t7() {}
+// CHECK: @t12 = global i32 0, section "SECT"
+int t12 __attribute__((section("SECT")));
 
+// CHECK: @t9 = alias weak bitcast (void ()* @__t8 to void (...)*)
 void __t8() {}
 void t9() __attribute__((weak, alias("__t8")));
 
-void t10(void) __attribute__((section("SECT")));
-void t10(void) {}
-void __attribute__((section("SECT"))) t11(void) {}
-
-int t12 __attribute__((section("SECT")));
-struct s0 { int x; };
-struct s0 t13 __attribute__((section("SECT"))) = { 0 };
-
-void t14(void) {
-  static int x __attribute__((section("SECT"))) = 0;
-}
-
+// CHECK: declare extern_weak i32 @t15()
 int __attribute__((weak_import)) t15(void);
-extern int t16 __attribute__((weak_import));
 int t17() {
   return t15() + t16;
 }
 
-// RUN: grep '@t18 = global i[0-9]* 1, align .*' %t &&
-extern int t18 __attribute__((weak_import));
-int t18 = 1;
+// CHECK: define void @t1() noreturn nounwind {
+void t1() __attribute__((noreturn));
+void t1() { while (1) {} }
+
+// CHECK: define void @t2() nounwind {
+void t2() __attribute__((nothrow));
+void t2() {}
 
-// RUN: grep 'define i[0-9]* @t19()' %t &&
+// CHECK: define weak void @t3() nounwind {
+void t3() __attribute__((weak));
+void t3() {}
+
+// CHECK: define hidden void @t4() nounwind {
+void t4() __attribute__((visibility("hidden")));
+void t4() {}
+
+// CHECK: define void @t7() noreturn nounwind {
+void t7() __attribute__((noreturn, nothrow));
+void t7() { while (1) {} }
+
+// CHECK: define void @t10() nounwind section "SECT" {
+void t10(void) __attribute__((section("SECT")));
+void t10(void) {}
+// CHECK: define void @t11() nounwind section "SECT" {
+void __attribute__((section("SECT"))) t11(void) {}
+
+// CHECK: define i32 @t19() nounwind {
 extern int t19(void) __attribute__((weak_import));
 int t19(void) {
   return 10;
 }
 
-// RUN: true
+// CHECK:define void @t20() nounwind {
+// CHECK-NEXT:entry:
+// CHECK-NEXT: call void @abort()
+// CHECK-NEXT: unreachable
+void t20(void) {
+  __builtin_abort();
+}
diff --git a/test/CodeGen/blocks-2.c b/test/CodeGen/blocks-2.c
index 5ee2a73a82c9..bc6c2b916abd 100644
--- a/test/CodeGen/blocks-2.c
+++ b/test/CodeGen/blocks-2.c
@@ -1,6 +1,7 @@
-// RUN: clang-cc -g %s -emit-llvm -o %t -fblocks 
+// RUN: clang-cc -g %s -emit-llvm -o %t -fblocks &&
 // RUN: grep "func.start" %t | count 4
 // 1 declaration, 1 bar, 1 test_block_dbg and 1 for the block.
+// XFAIL
 
 static __inline__ __attribute__((always_inline)) int bar(int va, int vb) { return (va == vb); }
 
diff --git a/test/CodeGen/blocks-aligned-byref-variable.c b/test/CodeGen/blocks-aligned-byref-variable.c
new file mode 100644
index 000000000000..1ae306254157
--- /dev/null
+++ b/test/CodeGen/blocks-aligned-byref-variable.c
@@ -0,0 +1,19 @@
+// RUN: clang-cc -emit-llvm -o - -triple x86_64-apple-darwin10 &&
+// RUN: clang-cc -emit-llvm -o - -triple i386-apple-darwin10 
+typedef int __attribute__((aligned(32)))  ai;
+
+void f() {
+  __block ai a = 10;
+
+  ^{
+    a = 20;
+  }();
+}
+
+void g() {
+  __block double a = 10;
+
+  ^{
+    a = 20;
+  }();
+}
diff --git a/test/CodeGen/blocks-seq.c b/test/CodeGen/blocks-seq.c
index f637fbc0782e..3ff241e3f6e3 100644
--- a/test/CodeGen/blocks-seq.c
+++ b/test/CodeGen/blocks-seq.c
@@ -1,13 +1,13 @@
-// RUN: clang-cc -fblocks -triple x86_64-apple-darwin10 -emit-llvm -o %t %s &&
-// RUN: grep '%call = call i32 (...)\* @rhs()' %t | count 1 &&
-// If this fails, see about sliding %4, %5, %6 and %7...
-// RUN: grep '%forwarding1 = getelementptr %0\* %i, i32 0, i32 1' %t | count 1 &&
-// RUN: grep '%4 = bitcast i8\*\* %forwarding1 to %0\*\*' %t | count 1 &&
-// RUN: grep '%5 = load %0\*\* %4' %t | count 1 &&
-// RUN: grep '%call2 = call i32 (...)\* @rhs()' %t | count 1 &&
-// RUN: grep '%forwarding3 = getelementptr %0\* %i, i32 0, i32 1' %t | count 1 &&
-// RUN: grep '%6 = bitcast i8\*\* %forwarding3 to %0\*\*' %t | count 1 &&
-// RUN: grep '%7 = load %0\*\* %6' %t | count 1
+// FIXME: We forcibly strip the names so that the test doesn't vary between
+// builds with and without asserts. We need a better solution for this.
+
+// RUN: clang-cc -fblocks -triple x86_64-apple-darwin10 -emit-llvm-bc -o - %s | opt -strip | llvm-dis > %t &&
+// RUN: grep '%6 = call i32 (...)\* @rhs()' %t | count 1 &&
+// RUN: grep '%7 = getelementptr inbounds %0\* %1, i32 0, i32 1' %t | count 1 &&
+// RUN: grep '%8 = load %0\*\* %7' %t | count 1 &&
+// RUN: grep '%10 = call i32 (...)\* @rhs()' %t | count 1 &&
+// RUN: grep '%11 = getelementptr inbounds %0\* %1, i32 0, i32 1' %t | count 1 &&
+// RUN: grep '%12 = load %0\*\* %11' %t | count 1
 
 int rhs();
 
diff --git a/test/CodeGen/boolassign.c b/test/CodeGen/boolassign.c
index 2d14f8c1de19..73aab8db7cb1 100644
--- a/test/CodeGen/boolassign.c
+++ b/test/CodeGen/boolassign.c
@@ -1,6 +1,7 @@
 // RUN: clang-cc %s -emit-llvm -o %t
 
 int testBoolAssign(void) {
-int ss;
-if ((ss = ss && ss)) {}
+  int ss;
+  if ((ss = ss && ss)) {}
+  return 1;
 }
diff --git a/test/CodeGen/builtin-attributes.c b/test/CodeGen/builtin-attributes.c
new file mode 100644
index 000000000000..184e9676edaa
--- /dev/null
+++ b/test/CodeGen/builtin-attributes.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc -triple arm-unknown-unknown -emit-llvm -o - %s | FileCheck %s
+
+// CHECK: declare arm_aapcscc i32 @printf(i8*, ...)
+void f0() {
+  printf("a\n");
+}
+
+// CHECK: call arm_aapcscc void @exit
+// CHECK: unreachable
+void f1() {
+  exit(1);
+}
diff --git a/test/CodeGen/builtins-ffs_parity_popcount.c b/test/CodeGen/builtins-ffs_parity_popcount.c
index 47469985eeda..e3fa4d2d8212 100644
--- a/test/CodeGen/builtins-ffs_parity_popcount.c
+++ b/test/CodeGen/builtins-ffs_parity_popcount.c
@@ -1,5 +1,5 @@
-// RUN: clang-cc -emit-llvm -o - %s > %t
-// RUN: ! grep "__builtin" %t
+// RUN: clang-cc -emit-llvm -o - %s > %t &&
+// RUN: not grep "__builtin" %t
 
 #include <stdio.h>
 
diff --git a/test/CodeGen/builtins-powi.c b/test/CodeGen/builtins-powi.c
index 73f752f5e80e..5b413a889502 100644
--- a/test/CodeGen/builtins-powi.c
+++ b/test/CodeGen/builtins-powi.c
@@ -1,5 +1,5 @@
-// RUN: clang-cc -emit-llvm -o - %s > %t
-// RUN: ! grep "__builtin" %t
+// RUN: clang-cc -emit-llvm -o - %s > %t &&
+// RUN: not grep "__builtin" %t
 
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/test/CodeGen/builtins.c b/test/CodeGen/builtins.c
index ce5cd74bd4c4..165db9c26753 100644
--- a/test/CodeGen/builtins.c
+++ b/test/CodeGen/builtins.c
@@ -54,6 +54,8 @@ int main() {
   P(islessgreater, (1., 2.));
   P(isunordered, (1., 2.));
 
+  P(isnan, (1.));
+
   // Bitwise & Numeric Functions
 
   P(abs, (N));
diff --git a/test/CodeGen/cast-to-union.c b/test/CodeGen/cast-to-union.c
index 6098bcc5a07c..674299294928 100644
--- a/test/CodeGen/cast-to-union.c
+++ b/test/CodeGen/cast-to-union.c
@@ -1,7 +1,7 @@
-// RUN: clang-cc -emit-llvm < %s -o %t &&
-// RUN: grep "store i32 351, i32*" %t &&
-// RUN: grep "w = global %0 <{ i32 2, i8 0, i8 0, i8 0, i8 0 }>" %t &&
-// RUN: grep "y = global %1 <{ double 7.300000e+01 }>" %t
+// RUN: clang-cc -emit-llvm  %s -o - | FileCheck %s
+// CHECK: w = global %0 { i32 2, [4 x i8] zeroinitializer }
+// CHECK: y = global %union.u { double 7.300000e+0{{[0]*}}1 }
+// CHECK: store i32 351, i32
 
 union u { int i; double d; };
 
diff --git a/test/CodeGen/conditional.c b/test/CodeGen/conditional.c
index 22286705c89c..8a30463cb7e4 100644
--- a/test/CodeGen/conditional.c
+++ b/test/CodeGen/conditional.c
@@ -1,11 +1,10 @@
 // RUN: clang-cc -emit-llvm %s -o %t
 
-float test1(int cond, float a, float b)
-{
+float test1(int cond, float a, float b) {
   return cond ? a : b;
 }
-double test2(int cond, float a, double b)
-{
+
+double test2(int cond, float a, double b) {
   return cond ? a : b;
 }
 
@@ -16,8 +15,8 @@ void test3(){
 }
 
 void test4() {
-int i; short j;
-float* k = 1 ? &i : &j;
+  int i; short j;
+  float* k = 1 ? &i : &j;
 }
 
 void test5() {
@@ -33,12 +32,10 @@ void* test8() {return 1 ? test6 : test7;}
 
 void _efree(void *ptr);
 
-void _php_stream_free3()
-{
-	(1 ? free(0) : _efree(0));
+void _php_stream_free3() {
+  (1 ? free(0) : _efree(0));
 }
 
-void _php_stream_free4()
-{
-	1 ? _efree(0) : free(0);
+void _php_stream_free4() {
+  1 ? _efree(0) : free(0);
 }
diff --git a/test/CodeGen/const-init.c b/test/CodeGen/const-init.c
index 0364cc153ff8..29e9c5561527 100644
--- a/test/CodeGen/const-init.c
+++ b/test/CodeGen/const-init.c
@@ -1,4 +1,4 @@
-// RUN: clang-cc -triple i386-pc-linux-gnu -verify -emit-llvm -o %t %s &&
+// RUN: clang-cc -triple i386-pc-linux-gnu -verify -emit-llvm -o - %s | FileCheck %s
 
 #include <stdint.h>
 
@@ -22,44 +22,57 @@ union s2 {
 
 int g0 = (int)(&(((union s2 *) 0)->f0.f0) - 0);
 
-// RUN: grep '@g1x = global %. { double 1.000000e+00, double 0.000000e+00 }' %t &&
+// CHECK: @g1x = global {{%.}} { double 1.000000e+00{{[0]*}}, double 0.000000e+00{{[0]*}} }
 _Complex double g1x = 1.0f;
-// RUN: grep '@g1y = global %. { double 0.000000e+00, double 1.000000e+00 }' %t &&
+// CHECK: @g1y = global {{%.}} { double 0.000000e+00{{[0]*}}, double 1.000000e+00{{[0]*}} }
 _Complex double g1y = 1.0fi;
-// RUN: grep '@g1 = global %. { i8 1, i8 10 }' %t &&
+// CHECK: @g1 = global {{%.}} { i8 1, i8 10 }
 _Complex char g1 = (char) 1 + (char) 10 * 1i;
-// RUN: grep '@g2 = global %2 { i32 1, i32 10 }' %t &&
+// CHECK: @g2 = global %2 { i32 1, i32 10 }
 _Complex int g2 = 1 + 10i;
-// RUN: grep '@g3 = global %. { float 1.000000e+00, float 1.000000e+01 }' %t &&
+// CHECK: @g3 = global {{%.}} { float 1.000000e+00{{[0]*}}, float 1.000000e+0{{[0]*}}1 }
 _Complex float g3 = 1.0 + 10.0i;
-// RUN: grep '@g4 = global %. { double 1.000000e+00, double 1.000000e+01 }' %t &&
+// CHECK: @g4 = global {{%.}} { double 1.000000e+00{{[0]*}}, double 1.000000e+0{{[0]*}}1 }
 _Complex double g4 = 1.0 + 10.0i;
-// RUN: grep '@g5 = global %2 zeroinitializer' %t &&
+// CHECK: @g5 = global %2 zeroinitializer
 _Complex int g5 = (2 + 3i) == (5 + 7i);
-// RUN: grep '@g6 = global %. { double -1.100000e+01, double 2.900000e+01 }' %t &&
+// CHECK: @g6 = global {{%.}} { double -1.100000e+0{{[0]*}}1, double 2.900000e+0{{[0]*}}1 }
 _Complex double g6 = (2.0 + 3.0i) * (5.0 + 7.0i);
-// RUN: grep '@g7 = global i32 1' %t &&
+// CHECK: @g7 = global i32 1
 int g7 = (2 + 3i) * (5 + 7i) == (-11 + 29i);
-// RUN: grep '@g8 = global i32 1' %t &&
+// CHECK: @g8 = global i32 1
 int g8 = (2.0 + 3.0i) * (5.0 + 7.0i) == (-11.0 + 29.0i);
-// RUN: grep '@g9 = global i32 0' %t &&
+// CHECK: @g9 = global i32 0
 int g9 = (2 + 3i) * (5 + 7i) != (-11 + 29i);
-// RUN: grep '@g10 = global i32 0' %t &&
+// CHECK: @g10 = global i32 0
 int g10 = (2.0 + 3.0i) * (5.0 + 7.0i) != (-11.0 + 29.0i);
 
+// PR5108
+// CHECK: @gv1 = global %4 <{ i32 0, i8 7 }>, align 1
+struct {
+  unsigned long a;
+  unsigned long b:3;
+} __attribute__((__packed__)) gv1  = { .a = 0x0, .b = 7,  };
+
+// PR5118
+// CHECK: @gv2 = global %5 <{ i8 1, i8* null }>, align 1 
+struct {
+  unsigned char a;
+  char *b;
+} __attribute__((__packed__)) gv2 = { 1, (void*)0 };
 
 // Global references
-// RUN: grep '@g11.l0 = internal global i32 ptrtoint (i32 ()\* @g11 to i32)' %t &&
+// CHECK: @g11.l0 = internal global i32 ptrtoint (i32 ()* @g11 to i32)
 long g11() { 
   static long l0 = (long) g11;
   return l0; 
 }
 
-// RUN: grep '@g12 = global i32 ptrtoint (i8\* @g12_tmp to i32)' %t &&
+// CHECK: @g12 = global i32 ptrtoint (i8* @g12_tmp to i32)
 static char g12_tmp;
 long g12 = (long) &g12_tmp;
 
-// RUN: grep '@g13 = global \[1 x .struct.g13_s0\] \[.struct.g13_s0 <{ i32 ptrtoint (i8\* @g12_tmp to i32) }>\]' %t &&
+// CHECK: @g13 = global [1 x %struct.g13_s0] [%struct.g13_s0 { i32 ptrtoint (i8* @g12_tmp to i32) }]
 struct g13_s0 {
    long a;
 };
@@ -67,26 +80,25 @@ struct g13_s0 g13[] = {
    { (long) &g12_tmp }
 };
 
-// RUN: grep '@g14 = global i8\* inttoptr (i64 100 to i8\*)' %t &&
+// CHECK: @g14 = global i8* inttoptr (i64 100 to i8*)
 void *g14 = (void*) 100;
 
-// RUN: grep '@g15 = global i32 -1' %t &&
+// CHECK: @g15 = global i32 -1
 int g15 = (int) (char) ((void*) 0 + 255);
 
-// RUN: grep '@g16 = global i64 4294967295' %t &&
+// CHECK: @g16 = global i64 4294967295
 long long g16 = (long long) ((void*) 0xFFFFFFFF);
 
-// RUN: grep '@g17 = global i32\* @g15' %t &&
+// CHECK: @g17 = global i32* @g15
 int *g17 = (int *) ((long) &g15);
 
-// RUN: grep '@g18.p = internal global \[1 x i32\*\] \[i32\* @g19\]' %t &&
+// CHECK: @g18.p = internal global [1 x i32*] [i32* @g19]
 void g18(void) {
   extern int g19;
   static int *p[] = { &g19 };
 }
 
-// RUN: grep '@g20.l0 = internal global .struct.g20_s1 <{ .struct.g20_s0\* null, .struct.g20_s0\*\* getelementptr (.struct.g20_s1\* @g20.l0, i32 0, i32 0) }>'  %t &&
-
+// CHECK: @g20.l0 = internal global %struct.g20_s1 { %struct.g20_s0* null, %struct.g20_s0** getelementptr inbounds (%struct.g20_s1* @g20.l0, i32 0, i32 0) }
 struct g20_s0;
 struct g20_s1 {
   struct g20_s0 *f0, **f1;
@@ -99,6 +111,3 @@ void *g20(void) {
 // PR4108
 struct g21 {int g21;};
 const struct g21 g21 = (struct g21){1};
-
-// RUN: true
-
diff --git a/test/CodeGen/darwin-string-literals.c b/test/CodeGen/darwin-string-literals.c
index ff245fcc7a5c..04e43a234d19 100644
--- a/test/CodeGen/darwin-string-literals.c
+++ b/test/CodeGen/darwin-string-literals.c
@@ -1,10 +1,16 @@
-// RUN: clang-cc -triple i386-apple-darwin9 -emit-llvm %s -o %t &&
+// RUN: clang-cc -triple i386-apple-darwin9 -emit-llvm %s -o - | FileCheck -check-prefix LSB %s &&
 
-// RUN: grep -F '@"\01LC" = internal constant [8 x i8] c"string0\00"' %t &&
-// RUN: grep -F '@"\01LC1" = internal constant [8 x i8] c"string1\00", section "__TEXT,__cstring,cstring_literals"' %t &&
-// RUN: grep -F '@__utf16_string_ = internal global [35 x i8] c"h\00e\00l\00l\00o\00 \00\92! \00\03& \00\90! \00w\00o\00r\00l\00d\00\00", section "__TEXT,__ustring", align 2' %t &&
-// RUN: true
+// CHECK-LSB: @.str = private constant [8 x i8] c"string0\00"
+// CHECK-LSB: @.str1 = private constant [8 x i8] c"string1\00"
+// CHECK-LSB: @.str2 = internal constant [36 x i8] c"h\00e\00l\00l\00o\00 \00\92! \00\03& \00\90! \00w\00o\00r\00l\00d\00\00\00", section "__TEXT,__ustring", align 2
+
+// RUN: clang-cc -triple powerpc-apple-darwin9 -emit-llvm %s -o - | FileCheck -check-prefix MSB %s
+
+// CHECK-MSB: @.str = private constant [8 x i8] c"string0\00"
+// CHECK-MSB: @.str1 = private constant [8 x i8] c"string1\00"
+// CHECK-MSB: @.str2 = internal constant [36 x i8] c"\00h\00e\00l\00l\00o\00 !\92\00 &\03\00 !\90\00 \00w\00o\00r\00l\00d\00\00", section "__TEXT,__ustring", align 2
 
 const char *g0 = "string0";
 const void *g1 = __builtin___CFStringMakeConstantString("string1");
 const void *g2 = __builtin___CFStringMakeConstantString("hello \u2192 \u2603 \u2190 world");
+const void *g3 = __builtin___CFStringMakeConstantString("test™");
diff --git a/test/CodeGen/debug-info.c b/test/CodeGen/debug-info.c
index e0ec2c9027cf..beee7ac9b61a 100644
--- a/test/CodeGen/debug-info.c
+++ b/test/CodeGen/debug-info.c
@@ -24,14 +24,14 @@ char xpto[];
 
 // PR3427
 struct foo {
-	int a;
-	void *ptrs[];
+  int a;
+  void *ptrs[];
 };
 struct foo bar;
 
 // PR4143
 struct foo2 {
-        enum bar *bar;
+  enum bar *bar;
 };
 
 struct foo2 foo2;
diff --git a/test/CodeGen/designated-initializers.c b/test/CodeGen/designated-initializers.c
index 466933928665..f20bc782b6ac 100644
--- a/test/CodeGen/designated-initializers.c
+++ b/test/CodeGen/designated-initializers.c
@@ -1,5 +1,6 @@
-// RUN: clang-cc -triple i386-unknown-unknown %s -emit-llvm -o - | grep "<{ i8\* null, i32 1024 }>" &&
-// RUN: clang-cc -triple i386-unknown-unknown %s -emit-llvm -o - | grep "i32 0, i32 22"
+// RUN: clang-cc -triple i386-unknown-unknown %s -emit-llvm -o %t &&
+// RUN: grep "{ i8\* null, i32 1024 }" %t &&
+// RUN: grep "i32 0, i32 22" %t
 
 struct foo {
     void *a;
diff --git a/test/CodeGen/exprs.c b/test/CodeGen/exprs.c
index 36cfff9e8a69..a0e5b7644aeb 100644
--- a/test/CodeGen/exprs.c
+++ b/test/CodeGen/exprs.c
@@ -15,7 +15,7 @@ void *test(int *i) {
 }
 
 _Bool test2b; 
-int test2() {if (test2b);}
+int test2() { if (test2b); return 0; }
 
 // PR1921
 int test3() {
@@ -48,9 +48,9 @@ int ola() {
 
 // this one shouldn't fold as well
 void eMaisUma() {
-	double t[1];
-	if (*t)
-		return;
+  double t[1];
+  if (*t)
+    return;
 }
 
 // rdar://6520707
diff --git a/test/CodeGen/ext-vector-shuffle.c b/test/CodeGen/ext-vector-shuffle.c
index 37d3ed42d060..f53db945da03 100644
--- a/test/CodeGen/ext-vector-shuffle.c
+++ b/test/CodeGen/ext-vector-shuffle.c
@@ -1,5 +1,5 @@
-// RUN: clang-cc %s -emit-llvm -o - | not grep 'extractelement'
-// RUN: clang-cc %s -emit-llvm -o - | not grep 'insertelement'
+// RUN: clang-cc %s -emit-llvm -o - | not grep 'extractelement' &&
+// RUN: clang-cc %s -emit-llvm -o - | not grep 'insertelement' &&
 // RUN: clang-cc %s -emit-llvm -o - | grep 'shufflevector'
 
 typedef __attribute__(( ext_vector_type(2) )) float float2;
diff --git a/test/CodeGen/ext-vector.c b/test/CodeGen/ext-vector.c
index e3b6211ee991..6a246db63515 100644
--- a/test/CodeGen/ext-vector.c
+++ b/test/CodeGen/ext-vector.c
@@ -115,9 +115,21 @@ void test7(int4 *ap, int4 *bp, int c) {
   a /= c;
   a %= c;
 
-  // Vector comparisons can sometimes crash the x86 backend: rdar://6326239,
-  // reject them until the implementation is stable.
-#if 0
+  // Vector comparisons.
+  int4 cmp;
+  cmp = a < b;
+  cmp = a <= b;
+  cmp = a < b;
+  cmp = a >= b;
+  cmp = a == b;
+  cmp = a != b;
+}
+
+void test8(float4 *ap, float4 *bp, int c) {
+  float4 a = *ap;
+  float4 b = *bp;
+
+  // Vector comparisons.
   int4 cmp;
   cmp = a < b;
   cmp = a <= b;
@@ -125,5 +137,4 @@ void test7(int4 *ap, int4 *bp, int c) {
   cmp = a >= b;
   cmp = a == b;
   cmp = a != b;
-#endif
 }
diff --git a/test/CodeGen/function-attributes.c b/test/CodeGen/function-attributes.c
index ba2e4e4d564d..d2d3b031a83b 100644
--- a/test/CodeGen/function-attributes.c
+++ b/test/CodeGen/function-attributes.c
@@ -56,7 +56,7 @@ int ai_1() {  return 4; }
 static __inline__ __attribute__((always_inline))
 struct {
   int a, b, c, d, e;
-} ai_2() { }
+} ai_2() { while (1) {} }
 
 
 int foo() {
diff --git a/test/CodeGen/functions.c b/test/CodeGen/functions.c
index 12dff1b72cbc..dba29316e1a3 100644
--- a/test/CodeGen/functions.c
+++ b/test/CodeGen/functions.c
@@ -3,11 +3,11 @@
 int g();
 
 int foo(int i) {
-	return g(i);
+  return g(i);
 }
 
 int g(int i) {
-	return g(i);
+  return g(i);
 }
 
 // rdar://6110827
@@ -32,6 +32,7 @@ void f1() {}
 
 // RUN: grep 'define .* @f3' %t | not grep -F '...'
 struct foo { int X, Y, Z; } f3() {
+  while (1) {}
 }
 
 // PR4423 - This shouldn't crash in codegen
diff --git a/test/CodeGen/global-decls.c b/test/CodeGen/global-decls.c
index 80222ea85ef1..decb6a981c7f 100644
--- a/test/CodeGen/global-decls.c
+++ b/test/CodeGen/global-decls.c
@@ -11,7 +11,7 @@ int g0_common __attribute__((weak));
 // RUN: grep '@g0_def = weak global i32' %t &&
 int g0_def __attribute__((weak)) = 52;
 // RUN: grep 'define weak i32 @g1_def()' %t &&
-int __attribute__((weak)) g1_def (void) {}
+int __attribute__((weak)) g1_def (void) { return 0; }
 
 // Force _ext references
 void f0() {
diff --git a/test/CodeGen/global-init.c b/test/CodeGen/global-init.c
index 4b769f8ccbb0..2368422f3ab7 100644
--- a/test/CodeGen/global-init.c
+++ b/test/CodeGen/global-init.c
@@ -1,7 +1,30 @@
-// RUN: clang-cc -emit-llvm -o - %s | not grep "common"
+// RUN: clang-cc -emit-llvm -o - -triple i386-linux-gnu %s | FileCheck %s
 
 // This checks that the global won't be marked as common. 
 // (It shouldn't because it's being initialized).
 
 int a;
 int a = 242;
+// CHECK: @a = global i32 242
+
+// This should get normal weak linkage.
+int c __attribute__((weak))= 0;
+// CHECK: @c = weak global i32 0
+
+
+
+// Since this is marked const, it should get weak_odr linkage, since all
+// definitions have to be the same.
+// CHECK: @d = weak_odr constant i32 0
+const int d __attribute__((weak))= 0;
+
+
+
+// NOTE: tentative definitions are processed at the end of the translation unit.
+
+// This shouldn't be emitted as common because it has an explicit section.
+// rdar://7119244
+int b __attribute__((section("foo")));
+
+// CHECK: @b = global i32 0, section "foo"
+
diff --git a/test/CodeGen/global-with-initialiser.c b/test/CodeGen/global-with-initialiser.c
index 29b4e21b9129..d253782f66e1 100644
--- a/test/CodeGen/global-with-initialiser.c
+++ b/test/CodeGen/global-with-initialiser.c
@@ -17,9 +17,9 @@ long double globalLongDouble = 1;
 long double globalLongDoubleArray[5] = { 1.0, 2.0 };
 
 struct Struct {
-	int member1;
-	float member2;
-	char *member3; 
+  int member1;
+  float member2;
+  char *member3; 
 };
 
 struct Struct globalStruct = { 1, 2.0f, "foobar"};
diff --git a/test/CodeGen/globalinit.c b/test/CodeGen/globalinit.c
index 2798cae712a2..b3d0cb54d15c 100644
--- a/test/CodeGen/globalinit.c
+++ b/test/CodeGen/globalinit.c
@@ -37,7 +37,7 @@ static int a = { 1 };
 
 // References to enums.
 enum {
-	EnumA, EnumB
+  EnumA, EnumB
 };
 
 int c[] = { EnumA, EnumB };
diff --git a/test/CodeGen/init-with-member-expr.c b/test/CodeGen/init-with-member-expr.c
index 7750dbf9869d..197a9ab4e3b8 100644
--- a/test/CodeGen/init-with-member-expr.c
+++ b/test/CodeGen/init-with-member-expr.c
@@ -14,7 +14,7 @@ typedef struct mark_header_tag {
 } mark_header_t;
 int is_rar_archive(int fd) {
         const mark_header_t rar_hdr[2] = {{0x52, 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00}, {'U', 'n', 'i', 'q', 'u', 'E', '!'}};
-	foo(rar_hdr);
+        foo(rar_hdr);
 
         return 0;
 }
diff --git a/test/CodeGen/inline.c b/test/CodeGen/inline.c
index 234f1f8d93a8..bf17fd7c22ba 100644
--- a/test/CodeGen/inline.c
+++ b/test/CodeGen/inline.c
@@ -1,5 +1,5 @@
-// RUN: echo "C89 tests:" &&
-// RUN: clang %s -emit-llvm -S -o %t -std=c89 &&
+// RUN: echo "GNU89 tests:" &&
+// RUN: clang %s -emit-llvm -S -o %t -std=gnu89 &&
 // RUN: grep "define available_externally i32 @ei()" %t &&
 // RUN: grep "define i32 @foo()" %t &&
 // RUN: grep "define i32 @bar()" %t &&
@@ -24,9 +24,9 @@
 // RUN: grep "define available_externally void @gnu_ei_inline()" %t &&
 // RUN: grep "define i32 @test1" %t &&
 // RUN: grep "define i32 @test2" %t &&
-// RUN: grep "define available_externally void @test3" %t &&
+// RUN: grep "define void @test3" %t &&
 // RUN: grep "define available_externally i32 @test4" %t &&
-// RUN: grep "define i32 @test5" %t &&
+// RUN: grep "define available_externally i32 @test5" %t &&
 
 // RUN: echo "\nC++ tests:" &&
 // RUN: clang %s -emit-llvm -S -o %t -std=c++98 &&
@@ -67,20 +67,20 @@ void test_test2() { test2(); }
 
 // PR3989
 extern __inline void test3() __attribute__((gnu_inline));
-__inline void test3() {}
-
-void test_test3() { test3(); }
+__inline void __attribute__((gnu_inline)) test3() {}
 
 extern int test4(void);
 extern __inline __attribute__ ((__gnu_inline__)) int test4(void)
 {
+  return 0;
 }
 
 void test_test4() { test4(); }
 
-extern __inline int test5(void);
+extern __inline int test5(void)  __attribute__ ((__gnu_inline__));
 extern __inline int __attribute__ ((__gnu_inline__)) test5(void)
 {
+  return 0;
 }
 
 void test_test5() { test5(); }
diff --git a/test/CodeGen/inline2.c b/test/CodeGen/inline2.c
new file mode 100644
index 000000000000..6f165f50f8b7
--- /dev/null
+++ b/test/CodeGen/inline2.c
@@ -0,0 +1,62 @@
+// RUN: clang-cc -std=gnu89 -triple i386-apple-darwin9 -emit-llvm %s -o - | FileCheck -check-prefix GNU89 %s &&
+// RUN: clang-cc -std=c99 -triple i386-apple-darwin9 -emit-llvm %s -o - | FileCheck -check-prefix C99 %s
+
+// CHECK-GNU89: define i32 @f0()
+// CHECK-C99: define i32 @f0()
+int f0(void);
+int f0(void) { return 0; }
+
+// CHECK-GNU89: define i32 @f1()
+// CHECK-C99: define i32 @f1()
+inline int f1(void);
+int f1(void) { return 0; }
+
+// CHECK-GNU89: define i32 @f2()
+// CHECK-C99: define i32 @f2()
+int f2(void);
+inline int f2(void) { return 0; }
+
+// CHECK-GNU89: define i32 @f3()
+// CHECK-C99: define i32 @f3()
+extern inline int f3(void);
+int f3(void) { return 0; }
+
+// CHECK-GNU89: define i32 @f5()
+// CHECK-C99: define i32 @f5()
+extern inline int f5(void);
+inline int f5(void) { return 0; }
+
+// CHECK-GNU89: define i32 @f6()
+// CHECK-C99: define i32 @f6()
+inline int f6(void);
+extern inline int f6(void) { return 0; }
+
+// CHECK-GNU89: define i32 @f7()
+// CHECK-C99: define i32 @f7()
+extern inline int f7(void);
+extern int f7(void) { return 0; }
+
+// CHECK-GNU89: define i32 @fA()
+inline int fA(void) { return 0; }
+
+// CHECK-GNU89: define available_externally i32 @f4()
+// CHECK-C99: define i32 @f4()
+int f4(void);
+extern inline int f4(void) { return 0; }
+
+// CHECK-GNU89: define available_externally i32 @f8()
+// CHECK-C99: define i32 @f8()
+extern int f8(void);
+extern inline int f8(void) { return 0; }
+
+// CHECK-GNU89: define available_externally i32 @f9()
+// CHECK-C99: define i32 @f9()
+extern inline int f9(void);
+extern inline int f9(void) { return 0; }
+
+// CHECK-C99: define available_externally i32 @fA()
+
+int test_all() { 
+  return f0() + f1() + f2() + f3() + f4() + f5() + f6() + f7() + f8() + f9() 
+    + fA();
+}
diff --git a/test/CodeGen/packed-union.c b/test/CodeGen/packed-union.c
new file mode 100644
index 000000000000..d11d3a490234
--- /dev/null
+++ b/test/CodeGen/packed-union.c
@@ -0,0 +1,16 @@
+// RUN: clang-cc -triple x86_64-apple-darwin10 -emit-llvm %s -o %t &&
+
+// RUN: grep "struct._attrs = type <{ i32, i8 }>" %t &&
+typedef struct _attrs {
+        unsigned file_attributes;
+        unsigned char filename_length;
+} __attribute__((__packed__)) attrs;
+
+// RUN: grep "union._attr_union = type <{ i32, i8 }>" %t
+typedef union _attr_union {
+  attrs file_attrs;
+  unsigned owner_id;
+} __attribute__((__packed__)) attr_union;
+
+attr_union u;
+
diff --git a/test/CodeGen/parameter-passing.c b/test/CodeGen/parameter-passing.c
index 2ace299ef770..dce0ff80cdc4 100644
--- a/test/CodeGen/parameter-passing.c
+++ b/test/CodeGen/parameter-passing.c
@@ -11,7 +11,7 @@
 // RUN: clang-cc %s -triple x86_64-unknown-unknown -O3 -emit-llvm -o %t &&
 // RUN: not grep '@g0' %t &&
 
-// RUN: clang-cc %s -triple ppc-unknown-unknown -O3 -emit-llvm -o %t &&
+// RUN: clang-cc %s -triple powerpc-unknown-unknown -O3 -emit-llvm -o %t &&
 // RUN: not grep '@g0' %t &&
 // RUN: true
 
diff --git a/test/CodeGen/pragma-pack-1.c b/test/CodeGen/pragma-pack-1.c
new file mode 100644
index 000000000000..bcfcd5ac3ab9
--- /dev/null
+++ b/test/CodeGen/pragma-pack-1.c
@@ -0,0 +1,7 @@
+// RUN: clang-cc -emit-llvm -o - 
+
+// PR4610
+#pragma pack(4)
+struct ref {
+        struct ref *next;
+} refs;
diff --git a/test/CodeGen/pragma-pack-2.c b/test/CodeGen/pragma-pack-2.c
new file mode 100644
index 000000000000..306f02dd8cfe
--- /dev/null
+++ b/test/CodeGen/pragma-pack-2.c
@@ -0,0 +1,23 @@
+// RUN: clang-cc -triple i386-apple-darwin9 %s -emit-llvm -o - | FileCheck -check-prefix X32 %s &&
+// CHECK-X32: %struct.s0 = type { i64, i64, i32, [12 x i32] }
+// CHECK-X32: %struct.s1 = type { [15 x i32], %struct.s0 }
+
+// RUN: clang-cc -triple x86_64-apple-darwin9 %s -emit-llvm -o - | FileCheck -check-prefix X64 %s
+// CHECK-X64: %struct.s0 = type <{ i64, i64, i32, [12 x i32] }>
+// CHECK-X64: %struct.s1 = type <{ [15 x i32], %struct.s0 }>
+
+// rdar://problem/7095436
+#pragma pack(4)
+
+struct s0 {
+  long long a __attribute__((aligned(8)));
+  long long b __attribute__((aligned(8)));
+  unsigned int c __attribute__((aligned(8)));
+  int d[12];
+} a;
+
+struct s1 {
+  int a[15];
+  struct s0 b;
+} b;
+
diff --git a/test/CodeGen/pragma-pack-3.c b/test/CodeGen/pragma-pack-3.c
new file mode 100644
index 000000000000..b9166ae5d390
--- /dev/null
+++ b/test/CodeGen/pragma-pack-3.c
@@ -0,0 +1,19 @@
+// RUN: clang-cc -triple i386-apple-darwin9 %s -emit-llvm -o - | FileCheck -check-prefix X32 %s &&
+// CHECK-X32: %struct.menu = type <{ i8*, i8, i8 }>
+// CHECK-X32: %union.command = type <{ i8*, [2 x i8] }>
+
+// RUN: clang-cc -triple x86_64-apple-darwin9 %s -emit-llvm -o - | FileCheck -check-prefix X64 %s
+// CHECK-X64: %struct.menu = type <{ i8*, i8, i8 }>
+// CHECK-X64: %union.command = type <{ i8*, [2 x i8] }>
+
+// <rdar://problem/7184250>
+#pragma pack(push, 2)
+typedef union command {
+  void *windowRef;
+  struct menu {
+    void *menuRef;
+    unsigned char menuItemIndex;
+  } menu;
+} command;
+
+command c;
diff --git a/test/CodeGen/pragma-weak.c b/test/CodeGen/pragma-weak.c
new file mode 100644
index 000000000000..497039a8f42c
--- /dev/null
+++ b/test/CodeGen/pragma-weak.c
@@ -0,0 +1,165 @@
+// RUN: clang-cc -emit-llvm %s -o - -verify | FileCheck %s
+
+// CHECK: @weakvar = weak global
+// CHECK: @__weakvar_alias = common global
+// CHECK: @correct_linkage = weak global
+
+
+// CHECK: @both = alias void ()* @__both
+// CHECK: @both2 = alias void ()* @__both2
+// CHECK: @both3 = alias weak void ()* @__both3
+// CHECK: @a3 = alias weak void ()* @__a3
+// CHECK: @weakvar_alias = alias weak i32* @__weakvar_alias
+// CHECK: @foo = alias weak void ()* @__foo
+// CHECK: @foo2 = alias weak void ()* @__foo2
+// CHECK: @stutter = alias weak void ()* @__stutter
+// CHECK: @stutter2 = alias weak void ()* @__stutter2
+// CHECK: @declfirst = alias weak void ()* @__declfirst
+// CHECK: @declfirstattr = alias weak void ()* @__declfirstattr
+// CHECK: @mix2 = alias weak void ()* @__mix2
+// CHECK: @a1 = alias weak void ()* @__a1
+// CHECK: @xxx = alias weak void ()* @__xxx
+
+
+
+// CHECK: define weak void @weakdef()
+
+
+#pragma weak weakvar
+int weakvar;
+
+#pragma weak weakdef
+void weakdef(void) {}
+
+#pragma weak param // expected-warning {{weak identifier 'param' never declared}}
+#pragma weak correct_linkage
+void f(int param) {
+  int correct_linkage;
+}
+
+#pragma weak weakvar_alias = __weakvar_alias
+int __weakvar_alias;
+
+#pragma weak foo = __foo
+void __foo(void) {}
+// CHECK: define void @__foo()
+
+
+void __foo2(void) {}
+#pragma weak foo2 = __foo2
+// CHECK: define void @__foo2()
+
+
+///// test errors
+
+#pragma weak unused // expected-warning {{weak identifier 'unused' never declared}}
+#pragma weak unused_alias = __unused_alias  // expected-warning {{weak identifier '__unused_alias' never declared}}
+
+#pragma weak td // expected-warning {{weak identifier 'td' never declared}}
+typedef int td;
+
+#pragma weak td2 = __td2 // expected-warning {{weak identifier '__td2' never declared}}
+typedef int __td2;
+
+
+///// test weird cases
+
+// test repeats
+
+#pragma weak stutter = __stutter
+#pragma weak stutter = __stutter
+void __stutter(void) {}
+// CHECK: define void @__stutter()
+
+void __stutter2(void) {}
+#pragma weak stutter2 = __stutter2
+#pragma weak stutter2 = __stutter2
+// CHECK: define void @__stutter2()
+
+
+// test decl/pragma weak order
+
+void __declfirst(void);
+#pragma weak declfirst = __declfirst
+void __declfirst(void) {}
+// CHECK: define void @__declfirst()
+
+void __declfirstattr(void) __attribute((noinline));
+#pragma weak declfirstattr = __declfirstattr
+void __declfirstattr(void) {}
+// CHECK: define void @__declfirstattr()
+
+//// test that other attributes are preserved
+
+//// ensure that pragma weak/__attribute((weak)) play nice
+
+void mix(void);
+#pragma weak mix
+__attribute((weak)) void mix(void) { }
+// CHECK: define weak void @mix()
+
+// ensure following __attributes are preserved and that only a single
+// alias is generated
+#pragma weak mix2 = __mix2
+void __mix2(void) __attribute((noinline));
+void __mix2(void) __attribute((noinline));
+void __mix2(void) {}
+// CHECK: define void @__mix2()
+
+////////////// test #pragma weak/__attribute combinations
+
+// if the SAME ALIAS is already declared then it overrides #pragma weak
+// resulting in a non-weak alias in this case
+void both(void) __attribute((alias("__both")));
+#pragma weak both = __both
+void __both(void) {}
+// CHECK: define void @__both()
+
+// if the TARGET is previously declared then whichever aliasing method
+// comes first applies and subsequent aliases are discarded.
+// TODO: warn about this
+
+void __both2(void);
+void both2(void) __attribute((alias("__both2"))); // first, wins
+#pragma weak both2 = __both2
+void __both2(void) {}
+// CHECK: define void @__both2()
+
+void __both3(void);
+#pragma weak both3 = __both3 // first, wins
+void both3(void) __attribute((alias("__both3")));
+void __both3(void) {}
+// CHECK: define void @__both3()
+
+///////////// ensure that #pragma weak does not alter existing __attributes()
+
+void __a1(void) __attribute((noinline));
+#pragma weak a1 = __a1
+void __a1(void) {}
+// CHECK: define void @__a1()
+
+// attributes introduced BEFORE a combination of #pragma weak and alias()
+// hold...
+void __a3(void) __attribute((noinline));
+#pragma weak a3 = __a3
+void a3(void) __attribute((alias("__a3")));
+void __a3(void) {}
+// CHECK: define void @__a3()
+
+#pragma weak xxx = __xxx
+__attribute((pure,noinline,const,fastcall)) void __xxx(void) { }
+// CHECK: void @__xxx()
+
+/// TODO: stuff that still doesn't work
+
+// due to the fact that disparate TopLevelDecls cannot affect each other
+// (due to clang's Parser and ASTConsumer behavior, and quite reasonable)
+// #pragma weak must appear before or within the same TopLevelDecl as it
+// references.
+void yyy(void){}
+void zzz(void){}
+#pragma weak yyy
+// NOTE: weak doesn't apply, not before or in same TopLevelDec(!)
+// CHECK: define void @yyy()
+
+int correct_linkage;
diff --git a/test/CodeGen/predefined-expr.c b/test/CodeGen/predefined-expr.c
new file mode 100644
index 000000000000..9b645931a4a7
--- /dev/null
+++ b/test/CodeGen/predefined-expr.c
@@ -0,0 +1,45 @@
+// RUN: clang-cc %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: @__func__.plainFunction = private constant [14 x i8] c"plainFunction\00"
+// CHECK: @__PRETTY_FUNCTION__.plainFunction = private constant [21 x i8] c"void plainFunction()\00"
+// CHECK: @__func__.externFunction = private constant [15 x i8] c"externFunction\00"
+// CHECK: @__PRETTY_FUNCTION__.externFunction = private constant [22 x i8] c"void externFunction()\00"
+// CHECK: @__func__.privateExternFunction = private constant [22 x i8] c"privateExternFunction\00"
+// CHECK: @__PRETTY_FUNCTION__.privateExternFunction = private constant [29 x i8] c"void privateExternFunction()\00"
+// CHECK: @__func__.staticFunction = private constant [15 x i8] c"staticFunction\00"
+// CHECK: @__PRETTY_FUNCTION__.staticFunction = private constant [22 x i8] c"void staticFunction()\00"
+
+#include <stdio.h>
+
+void plainFunction() {
+  printf("__func__ %s\n", __func__);
+  printf("__FUNCTION__ %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+}
+
+extern void externFunction() {
+  printf("__func__ %s\n", __func__);
+  printf("__FUNCTION__ %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+}
+
+__private_extern__ void privateExternFunction() {
+  printf("__func__ %s\n", __func__);
+  printf("__FUNCTION__ %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+}
+
+static void staticFunction() {
+  printf("__func__ %s\n", __func__);
+  printf("__FUNCTION__ %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+}
+
+int main() {
+  plainFunction();
+  externFunction();
+  privateExternFunction();
+  staticFunction();
+
+  return 0;
+}
diff --git a/test/CodeGen/regparm.c b/test/CodeGen/regparm.c
index fdf07ead6de7..28dfae7f628b 100644
--- a/test/CodeGen/regparm.c
+++ b/test/CodeGen/regparm.c
@@ -9,11 +9,10 @@ typedef struct {
 } foo;
 
 static void FASTCALL
-reduced(char b, double c, foo* d, double e, int f)
-{
+reduced(char b, double c, foo* d, double e, int f) {
 }
 
 int
 main(void) {
-	reduced(0, 0.0, 0, 0.0, 0);
+  reduced(0, 0.0, 0, 0.0, 0);
 }
diff --git a/test/CodeGen/stack-protector.c b/test/CodeGen/stack-protector.c
index bdac853aed62..0b5924d81112 100644
--- a/test/CodeGen/stack-protector.c
+++ b/test/CodeGen/stack-protector.c
@@ -12,8 +12,7 @@
 // RUN: not grep 'ssp' %t &&
 // RUN: true
 
-#include <stdio.h>
-#include <string.h>
+int printf(const char * _Format, ...);
 
 void test1(const char *msg) {
   char a[strlen(msg) + 1];
diff --git a/test/CodeGen/statements.c b/test/CodeGen/statements.c
index 1ff7601adf68..45bbd9ac024f 100644
--- a/test/CodeGen/statements.c
+++ b/test/CodeGen/statements.c
@@ -11,3 +11,25 @@ bar();
 int test2() { return; }
 void test3() { return 4; }
 
+
+void test4() {
+bar:
+baz:
+blong:
+bing:
+ ;
+
+// PR5131
+static long x = &&bar - &&baz;
+static long y = &&baz;
+  &&bing;
+  &&blong;
+  if (y)
+    goto *y;
+
+  goto *x;
+}
+
+// PR3869
+int test5(long long b) { goto *b; }
+
diff --git a/test/CodeGen/staticinit.c b/test/CodeGen/staticinit.c
index 91fcdcf69f00..c68366f2ea77 100644
--- a/test/CodeGen/staticinit.c
+++ b/test/CodeGen/staticinit.c
@@ -2,9 +2,9 @@
 // RUN: grep "g.b = internal global i8. getelementptr" %t &&
 
 struct AStruct { 
-	int i;
-	char *s;
-	double d;
+  int i;
+  char *s;
+  double d;
 };
 
 void f() {
diff --git a/test/CodeGen/stdcall-fastcall.c b/test/CodeGen/stdcall-fastcall.c
index 11b652178ca8..89ed8c9ef672 100644
--- a/test/CodeGen/stdcall-fastcall.c
+++ b/test/CodeGen/stdcall-fastcall.c
@@ -1,4 +1,4 @@
-// RUN: clang-cc -emit-llvm < %s | grep 'fastcallcc' | count 4
+// RUN: clang-cc -emit-llvm < %s | grep 'fastcallcc' | count 4 &&
 // RUN: clang-cc -emit-llvm < %s | grep 'stdcallcc' | count 4
 
 void __attribute__((fastcall)) f1(void);
diff --git a/test/CodeGen/string-init.c b/test/CodeGen/string-init.c
index 38c7ec057597..4a808512601e 100644
--- a/test/CodeGen/string-init.c
+++ b/test/CodeGen/string-init.c
@@ -1,5 +1,5 @@
 // RUN: clang-cc -emit-llvm %s -o %t &&
-// RUN: grep 'internal constant \[10 x i8\]' %t &&
+// RUN: grep 'private constant \[10 x i8\]' %t &&
 // RUN: not grep -F "[5 x i8]" %t &&
 // RUN: not grep "store " %t
 
diff --git a/test/CodeGen/struct-init.c b/test/CodeGen/struct-init.c
index a38442b1a88f..cb84fef4d1c1 100644
--- a/test/CodeGen/struct-init.c
+++ b/test/CodeGen/struct-init.c
@@ -2,11 +2,11 @@
 
 typedef struct _zend_ini_entry zend_ini_entry;
 struct _zend_ini_entry {
-	void *mh_arg1;
+  void *mh_arg1;
 };
 
 char a;
 
 const zend_ini_entry ini_entries[] = {
-	{  ((char*)&((zend_ini_entry*)0)->mh_arg1 - (char*)(void*)0)},
+  {  ((char*)&((zend_ini_entry*)0)->mh_arg1 - (char*)(void*)0)},
 };
diff --git a/test/CodeGen/struct-x86-darwin.c b/test/CodeGen/struct-x86-darwin.c
index 050e26dcab9e..c61005f1bebd 100644
--- a/test/CodeGen/struct-x86-darwin.c
+++ b/test/CodeGen/struct-x86-darwin.c
@@ -1,13 +1,13 @@
-// RUN: clang-cc < %s -emit-llvm > %t1 -triple=i686-apple-darwin9
-// Run  grep "STest1 = type <{ i32, \[4 x i16\], double }>" %t1 &&
-// RUN: grep "STest2 = type <{ i16, i16, i32, i32 }>" %t1 &&
-// RUN: grep "STest3 = type <{ i8, i8, i16, i32 }>" %t1 &&
-// RUN: grep "STestB1 = type <{ i8, i8 }>" %t1 &&
-// RUN: grep "STestB2 = type <{ i8, i8, i8 }>" %t1 &&
-// RUN: grep "STestB3 = type <{ i8, i8 }>" %t1 &&
-// RUN: grep "STestB4 = type <{ i8, i8, i8, i8 }>" %t1 &&
-// RUN: grep "STestB5 = type <{ i8, i8, i8, i8, i8, i8 }>" %t1 &&
-// RUN: grep "STestB6 = type <{ i8, i8, i8, i8 }>" %t1
+// RUN: clang-cc < %s -emit-llvm > %t1 -triple=i686-apple-darwin9 &&
+// RUN: grep "STest1 = type { i32, \[4 x i16\], double }" %t1 &&
+// RUN: grep "STest2 = type { i16, i16, i32, i32 }" %t1 &&
+// RUN: grep "STest3 = type { i8, i16, i32 }" %t1 &&
+// RUN: grep "STestB1 = type { i8, i8 }" %t1 &&
+// RUN: grep "STestB2 = type { i8, i8, i8 }" %t1 &&
+// RUN: grep "STestB3 = type { i8, i8 }" %t1 &&
+// RUN: grep "STestB4 = type { i8, i8, i8, i8 }" %t1 &&
+// RUN: grep "STestB5 = type { i8, i8, \[2 x i8\], i8, i8 }" %t1 &&
+// RUN: grep "STestB6 = type { i8, i8, \[2 x i8\] }" %t1
 // Test struct layout for x86-darwin target
 
 struct STest1 {int x; short y[4]; double z; } st1;
diff --git a/test/CodeGen/struct.c b/test/CodeGen/struct.c
index ed3684280e88..d1e58a244561 100644
--- a/test/CodeGen/struct.c
+++ b/test/CodeGen/struct.c
@@ -70,8 +70,7 @@ typedef struct {
   int length;
 } range;
 extern range f6();
-void f7()
-{
+void f7() {
   range r = f6();
 }
 
@@ -81,27 +80,23 @@ typedef struct {
   range range2;
 } rangepair;
 
-void f8()
-{
+void f8() {
   rangepair p;
 
   range r = p.range1;
 }
 
-void f9(range *p)
-{
+void f9(range *p) {
   range r = *p;
 }
 
-void f10(range *p)
-{
+void f10(range *p) {
   range r = p[0];
 }
 
 /* _Bool types */
 
-struct _w
-{
+struct _w {
   short a,b;
   short c,d;
   short e,f;
@@ -113,27 +108,24 @@ struct _w
 } ws;
 
 /* Implicit casts (due to typedefs) */
-typedef struct _a
-{
+typedef struct _a {
   int a;
 } a;
 
-void f11()
-{
-    struct _a a1;
-    a a2;
+void f11() {
+  struct _a a1;
+  a a2;
     
-    a1 = a2;
-    a2 = a1;
+  a1 = a2;
+  a2 = a1;
 }
 
 /* Implicit casts (due to const) */
-void f12()
-{
-	struct _a a1;
-	const struct _a a2;
-	
-	a1 = a2;
+void f12() {
+  struct _a a1;
+  const struct _a a2;
+
+  a1 = a2;
 }
 
 /* struct initialization */
@@ -147,8 +139,7 @@ struct a15 {char a; int b[];} c15;
 int a16(void) {c15.a = 1;}
 
 /* compound literals */
-void f13()
-{
+void f13() {
   a13 x; x = (a13){1,2};
 }
 
diff --git a/test/CodeGen/union-init.c b/test/CodeGen/union-init.c
index c882d3180c72..f4e9e9a08f4d 100644
--- a/test/CodeGen/union-init.c
+++ b/test/CodeGen/union-init.c
@@ -4,19 +4,19 @@
 typedef int Py_ssize_t;
 
 typedef union _gc_head {
-	struct {
-		union _gc_head *gc_next;
-		union _gc_head *gc_prev;
-		Py_ssize_t gc_refs;
-	} gc;
-	long double dummy;  /* force worst-case alignment */
+  struct {
+    union _gc_head *gc_next;
+    union _gc_head *gc_prev;
+    Py_ssize_t gc_refs;
+  } gc;
+  long double dummy;  /* force worst-case alignment */
 } PyGC_Head;
 
 struct gc_generation {
-	PyGC_Head head;
-	int threshold; /* collection threshold */
-	int count; /* count of allocations or collections of younger
-		      generations */
+  PyGC_Head head;
+  int threshold; /* collection threshold */
+  int count;     /* count of allocations or collections of younger
+                    generations */
 };
 
 #define NUM_GENERATIONS 3
@@ -24,8 +24,8 @@ struct gc_generation {
 
 /* linked lists of container objects */
 struct gc_generation generations[NUM_GENERATIONS] = {
-	/* PyGC_Head,				threshold,	count */
-	{{{GEN_HEAD(0), GEN_HEAD(0), 0}},	700,		0},
-	{{{GEN_HEAD(1), GEN_HEAD(1), 0}},	10,		0},
-	{{{GEN_HEAD(2), GEN_HEAD(2), 0}},	10,		0},
+  /* PyGC_Head,                     threshold,      count */
+  {{{GEN_HEAD(0), GEN_HEAD(0), 0}}, 700,            0},
+  {{{GEN_HEAD(1), GEN_HEAD(1), 0}},  10,            0},
+  {{{GEN_HEAD(2), GEN_HEAD(2), 0}},  10,            0},
 };
diff --git a/test/CodeGen/union-init2.c b/test/CodeGen/union-init2.c
new file mode 100644
index 000000000000..184d75f47156
--- /dev/null
+++ b/test/CodeGen/union-init2.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc -emit-llvm %s -o - -triple i686-pc-linux-gnu | grep "bitcast (%0\* @r to %union.x\*), \[4 x i8\] zeroinitializer"
+
+// Make sure we generate something sane instead of a ptrtoint
+union x {long long b;union x* a;} r = {.a = &r};
diff --git a/test/CodeGen/unreachable.c b/test/CodeGen/unreachable.c
new file mode 100644
index 000000000000..ea4f0478bbd4
--- /dev/null
+++ b/test/CodeGen/unreachable.c
@@ -0,0 +1,37 @@
+// RUN: clang-cc -emit-llvm -o %t %s &&
+// RUN: grep '@unreachable' %t | count 0
+
+extern void abort() __attribute__((noreturn));
+extern int unreachable();
+
+int f0() {
+  return 0;
+  unreachable();
+}
+
+int f1(int i) {
+  goto L0;
+  int a = unreachable();
+ L0:
+  return 0;
+}
+
+int f2(int i) {
+  goto L0;
+  unreachable();
+  int a;
+  unreachable();
+ L0:
+  a = i + 1;
+  return a;
+}
+
+int f3(int i) {
+  if (i) {
+    return 0;
+  } else {
+    abort();
+  }
+  unreachable();
+  return 3;
+}
diff --git a/test/CodeGen/unwind-attr.c b/test/CodeGen/unwind-attr.c
index 4954a0b59ce4..86036f94b981 100644
--- a/test/CodeGen/unwind-attr.c
+++ b/test/CodeGen/unwind-attr.c
@@ -2,4 +2,5 @@
 // RUN: clang-cc -emit-llvm -o - %s | grep "@foo()" | grep nounwind 
 
 int foo(void) {
+  return 0;
 }
diff --git a/test/CodeGen/vector.c b/test/CodeGen/vector.c
index 1084f6d20b9b..5e48fd42b1d0 100644
--- a/test/CodeGen/vector.c
+++ b/test/CodeGen/vector.c
@@ -1,9 +1,8 @@
 // RUN: clang-cc -emit-llvm %s -o -
 typedef short __v4hi __attribute__ ((__vector_size__ (8)));
 
-void f()
-{
-    __v4hi A = (__v4hi)0LL;
+void f() {
+  __v4hi A = (__v4hi)0LL;
 }
 
 __v4hi x = {1,2,3};
@@ -15,7 +14,6 @@ int a() { vty b; return b[2LL]; }
 // PR4339
 typedef float vec4 __attribute__((vector_size(16)));
 
-void vac ( vec4* a, char b, float c )
-{
-	(*a)[b] = c;
+void vac ( vec4* a, char b, float c ) {
+  (*a)[b] = c;
 }
diff --git a/test/CodeGen/visibility.c b/test/CodeGen/visibility.c
index bb9b6e0d50ce..958eb618ee70 100644
--- a/test/CodeGen/visibility.c
+++ b/test/CodeGen/visibility.c
@@ -15,7 +15,7 @@
 // RUN: grep 'define internal void @f_deferred()' %t &&
 // RUN: grep 'define protected i32 @f_def()' %t &&
 // RUN: clang-cc -triple i386-unknown-unknown -fvisibility=hidden -emit-llvm -o %t %s &&
-// RUN: grep '@g_com = common hidden global i32 0' %t &&a
+// RUN: grep '@g_com = common hidden global i32 0' %t &&
 // RUN: grep '@g_def = hidden global i32 0' %t &&
 // RUN: grep '@g_ext = external global i32' %t &&
 // RUN: grep '@g_deferred = internal global' %t &&
diff --git a/test/CodeGen/volatile.c b/test/CodeGen/volatile.c
index 212a0aeb1e35..87cb5ff4eb4f 100644
--- a/test/CodeGen/volatile.c
+++ b/test/CodeGen/volatile.c
@@ -38,7 +38,7 @@ volatile extv4 vVE;
 
 volatile struct {int x;} aggFct(void);
 
-void main() {
+int main() {
   int i;
 
   // load
diff --git a/test/CodeGen/x86.c b/test/CodeGen/x86.c
index 66d82513795b..be0930237c82 100644
--- a/test/CodeGen/x86.c
+++ b/test/CodeGen/x86.c
@@ -1,4 +1,4 @@
-// RUN: clang-cc %s -triple=i686-pc-linux-gnu -emit-llvm -o - > %t1
+// RUN: clang-cc %s -triple=i686-pc-linux-gnu -emit-llvm -o - > %t1 &&
 // RUN: grep "ax" %t1 &&
 // RUN: grep "bx" %t1 &&
 // RUN: grep "cx" %t1 &&
diff --git a/test/CodeGen/x86_32-arguments.c b/test/CodeGen/x86_32-arguments.c
index 43a3ab246c71..78fb8342eebd 100644
--- a/test/CodeGen/x86_32-arguments.c
+++ b/test/CodeGen/x86_32-arguments.c
@@ -1,4 +1,4 @@
-// RUN: clang-cc -triple i386-apple-darwin9 -emit-llvm -o %t %s &&
+// RUN: clang-cc -fblocks -triple i386-apple-darwin9 -emit-llvm -o %t %s &&
 // RUN: grep 'define signext i8 @f0()' %t &&
 // RUN: grep 'define signext i16 @f1()' %t &&
 // RUN: grep 'define i32 @f2()' %t &&
@@ -11,39 +11,41 @@
 // RUN: grep 'define void @f8_2(i32 %a0.0, i32 %a0.1)' %t &&
 
 char f0(void) {
+  return 0;
 }
 
 short f1(void) {
+  return 0;
 }
 
 int f2(void) {
+  return 0;
 }
 
 float f3(void) {
+  return 0;
 }
 
 double f4(void) {
+  return 0;
 }
 
 long double f5(void) {
+  return 0;
 }
 
-void f6(char a0, short a1, int a2, long long a3, void *a4) {
-}
+void f6(char a0, short a1, int a2, long long a3, void *a4) {}
 
 typedef enum { A, B, C } E;
 
-void f7(E a0) {
-}
+void f7(E a0) {}
 
 struct s8 {
   int a;
   int b;
 };
-struct s8 f8_1(void) {
-}
-void f8_2(struct s8 a0) {
-}
+struct s8 f8_1(void) { while (1) {} }
+void f8_2(struct s8 a0) {}
 
 // This should be passed just as s8.
 
@@ -56,10 +58,8 @@ struct s9 {
   int a : 17;
   int b;
 };
-struct s9 f9_1(void) {
-}
-void f9_2(struct s9 a0) {
-}
+struct s9 f9_1(void) { while (1) {} }
+void f9_2(struct s9 a0) {}
 
 // Return of small structures and unions
 
@@ -67,7 +67,7 @@ void f9_2(struct s9 a0) {
 struct s10 {
   union { };
   float f;
-} f10(void) {}
+} f10(void) { while (1) {} }
 
 // Small vectors and 1 x {i64,double} are returned in registers
 
@@ -78,17 +78,17 @@ struct s10 {
 // RUN: grep '<2 x i64> @f15()' %t &&
 // RUN: grep '<2 x i64> @f16()' %t &&
 typedef short T11 __attribute__ ((vector_size (4)));
-T11 f11(void) {}
+T11 f11(void) { while (1) {} }
 typedef int T12 __attribute__ ((vector_size (8)));
-T12 f12(void) {}
+T12 f12(void) { while (1) {} }
 typedef long long T13 __attribute__ ((vector_size (8)));
-T13 f13(void) {}
+T13 f13(void) { while (1) {} }
 typedef double T14 __attribute__ ((vector_size (8)));
-T14 f14(void) {}
+T14 f14(void) { while (1) {} }
 typedef long long T15 __attribute__ ((vector_size (16)));
-T15 f15(void) {}
+T15 f15(void) { while (1) {} }
 typedef double T16 __attribute__ ((vector_size (16)));
-T16 f16(void) {}
+T16 f16(void) { while (1) {} }
 
 // And when the single element in a struct (but not for 64 and
 // 128-bits).
@@ -99,64 +99,107 @@ T16 f16(void) {}
 // RUN: grep -F 'void @f20(%4* noalias sret %agg.result)' %t &&
 // RUN: grep -F 'void @f21(%5* noalias sret %agg.result)' %t &&
 // RUN: grep -F 'void @f22(%6* noalias sret %agg.result)' %t &&
-struct { T11 a; } f17(void) {}
-struct { T12 a; } f18(void) {}
-struct { T13 a; } f19(void) {}
-struct { T14 a; } f20(void) {}
-struct { T15 a; } f21(void) {}
-struct { T16 a; } f22(void) {}
+struct { T11 a; } f17(void) { while (1) {} }
+struct { T12 a; } f18(void) { while (1) {} }
+struct { T13 a; } f19(void) { while (1) {} }
+struct { T14 a; } f20(void) { while (1) {} }
+struct { T15 a; } f21(void) { while (1) {} }
+struct { T16 a; } f22(void) { while (1) {} }
 
 // Single element structures are handled specially
 
 // RUN: grep -F 'float @f23()' %t &&
 // RUN: grep -F 'float @f24()' %t &&
 // RUN: grep -F 'float @f25()' %t &&
-struct { float a; } f23(void) {}
-struct { float a[1]; } f24(void) {}
-struct { struct {} a; struct { float a[1]; } b; } f25(void) {}
+struct { float a; } f23(void) { while (1) {} }
+struct { float a[1]; } f24(void) { while (1) {} }
+struct { struct {} a; struct { float a[1]; } b; } f25(void) { while (1) {} }
 
 // Small structures are handled recursively
 // RUN: grep -F 'i32 @f26()' %t &&
 // RUN: grep 'void @f27(%.truct.s27\* noalias sret %agg.result)' %t &&
-struct s26 { struct { char a, b; } a; struct { char a, b; } b; } f26(void) {}
-struct s27 { struct { char a, b, c; } a; struct { char a; } b; } f27(void) {}
+struct s26 { struct { char a, b; } a; struct { char a, b; } b; } f26(void) { while (1) {} }
+struct s27 { struct { char a, b, c; } a; struct { char a; } b; } f27(void) { while (1) {} }
 
 // RUN: grep 'void @f28(%.truct.s28\* noalias sret %agg.result)' %t &&
-struct s28 { int a; int b[]; } f28(void) {}
+struct s28 { int a; int b[]; } f28(void) { while (1) {} }
 
 // RUN: grep 'define i16 @f29()' %t &&
-struct s29 { struct { } a[1]; char b; char c; } f29(void) {}
+struct s29 { struct { } a[1]; char b; char c; } f29(void) { while (1) {} }
 
 // RUN: grep 'define i16 @f30()' %t &&
-struct s30 { char a; char b : 4; } f30(void) {}
+struct s30 { char a; char b : 4; } f30(void) { while (1) {} }
 
 // RUN: grep 'define float @f31()' %t &&
-struct s31 { char : 0; float b; char : 0; } f31(void) {}
+struct s31 { char : 0; float b; char : 0; } f31(void) { while (1) {} }
 
 // RUN: grep 'define i32 @f32()' %t &&
-struct s32 { char a; unsigned : 0; } f32(void) {}
+struct s32 { char a; unsigned : 0; } f32(void) { while (1) {} }
 
 // RUN: grep 'define float @f33()' %t &&
-struct s33 { float a; long long : 0; } f33(void) {}
+struct s33 { float a; long long : 0; } f33(void) { while (1) {} }
 
 // RUN: grep 'define float @f34()' %t &&
-struct s34 { struct { int : 0; } a; float b; } f34(void) {}
+struct s34 { struct { int : 0; } a; float b; } f34(void) { while (1) {} }
 
 // RUN: grep 'define i16 @f35()' %t &&
-struct s35 { struct { int : 0; } a; char b; char c; } f35(void) {}
+struct s35 { struct { int : 0; } a; char b; char c; } f35(void) { while (1) {} }
 
 // RUN: grep 'define i16 @f36()' %t &&
-struct s36 { struct { int : 0; } a[2][10]; char b; char c; } f36(void) {}
+struct s36 { struct { int : 0; } a[2][10]; char b; char c; } f36(void) { while (1) {} }
 
 // RUN: grep 'define float @f37()' %t &&
-struct s37 { float c[1][1]; } f37(void) {}
+struct s37 { float c[1][1]; } f37(void) { while (1) {} }
 
 // RUN: grep 'define void @f38(.struct.s38. noalias sret .agg.result)' %t &&
-struct s38 { char a[3]; short b; } f38(void) {}
+struct s38 { char a[3]; short b; } f38(void) { while (1) {} }
 
 // RUN: grep 'define void @f39(.struct.s39. byval align 16 .x)' %t &&
 typedef int v39 __attribute((vector_size(16)));
 struct s39 { v39 x; };
 void f39(struct s39 x) {}
 
+// <rdar://problem/7247671>
+// RUN: grep 'define i32 @f40()' %t &&
+enum e40 { ec0 = 0 };
+enum e40 f40(void) { }
+
+// RUN: grep 'define void ()\* @f41()' %t &&
+typedef void (^vvbp)(void);
+vvbp f41(void) { }
+
+// RUN: grep 'define i32 @f42()' %t &&
+struct s42 { enum e40 f0; } f42(void) {  }
+
+// RUN: grep 'define i64 @f43()' %t &&
+struct s43 { enum e40 f0; int f1; } f43(void) {  }
+
+// RUN: grep 'define i32 @f44()' %t &&
+struct s44 { vvbp f0; } f44(void) {  }
+
+// RUN: grep 'define i64 @f45()' %t &&
+struct s45 { vvbp f0; int f1; } f45(void) {  }
+
+// RUN: grep 'define void @f46(i32 %a0)' %t &&
+void f46(enum e40 a0) { }
+
+// RUN: grep 'define void @f47(void ()\* %a1)' %t &&
+void f47(vvbp a1) { }
+
+// RUN: grep 'define void @f48(i32 %a0.0)' %t &&
+struct s48 { enum e40 f0; };
+void f48(struct s48 a0) { }
+
+// RUN: grep 'define void @f49(i32 %a0.0, i32 %a0.1)' %t &&
+struct s49 { enum e40 f0; int f1; };
+void f49(struct s49 a0) { }
+
+// RUN: grep 'define void @f50(void ()\* %a0.0)' %t &&
+struct s50 { vvbp f0; };
+void f50(struct s50 a0) { }
+
+// RUN: grep 'define void @f51(void ()\* %a0.0, i32 %a0.1)' %t &&
+struct s51 { vvbp f0; int f1; };
+void f51(struct s51 a0) { }
+
 // RUN: true
diff --git a/test/CodeGen/x86_64-arguments.c b/test/CodeGen/x86_64-arguments.c
index 0b68afdb4edd..19f9cdaa2918 100644
--- a/test/CodeGen/x86_64-arguments.c
+++ b/test/CodeGen/x86_64-arguments.c
@@ -7,26 +7,32 @@
 // RUN: grep 'define x86_fp80 @f5()' %t &&
 // RUN: grep 'define void @f6(i8 signext %a0, i16 signext %a1, i32 %a2, i64 %a3, i8\* %a4)' %t &&
 // RUN: grep 'define void @f7(i32 %a0)' %t &&
-// RUN: grep 'type { i64, double }.*type .0' %t &&
+// RUN: grep '.0 = type { i64, double }' %t &&
 // RUN: grep 'define .0 @f8_1()' %t &&
 // RUN: grep 'define void @f8_2(.0)' %t &&
 
 char f0(void) {
+  return 0;
 }
 
 short f1(void) {
+  return 0;
 }
 
 int f2(void) {
+  return 0;
 }
 
 float f3(void) {
+  return 0;
 }
 
 double f4(void) {
+  return 0;
 }
 
 long double f5(void) {
+  return 0;
 }
 
 void f6(char a0, short a1, int a2, long long a3, void *a4) {
@@ -42,23 +48,23 @@ union u8 {
   long double a;
   int b;
 };
-union u8 f8_1() {}
+union u8 f8_1() { while (1) {} }
 void f8_2(union u8 a0) {}
 
 // RUN: grep 'define i64 @f9()' %t &&
-struct s9 { int a; int b; int : 0; } f9(void) {}
+struct s9 { int a; int b; int : 0; } f9(void) { while (1) {} }
 
 // RUN: grep 'define void @f10(i64)' %t &&
 struct s10 { int a; int b; int : 0; };
 void f10(struct s10 a0) {}
 
 // RUN: grep 'define void @f11(.union.anon. noalias sret .agg.result)' %t &&
-union { long double a; float b; } f11() {}
+union { long double a; float b; } f11() { while (1) {} }
 
 // RUN: grep 'define i64 @f12_0()' %t &&
 // RUN: grep 'define void @f12_1(i64)' %t &&
 struct s12 { int a __attribute__((aligned(16))); };
-struct s12 f12_0(void) {}
+struct s12 f12_0(void) { while (1) {} }
 void f12_1(struct s12 a0) {}
 
 // Check that sret parameter is accounted for when checking available integer
@@ -66,8 +72,9 @@ void f12_1(struct s12 a0) {}
 // RUN: grep 'define void @f13(.struct.s13_0. noalias sret .agg.result, i32 .a, i32 .b, i32 .c, i32 .d, .struct.s13_1. byval .e, i32 .f)' %t &&
 
 struct s13_0 { long long f0[3]; };
+struct s13_1 { long long f0[2]; };
 struct s13_0 f13(int a, int b, int c, int d, 
-                 struct s13_1 { long long f0[2]; } e, int f) {}
+                 struct s13_1 e, int f) { while (1) {} }
 
 // RUN: grep 'define void @f14(.*, i8 signext .X)' %t &&
 void f14(int a, int b, int c, int d, int e, int f, 
@@ -83,9 +90,10 @@ void f17(float a, float b, float c, float d, float e, float f, float g, float h,
          long double X) {}
 
 // Check for valid coercion.
-// RUN: grep '.1 = bitcast i64. .tmp to .struct.f18_s0.' %t &&
-// RUN: grep '.2 = load .struct.f18_s0. .1, align 1' %t &&
-// RUN: grep 'store .struct.f18_s0 .2, .struct.f18_s0. .f18_arg1' %t &&
-void f18(int a, struct f18_s0 { int f0; } f18_arg1) {}
+// RUN: grep '.. = bitcast i64. .* to .struct.f18_s0.' %t &&
+// RUN: grep '.. = load .struct.f18_s0. .., align 1' %t &&
+// RUN: grep 'store .struct.f18_s0 .., .struct.f18_s0. .f18_arg1' %t &&
+struct f18_s0 { int f0; };
+void f18(int a, struct f18_s0 f18_arg1) { while (1) {} }
 
 // RUN: true
diff --git a/test/CodeGenCXX/PR4827-cast.cpp b/test/CodeGenCXX/PR4827-cast.cpp
new file mode 100644
index 000000000000..958798d77f60
--- /dev/null
+++ b/test/CodeGenCXX/PR4827-cast.cpp
@@ -0,0 +1,5 @@
+// RUN: clang-cc -emit-llvm -o - %s
+struct A;
+struct B;
+extern A *f();
+void a() { (B *) f(); }
diff --git a/test/CodeGenCXX/PR4890-debug-info-dtor.cpp b/test/CodeGenCXX/PR4890-debug-info-dtor.cpp
new file mode 100644
index 000000000000..a0d3a8ddac23
--- /dev/null
+++ b/test/CodeGenCXX/PR4890-debug-info-dtor.cpp
@@ -0,0 +1,6 @@
+// RUN: clang-cc -emit-llvm-only -g %s
+struct X {
+  ~X();
+};
+
+X::~X() { }
diff --git a/test/CodeGenCXX/PR4983-constructor-conversion.cpp b/test/CodeGenCXX/PR4983-constructor-conversion.cpp
new file mode 100644
index 000000000000..31eae2e791f6
--- /dev/null
+++ b/test/CodeGenCXX/PR4983-constructor-conversion.cpp
@@ -0,0 +1,16 @@
+// RUN: clang-cc -emit-llvm-only %s
+
+struct A {
+  A(const char *s){}
+};
+
+struct B {
+  A a;
+  
+  B() : a("test") { }
+};
+
+void f() {
+    A a("test");
+}
+
diff --git a/test/CodeGenCXX/PR5050-constructor-conversion.cpp b/test/CodeGenCXX/PR5050-constructor-conversion.cpp
new file mode 100644
index 000000000000..e5f722c513de
--- /dev/null
+++ b/test/CodeGenCXX/PR5050-constructor-conversion.cpp
@@ -0,0 +1,19 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+struct A { A(const A&, int i1 = 1); };
+
+struct B : A { };
+
+A f(const B &b) {
+  return b;
+}
+
+// CHECK-LP64: call     __ZN1AC1ERKS_i
+
+// CHECK-LP32: call     L__ZN1AC1ERKS_i
+
+
diff --git a/test/CodeGenCXX/PR5093-static-member-function.cpp b/test/CodeGenCXX/PR5093-static-member-function.cpp
new file mode 100644
index 000000000000..a27b08f6ada7
--- /dev/null
+++ b/test/CodeGenCXX/PR5093-static-member-function.cpp
@@ -0,0 +1,9 @@
+// RUN: clang-cc %s -emit-llvm -o - | FileCheck %s
+struct a {
+  static void f();
+};
+
+void g(a *a) {
+  // CHECK: call void @_ZN1a1fEv()
+  a->f();
+}
diff --git a/test/CodeGenCXX/anonymous-namespaces.cpp b/test/CodeGenCXX/anonymous-namespaces.cpp
new file mode 100644
index 000000000000..dcfd518d684b
--- /dev/null
+++ b/test/CodeGenCXX/anonymous-namespaces.cpp
@@ -0,0 +1,22 @@
+// RUN: clang-cc -emit-llvm %s -o - | FileCheck %s
+
+namespace {
+  // CHECK: @_ZN12_GLOBAL__N_11aE = internal global i32 0
+  int a = 0;
+
+  // CHECK: define internal i32 @_ZN12_GLOBAL__N_13fooEv()
+  int foo() {
+    return 32;
+  }
+
+  // CHECK: define internal i32 @_ZN12_GLOBAL__N_11A3fooEv()
+  namespace A {
+    int foo() {
+      return 45;
+    }
+  }
+}
+
+int concrete() {
+  return a + foo() + A::foo();
+}
diff --git a/test/CodeGenCXX/anonymous-union-member-initializer.cpp b/test/CodeGenCXX/anonymous-union-member-initializer.cpp
new file mode 100644
index 000000000000..2030f4053c90
--- /dev/null
+++ b/test/CodeGenCXX/anonymous-union-member-initializer.cpp
@@ -0,0 +1,12 @@
+// RUN: clang-cc -emit-llvm -o - %s
+
+struct A {
+  union {
+    int a;
+    void* b;
+  };
+  
+  A() : a(0) { }
+};
+
+A a;
diff --git a/test/CodeGenCXX/array-pointer-decay.cpp b/test/CodeGenCXX/array-pointer-decay.cpp
new file mode 100644
index 000000000000..5751b67b7491
--- /dev/null
+++ b/test/CodeGenCXX/array-pointer-decay.cpp
@@ -0,0 +1,7 @@
+// RUN: clang-cc %s -emit-llvm -o -
+
+void f(const char*);
+
+void g() {
+  f("hello");
+}
diff --git a/test/CodeGenCXX/attr.cpp b/test/CodeGenCXX/attr.cpp
new file mode 100644
index 000000000000..8077b7839d88
--- /dev/null
+++ b/test/CodeGenCXX/attr.cpp
@@ -0,0 +1,36 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -O0 -S %s -o %t.s &&
+// RUN: FileCheck --input-file=%t.s %s
+
+int foo() __attribute__((aligned(1024)));
+int foo() { }
+
+// CHECK:.align 10, 0x90
+// CHECK:.globl __Z3foov
+// CHECK:__Z3foov:
+
+
+class C {
+  virtual void bar1() __attribute__((aligned(1)));
+  virtual void bar2() __attribute__((aligned(2)));
+  virtual void bar3() __attribute__((aligned(1024)));
+} c;
+
+void C::bar1() { }
+
+// CHECK:.align 1, 0x90
+// CHECK-NEXT:.globl __ZN1C4bar1Ev
+// CHECK-NEXT:__ZN1C4bar1Ev:
+
+
+void C::bar2() { }
+
+// CHECK:.align 1, 0x90
+// CHECK-NEXT:.globl __ZN1C4bar2Ev
+// CHECK-NEXT:__ZN1C4bar2Ev:
+
+
+void C::bar3() { }
+
+// CHECK:.align 10, 0x90
+// CHECK-NEXT:.globl __ZN1C4bar3Ev
+// CHECK-NEXT:__ZN1C4bar3Ev:
diff --git a/test/CodeGenCXX/cast-conversion.cpp b/test/CodeGenCXX/cast-conversion.cpp
new file mode 100644
index 000000000000..f571f549d094
--- /dev/null
+++ b/test/CodeGenCXX/cast-conversion.cpp
@@ -0,0 +1,33 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+struct A {
+  A(int);
+};
+
+struct B {
+  B(A);
+};
+
+int main () {
+  (B)10;
+  B(10);
+  static_cast<B>(10);
+}
+
+// CHECK-LP64: call     __ZN1AC1Ei
+// CHECK-LP64: call     __ZN1BC1E1A
+// CHECK-LP64: call     __ZN1AC1Ei
+// CHECK-LP64: call     __ZN1BC1E1A
+// CHECK-LP64: call     __ZN1AC1Ei
+// CHECK-LP64: call     __ZN1BC1E1A
+
+// CHECK-LP32: call     L__ZN1AC1Ei
+// CHECK-LP32: call     L__ZN1BC1E1A
+// CHECK-LP32: call     L__ZN1AC1Ei
+// CHECK-LP32: call     L__ZN1BC1E1A
+// CHECK-LP32: call     L__ZN1AC1Ei
+// CHECK-LP32: call     L__ZN1BC1E1A
diff --git a/test/CodeGenCXX/class-layout.cpp b/test/CodeGenCXX/class-layout.cpp
new file mode 100644
index 000000000000..7255d3e4f94d
--- /dev/null
+++ b/test/CodeGenCXX/class-layout.cpp
@@ -0,0 +1,5 @@
+// RUN: clang-cc %s -emit-llvm -o %t &&
+
+// An extra byte shoudl be allocated for an empty class.
+// RUN: grep '%.truct.A = type { i8 }' %t
+struct A { } a;
diff --git a/test/CodeGenCXX/conditional-expr-lvalue.cpp b/test/CodeGenCXX/conditional-expr-lvalue.cpp
new file mode 100644
index 000000000000..7b3233a5bed0
--- /dev/null
+++ b/test/CodeGenCXX/conditional-expr-lvalue.cpp
@@ -0,0 +1,7 @@
+// RUN: clang-cc -emit-llvm-only %s
+void f(bool flag) {
+  int a = 1;
+  int b = 2;
+  
+  (flag ? a : b) = 3;
+}
diff --git a/test/CodeGenCXX/constructor-conversion.cpp b/test/CodeGenCXX/constructor-conversion.cpp
new file mode 100644
index 000000000000..980b230118d8
--- /dev/null
+++ b/test/CodeGenCXX/constructor-conversion.cpp
@@ -0,0 +1,55 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+extern "C" int printf(...);
+
+class X { // ...
+public: 
+  X(int) : iX(2), fX(2.3) , name("HELLO\n") {  }
+
+  X(const char* arg, int ix=0) { iX = ix; fX = 6.0; name = arg+ix; }
+  X(): iX(100), fX(1.2) {}
+  int iX;
+  float fX;
+  const char *name;
+  void pr(void) {
+    printf("iX = %d  fX = %f name = %s\n", iX, fX, name);
+  }
+};
+
+void g(X arg) {
+  arg.pr();
+}
+
+void f(X arg) {
+  X a = 1;        // a = X(1)
+
+  a.pr();
+
+  X b = "Jessie"; //  b=X("Jessie",0)
+
+  b.pr();
+
+
+  a = 2;          // a = X(2)
+
+  a.pr();
+}
+
+
+int main() {
+  X x;
+  f(x);
+  g(3);           // g(X(3))
+}
+
+// CHECK-LP64: call     __ZN1XC1Ei
+// CHECK-LP64: call     __ZN1XC1EPKci
+// CHECK-LP64: call     __ZN1XC1Ev
+
+// CHECK-LP32: call     L__ZN1XC1Ei
+// CHECK-LP32: call     L__ZN1XC1EPKci
+// CHECK-LP32: call     L__ZN1XC1Ev
diff --git a/test/CodeGenCXX/constructor-default-arg.cpp b/test/CodeGenCXX/constructor-default-arg.cpp
new file mode 100644
index 000000000000..7e6a7cd8f71a
--- /dev/null
+++ b/test/CodeGenCXX/constructor-default-arg.cpp
@@ -0,0 +1,40 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+extern "C" int printf(...);
+
+
+struct C {
+  C() : iC(6) {}
+  int iC;
+};
+
+int foo() {
+  return 6;
+};
+
+class X { // ...
+public: 
+  X(int) {}
+  X(const X&, int i = 1, int j = 2, int k = foo()) {
+    printf("X(const X&, %d, %d, %d)\n", i, j, k);
+  }
+};
+
+int main() {
+  X a(1);
+  X b(a, 2);
+  X c = b;
+  X d(a, 5, 6);
+}
+
+// CHECK-LP64: call __ZN1XC1ERKS_iii
+// CHECK-LP64: call __ZN1XC1ERKS_iii
+// CHECK-LP64: call __ZN1XC1ERKS_iii
+
+// CHECK-LP32: call L__ZN1XC1ERKS_iii
+// CHECK-LP32: call L__ZN1XC1ERKS_iii
+// CHECK-LP32: call L__ZN1XC1ERKS_iii
diff --git a/test/CodeGenCXX/constructor-for-array-members.cpp b/test/CodeGenCXX/constructor-for-array-members.cpp
new file mode 100644
index 000000000000..fbb13e0aa3c2
--- /dev/null
+++ b/test/CodeGenCXX/constructor-for-array-members.cpp
@@ -0,0 +1,44 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+extern "C" int printf(...);
+
+int i = 1234;
+float vf = 1.00;
+
+struct S {
+  S() : iS(i++), f1(vf++) {printf("S::S()\n");}
+  ~S(){printf("S::~S(iS = %d  f1 = %f)\n", iS, f1); }
+  int iS;
+  float f1;
+};
+
+struct M {
+  double dM;
+  S ARR_S[3];
+  void pr() {
+    for (int i = 0; i < 3; i++)
+     printf("ARR_S[%d].iS = %d ARR_S[%d].f1 = %f\n", i, ARR_S[i].iS, i, ARR_S[i].f1);
+
+    for (int i = 0; i < 2; i++)
+      for (int j = 0; j < 3; j++)
+        for (int k = 0; k < 4; k++)
+           printf("MULTI_ARR[%d][%d][%d].iS = %d MULTI_ARR[%d][%d][%d].f1 = %f\n", 
+                  i,j,k, MULTI_ARR[i][j][k].iS, i,j,k, MULTI_ARR[i][j][k].f1);
+
+  }
+
+ S MULTI_ARR[2][3][4];
+};
+
+int main() {
+  M m1;
+  m1.pr();
+}
+
+// CHECK-LP64: call __ZN1SC1Ev
+
+// CHECK-LP32: call L__ZN1SC1Ev
diff --git a/test/CodeGenCXX/constructor-init-reference.cpp b/test/CodeGenCXX/constructor-init-reference.cpp
new file mode 100644
index 000000000000..040441fde0f8
--- /dev/null
+++ b/test/CodeGenCXX/constructor-init-reference.cpp
@@ -0,0 +1,9 @@
+// RUN: clang-cc -emit-llvm -o - %s | grep "store i32\* @x, i32\*\*"
+
+int x;
+class A {
+  int& y;
+  A() : y(x) {}
+};
+A z;
+
diff --git a/test/CodeGenCXX/constructor-init.cpp b/test/CodeGenCXX/constructor-init.cpp
new file mode 100644
index 000000000000..1b025126a345
--- /dev/null
+++ b/test/CodeGenCXX/constructor-init.cpp
@@ -0,0 +1,61 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+
+extern "C" int printf(...);
+
+struct M {
+  M() { printf("M()\n"); }
+  M(int i) { iM = i; printf("M(%d)\n", i); }
+  int iM;
+  void MPR() {printf("iM = %d\n", iM); };
+};
+
+struct P {
+  P() { printf("P()\n"); }
+  P(int i) { iP = i; printf("P(%d)\n", i); }
+  int iP;
+  void PPR() {printf("iP = %d\n", iP); };
+};
+
+struct Q {
+  Q() { printf("Q()\n"); }
+  Q(int i) { iQ = i; printf("Q(%d)\n", i); }
+  int iQ;
+  void QPR() {printf("iQ = %d\n", iQ); };
+};
+
+struct N : M , P, Q {
+  N() : f1(1.314), P(2000), ld(00.1234+f1), M(1000), Q(3000),
+        d1(3.4567), i1(1234), m1(100) { printf("N()\n"); }
+  M m1;
+  M m2;
+  float f1;
+  int i1;
+  float d1;
+  void PR() {
+    printf("f1 = %f d1 = %f i1 = %d ld = %f \n", f1,d1,i1, ld); 
+    MPR();
+    PPR();
+    QPR();
+    printf("iQ = %d\n", iQ);
+    printf("iP = %d\n", iP);
+    printf("iM = %d\n", iM);
+    // FIXME. We don't yet support this syntax.
+    // printf("iQ = %d\n", (*this).iQ);
+    printf("iQ = %d\n", this->iQ);
+    printf("iP = %d\n", this->iP);
+    printf("iM = %d\n", this->iM);
+  }
+  float ld;
+  float ff;
+  M arr_m[3];
+  P arr_p[1][3];
+  Q arr_q[2][3][4];
+};
+
+int main() {
+  M m1;
+
+  N n1;
+  n1.PR();
+}
+
diff --git a/test/CodeGenCXX/constructor-template.cpp b/test/CodeGenCXX/constructor-template.cpp
new file mode 100644
index 000000000000..8c4f2c912709
--- /dev/null
+++ b/test/CodeGenCXX/constructor-template.cpp
@@ -0,0 +1,56 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+// PR4826
+struct A {
+  A() {
+  }
+};
+
+template<typename T>
+struct B {
+  B(T) {}
+  
+  A nodes;
+};
+
+
+// PR4853
+template <typename T> class List {
+public:
+  List(){ }     // List<BinomialNode<int>*>::List() remains undefined.
+  ~List() {}
+};
+
+template <typename T> class Node {
+ int i;
+public:
+ Node(){ }      // Node<BinomialNode<int>*>::Node() remains undefined.
+ ~Node() {}
+};
+
+
+template<typename T> class BinomialNode : Node<BinomialNode<T>*> {
+public:
+  BinomialNode(T value) {}
+  List<BinomialNode<T>*> nodes;
+};
+
+int main() {
+  B<int> *n = new B<int>(4);
+  BinomialNode<int> *node = new BinomialNode<int>(1);
+  delete node;
+}
+
+// CHECK-LP64: __ZN4ListIP12BinomialNodeIiEED1Ev:
+// CHECK-LP64: __ZN4ListIP12BinomialNodeIiEED2Ev:
+// CHECK-LP64: __ZN4NodeIP12BinomialNodeIiEEC1Ev:
+// CHECK-LP64: __ZN4ListIP12BinomialNodeIiEEC1Ev:
+
+// CHECK-LP32: __ZN4ListIP12BinomialNodeIiEED1Ev:
+// CHECK-LP32: __ZN4ListIP12BinomialNodeIiEED2Ev:
+// CHECK-LP32: __ZN4NodeIP12BinomialNodeIiEEC1Ev:
+// CHECK-LP32: __ZN4ListIP12BinomialNodeIiEEC1Ev:
diff --git a/test/CodeGenCXX/conversion-function.cpp b/test/CodeGenCXX/conversion-function.cpp
new file mode 100644
index 000000000000..0bfd4af7e265
--- /dev/null
+++ b/test/CodeGenCXX/conversion-function.cpp
@@ -0,0 +1,115 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+extern "C" int printf(...);
+struct S {
+  operator int();
+};
+
+S::operator int() {
+  return 10;
+}
+
+
+class X { // ...
+  public: operator int() { printf("operator int()\n"); return iX; }
+  public: operator float() { printf("operator float()\n"); return fX; }
+  X() : iX(100), fX(1.234)  {}
+  int iX;
+  float fX;
+};
+
+X x;
+
+struct Z {
+    operator X() { printf("perator X()\n"); x.iX += iZ; x.fX += fZ; return x; }
+    int iZ;
+    float fZ;
+    Z() : iZ(1), fZ(1.00) {}
+};
+
+Z z;
+
+class Y { // ...
+  public: operator Z(){printf("perator Z()\n"); return z; }
+};
+
+Y y;
+
+int count=0;
+class O { // ...
+public: 
+  operator int(){ return ++iO; }
+  O() : iO(count++) {}
+  int iO;
+};
+
+void g(O a, O b) {
+  int i = (a) ? 1+a : 0; 
+  int j = (a&&b) ? a+b : i; 
+  if (a) { }
+  printf("i = %d j = %d a.iO = %d b.iO = %d\n", i, j, a.iO, b.iO);
+}
+
+int main() {
+  int c = X(Z(y)); // OK: y.operator Z().operator X().operator int()
+  printf("c = %d\n", c);
+  float f = X(Z(y));
+  printf("f = %f\n", f);
+  int i = x;
+  printf("i = %d float = %f\n", i, float(x));
+  i = int(X(Z(y)));
+  f = float(X(Z(y)));
+  printf("i = %d float = %f\n", i,f);
+  f = (float)x;
+  i = (int)x;
+  printf("i = %d float = %f\n", i,f);
+
+  int d = (X)((Z)y);
+  printf("d = %d\n", d);
+
+  int e = (int)((X)((Z)y));
+  printf("e = %d\n", e);
+  O o1, o2;
+  g(o1, o2);
+}
+
+// Test. Conversion in base class is visible in derived class.
+class XB {
+  int a;
+public:
+  operator int();
+};
+
+class Yb : public XB {
+  double b;
+public:
+  operator char();
+};
+
+void f(Yb& a) {
+  int i = a; // OK. calls XB::operator int();
+  char ch = a;  // OK. calls Yb::operator char();
+}
+
+
+// CHECK-LP64: .globl __ZN1ScviEv
+// CHECK-LP64-NEXT: __ZN1ScviEv:
+// CHECK-LP64: call __ZN1Ycv1ZEv
+// CHECK-LP64: call __ZN1Zcv1XEv
+// CHECK-LP64: call __ZN1XcviEv
+// CHECK-LP64: call __ZN1XcvfEv
+// CHECK-LP64: call __ZN2XBcviEv
+// CHECK-LP64: call __ZN2YbcvcEv
+
+// CHECK-LP32: .globl  __ZN1ScviEv
+// CHECK-LP32-NEXT: __ZN1ScviEv:
+// CHECK-LP32: call L__ZN1Ycv1ZEv
+// CHECK-LP32: call L__ZN1Zcv1XEv
+// CHECK-LP32: call L__ZN1XcviEv
+// CHECK-LP32: call L__ZN1XcvfEv
+// CHECK-LP32: call L__ZN2XBcviEv
+// CHECK-LP32: call L__ZN2YbcvcEv
diff --git a/test/CodeGenCXX/convert-to-fptr.cpp b/test/CodeGenCXX/convert-to-fptr.cpp
new file mode 100644
index 000000000000..c0bd2f7b856e
--- /dev/null
+++ b/test/CodeGenCXX/convert-to-fptr.cpp
@@ -0,0 +1,47 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+extern "C" int printf(...);
+
+int f1(int arg)  { return arg; }; 
+
+int f2(float arg) { return int(arg); }; 
+
+typedef int (*fp1)(int); 
+
+typedef int (*fp2)(float); 
+
+struct A {
+  operator fp1() { return f1; }
+  operator fp2() { return f2; } 
+} a;
+
+
+// Test for function reference.
+typedef int (&fr1)(int); 
+typedef int (&fr2)(float); 
+
+struct B {
+  operator fr1() { return f1; }
+  operator fr2() { return f2; } 
+} b;
+
+int main()
+{
+ int i = a(10); // Calls f1 via pointer returned from conversion function
+ printf("i = %d\n", i);
+
+ int j = b(20); // Calls f1 via pointer returned from conversion function
+ printf("j = %d\n", j);
+ return 0;
+}
+
+// CHECK-LP64: call __ZN1AcvPFiiEEv
+// CHECK-LP64: call __ZN1BcvRFiiEEv
+
+// CHECK-LP32: call L__ZN1AcvPFiiEEv
+// CHECK-LP32: call L__ZN1BcvRFiiEEv
+
diff --git a/test/CodeGenCXX/copy-assign-synthesis-1.cpp b/test/CodeGenCXX/copy-assign-synthesis-1.cpp
new file mode 100644
index 000000000000..d4a93afefbfa
--- /dev/null
+++ b/test/CodeGenCXX/copy-assign-synthesis-1.cpp
@@ -0,0 +1,109 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+extern "C" int printf(...);
+
+struct B {
+  B() : B1(3.14), B2(3.15), auB2(3.16)  {} 
+  float B1;
+  float B2;
+  void pr() {
+    printf("B1 = %f B2 = %f auB1 = %f\n", B1, B2, auB1);
+  }
+
+  B& operator=(const B& arg) { B1 = arg.B1; B2 = arg.B2; 
+                               auB1 = arg.auB1; return *this; }
+  union {
+    float auB1;
+    float auB2;
+  };
+};
+
+struct M {
+  M() : M1(10), M2(11) , auM1(12) {} 
+  int M1;
+  int M2;
+  void pr() {
+    printf("M1 = %d M2 = %d auM1 = %d auM2 = %d\n", M1, M2, auM1, auM2);
+  }
+  union {
+    int auM1;
+    int auM2;
+  };
+};
+
+struct N  : B {
+  N() : N1(20), N2(21) {} 
+  int N1;
+  int N2;
+  void pr() {
+    printf("N1 = %d N2 = %d\n", N1, N2);
+    for (unsigned i = 0; i < 3; i++)
+      for (unsigned j = 0; j < 2; j++)
+        printf("arr_b[%d][%d] = %f\n", i,j,arr_b[i][j].B1);
+    B::pr();
+  }
+  N& operator=(const N& arg) {
+    N1 = arg.N1; N2 = arg.N2; 
+    for (unsigned i = 0; i < 3; i++)
+      for (unsigned j = 0; j < 2; j++)
+        arr_b[i][j] = arg.arr_b[i][j];
+    return *this;
+  }
+  B arr_b[3][2];
+};
+
+struct Q  : B {
+  Q() : Q1(30), Q2(31) {} 
+  int Q1;
+  int Q2;
+  void pr() {
+    printf("Q1 = %d Q2 = %d\n", Q1, Q2);
+  }
+};
+
+
+struct X : M , N { 
+  X() : d(0.0), d1(1.1), d2(1.2), d3(1.3) {}
+  double d;
+  double d1;
+  double d2;
+  double d3;
+  void pr() {
+    printf("d = %f d1 = %f d2 = %f d3 = %f\n", d, d1,d2,d3);
+    M::pr(); N::pr();
+    q1.pr(); q2.pr();
+  }
+
+ Q q1, q2;
+}; 
+
+
+X srcX; 
+X dstX; 
+X dstY; 
+
+int main() {
+  dstY = dstX = srcX;
+  srcX.pr();
+  dstX.pr();
+  dstY.pr();
+}
+
+// CHECK-LP64: .globl   __ZN1XaSERKS_
+// CHECK-LP64: .weak_definition  __ZN1XaSERKS_
+// CHECK-LP64: __ZN1XaSERKS_:
+// CHECK-LP64: .globl   __ZN1QaSERKS_
+// CHECK-LP64: .weak_definition  __ZN1QaSERKS_
+// CHECK-LP64: __ZN1QaSERKS_:
+
+// CHECK-LP32: .globl   __ZN1XaSERKS_
+// CHECK-LP32: .weak_definition  __ZN1XaSERKS_
+// CHECK-LP32: __ZN1XaSERKS_:
+// CHECK-LP32: .globl   __ZN1QaSERKS_
+// CHECK-LP32: .weak_definition  __ZN1QaSERKS_
+// CHECK-LP32: __ZN1QaSERKS_:
+
diff --git a/test/CodeGenCXX/copy-assign-synthesis.cpp b/test/CodeGenCXX/copy-assign-synthesis.cpp
new file mode 100644
index 000000000000..f9baa8f03f3c
--- /dev/null
+++ b/test/CodeGenCXX/copy-assign-synthesis.cpp
@@ -0,0 +1,79 @@
+// RUN: clang-cc -emit-llvm -o %t %s &&
+// RUN: grep "_ZN1XaSERK1X" %t | count 0
+
+extern "C" int printf(...);
+
+struct B {
+  B() : B1(3.14), B2(3.15), auB2(3.16)  {} 
+  float B1;
+  float B2;
+  void pr() {
+    printf("B1 = %f B2 = %f auB1 = %f\n", B1, B2, auB1);
+  }
+
+  union {
+    float auB1;
+    float auB2;
+  };
+};
+
+struct M {
+  M() : M1(10), M2(11) , auM1(12) {} 
+  int M1;
+  int M2;
+  void pr() {
+    printf("M1 = %d M2 = %d auM1 = %d auM2 = %d\n", M1, M2, auM1, auM2);
+  }
+  union {
+    int auM1;
+    int auM2;
+  };
+};
+
+struct N  : B {
+  N() : N1(20), N2(21) {} 
+  int N1;
+  int N2;
+  void pr() {
+    printf("N1 = %d N2 = %d\n", N1, N2);
+    B::pr();
+  }
+};
+
+struct Q {
+  Q() : Q1(30), Q2(31) {} 
+  int Q1;
+  int Q2;
+  void pr() {
+    printf("Q1 = %d Q2 = %d\n", Q1, Q2);
+  }
+};
+
+
+struct X : M , N { 
+  X() : d(0.0), d1(1.1), d2(1.2), d3(1.3) {}
+  double d;
+  double d1;
+  double d2;
+  double d3;
+  void pr() {
+    printf("d = %f d1 = %f d2 = %f d3 = %f\n", d, d1,d2,d3);
+    M::pr(); N::pr();
+    q1.pr(); q2.pr();
+  }
+
+ Q q1, q2;
+}; 
+
+
+X srcX; 
+X dstX; 
+X dstY; 
+
+int main() {
+  dstY = dstX = srcX;
+  srcX.pr();
+  dstX.pr();
+  dstY.pr();
+}
+
diff --git a/test/CodeGenCXX/copy-constructor-elim.cpp b/test/CodeGenCXX/copy-constructor-elim.cpp
new file mode 100644
index 000000000000..daef92cdb767
--- /dev/null
+++ b/test/CodeGenCXX/copy-constructor-elim.cpp
@@ -0,0 +1,43 @@
+// RUN: clang-cc -emit-llvm -o %t %s &&
+// RUN: grep "_ZN1CC1ERK1C" %t | count 0 &&
+// RUN: grep "_ZN1SC1ERK1S" %t | count 0 &&
+// RUN: true
+
+extern "C" int printf(...);
+
+
+struct C {
+  C() : iC(6) {printf("C()\n"); }
+  C(const C& c) { printf("C(const C& c)\n"); }
+  int iC;
+};
+
+C foo() {
+  return C();
+};
+
+class X { // ...
+public: 
+  X(int) {}
+  X(const X&, int i = 1, int j = 2, C c = foo()) {
+    printf("X(const X&, %d, %d, %d)\n", i, j, c.iC);
+  }
+};
+
+
+struct S {
+  S();
+};
+
+S::S() { printf("S()\n"); }
+
+void Call(S) {};
+
+int main() {
+  X a(1);
+  X b(a, 2);
+  X c = b;
+  X d(a, 5, 6);
+  S s;
+  Call(s);
+}
diff --git a/test/CodeGenCXX/copy-constructor-synthesis.cpp b/test/CodeGenCXX/copy-constructor-synthesis.cpp
new file mode 100644
index 000000000000..47971afe61d4
--- /dev/null
+++ b/test/CodeGenCXX/copy-constructor-synthesis.cpp
@@ -0,0 +1,110 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+extern "C" int printf(...);
+
+int init = 100;
+
+struct M {
+  int iM;
+  M() : iM(init++) {}
+};
+
+struct N {
+  int iN;
+  N() : iN(200) {}
+  N(N const & arg){this->iN = arg.iN; }
+};
+
+struct P {
+  int iP;
+  P() : iP(init++) {}
+};
+
+
+struct X  : M, N, P { // ...
+  X() : f1(1.0), d1(2.0), i1(3), name("HELLO"), bf1(0xff), bf2(0xabcd),
+        au_i1(1234), au1_4("MASKED") {}
+  P p0;
+  void pr() {
+    printf("iM = %d iN = %d, m1.iM = %d\n", iM, iN, m1.iM); 
+    printf("im = %d p0.iP = %d, p1.iP = %d\n", iP, p0.iP, p1.iP); 
+    printf("f1 = %f  d1 = %f  i1 = %d name(%s) \n", f1, d1, i1, name);
+    printf("bf1 = %x  bf2 = %x\n", bf1, bf2);
+    printf("au_i2 = %d\n", au_i2); 
+    printf("au1_1 = %s\n", au1_1); 
+  }
+  M m1;
+  P p1;
+  float f1;
+  double d1;
+  int i1;
+  const char *name;
+  unsigned bf1 : 8;
+  unsigned bf2 : 16;
+
+  union {
+    int au_i1;
+    int au_i2;
+  };
+  union {
+    const char * au1_1;
+    float au1_2;
+    int au1_3;
+    const char * au1_4;
+  };
+};
+
+static int ix = 1;
+// class with user-defined copy constructor.
+struct S {
+  S() : iS(ix++) {  }
+  S(const S& arg) { *this = arg; }
+  int iS;
+};
+
+// class with trivial copy constructor.
+struct I {
+  I() : iI(ix++) {  }
+  int iI;
+};
+
+struct XM {
+  XM() {  }
+  double dXM;
+  S ARR_S[3][4][2];
+  void pr() {
+   for (unsigned i = 0; i < 3; i++)
+     for (unsigned j = 0; j < 4; j++)
+      for (unsigned k = 0; k < 2; k++)
+        printf("ARR_S[%d][%d][%d] = %d\n", i,j,k, ARR_S[i][j][k].iS);
+   for (unsigned i = 0; i < 3; i++)
+      for (unsigned k = 0; k < 2; k++)
+        printf("ARR_I[%d][%d] = %d\n", i,k, ARR_I[i][k].iI);
+  }
+  I ARR_I[3][2];
+};
+
+int main() {
+  X a;
+  X b(a);
+  b.pr();
+  X x;
+  X c(x);
+  c.pr();
+
+  XM m0;
+  XM m1 = m0;
+  m1.pr();
+}
+
+// CHECK-LP64: .globl  __ZN1XC1ERKS_
+// CHECK-LP64: .weak_definition __ZN1XC1ERKS_
+// CHECK-LP64: __ZN1XC1ERKS_:
+
+// CHECK-LP32: .globl  __ZN1XC1ERKS_
+// CHECK-LP32: .weak_definition __ZN1XC1ERKS_
+// CHECK-LP32: __ZN1XC1ERKS_:
diff --git a/test/CodeGenCXX/decl-ref-init.cpp b/test/CodeGenCXX/decl-ref-init.cpp
new file mode 100644
index 000000000000..27d200f4635b
--- /dev/null
+++ b/test/CodeGenCXX/decl-ref-init.cpp
@@ -0,0 +1,31 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+struct A {};
+
+struct B 
+{ 
+  operator A&();
+}; 
+
+
+struct D : public B {
+  operator A();
+};
+
+extern B f(); 
+extern D d(); 
+
+int main() {
+	const A& rca = f();
+	const A& rca2 = d();
+}
+
+// CHECK-LP64: call     __ZN1BcvR1AEv
+// CHECK-LP64: call     __ZN1BcvR1AEv
+
+// CHECK-LP32: call     L__ZN1BcvR1AEv
+// CHECK-LP32: call     L__ZN1BcvR1AEv
diff --git a/test/CodeGenCXX/default-arg-temps.cpp b/test/CodeGenCXX/default-arg-temps.cpp
index 2dcf773346a8..2651446669b8 100644
--- a/test/CodeGenCXX/default-arg-temps.cpp
+++ b/test/CodeGenCXX/default-arg-temps.cpp
@@ -7,9 +7,19 @@ struct T {
 
 void f(const T& t = T());
 
+class X { // ...
+public:
+        X();
+        X(const X&, const T& t = T());
+};
+
 void g() {
-  // RUN: grep "call void @_ZN1TC1Ev" %t | count 2 &&
-  // RUN: grep "call void @_ZN1TD1Ev" %t | count 2
+  // RUN: grep "call void @_ZN1TC1Ev" %t | count 4 &&
+  // RUN: grep "call void @_ZN1TD1Ev" %t | count 4
   f();
   f();
+
+  X a;
+  X b(a);
+  X c = a;
 }
diff --git a/test/CodeGenCXX/default-constructor-for-members.cpp b/test/CodeGenCXX/default-constructor-for-members.cpp
new file mode 100644
index 000000000000..2d04bc941427
--- /dev/null
+++ b/test/CodeGenCXX/default-constructor-for-members.cpp
@@ -0,0 +1,24 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+extern "C" int printf(...);
+
+struct S {
+  S() { printf("S::S()\n"); }
+  int iS;
+};
+
+struct M {
+  S ARR_S; 
+};
+
+int main() {
+  M m1;
+}
+
+// CHECK-LP64: call __ZN1SC1Ev
+
+// CHECK-LP32: call L__ZN1SC1Ev
diff --git a/test/CodeGenCXX/default-destructor-synthesis.cpp b/test/CodeGenCXX/default-destructor-synthesis.cpp
new file mode 100644
index 000000000000..9cc802c85dfa
--- /dev/null
+++ b/test/CodeGenCXX/default-destructor-synthesis.cpp
@@ -0,0 +1,60 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -O0 -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -O0 -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 -input-file=%t-32.s %s &&
+// RUN: true
+
+extern "C" int printf(...);
+
+int count = 1;
+
+struct S {
+  S() : iS(count++), fS(1.23) {};
+  ~S(){printf("S::~S(%d, %f)\n", iS, fS); };
+  int iS;
+  float fS;
+};
+
+struct Q {
+  Q() : iQ(count++), dQ(2.34) {};
+  ~Q(){printf("Q::~Q(%d, %f)\n", iQ, dQ); };
+  int iQ;
+  double dQ;
+};
+
+struct P {
+  P() : fP(3.45) , iP(count++) {};
+  ~P(){printf("P::~P(%d, %f)\n", iP, fP); };
+  float fP;
+  int iP;
+};
+
+struct M  : Q, P {
+  S s;
+
+  Q q;
+
+  P p; 
+
+ P p_arr[3];
+
+ Q q_arr[2][3];
+
+};
+
+M gm;
+
+int main() {M m1;}
+
+// CHECK-LP64: call __ZN1MC1Ev
+// CHECK-LP64: call __ZN1MD1Ev
+// CHECK-LP64: .globl __ZN1MD1Ev
+// CHECK-LP64-NEXT: .weak_definition __ZN1MD1Ev
+// CHECK-LP64-NEXT: __ZN1MD1Ev:
+
+
+// CHECK-LP32: call L__ZN1MC1Ev
+// CHECK-LP32: call L__ZN1MD1Ev
+// CHECK-LP32: .globl __ZN1MD1Ev
+// CHECK-LP32-NEXT: .weak_definition __ZN1MD1Ev
+// CHECK-LP32-NEXT:__ZN1MD1Ev:
diff --git a/test/CodeGenCXX/delete.cpp b/test/CodeGenCXX/delete.cpp
new file mode 100644
index 000000000000..9e3feefefeda
--- /dev/null
+++ b/test/CodeGenCXX/delete.cpp
@@ -0,0 +1,37 @@
+// RUN: clang-cc %s -emit-llvm -o %t &&
+
+void t1(int *a) {
+  delete a;
+}
+
+struct S {
+  int a;
+};
+
+// POD types.
+void t3(S *s) {
+  delete s;
+}
+
+// Non-POD
+struct T {
+  ~T();
+  int a;
+};
+
+void t4(T *t) {
+  // RUN: grep "call void @_ZN1TD1Ev" %t | count 1
+  delete t;
+}
+
+// PR5102
+template <typename T>
+class A {
+  operator T *() const;
+};
+
+void f() {
+  A<char*> a;
+  
+  delete a;
+}
diff --git a/test/CodeGenCXX/derived-to-base.cpp b/test/CodeGenCXX/derived-to-base.cpp
new file mode 100644
index 000000000000..63492d604d17
--- /dev/null
+++ b/test/CodeGenCXX/derived-to-base.cpp
@@ -0,0 +1,16 @@
+// RUN: clang-cc -emit-llvm %s -o -
+struct A { 
+  void f(); 
+  
+  int a;
+};
+
+struct B : A { 
+  double b;
+};
+
+void f() {
+  B b;
+  
+  b.f();
+}
diff --git a/test/CodeGenCXX/destructor-calls.cpp b/test/CodeGenCXX/destructor-calls.cpp
new file mode 100644
index 000000000000..3f0288b85c14
--- /dev/null
+++ b/test/CodeGenCXX/destructor-calls.cpp
@@ -0,0 +1,41 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+
+extern "C" int printf(...);
+
+static int val;
+
+struct B {
+  B() : iB(++val) { printf("B()\n"); }
+  int iB;
+  ~B() { printf("~B(%d)\n", iB); --val; }
+};
+
+struct M : B {
+  M() : iM(++val) { printf("M()\n"); }
+  int iM;
+  ~M() { printf("~M(%d)\n", iM); --val; }
+};
+
+struct P {
+  P() : iP(++val) { printf("P()\n"); }
+  int iP;
+  ~P() { printf("~P(%d)\n", iP); --val; }
+};
+
+struct N : M, P {
+  N() { printf("N()\n"); iN = ++val; }
+  ~N() { printf("~N(%d) val = %d\n", iN, --val);  }
+  int iN;
+  M m;
+  P p;
+};
+
+struct O : B { 
+  ~O() { return; } 
+};
+
+int main() {
+  N n1;
+  N n2;
+  O o;
+}
diff --git a/test/CodeGenCXX/destructors.cpp b/test/CodeGenCXX/destructors.cpp
new file mode 100644
index 000000000000..44d2b2936864
--- /dev/null
+++ b/test/CodeGenCXX/destructors.cpp
@@ -0,0 +1,30 @@
+// RUN: clang-cc %s -emit-llvm -o -
+struct A {
+  int a;
+  
+  ~A();
+};
+
+// Base with non-trivial destructor
+struct B : A {
+  ~B();
+};
+
+B::~B() { }
+
+// Field with non-trivial destructor
+struct C {
+  A a;
+  
+  ~C();
+};
+
+C::~C() { }
+
+// PR5084
+template<typename T>
+class A1 {
+  ~A1();
+};
+
+template<> A1<char>::~A1();
diff --git a/test/CodeGenCXX/devirtualize-virtual-function-calls.cpp b/test/CodeGenCXX/devirtualize-virtual-function-calls.cpp
new file mode 100644
index 000000000000..cbf55ad61331
--- /dev/null
+++ b/test/CodeGenCXX/devirtualize-virtual-function-calls.cpp
@@ -0,0 +1,47 @@
+// RUN: clang-cc %s -emit-llvm -o - | FileCheck %s
+
+struct A {
+  virtual void f();
+  
+  A h();
+};
+
+A g();
+
+void f(A a, A *ap, A& ar) {
+  // This should not be a virtual function call.
+  
+  // CHECK: call void @_ZN1A1fEv(%struct.A* %a)
+  a.f();
+
+  // CHECK: call void %  
+  ap->f();
+
+  // CHECK: call void %  
+  ar.f();
+  
+  // CHECK: call void @_ZN1A1fEv
+  A().f();
+
+  // CHECK: call void @_ZN1A1fEv
+  g().f();
+  
+  // CHECK: call void @_ZN1A1fEv
+  a.h().f();
+}
+
+struct B {
+  virtual void f();
+  ~B();
+  
+  B h();
+};
+
+
+void f() {
+  // CHECK: call void @_ZN1B1fEv
+  B().f();
+  
+  // CHECK: call void @_ZN1B1fEv
+  B().h().f();
+}
diff --git a/test/CodeGenCXX/explicit-instantiation.cpp b/test/CodeGenCXX/explicit-instantiation.cpp
index 38966aad2deb..8a9e65c4e2e3 100644
--- a/test/CodeGenCXX/explicit-instantiation.cpp
+++ b/test/CodeGenCXX/explicit-instantiation.cpp
@@ -1,11 +1,14 @@
-// RUN: clang-cc -emit-llvm -femit-all-decls -o %t %s &&
-// RUN: grep "_ZNK4plusIillEclERKiRKl" %t | count 1
+// RUN: clang-cc -emit-llvm -triple i686-pc-linue-gnu -o %t %s &&
+// RUN: grep "define i32 @_ZNK4plusIillEclERKiRKl" %t | count 1
 
 template<typename T, typename U, typename Result>
 struct plus {
-  Result operator()(const T& t, const U& u) const {
-    return t + u;
-  }
+  Result operator()(const T& t, const U& u) const;
 };
 
+template<typename T, typename U, typename Result>
+Result plus<T, U, Result>::operator()(const T& t, const U& u) const {
+  return t + u;
+}
+
 template struct plus<int, long, long>;
diff --git a/test/CodeGenCXX/function-template-specialization.cpp b/test/CodeGenCXX/function-template-specialization.cpp
index bea3af2bb5af..677be4cc0f9a 100644
--- a/test/CodeGenCXX/function-template-specialization.cpp
+++ b/test/CodeGenCXX/function-template-specialization.cpp
@@ -1,4 +1,4 @@
-// RUN: clang-cc -emit-llvm %s -o %t &&
+// RUN: clang-cc -emit-llvm %s -o - | FileCheck %s
 template<typename T, typename U>
 T* next(T* ptr, const U& diff);
 
@@ -8,11 +8,10 @@ T* next(T* ptr, const U& diff) {
 }
 
 void test(int *iptr, float *fptr, int diff) {
-  // FIXME: should be "_Z4nextIiiEPT_S1_RKT0_"
-  // RUN: grep "_Z4nextIiiEPiPiRKi" %t &&
+  // CHECK: _Z4nextIiiEPT_S1_RKT0_
   iptr = next(iptr, diff);
-  // FIXME: should be "_Z4nextIfiEPT_S1_RKT0_"
-  // RUN: grep "_Z4nextIfiEPfPfRKi" %t &&
+
+  // CHECK: _Z4nextIfiEPT_S1_RKT0_
   fptr = next(fptr, diff);
 }
 
@@ -21,7 +20,7 @@ T* next(T* ptr, const U& diff);
 
 void test2(int *iptr, double *dptr, int diff) {
   iptr = next(iptr, diff);
-  // FIXME: should be "_Z4nextIdiEPT_S1_RKT0_"
-  // RUN: grep "_Z4nextIdiEPdPdRKi" %t
+
+  // CHECK: _Z4nextIdiEPT_S1_RKT0_
   dptr = next(dptr, diff);
-}
\ No newline at end of file
+}
diff --git a/test/CodeGenCXX/global-init.cpp b/test/CodeGenCXX/global-init.cpp
new file mode 100644
index 000000000000..ae450e17e85e
--- /dev/null
+++ b/test/CodeGenCXX/global-init.cpp
@@ -0,0 +1,16 @@
+// RUN: clang-cc -triple=x86_64-apple-darwin10 -emit-llvm %s -o - |FileCheck %s
+
+struct A {
+  A();
+  ~A();
+};
+
+struct B { B(); ~B(); };
+
+// CHECK: call void @_ZN1AC1Ev(%struct.A* @a)
+// CHECK: call i32 @__cxa_atexit(void (i8*)* bitcast (void (%struct.A*)* @_ZN1AD1Ev to void (i8*)*), i8* getelementptr inbounds (%struct.A* @a, i32 0, i32 0), i8* bitcast (i8** @__dso_handle to i8*))
+A a;
+
+// CHECK: call void @_ZN1BC1Ev(%struct.A* @b)
+// CHECK: call i32 @__cxa_atexit(void (i8*)* bitcast (void (%struct.A*)* @_ZN1BD1Ev to void (i8*)*), i8* getelementptr inbounds (%struct.A* @b, i32 0, i32 0), i8* bitcast (i8** @__dso_handle to i8*))
+B b;
diff --git a/test/CodeGenCXX/mangle-extreme.cpp b/test/CodeGenCXX/mangle-extreme.cpp
new file mode 100644
index 000000000000..77558d29d824
--- /dev/null
+++ b/test/CodeGenCXX/mangle-extreme.cpp
@@ -0,0 +1,47 @@
+// RUN: clang-cc -emit-llvm %s -o - -triple=x86_64-apple-darwin9 | FileCheck %s
+
+struct X { };
+
+// CHECK: define void @_Z1fPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP1XS13_S12_S11_S10_SZ_SY_SX_SW_SV_SU_ST_SS_SR_SQ_SP_SO_SN_SM_SL_SK_SJ_SI_SH_SG_SF_SE_SD_SC_SB_SA_S9_S8_S7_S6_S5_S4_S3_S2_S1_S0_S_(
+void f(X****************************************,
+       X****************************************,
+       X***************************************,
+       X**************************************,
+       X*************************************,
+       X************************************,
+       X***********************************,
+       X**********************************,
+       X*********************************,
+       X********************************,
+       X*******************************,
+       X******************************,
+       X*****************************,
+       X****************************,
+       X***************************,
+       X**************************,
+       X*************************,
+       X************************,
+       X***********************,
+       X**********************,
+       X*********************,
+       X********************,
+       X*******************,
+       X******************,
+       X*****************,
+       X****************,
+       X***************,
+       X**************,
+       X*************,
+       X************,
+       X***********,
+       X**********,
+       X*********,
+       X********,
+       X*******,
+       X******,
+       X*****,
+       X****,
+       X***,
+       X**,
+       X*,
+       X) { }
diff --git a/test/CodeGenCXX/mangle-subst-std.cpp b/test/CodeGenCXX/mangle-subst-std.cpp
new file mode 100644
index 000000000000..fbce20451264
--- /dev/null
+++ b/test/CodeGenCXX/mangle-subst-std.cpp
@@ -0,0 +1,39 @@
+// RUN: clang-cc -emit-llvm %s -o - -triple=x86_64-apple-darwin9 | FileCheck %s
+
+namespace std {
+  struct A { A(); };
+  
+  // CHECK: define void @_ZNSt1AC1Ev
+  // CHECK: define void @_ZNSt1AC2Ev
+  A::A() { }
+};
+
+namespace std {
+  template<typename> struct allocator { };
+}
+
+// CHECK: define void @_Z1fSaIcESaIiE
+void f(std::allocator<char>, std::allocator<int>) { }
+
+namespace std {
+  template<typename, typename, typename> struct basic_string { };
+}
+
+// CHECK: define void @_Z1fSbIcciE
+void f(std::basic_string<char, char, int>) { }
+
+namespace std {
+  template<typename> struct char_traits { };
+  
+  typedef std::basic_string<char, std::char_traits<char>, std::allocator<char> > string;
+}
+
+// CHECK: _Z1fSs
+void f(std::string) { }
+
+namespace std {
+  template<typename, typename> struct basic_ostream { };
+}
+
+// CHECK: _Z1fSo
+void f(std::basic_ostream<char, std::char_traits<char> >) { }
diff --git a/test/CodeGenCXX/mangle-subst.cpp b/test/CodeGenCXX/mangle-subst.cpp
new file mode 100644
index 000000000000..c53a6300aa19
--- /dev/null
+++ b/test/CodeGenCXX/mangle-subst.cpp
@@ -0,0 +1,56 @@
+// RUN: clang-cc -emit-llvm %s -o - -triple=x86_64-apple-darwin9 | FileCheck %s
+
+struct X {};
+
+// CHECK: define void @_Z1f1XS_(
+void f(X, X) { }
+
+// CHECK: define void @_Z1fR1XS0_(
+void f(X&, X&) { }
+
+// CHECK: define void @_Z1fRK1XS1_(
+void f(const X&, const X&) { }
+
+typedef void T();
+struct S {};
+
+// CHECK: define void @_Z1fPFvvEM1SFvvE(
+void f(T*, T (S::*)) {}
+
+namespace A {
+  struct A { };
+  struct B { };
+};
+
+// CHECK: define void @_Z1fN1A1AENS_1BE(
+void f(A::A a, A::B b) { }
+
+struct C {
+  struct D { };
+};
+
+// CHECK: define void @_Z1fN1C1DERS_PS_S1_(
+void f(C::D, C&, C*, C&) { }
+
+template<typename T>
+struct V {
+  typedef int U;
+};
+
+template <typename T> void f1(typename V<T>::U, V<T>) { }
+
+// CHECK: @_Z2f1IiEvN1VIT_E1UES2_
+template void f1<int>(int, V<int>);
+
+template <typename T> void f2(V<T>, typename V<T>::U) { }
+
+// CHECK: @_Z2f2IiEv1VIT_ENS2_1UE
+template void f2<int>(V<int>, int);
+
+namespace NS {
+template <typename T> struct S1 {};
+template<typename T> void ft3(S1<T>, S1<char>) {  }
+
+// CHECK: @_ZN2NS3ft3IiEEvNS_2S1IT_EENS1_IcEE
+template void ft3<int>(S1<int>, S1<char>);
+}
diff --git a/test/CodeGenCXX/mangle.cpp b/test/CodeGenCXX/mangle.cpp
index ef36a8b23cfc..2ffbae71da01 100644
--- a/test/CodeGenCXX/mangle.cpp
+++ b/test/CodeGenCXX/mangle.cpp
@@ -1,87 +1,223 @@
-// RUN: clang-cc -emit-llvm %s -o %t -triple=x86_64-apple-darwin9 && 
+// RUN: clang-cc -emit-llvm %s -o - -triple=x86_64-apple-darwin9 | FileCheck %s
 
-// FIXME: This test is intentionally trivial, because we can't yet
-// CodeGen anything real in C++.
 struct X { };
 struct Y { };
 
-// RUN: grep _ZplRK1YRA100_P1X %t | count 1 &&
+// CHECK: @unmangled_variable = global
+// CHECK: @_ZN1N1iE = global
+// CHECK: @_ZZN1N1fEiiE1b = internal global
+// CHECK: @_ZZN1N1gEvE1a = internal global
+// CHECK: @_ZGVZN1N1gEvE1a = internal global
+
+// CHECK: define zeroext i1 @_ZplRK1YRA100_P1X
 bool operator+(const Y&, X* (&xs)[100]) { return false; }
 
-// RUN: grep _Z1f1s %t | count 1 &&
+// CHECK: define void @_Z1f1s
 typedef struct { int a; } s;
 void f(s) { }
 
-// RUN: grep _Z1f1e %t| count 1 &&
+// CHECK: define void @_Z1f1e
 typedef enum { foo } e;
 void f(e) { }
 
-// RUN: grep _Z1f1u %t | count 1 &&
+// CHECK: define void @_Z1f1u
 typedef union { int a; } u;
 void f(u) { }
 
-// RUN: grep _Z1f1x %t | count 1 &&
+// CHECK: define void @_Z1f1x
 typedef struct { int a; } x,y;
 void f(y) { }
 
-// RUN: grep _Z1fv %t | count 1 &&
+// CHECK: define void @_Z1fv
 void f() { }
 
-// RUN: grep _ZN1N1fEv %t | count 1 &&
+// CHECK: define void @_ZN1N1fEv
 namespace N { void f() { } }
 
-// RUN: grep _ZN1N1N1fEv %t | count 1 &&
+// CHECK: define void @_ZN1N1N1fEv
 namespace N { namespace N { void f() { } } }
 
-// RUN: grep unmangled_function %t | count 1 &&
+// CHECK: define void @unmangled_function
 extern "C" { namespace N { void unmangled_function() { } } }
 
-// RUN: grep unmangled_variable %t | count 1 &&
 extern "C" { namespace N { int unmangled_variable = 10; } }
 
-// RUN: grep _ZN1N1iE %t | count 1 &&
 namespace N { int i; }
 
-// RUN: grep _ZZN1N1fEiiE1b %t | count 2 &&
 namespace N { int f(int, int) { static int b; return b; } }
 
-// RUN: grep "_ZZN1N1gEvE1a =" %t | count 1 &&
-// RUN: grep "_ZGVZN1N1gEvE1a =" %t | count 1 &&
 namespace N { int h(); void g() { static int a = h(); } }
 
-// RUN: grep "_Z1fno" %t | count 1 &&
+// CHECK: define void @_Z1fno
 void f(__int128_t, __uint128_t) { } 
 
 template <typename T> struct S1 {};
 
-// RUN: grep "_Z1f2S1IiE" %t | count 1 &&
+// CHECK: define void @_Z1f2S1IiE
 void f(S1<int>) {}
 
-// RUN: grep "_Z1f2S1IdE" %t | count 1 &&
+// CHECK: define void @_Z1f2S1IdE
 void f(S1<double>) {}
 
 template <int N> struct S2 {};
-// RUN: grep "_Z1f2S2ILi100EE" %t | count 1 &&
+// CHECK: define void @_Z1f2S2ILi100EE
 void f(S2<100>) {}
 
-// RUN: grep "_Z1f2S2ILin100EE" %t | count 1 &&
+// CHECK: define void @_Z1f2S2ILin100EE
 void f(S2<-100>) {}
 
 template <bool B> struct S3 {};
 
-// RUN: grep "_Z1f2S3ILb1EE" %t | count 1 &&
+// CHECK: define void @_Z1f2S3ILb1EE
 void f(S3<true>) {}
 
-// RUN: grep "_Z1f2S3ILb0EE" %t | count 1 &&
+// CHECK: define void @_Z1f2S3ILb0EE
 void f(S3<false>) {}
 
-// RUN: grep "_Z2f22S3ILb1EE" %t | count 1 &&
+// CHECK: define void @_Z2f22S3ILb1EE
 void f2(S3<100>) {}
 
 struct S;
 
-// RUN: grep "_Z1fM1SKFvvE" %t | count 1 &&
+// CHECK: define void @_Z1fM1SKFvvE
 void f(void (S::*)() const) {}
 
-// RUN: grep "_Z1fM1SFvvE" %t | count 1
+// CHECK: define void @_Z1fM1SFvvE
 void f(void (S::*)()) {}
+
+// CHECK: define void @_Z1fi
+void f(const int) { }
+
+template<typename T, typename U> void ft1(U u, T t) { }
+
+template<typename T> void ft2(T t, void (*)(T), void (*)(T)) { }
+
+template<typename T, typename U = S1<T> > struct S4 { };
+template<typename T> void ft3(S4<T>*) {  }
+
+namespace NS {
+  template<typename T> void ft1(T) { }
+}
+
+void g1() {
+  // CHECK: @_Z3ft1IidEvT0_T_
+  ft1<int, double>(1, 0);
+  
+  // CHECK: @_Z3ft2IcEvT_PFvS0_ES2_
+  ft2<char>(1, 0, 0);
+  
+  // CHECK: @_Z3ft3IiEvP2S4IT_2S1IS1_EE
+  ft3<int>(0);
+  
+  // CHECK: @_ZN2NS3ft1IiEEvT_
+  NS::ft1<int>(1);
+}
+
+// Expressions
+template<int I> struct S5 { };
+
+template<int I> void ft4(S5<I>) { }
+void g2() {
+  // CHECK: @_Z3ft4ILi10EEv2S5IXT_EE
+  ft4(S5<10>());
+  
+  // CHECK: @_Z3ft4ILi20EEv2S5IXT_EE
+  ft4(S5<20>());
+}
+
+extern "C++" {
+  // CHECK: @_Z1hv
+ void h() { } 
+}
+
+// PR5019
+extern "C" { struct a { int b; }; }
+
+// CHECK: @_Z1fP1a
+int f(struct a *x) {
+    return x->b;
+}
+
+// PR5017
+extern "C" {
+struct Debug {
+ const Debug& operator<< (unsigned a) const { }
+};
+Debug dbg;
+// CHECK: @_ZNK5DebuglsEj
+int main(void) {  dbg << 32 ;}
+}
+
+template<typename T> struct S6 {
+  typedef int B;
+};
+
+template<typename T> void ft5(typename S6<T>::B) { }
+// CHECK: @_Z3ft5IiEvN2S6IT_E1BE
+template void ft5<int>(int);
+
+template<typename T> class A {};
+
+namespace NS {
+template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; }
+}
+
+// CHECK: @_ZN2NSeqIcEEbRK1AIT_ES5_
+template bool NS::operator==(const ::A<char>&, const ::A<char>&);
+
+namespace std {
+template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; }
+}
+
+// CHECK: @_ZSteqIcEbRK1AIT_ES4_
+template bool std::operator==(const ::A<char>&, const ::A<char>&);
+
+struct S {
+  typedef int U;
+};
+
+template <typename T> typename T::U ft6(const T&) { return 0; }
+
+// CHECK: @_Z3ft6I1SENT_1UERKS1_
+template int ft6<S>(const S&);
+
+template<typename> struct __is_scalar {
+  enum { __value = 1 };
+};
+
+template<bool, typename> struct __enable_if { };
+
+template<typename T> struct __enable_if<true, T> {
+  typedef T __type;
+};
+
+// PR5063
+template<typename T> typename __enable_if<__is_scalar<T>::__value, void>::__type ft7() { }
+
+// CHECK: @_Z3ft7IiEN11__enable_ifIXsr11__is_scalarIT_E7__valueEvE6__typeEv
+template void ft7<int>();
+// CHECK: @_Z3ft7IPvEN11__enable_ifIXsr11__is_scalarIT_E7__valueEvE6__typeEv
+template void ft7<void*>();
+
+// PR5144
+extern "C" {
+void extern_f(void);
+};
+
+// CHECK: @extern_f
+void extern_f(void) { }
+
+struct S7 {
+  struct S { S(); };
+  
+  struct {
+    S s;
+  } a;
+};
+
+// PR5139
+// CHECK: @_ZN2S7C1Ev
+// CHECK: @_ZN2S7C2Ev
+// CHECK: @"_ZN2S73$_0C1Ev"
+S7::S7() {}
+
diff --git a/test/CodeGenCXX/member-function-pointers.cpp b/test/CodeGenCXX/member-function-pointers.cpp
new file mode 100644
index 000000000000..13f7de5a631b
--- /dev/null
+++ b/test/CodeGenCXX/member-function-pointers.cpp
@@ -0,0 +1,73 @@
+// RUN: clang-cc %s -emit-llvm -o - -triple=x86_64-apple-darwin9 | FileCheck %s
+
+struct A { int a; void f(); virtual void vf(); };
+struct B { int b; virtual void g(); };
+struct C : B, A { };
+
+void (A::*pa)();
+void (A::*volatile vpa)();
+void (B::*pb)();
+void (C::*pc)();
+
+// CHECK: @pa2 = global %0 { i64 ptrtoint (void ()* @_ZN1A1fEv to i64), i64 0 }, align 8
+void (A::*pa2)() = &A::f;
+
+// CHECK: @pa3 = global %0 { i64 1, i64 0 }, align 8
+void (A::*pa3)() = &A::vf;
+
+// CHECK: @pc2 = global %0 { i64 ptrtoint (void ()* @_ZN1A1fEv to i64), i64 16 }, align 8
+void (C::*pc2)() = &C::f;
+
+// CHECK: @pc3 = global %0 { i64 1, i64 0 }, align 8
+void (A::*pc3)() = &A::vf;
+
+void f() {
+  // CHECK: store i64 0, i64* getelementptr inbounds (%0* @pa, i32 0, i32 0)
+  // CHECK: store i64 0, i64* getelementptr inbounds (%0* @pa, i32 0, i32 1)
+  pa = 0;
+
+  // CHECK: volatile store i64 0, i64* getelementptr inbounds (%0* @vpa, i32 0, i32 0)
+  // CHECK: volatile store i64 0, i64* getelementptr inbounds (%0* @vpa, i32 0, i32 1)
+  vpa = 0;
+
+  // CHECK: store i64 %0, i64* getelementptr inbounds (%0* @pc, i32 0, i32 0)
+  // CHECK: [[ADJ:%[a-zA-Z0-9\.]+]] = add i64 %1, 16
+  // CHECK: store i64 [[ADJ]], i64* getelementptr inbounds (%0* @pc, i32 0, i32 1)
+  pc = pa;
+}
+
+void f2() {
+  // CHECK: [[pa2ptr:%[a-zA-Z0-9\.]+]] = getelementptr inbounds %0* %pa2, i32 0, i32 0 
+  // CHECK: store i64 ptrtoint (void ()* @_ZN1A1fEv to i64), i64* [[pa2ptr]]
+  // CHECK: [[pa2adj:%[a-zA-Z0-9\.]+]] = getelementptr inbounds %0* %pa2, i32 0, i32 1
+  // CHECK: store i64 0, i64* [[pa2adj]]
+  void (A::*pa2)() = &A::f;
+  
+  // CHECK: [[pa3ptr:%[a-zA-Z0-9\.]+]] = getelementptr inbounds %0* %pa3, i32 0, i32 0 
+  // CHECK: store i64 1, i64* [[pa3ptr]]
+  // CHECK: [[pa3adj:%[a-zA-Z0-9\.]+]] = getelementptr inbounds %0* %pa3, i32 0, i32 1
+  // CHECK: store i64 0, i64* [[pa2adj]]
+  void (A::*pa3)() = &A::vf;
+}
+
+void f3(A *a, A &ar) {
+  (a->*pa)();
+  (ar.*pa)();
+}
+
+// PR5177
+namespace PR5177 {
+  struct A {
+   bool foo(int*) const;
+  } a;
+
+  struct B1 {
+   bool (A::*pmf)(int*) const;
+   const A* pa;
+
+   B1() : pmf(&A::foo), pa(&a) {}
+   bool operator()() const { return (pa->*pmf)(new int); }
+  };
+
+  void bar(B1 b2) { while (b2()) ; }
+}
diff --git a/test/CodeGenCXX/member-functions.cpp b/test/CodeGenCXX/member-functions.cpp
index 8ada907117be..29629d5bf824 100644
--- a/test/CodeGenCXX/member-functions.cpp
+++ b/test/CodeGenCXX/member-functions.cpp
@@ -58,6 +58,6 @@ struct T {
 void test3() {
   T t1, t2;
   
-  // RUN: grep "call void @_ZN1TpsERK1T" %t
+  // RUN: grep "call void @_ZN1TpsERKS_" %t
   T result = t1 + t2;
 }
diff --git a/test/CodeGenCXX/member-pointers-zero-init.cpp b/test/CodeGenCXX/member-pointers-zero-init.cpp
new file mode 100644
index 000000000000..e7b0fdafba6a
--- /dev/null
+++ b/test/CodeGenCXX/member-pointers-zero-init.cpp
@@ -0,0 +1,34 @@
+// RUN: clang-cc -emit-llvm %s -o %t -triple=x86_64-apple-darwin9 &&
+
+struct A {
+  int i;
+};
+
+// RUN: grep "@a = global i64 -1" %t &&
+int A::* a;
+
+// RUN: grep "@aa = global \[2 x i64\] \[i64 -1, i64 -1\]" %t &&
+int A::* aa[2];
+
+// RUN: grep "@aaa = global \[2 x \[2 x i64\]\] \[\[2 x i64\] \[i64 -1, i64 -1\], \[2 x i64\] \[i64 -1, i64 -1\]\]" %t &&
+int A::* aaa[2][2];
+
+// RUN: grep "@b = global i64 -1" %t &&
+int A::* b = 0;
+
+void f() {
+  // RUN: grep "%.* = icmp ne i64 %.*, -1" %t | count 2 &&
+  if (a) { }
+  if (a != 0) { }
+
+  // RUN: grep "%.* = icmp ne i64 -1, %.*" %t | count 1 &&
+  if (0 != a) { }
+  
+  // RUN: grep "%.* = icmp eq i64 %.*, -1" %t | count 1 &&
+  if (a == 0) { }
+
+  // RUN: grep "%.* = icmp eq i64 -1, %.*" %t | count 1
+  if (0 == a) { }
+    
+}
+
diff --git a/test/CodeGenCXX/namespace-aliases.cpp b/test/CodeGenCXX/namespace-aliases.cpp
new file mode 100644
index 000000000000..5baea8791ef9
--- /dev/null
+++ b/test/CodeGenCXX/namespace-aliases.cpp
@@ -0,0 +1,3 @@
+// RUN: clang-cc -emit-llvm-only %s
+namespace A { }
+namespace B = A;
diff --git a/test/CodeGenCXX/nested-base-member-access.cpp b/test/CodeGenCXX/nested-base-member-access.cpp
new file mode 100644
index 000000000000..308f952c6dc2
--- /dev/null
+++ b/test/CodeGenCXX/nested-base-member-access.cpp
@@ -0,0 +1,52 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+
+extern "C" int printf(...);
+
+struct M {
+  M(int i){ iM = i; }
+  int iM;
+  void MPR() { printf("iM = %d\n", iM); }
+
+};
+
+struct Q {
+  Q(int i){ iQ = i; }
+  int iQ;
+  void QPR() { printf("iQ = %d\n", iQ); }
+};
+
+struct IQ {
+  IQ(int i) { iIQ = i; }
+  void IQPR() { printf("iIQ = %d\n", iIQ); }
+  int iIQ;
+};
+
+struct L : IQ {
+  L(int i) : IQ(i+100) { iL = i; }
+  int iL;
+};
+
+struct P : Q, L  {
+  P(int i) : Q(i+100), L(i+200) { iP = i; }
+  int iP;
+  void PPR() { printf("iP = %d\n", iP); }
+};
+
+
+struct N : M,P {
+  N() : M(100), P(200) {}
+  void PR() {
+    this->MPR(); this->PPR(); this->QPR(); 
+    IQPR();
+    printf("iM = %d\n", iM); 
+    printf("iP = %d\n", iP);
+    printf("iQ = %d\n", iQ);
+    printf("iL = %d\n", iL);
+    printf("iIQ = %d\n", iIQ);
+  }
+};
+
+int main() {
+  N n1;
+  n1.PR();
+}
diff --git a/test/CodeGenCXX/new.cpp b/test/CodeGenCXX/new.cpp
index 480bbcefc08d..c6cee1845670 100644
--- a/test/CodeGenCXX/new.cpp
+++ b/test/CodeGenCXX/new.cpp
@@ -1,4 +1,4 @@
-// RUN: clang-cc %s -emit-llvm -o %t &&
+// RUN: clang-cc %s -emit-llvm -o - | FileCheck %s
 
 void t1() {
   int* a = new int;
@@ -32,7 +32,7 @@ struct T {
 };
 
 void t4() {
-  // RUN: grep "call void @_ZN1TC1Ev" %t | count 1 &&
+  // CHECK: call void @_ZN1TC1Ev
   T *t = new T;
 }
 
@@ -42,7 +42,7 @@ struct T2 {
 };
 
 void t5() { 
-  // RUN: grep "call void @_ZN2T2C1Eii" %t | count 1 
+  // CHECK: call void @_ZN2T2C1Eii
   T2 *t2 = new T2(10, 10);
 }
 
@@ -54,3 +54,20 @@ int *t6() {
 void t7() {
   new int();
 }
+
+struct U {
+  ~U();
+};
+  
+void t8(int n) {
+  new int[10];
+  new int[n];
+  
+  // Non-POD
+  new T[10];
+  new T[n];
+  
+  // Cookie required
+  new U[10];
+  new U[n];
+}
diff --git a/test/CodeGenCXX/nullptr.cpp b/test/CodeGenCXX/nullptr.cpp
new file mode 100644
index 000000000000..7bc52ad5210a
--- /dev/null
+++ b/test/CodeGenCXX/nullptr.cpp
@@ -0,0 +1,7 @@
+// RUN: clang-cc -std=c++0x  %s -emit-llvm -o %t
+
+int* a = nullptr;
+
+void f() {
+  int* a = nullptr;
+}
diff --git a/test/CodeGenCXX/overload-binop-implicitconvert.cpp b/test/CodeGenCXX/overload-binop-implicitconvert.cpp
new file mode 100644
index 000000000000..f17a4585e69f
--- /dev/null
+++ b/test/CodeGenCXX/overload-binop-implicitconvert.cpp
@@ -0,0 +1,22 @@
+// RUN: clang-cc %s -emit-llvm-only
+class T
+{};
+
+void print(const char *t);
+
+T& operator<< (T& t,const char* c)
+{
+  print(c);
+  return t;
+}
+
+
+int main()
+{
+  T t;
+  print("foo");
+  t<<"foo";
+  
+  return 0;
+}
+  
diff --git a/test/CodeGenCXX/predefined-expr-sizeof.cpp b/test/CodeGenCXX/predefined-expr-sizeof.cpp
new file mode 100644
index 000000000000..e318fbec18ae
--- /dev/null
+++ b/test/CodeGenCXX/predefined-expr-sizeof.cpp
@@ -0,0 +1,30 @@
+// RUN: clang-cc %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: store i32 49, i32* %size
+// CHECK: store i32 52, i32* %size
+template<typename T>
+class TemplateClass {
+public:
+  void templateClassFunction() {
+    int size = sizeof(__PRETTY_FUNCTION__);
+  }
+};
+
+// CHECK: store i32 27, i32* %size
+// CHECK: store i32 30, i32* %size
+template<typename T>
+void functionTemplate(T t) {
+  int size = sizeof(__PRETTY_FUNCTION__);
+}
+
+int main() {
+  TemplateClass<int> t1;
+  t1.templateClassFunction();
+  TemplateClass<double> t2;
+  t2.templateClassFunction();
+
+  functionTemplate<int>(0);
+  functionTemplate(0.0);
+
+  return 0;
+}
diff --git a/test/CodeGenCXX/predefined-expr.cpp b/test/CodeGenCXX/predefined-expr.cpp
new file mode 100644
index 000000000000..95bc255bdde0
--- /dev/null
+++ b/test/CodeGenCXX/predefined-expr.cpp
@@ -0,0 +1,226 @@
+// RUN: clang-cc %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: private constant [15 x i8] c"externFunction\00"
+// CHECK: private constant [26 x i8] c"void NS::externFunction()\00"
+
+// CHECK: private constant [22 x i8] c"classTemplateFunction\00"
+// CHECK: private constant [60 x i8] c"void NS::ClassTemplate<NS::Base *>::classTemplateFunction()\00"
+// CHECK: private constant [53 x i8] c"void NS::ClassTemplate<int>::classTemplateFunction()\00"
+
+// CHECK: private constant [18 x i8] c"functionTemplate1\00"
+// CHECK: private constant [45 x i8] c"void NS::Base::functionTemplate1(NS::Base *)\00"
+// CHECK: private constant [38 x i8] c"void NS::Base::functionTemplate1(int)\00"
+
+// CHECK: private constant [12 x i8] c"~Destructor\00"
+// CHECK: private constant [35 x i8] c"void NS::Destructor::~Destructor()\00"
+
+// CHECK: private constant [12 x i8] c"Constructor\00"
+// CHECK: private constant [46 x i8] c"void NS::Constructor::Constructor(NS::Base *)\00"
+// CHECK: private constant [39 x i8] c"void NS::Constructor::Constructor(int)\00"
+// CHECK: private constant [36 x i8] c"void NS::Constructor::Constructor()\00"
+
+// CHECK: private constant [16 x i8] c"virtualFunction\00"
+// CHECK: private constant [44 x i8] c"virtual void NS::Derived::virtualFunction()\00"
+
+// CHECK: private constant [26 x i8] c"functionReturingTemplate2\00"
+// CHECK: private constant [64 x i8] c"ClassTemplate<NS::Base *> NS::Base::functionReturingTemplate2()\00"
+
+// CHECK: private constant [26 x i8] c"functionReturingTemplate1\00"
+// CHECK: private constant [57 x i8] c"ClassTemplate<int> NS::Base::functionReturingTemplate1()\00"
+
+// CHECK: private constant [23 x i8] c"withTemplateParameter2\00"
+// CHECK: private constant [65 x i8] c"void NS::Base::withTemplateParameter2(ClassTemplate<NS::Base *>)\00"
+
+// CHECK: private constant [23 x i8] c"withTemplateParameter1\00"
+// CHECK: private constant [58 x i8] c"void NS::Base::withTemplateParameter1(ClassTemplate<int>)\00"
+
+// CHECK: private constant [23 x i8] c"functionReturningClass\00"
+// CHECK: private constant [45 x i8] c"NS::Base *NS::Base::functionReturningClass()\00"
+
+// CHECK: private constant [23 x i8] c"functionWithParameters\00"
+// CHECK: private constant [64 x i8] c"void NS::Base::functionWithParameters(int, float *, NS::Base *)\00"
+
+// CHECK: private constant [17 x i8] c"variadicFunction\00"
+// CHECK: private constant [42 x i8] c"void NS::Base::variadicFunction(int, ...)\00"
+
+// CHECK: private constant [41 x i8] c"virtual void NS::Base::virtualFunction()\00"
+
+// CHECK: private constant [15 x i8] c"inlineFunction\00"
+// CHECK: private constant [32 x i8] c"void NS::Base::inlineFunction()\00"
+
+// CHECK: private constant [11 x i8] c"staticFunc\00"
+// CHECK: private constant [28 x i8] c"void NS::Base::staticFunc()\00"
+
+int printf(const char * _Format, ...);
+
+namespace NS {
+
+template<typename T>
+class ClassTemplate {
+public:
+  void classTemplateFunction() {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+};
+
+class Base {
+public:
+  static void staticFunc() {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+
+  inline void inlineFunction() {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+
+  virtual void virtualFunction() {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+
+  void functionWithParameters(int, float*, Base* base) {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+
+  Base *functionReturningClass() {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+    return 0;
+  }
+
+  void variadicFunction(int, ...) {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+
+  void withTemplateParameter1(ClassTemplate<int>) {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+
+  void withTemplateParameter2(ClassTemplate<Base *>) {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+
+  ClassTemplate<int> functionReturingTemplate1() {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+    return ClassTemplate<int>();
+  }
+
+  ClassTemplate<Base *> functionReturingTemplate2() {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+    return ClassTemplate<Base *>();
+  }
+
+  template<typename T>
+  void functionTemplate1(T t) {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+};
+
+class Derived : public Base {
+public:
+  // Virtual function without being explicitally written.
+  void virtualFunction() {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+};
+
+class Constructor {
+public:
+  Constructor() {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+
+  Constructor(int) {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+
+  Constructor(Base *) {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+
+};
+
+class Destructor {
+public:
+  ~Destructor() {
+    printf("__func__ %s\n", __func__);
+    printf("__FUNCTION__ %s\n", __FUNCTION__);
+    printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+  }
+};
+
+extern void externFunction() {
+  printf("__func__ %s\n", __func__);
+  printf("__FUNCTION__ %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__ %s\n\n", __PRETTY_FUNCTION__);
+}
+
+}
+
+int main() {
+  NS::Base::staticFunc();
+
+  NS::Base b;
+  b.inlineFunction();
+  b.virtualFunction();
+  b.variadicFunction(0);
+  b.functionWithParameters(0, 0, 0);
+  b.functionReturningClass();
+  
+  b.withTemplateParameter1(NS::ClassTemplate<int>());
+  b.withTemplateParameter2(NS::ClassTemplate<NS::Base *>());
+  b.functionReturingTemplate1();
+  b.functionReturingTemplate2();
+  b.functionTemplate1<int>(0);
+  b.functionTemplate1<NS::Base *>(0);
+  
+  NS::Derived d;
+  d.virtualFunction();
+  
+  NS::ClassTemplate<int> t1;
+  t1.classTemplateFunction();
+  NS::ClassTemplate<NS::Base *> t2;
+  t2.classTemplateFunction();
+  
+  NS::Constructor c1;
+  NS::Constructor c2(0);
+  NS::Constructor c3((NS::Base *)0);
+  
+  {
+    NS::Destructor destructor;
+  }
+  
+  NS::externFunction();
+  
+  return 0;
+}
diff --git a/test/CodeGenCXX/references.cpp b/test/CodeGenCXX/references.cpp
index 8e1935675766..c235521d43b1 100644
--- a/test/CodeGenCXX/references.cpp
+++ b/test/CodeGenCXX/references.cpp
@@ -87,3 +87,16 @@ int reference_decl() {
   const int& b = 1;
   return a+b;
 }
+
+struct A {
+  int& b();
+};
+
+void f(A* a) {
+  int b = a->b();
+}
+
+// PR5122
+void *foo = 0;
+void * const & kFoo = foo;
+
diff --git a/test/CodeGenCXX/reinterpret-cast.cpp b/test/CodeGenCXX/reinterpret-cast.cpp
new file mode 100644
index 000000000000..ae3ab2f8b0d7
--- /dev/null
+++ b/test/CodeGenCXX/reinterpret-cast.cpp
@@ -0,0 +1,12 @@
+// RUN: clang-cc -emit-llvm -o - %s -std=c++0x
+void *f1(unsigned long l) {
+  return reinterpret_cast<void *>(l);
+}
+
+unsigned long f2() {
+  return reinterpret_cast<unsigned long>(nullptr);
+}
+
+unsigned long f3(void *p) {
+  return reinterpret_cast<unsigned long>(p);
+}
\ No newline at end of file
diff --git a/test/CodeGenCXX/static-data-member.cpp b/test/CodeGenCXX/static-data-member.cpp
new file mode 100644
index 000000000000..6e2abcc1adea
--- /dev/null
+++ b/test/CodeGenCXX/static-data-member.cpp
@@ -0,0 +1,8 @@
+// RUN: clang-cc -emit-llvm -o - %s
+struct S { 
+  static int i;
+};
+
+void f() { 
+  int a = S::i;
+}
diff --git a/test/CodeGenCXX/static-init.cpp b/test/CodeGenCXX/static-init.cpp
new file mode 100644
index 000000000000..44dd14284107
--- /dev/null
+++ b/test/CodeGenCXX/static-init.cpp
@@ -0,0 +1,13 @@
+// RUN: clang-cc -triple=x86_64-apple-darwin9 -emit-llvm %s -o %t &&
+// RUN: grep "call void @_ZN1AC1Ev" %t | count 1 &&
+// RUN: grep "call i32 @__cxa_atexit(void (i8\*)\* bitcast (void (%.truct.A\*)\* @_ZN1AD1Ev to void (i8\*)\*), i8\* getelementptr inbounds (%.truct.A\* @_ZZ1fvE1a, i32 0, i32 0), i8\* bitcast (i8\*\* @__dso_handle to i8\*))" %t | count 1 
+
+struct A {
+  A();
+  ~A();
+};
+
+void f() {
+  static A a;
+}
+
diff --git a/test/CodeGenCXX/temp-1.cpp b/test/CodeGenCXX/temp-1.cpp
new file mode 100644
index 000000000000..9b97f0083c83
--- /dev/null
+++ b/test/CodeGenCXX/temp-1.cpp
@@ -0,0 +1,83 @@
+// RUN: clang-cc -emit-llvm %s -o %t -triple=x86_64-apple-darwin9 && 
+struct A {
+  A();
+  ~A();
+  void f();
+};
+
+// RUN: grep "call void @_ZN1AC1Ev" %t | count 2 &&
+// RUN: grep "call void @_ZN1AD1Ev" %t | count 2 &&
+void f1() {
+  (void)A();
+  A().f();
+}
+
+// Function calls
+struct B {
+  B();
+  ~B();
+};
+
+B g();
+
+// RUN: grep "call void @_ZN1BC1Ev" %t | count 0 &&
+// RUN: grep "call void @_ZN1BD1Ev" %t | count 1 &&
+void f2() {
+  (void)g();
+}
+
+// Member function calls
+struct C {
+  C();
+  ~C();
+  
+  C f();
+};
+
+// RUN: grep "call void @_ZN1CC1Ev" %t | count 1 &&
+// RUN: grep "call void @_ZN1CD1Ev" %t | count 2 &&
+void f3() {
+  C().f();
+}
+
+// Function call operator
+struct D {
+  D();
+  ~D();
+  
+  D operator()();
+};
+
+// RUN: grep "call void @_ZN1DC1Ev" %t | count 1 &&
+// RUN: grep "call void @_ZN1DD1Ev" %t | count 2 &&
+void f4() {
+  D()();
+}
+
+// Overloaded operators
+struct E {
+  E();
+  ~E();
+  E operator+(const E&);
+  E operator!();
+};
+
+// RUN: grep "call void @_ZN1EC1Ev" %t | count 3 &&
+// RUN: grep "call void @_ZN1ED1Ev" %t | count 5 &&
+void f5() {
+  E() + E();
+  !E();
+}
+
+struct F {
+  F();
+  ~F();
+  F& f();
+};
+
+// RUN: grep "call void @_ZN1FC1Ev" %t | count 1 &&
+// RUN: grep "call void @_ZN1FD1Ev" %t | count 1 
+void f6() {
+  F().f();
+}
+
diff --git a/test/CodeGenCXX/template-anonymous-union-member-initializer.cpp b/test/CodeGenCXX/template-anonymous-union-member-initializer.cpp
new file mode 100644
index 000000000000..f8454282badc
--- /dev/null
+++ b/test/CodeGenCXX/template-anonymous-union-member-initializer.cpp
@@ -0,0 +1,10 @@
+// RUN: clang-cc -emit-llvm -o %t %s
+template <typename T>
+class A
+{
+    union { void *d; };
+
+    A() : d(0) { }
+};
+
+A<int> a0;
diff --git a/test/CodeGenCXX/trivial-constructor-init.cpp b/test/CodeGenCXX/trivial-constructor-init.cpp
new file mode 100644
index 000000000000..183b31a801e3
--- /dev/null
+++ b/test/CodeGenCXX/trivial-constructor-init.cpp
@@ -0,0 +1,21 @@
+// RUN: clang-cc  -S %s -o %t-64.s &&
+// RUN: clang-cc  -S %s -o %t-32.s &&
+// RUN: true
+
+extern "C" int printf(...);
+
+struct S {
+  S() { printf("S::S\n"); }
+};
+
+struct A {
+  double x;
+  A() : x(), y(), s() { printf("x = %f y = %x \n", x, y); }
+  int *y;
+  S s;
+};
+
+A a;
+
+int main() {
+}
diff --git a/test/CodeGenCXX/virt.cpp b/test/CodeGenCXX/virt.cpp
new file mode 100644
index 000000000000..9ae81e5d3f33
--- /dev/null
+++ b/test/CodeGenCXX/virt.cpp
@@ -0,0 +1,1024 @@
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -O0 -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -O0 -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 -input-file=%t-32.s %s &&
+
+// RUN: clang-cc -triple x86_64-apple-darwin -std=c++0x -O3 -S %s -o %t-O3-64.s &&
+// RUN: FileCheck -check-prefix LPOPT64 --input-file=%t-O3-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -std=c++0x -O3 -S %s -o %t-O3-32.s &&
+// RUN: FileCheck -check-prefix LPOPT32 -input-file=%t-O3-32.s %s &&
+
+// RUN: true
+
+struct B {
+  virtual void bar1();
+  virtual void bar2();
+  int b;
+};
+void B::bar1() { }
+void B::bar2() { }
+
+struct C {
+  virtual void bee1();
+  virtual void bee2();
+};
+void C::bee1() { }
+void C::bee2() { }
+
+struct D {
+  virtual void boo();
+};
+void D::boo() { }
+
+struct D1 {
+  virtual void bar();
+  virtual void bar2();
+  virtual void bar3();
+  virtual void bar4();
+  virtual void bar5();
+  void *d1;
+};
+void D1::bar() { }
+
+class F : virtual public D1, virtual public D {
+public:
+  virtual void foo();
+  void *f;
+};
+void F::foo() { }
+
+int j;
+void test2() {
+  F f;
+  static int sz = (char *)(&f.f) - (char *)(&f);
+  j = sz;
+  // FIXME: These should result in a frontend constant a la fold, no run time
+  // initializer
+  // CHECK-LPOPT32: movl $4, __ZZ5test2vE2sz
+  // CHECK-LPOPT64: movl $8, __ZZ5test2vE2sz(%rip)
+}
+
+static_assert(sizeof(F) == sizeof(void*)*4, "invalid vbase size");
+
+struct E {
+  int e;
+};
+
+static_assert (sizeof (C) == (sizeof(void *)), "vtable pointer layout");
+
+class A : public E, public B, public C {
+public:
+  virtual void foo1();
+  virtual void foo2();
+  A() { }
+  int a;
+} *ap;
+void A::foo1() { }
+void A::foo2() { }
+
+int main() {
+  A a;
+  B b;
+  ap->e = 1;
+  ap->b = 2;
+}
+
+// CHECK-LP32: main:
+// CHECK-LP32: movl $1, 8(%eax)
+// CHECK-LP32: movl $2, 4(%eax)
+
+// CHECK-LP64: main:
+// CHECK-LP64: movl $1, 12(%rax)
+// CHECK-LP64: movl $2, 8(%rax)
+
+struct test12_A {
+  virtual void foo0() { }
+  virtual void foo();
+} *test12_pa;
+
+struct test12_B : public test12_A {
+  virtual void foo() { }
+} *test12_pb;
+
+struct test12_D : public test12_B {
+} *test12_pd;
+void test12_foo() {
+  test12_pa->foo0();
+  test12_pb->foo0();
+  test12_pd->foo0();
+  test12_pa->foo();
+  test12_pb->foo();
+  test12_pd->foo();
+  test12_pa->test12_A::foo();
+}
+
+// CHECK-LPOPT32:__Z10test12_foov:
+// CHECK-LPOPT32: movl _test12_pa, %eax
+// CHECK-LPOPT32-NEXT: movl (%eax), %ecx
+// CHECK-LPOPT32-NEXT: movl %eax, (%esp)
+// CHECK-LPOPT32-NEXT: call *(%ecx)
+// CHECK-LPOPT32-NEXT: movl _test12_pb, %eax
+// CHECK-LPOPT32-NEXT: movl (%eax), %ecx
+// CHECK-LPOPT32-NEXT: movl %eax, (%esp)
+// CHECK-LPOPT32-NEXT: call *(%ecx)
+// CHECK-LPOPT32-NEXT: movl _test12_pd, %eax
+// CHECK-LPOPT32-NEXT: movl (%eax), %ecx
+// CHECK-LPOPT32-NEXT: movl %eax, (%esp)
+// CHECK-LPOPT32-NEXT: call *(%ecx)
+// CHECK-LPOPT32-NEXT: movl _test12_pa, %eax
+// CHECK-LPOPT32-NEXT: movl (%eax), %ecx
+// CHECK-LPOPT32-NEXT: movl %eax, (%esp)
+// CHECK-LPOPT32-NEXT: call *4(%ecx)
+// CHECK-LPOPT32-NEXT: movl _test12_pb, %eax
+// CHECK-LPOPT32-NEXT: movl (%eax), %ecx
+// CHECK-LPOPT32-NEXT: movl %eax, (%esp)
+// CHECK-LPOPT32-NEXT: call *4(%ecx)
+// CHECK-LPOPT32-NEXT: movl _test12_pd, %eax
+// CHECK-LPOPT32-NEXT: movl (%eax), %ecx
+// CHECK-LPOPT32-NEXT: movl %eax, (%esp)
+// CHECK-LPOPT32-NEXT: call *4(%ecx)
+// CHECK-LPOPT32-NEXT: movl _test12_pa, %eax
+// CHECK-LPOPT32-NEXT: movl %eax, (%esp)
+// CHECK-LPOPT32-NEXT: call L__ZN8test12_A3fooEv$stub
+
+// CHECK-LPOPT64:__Z10test12_foov:
+// CHECK-LPOPT64: movq _test12_pa(%rip), %rdi
+// CHECK-LPOPT64-NEXT: movq (%rdi), %rax
+// CHECK-LPOPT64-NEXT: call *(%rax)
+// CHECK-LPOPT64-NEXT: movq _test12_pb(%rip), %rdi
+// CHECK-LPOPT64-NEXT: movq (%rdi), %rax
+// CHECK-LPOPT64-NEXT: call *(%rax)
+// CHECK-LPOPT64-NEXT: movq _test12_pd(%rip), %rdi
+// CHECK-LPOPT64-NEXT: movq (%rdi), %rax
+// CHECK-LPOPT64-NEXT: call *(%rax)
+// CHECK-LPOPT64-NEXT: movq _test12_pa(%rip), %rdi
+// CHECK-LPOPT64-NEXT: movq (%rdi), %rax
+// CHECK-LPOPT64-NEXT: call *8(%rax)
+// CHECK-LPOPT64-NEXT: movq _test12_pb(%rip), %rdi
+// CHECK-LPOPT64-NEXT: movq (%rdi), %rax
+// CHECK-LPOPT64-NEXT: call *8(%rax)
+// CHECK-LPOPT64-NEXT: movq _test12_pd(%rip), %rdi
+// CHECK-LPOPT64-NEXT: movq (%rdi), %rax
+// CHECK-LPOPT64-NEXT: call *8(%rax)
+// CHECK-LPOPT64-NEXT: movq _test12_pa(%rip), %rdi
+// CHECK-LPOPT64-NEXT: call __ZN8test12_A3fooEv
+
+struct test6_B2 { virtual void funcB2(); char b[1000]; };
+struct test6_B1 : virtual test6_B2 { virtual void funcB1(); };
+
+struct test6_D : test6_B2, virtual test6_B1 {
+};
+
+// CHECK-LP32: .zerofill __DATA, __common, _d6, 2012, 4
+// CHECK-LP64: .zerofill __DATA, __common, _d6, 2024, 4
+
+struct test7_B2 { virtual void funcB2(); };
+struct test7_B1 : virtual test7_B2 { virtual void funcB1(); };
+
+struct test7_D : test7_B2, virtual test7_B1 {
+};
+
+// CHECK-LP32: .zerofill __DATA, __common, _d7, 8, 3
+// CHECK-LP64: .zerofill __DATA, __common, _d7, 16, 3
+
+
+struct test3_B3 { virtual void funcB3(); };
+struct test3_B2 : virtual test3_B3 { virtual void funcB2(); };
+struct test3_B1 : virtual test3_B2 { virtual void funcB1(); };
+
+struct test3_D : virtual test3_B1 {
+  virtual void funcD() { }
+};
+
+// CHECK-LP32:__ZTV7test3_D:
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI7test3_D
+// CHECK-LP32-NEXT: .long __ZN8test3_B36funcB3Ev
+// CHECK-LP32-NEXT: .long __ZN8test3_B26funcB2Ev
+// CHECK-LP32-NEXT: .long __ZN8test3_B16funcB1Ev
+// CHECK-LP32-NEXT: .long __ZN7test3_D5funcDEv
+
+// CHECK-LP64:__ZTV7test3_D:
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI7test3_D
+// CHECK-LP64-NEXT: .quad __ZN8test3_B36funcB3Ev
+// CHECK-LP64-NEXT: .quad __ZN8test3_B26funcB2Ev
+// CHECK-LP64-NEXT: .quad __ZN8test3_B16funcB1Ev
+// CHECK-LP64-NEXT: .quad __ZN7test3_D5funcDEv
+
+struct test4_D : virtual B, virtual C {
+};
+
+// CHECK-LP32:__ZTV7test4_D:
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI7test4_D
+// CHECK-LP32-NEXT: .long __ZN1C4bee1Ev
+// CHECK-LP32-NEXT: .long __ZN1C4bee2Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967292
+// CHECK-LP32-NEXT: .long __ZTI7test4_D 
+// CHECK-LP32-NEXT: .long __ZN1B4bar1Ev
+// CHECK-LP32-NEXT: .long __ZN1B4bar2Ev
+
+// CHECK-LP64:__ZTV7test4_D:
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI7test4_D
+// CHECK-LP64-NEXT: .quad __ZN1C4bee1Ev
+// CHECK-LP64-NEXT: .quad __ZN1C4bee2Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551608
+// CHECK-LP64-NEXT: .quad __ZTI7test4_D
+// CHECK-LP64-NEXT: .quad __ZN1B4bar1Ev
+// CHECK-LP64-NEXT: .quad __ZN1B4bar2Ev
+
+
+struct test5_B3 { virtual void funcB3(); };
+struct test5_B2 : virtual test5_B3 { virtual void funcB2(); };
+struct test5_B1 : virtual test5_B2 { virtual void funcB1(); };
+
+struct test5_B23 { virtual void funcB23(); };
+struct test5_B22 : virtual test5_B23 { virtual void funcB22(); };
+struct test5_B21 : virtual test5_B22 { virtual void funcB21(); };
+
+
+struct B232 { virtual void funcB232(); };
+struct B231 { virtual void funcB231(); };
+
+struct test5_B33 { virtual void funcB33(); };
+struct test5_B32 : virtual test5_B33, virtual B232 { virtual void funcB32(); };
+struct test5_B31 : virtual test5_B32, virtual B231 { virtual void funcB31(); };
+
+struct test5_D  : virtual test5_B1, virtual test5_B21, virtual test5_B31 {
+  virtual void funcD() { }
+};
+
+// CHECK-LP32:__ZTV7test5_D:
+// CHECK-LP32-NEXT: .long 16
+// CHECK-LP32-NEXT: .long 12
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .long 4
+// CHECK-LP32-NEXT: .long 4
+// CHECK-LP32-NEXT: .long 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI7test5_D
+// CHECK-LP32-NEXT: .long __ZN8test5_B36funcB3Ev
+// CHECK-LP32-NEXT: .long __ZN8test5_B26funcB2Ev
+// CHECK-LP32-NEXT: .long __ZN8test5_B16funcB1Ev
+// CHECK-LP32-NEXT: .long __ZN7test5_D5funcDEv
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967292
+// CHECK-LP32-NEXT: .long __ZTI7test5_D
+// CHECK-LP32-NEXT: .long __ZN9test5_B237funcB23Ev
+// CHECK-LP32-NEXT: .long __ZN9test5_B227funcB22Ev
+// CHECK-LP32-NEXT: .long __ZN9test5_B217funcB21Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32: .long 8
+// CHECK-LP32 .space 4
+// CHECK-LP32 .space 4                       FIXME
+// CHECK-LP32: .long 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967288
+// CHECK-LP32-NEXT: .long __ZTI7test5_D
+// CHECK-LP32-NEXT: .long __ZN9test5_B337funcB33Ev
+// CHECK-LP32-NEXT: .long __ZN9test5_B327funcB32Ev
+// CHECK-LP32-NEXT: .long __ZN9test5_B317funcB31Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967284
+// CHECK-LP32-NEXT: .long __ZTI7test5_D
+// CHECK-LP32-NEXT: .long __ZN4B2328funcB232Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967280
+// CHECK-LP32-NEXT: .long __ZTI7test5_D
+// CHECK-LP32-NEXT: .long __ZN4B2318funcB231Ev
+
+// CHECK-LP64:__ZTV7test5_D:
+// CHECK-LP64-NEXT: .quad 32
+// CHECK-LP64-NEXT: .quad 24
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 8
+// CHECK-LP64-NEXT: .quad 8
+// CHECK-LP64-NEXT: .quad 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI7test5_D
+// CHECK-LP64-NEXT: .quad __ZN8test5_B36funcB3Ev
+// CHECK-LP64-NEXT: .quad __ZN8test5_B26funcB2Ev
+// CHECK-LP64-NEXT: .quad __ZN8test5_B16funcB1Ev
+// CHECK-LP64-NEXT: .quad __ZN7test5_D5funcDEv
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551608
+// CHECK-LP64-NEXT: .quad __ZTI7test5_D
+// CHECK-LP64-NEXT: .quad __ZN9test5_B237funcB23Ev
+// CHECK-LP64-NEXT: .quad __ZN9test5_B227funcB22Ev
+// CHECK-LP64-NEXT: .quad __ZN9test5_B217funcB21Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64: .quad 16
+// CHECK-LP64 .space 8
+// CHECK-LP64 .space 8
+// CHECK-LP64: .quad 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551600
+// CHECK-LP64-NEXT: .quad __ZTI7test5_D
+// CHECK-LP64-NEXT: .quad __ZN9test5_B337funcB33Ev
+// CHECK-LP64-NEXT: .quad __ZN9test5_B327funcB32Ev
+// CHECK-LP64-NEXT: .quad __ZN9test5_B317funcB31Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551592
+// CHECK-LP64-NEXT: .quad __ZTI7test5_D
+// CHECK-LP64-NEXT: .quad __ZN4B2328funcB232Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551584
+// CHECK-LP64-NEXT: .quad __ZTI7test5_D
+// CHECK-LP64-NEXT: .quad __ZN4B2318funcB231Ev
+
+struct test8_B1 {
+  virtual void ftest8_B1() { }
+};
+struct test8_B2aa {
+  virtual void ftest8_B2aa() { }
+  int i;
+};
+struct test8_B2ab {
+  virtual void ftest8_B2ab() { }
+  int i;
+};
+struct test8_B2a : virtual test8_B2aa, virtual test8_B2ab {
+  virtual void ftest8_B2a() { }
+};
+struct test8_B2b {
+  virtual void ftest8_B2b() { }
+};
+struct test8_B2 : test8_B2a, test8_B2b {
+  virtual void ftest8_B2() { }
+};
+struct test8_B3 {
+  virtual void ftest8_B3() { }
+};
+class test8_D : test8_B1, test8_B2, test8_B3 {
+};
+
+// CHECK-LP32:__ZTV7test8_D:
+// CHECK-LP32-NEXT: .long 24
+// CHECK-LP32-NEXT: .long 16
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI7test8_D
+// CHECK-LP32-NEXT: .long __ZN8test8_B19ftest8_B1Ev
+// CHECK-LP32-NEXT: .long 20
+// CHECK-LP32-NEXT: .long 12
+// CHECK-LP32-NEXT: .long 4294967292
+// CHECK-LP32-NEXT: .long __ZTI7test8_D
+// CHECK-LP32-NEXT: .long __ZN9test8_B2a10ftest8_B2aEv
+// CHECK-LP32-NEXT: .long __ZN8test8_B29ftest8_B2Ev
+// CHECK-LP32-NEXT: .long 4294967288
+// CHECK-LP32-NEXT: .long __ZTI7test8_D
+// CHECK-LP32-NEXT: .long __ZN9test8_B2b10ftest8_B2bEv
+// CHECK-LP32-NEXT: .long 4294967284
+// CHECK-LP32-NEXT: .long __ZTI7test8_D
+// CHECK-LP32-NEXT: .long __ZN8test8_B39ftest8_B3Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967280
+// CHECK-LP32-NEXT: .long __ZTI7test8_D
+// CHECK-LP32-NEXT: .long __ZN10test8_B2aa11ftest8_B2aaEv
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967272
+// CHECK-LP32-NEXT: .long __ZTI7test8_D
+// CHECK-LP32-NEXT: .long __ZN10test8_B2ab11ftest8_B2abEv
+
+// CHECK-LP64:__ZTV7test8_D:
+// CHECK-LP64-NEXT: .quad 48
+// CHECK-LP64-NEXT: .quad 32
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI7test8_D
+// CHECK-LP64-NEXT: .quad __ZN8test8_B19ftest8_B1Ev
+// CHECK-LP64-NEXT: .quad 40
+// CHECK-LP64-NEXT: .quad 24
+// CHECK-LP64-NEXT: .quad 18446744073709551608
+// CHECK-LP64-NEXT: .quad __ZTI7test8_D
+// CHECK-LP64-NEXT: .quad __ZN9test8_B2a10ftest8_B2aEv
+// CHECK-LP64-NEXT: .quad __ZN8test8_B29ftest8_B2Ev
+// CHECK-LP64-NEXT: .quad 18446744073709551600
+// CHECK-LP64-NEXT: .quad __ZTI7test8_D
+// CHECK-LP64-NEXT: .quad __ZN9test8_B2b10ftest8_B2bEv
+// CHECK-LP64-NEXT: .quad 18446744073709551592
+// CHECK-LP64-NEXT: .quad __ZTI7test8_D
+// CHECK-LP64-NEXT: .quad __ZN8test8_B39ftest8_B3Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551584
+// CHECK-LP64-NEXT: .quad __ZTI7test8_D
+// CHECK-LP64-NEXT: .quad __ZN10test8_B2aa11ftest8_B2aaEv
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551568
+// CHECK-LP64-NEXT: .quad __ZTI7test8_D
+// CHECK-LP64-NEXT: .quad __ZN10test8_B2ab11ftest8_B2abEv
+
+
+struct test9_B3 { virtual void funcB3(); int i; };
+struct test9_B2 : virtual test9_B3 { virtual void funcB2(); int i; };
+struct test9_B1 : virtual test9_B2 { virtual void funcB1(); int i; };
+
+struct test9_B23 { virtual void funcB23(); int i; };
+struct test9_B22 : virtual test9_B23 { virtual void funcB22(); int i; };
+struct test9_B21 : virtual test9_B22 { virtual void funcB21(); int i; };
+
+
+struct test9_B232 { virtual void funcB232(); int i; };
+struct test9_B231 { virtual void funcB231(); int i; };
+
+struct test9_B33 { virtual void funcB33(); int i; };
+struct test9_B32 : virtual test9_B33, virtual test9_B232 { virtual void funcB32(); int i; };
+struct test9_B31 : virtual test9_B32, virtual test9_B231 { virtual void funcB31(); int i; };
+
+struct test9_D  : virtual test9_B1, virtual test9_B21, virtual test9_B31 {
+  virtual void funcD() { }
+};
+
+// CHECK-LP64: __ZTV7test9_D:
+// CHECK-LP64-NEXT: .quad 168
+// CHECK-LP64-NEXT: .quad 152
+// CHECK-LP64-NEXT: .quad 136
+// CHECK-LP64-NEXT: .quad 120
+// CHECK-LP64-NEXT: .quad 104
+// CHECK-LP64-NEXT: .quad 88
+// CHECK-LP64-NEXT: .quad 72
+// CHECK-LP64-NEXT: .quad 56
+// CHECK-LP64-NEXT: .quad 40
+// CHECK-LP64-NEXT: .quad 24
+// CHECK-LP64-NEXT: .quad 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN7test9_D5funcDEv
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 32
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 18446744073709551608
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN8test9_B16funcB1Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 18446744073709551592
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN8test9_B26funcB2Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551576
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN8test9_B36funcB3Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 32
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 18446744073709551560
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN9test9_B217funcB21Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 18446744073709551544
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN9test9_B227funcB22Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551528
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN9test9_B237funcB23Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 64
+// CHECK-LP64-NEXT: .quad 48
+// CHECK-LP64-NEXT: .quad 32
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 18446744073709551512
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN9test9_B317funcB31Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 32
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 18446744073709551496
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN9test9_B327funcB32Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551480
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN9test9_B337funcB33Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551464
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN10test9_B2328funcB232Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551448
+// CHECK-LP64-NEXT: .quad __ZTI7test9_D
+// CHECK-LP64-NEXT: .quad __ZN10test9_B2318funcB231Ev
+
+// CHECK-LP32: __ZTV7test9_D:
+// CHECK-LP32-NEXT: .long 84
+// CHECK-LP32-NEXT: .long 76
+// CHECK-LP32-NEXT: .long 68
+// CHECK-LP32-NEXT: .long 60
+// CHECK-LP32-NEXT: .long 52
+// CHECK-LP32-NEXT: .long 44
+// CHECK-LP32-NEXT: .long 36
+// CHECK-LP32-NEXT: .long 28
+// CHECK-LP32-NEXT: .long 20
+// CHECK-LP32-NEXT: .long 12
+// CHECK-LP32-NEXT: .long 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN7test9_D5funcDEv
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 16
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .long 4294967292
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN8test9_B16funcB1Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .long 4294967284
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN8test9_B26funcB2Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967276
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN8test9_B36funcB3Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 16
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .long 4294967268
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN9test9_B217funcB21Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .long 4294967260
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN9test9_B227funcB22Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967252
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN9test9_B237funcB23Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 32
+// CHECK-LP32-NEXT: .long 24
+// CHECK-LP32-NEXT: .long 16
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .long 4294967244
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN9test9_B317funcB31Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 16
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .long 4294967236
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN9test9_B327funcB32Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967228
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN9test9_B337funcB33Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967220
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN10test9_B2328funcB232Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967212
+// CHECK-LP32-NEXT: .long __ZTI7test9_D
+// CHECK-LP32-NEXT: .long __ZN10test9_B2318funcB231Ev
+
+struct test10_O { int i; };
+
+struct test10_B1 : virtual test10_O {
+  virtual void ftest10_B1() { }
+};
+
+struct test10_B2aa : virtual test10_O {
+  int i;
+};
+struct test10_B2ab : virtual test10_O {
+  int i;
+};
+struct test10_B2a : virtual test10_B2aa, virtual test10_B2ab,virtual test10_O {
+  virtual void ftest10_B2a() { }
+};
+struct test10_B2b : virtual test10_O {
+  virtual void ftest10_B2b() { }
+};
+struct test10_B2 : test10_B2a {
+  virtual void ftest10_B2() { }
+};
+class test10_D : test10_B1, test10_B2 {
+  
+  void ftest10_B2aa() { }
+};
+
+// CHECK-LP64:__ZTV8test10_D:
+// CHECK-LP64-NEXT: .quad 40
+// CHECK-LP64-NEXT: .quad 24
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI8test10_D
+// CHECK-LP64-NEXT: .quad __ZN9test10_B110ftest10_B1Ev
+// CHECK-LP64-NEXT: .quad 32
+// CHECK-LP64-NEXT: .quad 8
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 18446744073709551608
+// CHECK-LP64-NEXT: .quad __ZTI8test10_D
+// CHECK-LP64-NEXT: .quad __ZN10test10_B2a11ftest10_B2aEv
+// CHECK-LP64-NEXT: .quad __ZN9test10_B210ftest10_B2Ev
+// CHECK-LP64-NEXT: .quad 18446744073709551608
+// CHECK-LP64-NEXT: .quad 18446744073709551592
+// CHECK-LP64-NEXT: .quad __ZTI8test10_D
+// CHECK-LP64-NEXT: .quad 18446744073709551592
+// CHECK-LP64-NEXT: .quad 18446744073709551576
+// CHECK-LP64-NEXT: .quad __ZTI8test10_D
+
+// CHECK-LP32: __ZTV8test10_D:
+// CHECK-LP32-NEXT: .long 20
+// CHECK-LP32-NEXT: .long 12
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI8test10_D
+// CHECK-LP32-NEXT: .long __ZN9test10_B110ftest10_B1Ev
+// CHECK-LP32-NEXT: .long 16
+// CHECK-LP32-NEXT: .long 4
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .long 4294967292
+// CHECK-LP32-NEXT: .long __ZTI8test10_D
+// CHECK-LP32-NEXT: .long __ZN10test10_B2a11ftest10_B2aEv
+// CHECK-LP32-NEXT: .long __ZN9test10_B210ftest10_B2Ev
+// CHECK-LP32-NEXT: .long 4294967292
+// CHECK-LP32-NEXT: .long 4294967284
+// CHECK-LP32-NEXT: .long __ZTI8test10_D
+// CHECK-LP32-NEXT: .long 4294967284
+// CHECK-LP32-NEXT: .long 4294967276
+// CHECK-LP32-NEXT: .long __ZTI8test10_D
+
+struct test11_B {
+  virtual void B1() { }
+  virtual void D() { }
+  virtual void B2() { }
+};
+
+struct test11_D : test11_B {
+  virtual void D1() { }
+  virtual void D() { }
+  virtual void D2() { }
+};
+
+// CHECK-LP32:__ZTV8test11_D:
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI8test11_D
+// CHECK-LP32-NEXT: .long __ZN8test11_B2B1Ev
+// CHECK-LP32-NEXT: .long __ZN8test11_D1DEv
+// CHECK-LP32-NEXT: .long __ZN8test11_B2B2Ev
+// CHECK-LP32-NEXT: .long __ZN8test11_D2D1Ev
+// CHECK-LP32-NEXT: .long __ZN8test11_D2D2Ev
+
+
+// CHECK-LP64:__ZTV8test11_D:
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI8test11_D
+// CHECK-LP64-NEXT: .quad __ZN8test11_B2B1Ev
+// CHECK-LP64-NEXT: .quad __ZN8test11_D1DEv
+// CHECK-LP64-NEXT: .quad __ZN8test11_B2B2Ev
+// CHECK-LP64-NEXT: .quad __ZN8test11_D2D1Ev
+// CHECK-LP64-NEXT: .quad __ZN8test11_D2D2Ev
+
+struct test13_B {
+  virtual void B1() { }
+  virtual void D() { }
+  virtual void Da();
+  virtual void Db() { }
+  virtual void Dc() { }
+  virtual void B2() { }
+  int i;
+};
+
+
+struct test13_NV1 {
+  virtual void fooNV1() { }
+  virtual void D() { }
+};
+
+
+struct test13_B2 : /* test13_NV1, */ virtual test13_B {
+  virtual void B2a() { }
+  virtual void B2() { }
+  virtual void D() { }
+  virtual void Da();
+  virtual void Dd() { }
+  virtual void B2b() { }
+  int i;
+};
+
+
+struct test13_D : test13_NV1, virtual test13_B2 {
+  virtual void D1() { }
+  virtual void D() { }
+  virtual void Db() { }
+  virtual void Dd() { }
+  virtual void D2() { }
+  virtual void fooNV1() { }
+};
+
+// CHECK-LP64:__ZTV8test13_D:
+// CHECK-LP64-NEXT: .quad 24
+// CHECK-LP64-NEXT: .quad 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI8test13_D
+// CHECK-LP64-NEXT: .quad __ZN8test13_D6fooNV1Ev
+// CHECK-LP64-NEXT: .quad __ZN8test13_D1DEv
+// CHECK-LP64-NEXT: .quad __ZN8test13_D2D1Ev
+// CHECK-LP64-NEXT: .quad __ZN8test13_D2DbEv
+// CHECK-LP64-NEXT: .quad __ZN8test13_D2DdEv
+// CHECK-LP64-NEXT: .quad __ZN8test13_D2D2Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551608
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551608
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 18446744073709551608
+// CHECK-LP64-NEXT: .quad __ZTI8test13_D
+// CHECK-LP64-NEXT: .quad __ZN9test13_B23B2aEv
+// CHECK-LP64-NEXT: .quad __ZN9test13_B22B2Ev
+// CHECK-LP64-NEXT: .quad __ZTv0_n48_N8test13_D1DEv
+// CHECK-LP64-NEXT: .quad __ZN9test13_B22DaEv
+// CHECK-LP64-NEXT: .quad __ZTv0_n64_N8test13_D2DdEv
+// CHECK-LP64-NEXT: .quad __ZN9test13_B23B2bEv
+// CHECK-LP64-NEXT: .quad 18446744073709551600
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551592
+// CHECK-LP64-NEXT: .quad 18446744073709551600
+// CHECK-LP64-NEXT: .quad 18446744073709551592
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551592
+// CHECK-LP64-NEXT: .quad __ZTI8test13_D
+// CHECK-LP64-NEXT: .quad __ZN8test13_B2B1Ev
+// CHECK-LP64-NEXT: .quad __ZTv0_n32_N8test13_D1DEv
+// CHECK-LP64-NEXT: .quad __ZTv0_n40_N9test13_B22DaEv
+// CHECK-LP64-NEXT: .quad __ZTv0_n48_N8test13_D2DbEv
+// CHECK-LP64-NEXT: .quad __ZN8test13_B2DcEv
+// CHECK-LP64-NEXT: .quad __ZTv0_n64_N9test13_B22B2Ev
+
+// CHECK-LP32:__ZTV8test13_D:
+// CHECK-LP32-NEXT: .long 12
+// CHECK-LP32-NEXT: .long 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI8test13_D
+// CHECK-LP32-NEXT: .long __ZN8test13_D6fooNV1Ev
+// CHECK-LP32-NEXT: .long __ZN8test13_D1DEv
+// CHECK-LP32-NEXT: .long __ZN8test13_D2D1Ev
+// CHECK-LP32-NEXT: .long __ZN8test13_D2DbEv
+// CHECK-LP32-NEXT: .long __ZN8test13_D2DdEv
+// CHECK-LP32-NEXT: .long __ZN8test13_D2D2Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967292
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967292
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .long 4294967292
+// CHECK-LP32-NEXT: .long __ZTI8test13_D
+// CHECK-LP32-NEXT: .long __ZN9test13_B23B2aEv
+// CHECK-LP32-NEXT: .long __ZN9test13_B22B2Ev
+// CHECK-LP32-NEXT: .long __ZTv0_n24_N8test13_D1DEv
+// CHECK-LP32-NEXT: .long __ZN9test13_B22DaEv
+// CHECK-LP32-NEXT: .long __ZTv0_n32_N8test13_D2DdEv
+// CHECK-LP32-NEXT: .long __ZN9test13_B23B2bEv
+// CHECK-LP32-NEXT: .long 4294967288
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967284
+// CHECK-LP32-NEXT: .long 4294967288
+// CHECK-LP32-NEXT: .long 4294967284
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967284
+// CHECK-LP32-NEXT: .long __ZTI8test13_D
+// CHECK-LP32-NEXT: .long __ZN8test13_B2B1Ev
+// CHECK-LP32-NEXT: .long __ZTv0_n16_N8test13_D1DEv
+// CHECK-LP32-NEXT: .long __ZTv0_n20_N9test13_B22DaEv
+// CHECK-LP32-NEXT: .long __ZTv0_n24_N8test13_D2DbEv
+// CHECK-LP32-NEXT: .long __ZN8test13_B2DcEv
+// CHECK-LP32-NEXT: .long __ZTv0_n32_N9test13_B22B2Ev
+
+
+class test14 {
+public:
+    virtual void initWithInt(int a);
+    static test14 *withInt(int a);
+};
+
+void test14::initWithInt(int a) { }
+
+test14 *test14::withInt(int a) {
+  test14 *me = new test14;
+  me->initWithInt(a);
+  return me;
+}
+
+
+struct test15_B {
+  virtual test15_B *foo1() { return 0; }
+  virtual test15_B *foo2() { return 0; }
+  virtual test15_B *foo3() { return 0; }
+  int i;
+};
+
+struct test15_NV1 {
+  virtual void fooNV1() { }
+  int i;
+};
+
+struct test15_B2 : test15_NV1, virtual test15_B {
+  virtual test15_B2 *foo1() { return 0; }
+  virtual test15_B2 *foo2() { return 0; }
+  int i;
+};
+
+struct test15_D : test15_NV1, virtual test15_B2 {
+  virtual test15_D *foo1() { return 0; }
+};
+
+// CHECK-LP64:__ZTV8test15_D:
+// CHECK-LP64-NEXT: .quad 32
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI8test15_D
+// CHECK-LP64-NEXT: .quad __ZN10test15_NV16fooNV1Ev
+// CHECK-LP64-NEXT: .quad __ZN8test15_D4foo1Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551600
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .quad 18446744073709551600
+// CHECK-LP64-NEXT: .quad __ZTI8test15_D
+// CHECK-LP64-NEXT: .quad __ZN10test15_NV16fooNV1Ev
+// CHECK-LP64-NEXT: .quad __ZTcv0_n40_v0_n24_N8test15_D4foo1Ev
+// CHECK-LP64-NEXT: .quad __ZN9test15_B24foo2Ev
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551600
+// CHECK-LP64-NEXT: .quad 18446744073709551584
+// CHECK-LP64-NEXT: .quad 18446744073709551584
+// CHECK-LP64-NEXT: .quad __ZTI8test15_D
+// CHECK-LP64-NEXT: .quad __ZTcv0_n24_v0_n32_N8test15_D4foo1Ev
+// CHECK-LP64-NEXT: .quad __ZTcv0_n32_v0_n24_N9test15_B24foo2Ev
+// CHECK-LP64-NEXT: .quad __ZN8test15_B4foo3Ev
+
+// CHECK-LP32:__ZTV8test15_D:
+// CHECK-LP32-NEXT: .long 20
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI8test15_D
+// CHECK-LP32-NEXT: .long __ZN10test15_NV16fooNV1Ev
+// CHECK-LP32-NEXT: .long __ZN8test15_D4foo1Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967288
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 12
+// CHECK-LP32-NEXT: .long 4294967288
+// CHECK-LP32-NEXT: .long __ZTI8test15_D
+// CHECK-LP32-NEXT: .long __ZN10test15_NV16fooNV1Ev
+// CHECK-LP32-NEXT: .long __ZTcv0_n20_v0_n12_N8test15_D4foo1Ev
+// CHECK-LP32-NEXT: .long __ZN9test15_B24foo2Ev
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967284
+// CHECK-LP32-NEXT: .long 4294967276
+// CHECK-LP32-NEXT: .long 4294967276
+// CHECK-LP32-NEXT: .long __ZTI8test15_D
+// CHECK-LP32-NEXT: .long __ZTcv0_n12_v0_n16_N8test15_D4foo1Ev
+// CHECK-LP32-NEXT: .long __ZTcv0_n16_v0_n12_N9test15_B24foo2Ev
+// CHECK-LP32-NEXT: .long __ZN8test15_B4foo3Ev
+
+
+
+// CHECK-LP64: __ZTV1B:
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI1B
+// CHECK-LP64-NEXT: .quad __ZN1B4bar1Ev
+// CHECK-LP64-NEXT: .quad __ZN1B4bar2Ev
+
+// CHECK-LP32: __ZTV1B:
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI1B
+// CHECK-LP32-NEXT: .long __ZN1B4bar1Ev
+// CHECK-LP32-NEXT: .long __ZN1B4bar2Ev
+
+// CHECK-LP64: __ZTV1A:
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI1A
+// CHECK-LP64-NEXT: .quad __ZN1B4bar1Ev
+// CHECK-LP64-NEXT: .quad __ZN1B4bar2Ev
+// CHECK-LP64-NEXT: .quad __ZN1A4foo1Ev
+// CHECK-LP64-NEXT: .quad __ZN1A4foo2Ev
+// CHECK-LP64-NEXT: .quad 18446744073709551600
+// CHECK-LP64-NEXT: .quad __ZTI1A
+// CHECK-LP64-NEXT: .quad __ZN1C4bee1Ev
+// CHECK-LP64-NEXT: .quad __ZN1C4bee2Ev
+
+// CHECK-LP32: __ZTV1A:
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI1A
+// CHECK-LP32-NEXT: .long __ZN1B4bar1Ev
+// CHECK-LP32-NEXT: .long __ZN1B4bar2Ev
+// CHECK-LP32-NEXT: .long __ZN1A4foo1Ev
+// CHECK-LP32-NEXT: .long __ZN1A4foo2Ev
+// CHECK-LP32-NEXT: .long 4294967284
+// CHECK-LP32-NEXT: .long __ZTI1A
+// CHECK-LP32-NEXT: .long __ZN1C4bee1Ev
+// CHECK-LP32-NEXT: .long __ZN1C4bee2Ev
+
+// CHECK-LP32:__ZTV1F:
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 8
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long __ZTI1F
+// CHECK-LP32-NEXT: .long __ZN1D3booEv
+// CHECK-LP32-NEXT: .long __ZN1F3fooEv
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .space 4
+// CHECK-LP32-NEXT: .long 4294967288
+// CHECK-LP32-NEXT: .long __ZTI1F
+// CHECK-LP32-NEXT: .long __ZN2D13barEv
+// CHECK-LP32-NEXT: .long __ZN2D14bar2Ev
+// CHECK-LP32-NEXT: .long __ZN2D14bar3Ev
+// CHECK-LP32-NEXT: .long __ZN2D14bar4Ev
+// CHECK-LP32-NEXT: .long __ZN2D14bar5Ev
+
+// CHECK-LP64: __ZTV1F:
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 16
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad __ZTI1F
+// CHECK-LP64-NEXT: .quad __ZN1D3booEv
+// CHECK-LP64-NEXT: .quad __ZN1F3fooEv
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .space 8
+// CHECK-LP64-NEXT: .quad 18446744073709551600
+// CHECK-LP64-NEXT: .quad __ZTI1F
+// CHECK-LP64-NEXT: .quad __ZN2D13barEv
+// CHECK-LP64-NEXT: .quad __ZN2D14bar2Ev
+// CHECK-LP64-NEXT: .quad __ZN2D14bar3Ev
+// CHECK-LP64-NEXT: .quad __ZN2D14bar4Ev
+// CHECK-LP64-NEXT: .quad __ZN2D14bar5Ev
+
+test15_D d15;
+test13_D d13;
+test11_D d11;
+test10_D d10;
+test9_D d9;
+test8_D d8;
+
+test5_D d5;
+test4_D d4;
+test3_D d3;
+
+test6_D d6;
+test7_D d7;
diff --git a/test/CodeGenCXX/virtual-base-cast.cpp b/test/CodeGenCXX/virtual-base-cast.cpp
new file mode 100644
index 000000000000..a825120ad229
--- /dev/null
+++ b/test/CodeGenCXX/virtual-base-cast.cpp
@@ -0,0 +1,9 @@
+// RUN: clang-cc -emit-llvm-only %s
+
+struct A { virtual ~A(); };
+struct B : A { virtual ~B(); };
+struct C : virtual B { virtual ~C(); };
+
+void f(C *c) {
+  A* a = c;
+}
diff --git a/test/CodeGenCXX/virtual-function-calls.cpp b/test/CodeGenCXX/virtual-function-calls.cpp
new file mode 100644
index 000000000000..ca5acbabcc99
--- /dev/null
+++ b/test/CodeGenCXX/virtual-function-calls.cpp
@@ -0,0 +1,11 @@
+// RUN: clang-cc %s -emit-llvm -o - | FileCheck %s
+
+// PR5021
+struct A {
+  virtual void f(char);
+};
+
+void f(A *a) {
+  // CHECK: call void %
+  a->f('c');
+}
diff --git a/test/CodeGenCXX/vtable-cast-crash.cpp b/test/CodeGenCXX/vtable-cast-crash.cpp
new file mode 100644
index 000000000000..a91d9790fe65
--- /dev/null
+++ b/test/CodeGenCXX/vtable-cast-crash.cpp
@@ -0,0 +1,21 @@
+// RUN: clang-cc -emit-llvm-only %s
+struct A
+{
+A();    
+virtual ~A();
+};
+
+struct B: A
+{
+  B();
+  ~B();
+};
+
+B::B()
+{
+}
+
+B::~B()
+{
+}
+                         
diff --git a/test/CodeGenCXX/x86_64-arguments.cpp b/test/CodeGenCXX/x86_64-arguments.cpp
new file mode 100644
index 000000000000..426c867a7b6b
--- /dev/null
+++ b/test/CodeGenCXX/x86_64-arguments.cpp
@@ -0,0 +1,10 @@
+// RUN: clang-cc -triple x86_64-unknown-unknown -emit-llvm -o %t %s &&
+struct A { ~A(); };
+
+// RUN: grep 'define void @_Z2f11A(.struct.A\* .a)' %t &&
+void f1(A a) { }
+
+// RUN: grep 'define void @_Z2f2v(.struct.A\* noalias sret .agg.result)' %t &&
+A f2() { return A(); }
+
+// RUN: true
diff --git a/test/CodeGenObjC/PR4541.m b/test/CodeGenObjC/PR4541.m
new file mode 100644
index 000000000000..9a651162c1e1
--- /dev/null
+++ b/test/CodeGenObjC/PR4541.m
@@ -0,0 +1,19 @@
+// RUN: clang-cc -o %t -w  -g %s
+
+
+@class NSString;
+@interface NSAttributedString 
+- (NSString *)string;
+@end 
+@interface NSMutableAttributedString : NSAttributedString 
+@end 
+@class NSImage;
+@implementation CYObjectsController 
++ (void)initialize {
+}
++ (NSAttributedString *)attributedStringWithString:(id)string image:(NSImage *)image  {
+  NSMutableAttributedString *attrStr;
+}
+@end
+
+
diff --git a/test/CodeGenObjC/PR4894-recursive-debug-crash.m b/test/CodeGenObjC/PR4894-recursive-debug-crash.m
new file mode 100644
index 000000000000..c5f901c2680e
--- /dev/null
+++ b/test/CodeGenObjC/PR4894-recursive-debug-crash.m
@@ -0,0 +1,40 @@
+// RUN: clang-cc -triple i386-apple-darwin9 -g -emit-llvm %s -o - | FileCheck %s
+// PR4894
+//
+// This test is actually just making sure we can generate the debug info for the
+// return type from im0 without crashing.
+// XFAIL
+
+@interface I0 {
+  I0 *_iv0;
+}
+@end
+@protocol P0 @end
+
+@interface I1 @end
+@implementation I1
+- (I0<P0> *) im0 {
+// CHECK: @"\01-[I1 im0]"
+// CHECK: llvm.dbg.func.start
+  return 0;
+}
+@end
+
+// FIXME: This was another PR4894 test case, which is crashing somewhere
+// else. PR5025.
+#if 0
+typedef const struct objc_selector {
+  void *sel_id;
+  const char *sel_types;
+} *SEL;
+
+@interface I2
++(id) dictionary;
+@end
+
+@implementation I3;
++(void) initialize {
+  I2 *a0 = [I2 dictionary];
+}
+@end
+#endif
diff --git a/test/CodeGenObjC/constant-strings.m b/test/CodeGenObjC/constant-strings.m
index d4fefd903653..82cd916b5ca8 100644
--- a/test/CodeGenObjC/constant-strings.m
+++ b/test/CodeGenObjC/constant-strings.m
@@ -1,4 +1,6 @@
-// RUN: clang-cc -fnext-runtime -emit-llvm -o %t %s
+// RUN: clang-cc -fnext-runtime -emit-llvm -o %t %s &&
+// RUN: clang-cc -fgnu-runtime -emit-llvm -o %t %s && grep NXConstantString %t | count 1 &&
+// RUN: clang-cc -fgnu-runtime -fconstant-string-class=NSConstantString -emit-llvm -o %t %s && grep NSConstantString %t | count 1
 
 id a = @"Hello World!";
 
diff --git a/test/CodeGenObjC/debug-info-linkagename.m b/test/CodeGenObjC/debug-info-linkagename.m
new file mode 100644
index 000000000000..730568954cb0
--- /dev/null
+++ b/test/CodeGenObjC/debug-info-linkagename.m
@@ -0,0 +1,17 @@
+// RUN: clang-cc  -g -S -o %t %s &&
+// RUN: not grep 001 %t
+
+@interface F 
+-(int) bar;
+@end
+
+@implementation F
+-(int) bar {
+	return 42;
+}
+@end
+
+extern int f(F *fn) {
+	return [fn bar];
+}
+	
diff --git a/test/CodeGenObjC/for-in.m b/test/CodeGenObjC/for-in.m
new file mode 100644
index 000000000000..434ff796b335
--- /dev/null
+++ b/test/CodeGenObjC/for-in.m
@@ -0,0 +1,44 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+void p(const char*, ...);
+
+@interface NSArray
++(NSArray*) arrayWithObjects: (id) first, ...;
+-(unsigned) count;
+@end
+@interface NSString
+-(const char*) cString;
+@end
+
+#define S(n) @#n
+#define L1(n) S(n+0),S(n+1)
+#define L2(n) L1(n+0),L1(n+2)
+#define L3(n) L2(n+0),L2(n+4)
+#define L4(n) L3(n+0),L3(n+8)
+#define L5(n) L4(n+0),L4(n+16)
+#define L6(n) L5(n+0),L5(n+32)
+
+void t0() {
+  NSArray *array = [NSArray arrayWithObjects: L1(0), (void*)0];
+
+  p("array.length: %d\n", [array count]);
+  unsigned index = 0;
+  for (NSString *i in array) {
+    p("element %d: %s\n", index++, [i cString]);
+  }
+}
+
+void t1() {
+  NSArray *array = [NSArray arrayWithObjects: L6(0), (void*)0];
+
+  p("array.length: %d\n", [array count]);
+  unsigned index = 0;
+  for (NSString *i in array) {
+    index++;
+    if (index == 10)
+      continue;
+    p("element %d: %s\n", index, [i cString]);
+    if (index == 55)
+      break;
+  }
+}
diff --git a/test/CodeGenObjC/ivar-layout-64-bitfields.m b/test/CodeGenObjC/ivar-layout-64-bitfields.m
new file mode 100644
index 000000000000..cb5611835f62
--- /dev/null
+++ b/test/CodeGenObjC/ivar-layout-64-bitfields.m
@@ -0,0 +1,40 @@
+// RUN: clang-cc -triple x86_64-apple-darwin9 -fobjc-gc -emit-llvm -o %t %s
+@interface I
+{
+  struct {
+    unsigned int d : 1;
+  } bitfield;
+}
+@end
+
+@implementation I
+@end
+
+@interface J
+{
+    struct {
+        unsigned short _reserved : 16;
+
+        _Bool _draggedNodesAreDeletable: 1;
+        _Bool _draggedOutsideOutlineView : 1;
+        _Bool _adapterRespondsTo_addRootPaths : 1;
+        _Bool _adapterRespondsTo_moveDataNodes : 1;
+        _Bool _adapterRespondsTo_removeRootDataNode : 1;
+        _Bool _adapterRespondsTo_doubleClickDataNode : 1;
+        _Bool _adapterRespondsTo_selectDataNode : 1;
+        _Bool _adapterRespondsTo_textDidEndEditing : 1;
+
+        _Bool _adapterRespondsTo_updateAndSaveRoots : 1;
+        _Bool _adapterRespondsTo_askToDeleteRootNodes : 1;
+        _Bool _adapterRespondsTo_contextMenuForSelectedNodes : 1;
+        _Bool _adapterRespondsTo_pasteboardFilenamesForNodes : 1;
+        _Bool _adapterRespondsTo_writeItemsToPasteboard : 1;
+        _Bool _adapterRespondsTo_writeItemsToPasteboardXXXX : 1;
+    } _flags;
+}
+@end
+
+@implementation J
+@end
+
+
diff --git a/test/CodeGenObjC/ivar-layout-no-optimize.m b/test/CodeGenObjC/ivar-layout-no-optimize.m
new file mode 100644
index 000000000000..d7796bc279e1
--- /dev/null
+++ b/test/CodeGenObjC/ivar-layout-no-optimize.m
@@ -0,0 +1,18 @@
+// RUN: clang-cc -fobjc-gc -triple x86_64-apple-darwin -O0 -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: true
+
+@interface NSObject {
+  id isa;
+}
+@end
+
+@interface AllPointers : NSObject {
+    id foo;
+    void *__strong bar;    NSObject *bletch;}
+@end
+@implementation AllPointers
+@end
+
+// CHECK-LP64: L_OBJC_CLASS_NAME_6:
+// CHECK-LP64-NEXT: .asciz	"\004"
diff --git a/test/CodeGenObjC/messages.m b/test/CodeGenObjC/messages.m
index f9b9be6e11a3..b7f42d126d2b 100644
--- a/test/CodeGenObjC/messages.m
+++ b/test/CodeGenObjC/messages.m
@@ -2,8 +2,8 @@
 // RUN: grep "objc_msgSend" %t | count 6 &&
 // RUN: clang-cc -fgnu-runtime --emit-llvm -o %t %s &&
 // RUN: grep "objc_msg_lookup" %t | count 6 &&
-// RUN: clang-cc -fgnu-runtime -fobjc-sender-dependent-dispatch --emit-llvm -o %t %s &&
-// RUN: grep "objc_msg_lookup_sender" %t | count 6
+// RUN: clang-cc -fgnu-runtime -fobjc-nonfragile-abi --emit-llvm -o %t %s &&
+// RUN: grep "objc_msg_lookup_sender" %t | count 6 &&
 // RUN: true
 
 typedef struct {
diff --git a/test/CodeGenObjC/objc-assign-ivar.m b/test/CodeGenObjC/objc-assign-ivar.m
new file mode 100644
index 000000000000..f79faaf23826
--- /dev/null
+++ b/test/CodeGenObjC/objc-assign-ivar.m
@@ -0,0 +1,53 @@
+// RUN: clang-cc -triple x86_64-apple-darwin10 -fobjc-gc -emit-llvm -o %t %s &&
+// RUN: grep -F '@objc_assign_ivar' %t  | count 14 &&
+// RUN: true
+
+typedef struct {
+  id  element;
+  id elementArray[10];
+  __strong id cfElement;
+  __strong id cfElementArray[10];
+} struct_with_ids_t;
+
+
+@interface NSString @end
+
+@interface Foo  {
+@public
+// assignments to any/all of these fields should generate objc_assign_ivar
+  __strong id dict;
+  __strong id dictArray[3];
+  id ivar;
+  id array[10];
+  id nsobject;
+  NSString *stringArray[10];
+  struct_with_ids_t inner;
+
+  Foo *obj[20];
+  short idx[5];
+}
+@end
+
+// The test cases
+int IvarAssigns;
+void *rhs = 0;
+#define ASSIGNTEST(expr, global) expr = rhs
+
+void testIvars() {
+  Foo *foo;
+  ASSIGNTEST(foo->ivar, IvarAssigns);                                   // objc_assign_ivar
+  ASSIGNTEST(foo->dict, IvarAssigns);                                   // objc_assign_ivar
+  ASSIGNTEST(foo->dictArray[0], IvarAssigns);                           // objc_assign_ivar
+  ASSIGNTEST(foo->array[0], IvarAssigns);                               // objc_assign_ivar
+  ASSIGNTEST(foo->nsobject, IvarAssigns);                               // objc_assign_ivar
+  ASSIGNTEST(foo->stringArray[0], IvarAssigns);                         // objc_assign_ivar
+  ASSIGNTEST(foo->inner.element, IvarAssigns);                          // objc_assign_ivar
+  ASSIGNTEST(foo->inner.elementArray[0], IvarAssigns);                  // objc_assign_ivar
+  ASSIGNTEST(foo->inner.cfElement, IvarAssigns);                        // objc_assign_ivar
+  ASSIGNTEST(foo->inner.cfElementArray[0], IvarAssigns);                // objc_assign_ivar
+  int counter=1;
+  ASSIGNTEST(foo->obj[5], IvarAssigns);                 // objc_assign_ivar
+  ASSIGNTEST(foo->obj[++counter], IvarAssigns);         // objc_assign_ivar
+  foo->idx[++counter] = 15;
+  ASSIGNTEST(foo->obj[foo->idx[2]], IvarAssigns);       // objc_assign_ivar
+}
diff --git a/test/CodeGenObjC/objc-gc-aggr-assign.m b/test/CodeGenObjC/objc-gc-aggr-assign.m
new file mode 100644
index 000000000000..96a9fdf65409
--- /dev/null
+++ b/test/CodeGenObjC/objc-gc-aggr-assign.m
@@ -0,0 +1,46 @@
+// RUN: clang-cc -fnext-runtime -fobjc-gc -emit-llvm -o %t %s &&
+// RUN: grep objc_memmove_collectable %t | grep call | count 3
+
+static int count;
+
+typedef struct S {
+   int ii;
+} SS;
+
+struct type_s {
+   SS may_recurse;
+   id id_val;
+};
+
+@interface NamedObject
+{
+  struct type_s type_s_ivar;
+}
+- (void) setSome : (struct type_s) arg;
+- (struct type_s) getSome;
+@property(assign) struct type_s aggre_prop;
+@end
+
+@implementation NamedObject 
+- (void) setSome : (struct type_s) arg
+  {
+     type_s_ivar = arg;
+  }
+- (struct type_s) getSome 
+  {
+    return type_s_ivar;
+  }
+@synthesize aggre_prop = type_s_ivar;
+@end
+
+struct type_s some = {{1234}, (id)0};
+
+struct type_s get(void)
+{
+  return some;
+}
+
+void f(const struct type_s *in, struct type_s *out) {
+  *out = *in;
+}
+
diff --git a/test/CodeGenObjC/objc-read-weak-byref.m b/test/CodeGenObjC/objc-read-weak-byref.m
new file mode 100644
index 000000000000..7c297be56679
--- /dev/null
+++ b/test/CodeGenObjC/objc-read-weak-byref.m
@@ -0,0 +1,26 @@
+// RUN: clang-cc -fblocks -fobjc-gc -triple x86_64-apple-darwin -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -fblocks -fobjc-gc -triple i386-apple-darwin -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+@interface NSObject 
+- copy;
+@end
+
+int main() {
+    NSObject *object = 0;
+    __weak __block NSObject* weak_object = object;
+    void (^callback) (void) = [^{
+        if (weak_object)
+                [weak_object copy];
+    } copy];
+    callback();
+    return 0;
+}
+
+// CHECK-LP64: call     _objc_read_weak
+// CHECK-LP64: call     _objc_read_weak
+
+// CHECK-LP32: call     L_objc_read_weak
+// CHECK-LP32: call     L_objc_read_weak
diff --git a/test/CodeGenObjC/objc2-assign-global.m b/test/CodeGenObjC/objc2-assign-global.m
index ae407619093e..9b6b4151f6a0 100644
--- a/test/CodeGenObjC/objc2-assign-global.m
+++ b/test/CodeGenObjC/objc2-assign-global.m
@@ -1,8 +1,81 @@
-// RUN: clang-cc -fnext-runtime -fobjc-gc -emit-llvm -o %t %s &&
-// RUN: grep -F '@objc_assign_global' %t  | count 2 &&
+// RUN: clang-cc -triple x86_64-apple-darwin10 -fnext-runtime -fobjc-gc -emit-llvm -o %t %s &&
+// RUN: grep -F '@objc_assign_global' %t  | count 26 &&
 // RUN: true
-id a;
+
+@class NSObject;
+typedef const struct __CFDictionary * CFDictionaryRef;
+typedef struct {
+  id  element;
+  id elementArray[10];
+  __strong CFDictionaryRef cfElement;
+  __strong CFDictionaryRef cfElementArray[10];
+} struct_with_ids_t;
+
+
+// assignments to these should generate objc_assign_global
+@interface A
+@end
+
+typedef struct s0 {
+  A *a[4];
+} T;
+
+T g0;
+
+extern id FileExternID;
+static id FileStaticID;
+id GlobalId;
+id GlobalArray[20];
+NSObject *GlobalObject;
+NSObject *GlobalObjectArray[20];
+__strong CFDictionaryRef Gdict;
+__strong CFDictionaryRef Gdictarray[10];
+struct_with_ids_t GlobalStruct;
+struct_with_ids_t GlobalStructArray[10];
+
+#define ASSIGNTEST(expr, global) expr = rhs
+void *rhs = 0;
+
 int main() {
-        a = 0;
-}
+  static id staticGlobalId;
+  static id staticGlobalArray[20];
+  static NSObject *staticGlobalObject;
+  static NSObject *staticGlobalObjectArray[20];
+  static __strong CFDictionaryRef staticGdict;
+  static __strong CFDictionaryRef staticGdictarray[10];
+  static struct_with_ids_t staticGlobalStruct;
+  static struct_with_ids_t staticGlobalStructArray[10];
+  extern id ExID;
+  id localID;
+
+  ASSIGNTEST(GlobalId, GlobalAssigns);                          // objc_assign_global
+  ASSIGNTEST(GlobalArray[0], GlobalAssigns);                    // objc_assign_global
+  ASSIGNTEST(GlobalObject, GlobalAssigns);                      // objc_assign_global
+  ASSIGNTEST(GlobalObjectArray[0], GlobalAssigns);              // objc_assign_global
+  ASSIGNTEST(Gdict, GlobalAssigns);                             // objc_assign_global
+  ASSIGNTEST(Gdictarray[1], GlobalAssigns);                     // objc_assign_global
+
+  ASSIGNTEST(GlobalStruct.element, GlobalAssigns);              // objc_assign_global
+  ASSIGNTEST(GlobalStruct.elementArray[0], GlobalAssigns);      // objc_assign_global
+  ASSIGNTEST(GlobalStruct.cfElement, GlobalAssigns);            // objc_assign_global
+  ASSIGNTEST(GlobalStruct.cfElementArray[0], GlobalAssigns);    // objc_assign_global
 
+  ASSIGNTEST(staticGlobalId, GlobalAssigns);                    // objc_assign_global
+  ASSIGNTEST(staticGlobalArray[0], GlobalAssigns);              // objc_assign_global
+  ASSIGNTEST(staticGlobalObject, GlobalAssigns);                // objc_assign_global
+  ASSIGNTEST(staticGlobalObjectArray[0], GlobalAssigns);        // objc_assign_global
+  ASSIGNTEST(staticGdict, GlobalAssigns);                       // objc_assign_global
+  ASSIGNTEST(staticGdictarray[1], GlobalAssigns);               // objc_assign_global
+
+  ASSIGNTEST(staticGlobalStruct.element, GlobalAssigns);                // objc_assign_global
+  ASSIGNTEST(staticGlobalStruct.elementArray[0], GlobalAssigns);        // objc_assign_global
+  ASSIGNTEST(staticGlobalStruct.cfElement, GlobalAssigns);              // objc_assign_global
+  ASSIGNTEST(staticGlobalStruct.cfElementArray[0], GlobalAssigns);      // objc_assign_global
+
+  ExID = 0;
+  localID = 0;
+  FileStaticID = 0;
+  FileExternID=0;
+  g0.a[0] = 0;
+  ((T*) &g0)->a[0] = 0;
+}
diff --git a/test/CodeGenObjC/objc2-ivar-assign.m b/test/CodeGenObjC/objc2-ivar-assign.m
new file mode 100644
index 000000000000..cfdf87f2f12b
--- /dev/null
+++ b/test/CodeGenObjC/objc2-ivar-assign.m
@@ -0,0 +1,41 @@
+// RUN: clang-cc -triple x86_64-apple-darwin10 -fobjc-gc -emit-llvm -o %t %s &&
+// RUN: grep objc_assign_ivar %t | count 6 &&
+// RUN: true
+
+@interface I @end
+
+typedef I TI;
+typedef I* TPI;
+
+typedef id ID;
+
+@interface MyClass {
+}
+
+@property id property;
+@property I* propertyI;
+
+@property TI* propertyTI;
+
+@property TPI propertyTPI;
+
+@property ID propertyID;
+@end
+
+@implementation MyClass
+	@synthesize property=_property;
+        @synthesize propertyI;
+        @synthesize propertyTI=_propertyTI;
+        @synthesize propertyTPI=_propertyTPI;
+         @synthesize propertyID = _propertyID;
+@end
+
+int main () {
+    MyClass *myObj;
+    myObj.property = 0;
+    myObj.propertyI = 0;
+    myObj.propertyTI = 0;
+    myObj.propertyTPI = 0;
+    myObj.propertyID = 0;
+    return 0;
+}
diff --git a/test/CodeGenObjC/objc2-new-gc-api-strongcast.m b/test/CodeGenObjC/objc2-new-gc-api-strongcast.m
new file mode 100644
index 000000000000..6a1aea6a7340
--- /dev/null
+++ b/test/CodeGenObjC/objc2-new-gc-api-strongcast.m
@@ -0,0 +1,26 @@
+// RUN: clang-cc -triple x86_64-apple-darwin10 -fblocks -fnext-runtime -fobjc-gc -emit-llvm -o %t %s &&
+// RUN: grep -F '@objc_assign_strongCast' %t  | count 4 &&
+// RUN: true
+
+@interface DSATextSearch @end
+
+DSATextSearch **_uniqueIdToIdentifierArray = ((void *)0);
+void foo (int _nextId)
+{
+	_uniqueIdToIdentifierArray[_nextId] = 0;  // objc_assign_strongCast
+}
+
+typedef struct {
+    unsigned long state;
+    id *itemsPtr;
+    void (^bp)();
+    unsigned long *mutationsPtr;
+    unsigned long extra[5];
+} NSFastEnumerationState;
+
+void foo1 (NSFastEnumerationState * state)
+{
+   state->itemsPtr = 0;
+   state->bp = ^{};
+}
+
diff --git a/test/CodeGenObjC/objc2-weak-assign.m b/test/CodeGenObjC/objc2-weak-assign.m
index a3740b207e85..635ca38df46c 100644
--- a/test/CodeGenObjC/objc2-weak-assign.m
+++ b/test/CodeGenObjC/objc2-weak-assign.m
@@ -9,6 +9,10 @@ __weak id* a1[20];
 id* __weak a2[30];
 id** __weak a3[40];
 
+void foo (__weak id *param) {
+ *param = 0;
+}
+
 int main()
 {
 	*x = 0;
diff --git a/test/CodeGenObjC/objc2-weak-ivar-debug.m b/test/CodeGenObjC/objc2-weak-ivar-debug.m
new file mode 100644
index 000000000000..24a7757b9acf
--- /dev/null
+++ b/test/CodeGenObjC/objc2-weak-ivar-debug.m
@@ -0,0 +1,15 @@
+// RUN: clang-cc -triple x86_64-apple-darwin9 -fobjc-gc -g -emit-llvm -o - %s &&
+// RUN: clang-cc -triple i386-apple-darwin9 -fobjc-gc -g -emit-llvm -o - %s
+
+// rdar://7252252
+@interface Loop {
+@public
+  __weak Loop *_loop;
+}
+@end
+
+@implementation Loop @end
+
+void loop(Loop *L) {
+  L->_loop = 0;
+}
diff --git a/test/CodeGenObjC/objc2-write-barrier-2.m b/test/CodeGenObjC/objc2-write-barrier-2.m
new file mode 100644
index 000000000000..c47224f1c516
--- /dev/null
+++ b/test/CodeGenObjC/objc2-write-barrier-2.m
@@ -0,0 +1,80 @@
+// RUN: clang-cc -triple x86_64-apple-darwin10 -fnext-runtime -fobjc-gc -emit-llvm -o %t %s &&
+// RUN: grep -F '@objc_assign_global' %t  | count 7 &&
+// RUN: grep -F '@objc_assign_ivar' %t  | count 5 &&
+// RUN: grep -F '@objc_assign_strongCast' %t  | count 8 &&
+// RUN: true
+
+extern id **somefunc(void);
+extern id *somefunc2(void);
+
+
+// Globals
+
+id W, *X, **Y;
+
+void func(id a, id *b, id **c) {
+   static id w, *x, **y;
+   W = a;  
+   w = a;
+   X = b;
+   x = b; 
+   Y = c;
+   y = c; 
+}
+
+// Instances
+
+@interface something {
+    id w, *x, **y;
+}
+@end
+
+@implementation something
+- (void)amethod {
+    id badIdea = *somefunc2();
+    w = badIdea;
+    x = &badIdea;
+    y = &x;
+}
+@end
+
+typedef struct {
+    int junk;
+    id  alfred;
+} AStruct;
+
+void funct2(AStruct *aptr) {
+    id **ppptr = somefunc();
+    aptr->alfred = 0;
+    **ppptr = aptr->alfred;
+    *ppptr = somefunc2(); 
+}
+
+typedef const struct __CFString * CFStringRef;
+@interface DSATextSearch {
+__strong CFStringRef *_documentNames;
+  struct {
+    id *innerNames;
+    struct {
+      id *nestedDeeperNames; 
+      struct I {
+         id *is1;
+         id is2[5];
+      } arrI [3];
+    } inner_most;
+  } inner;
+
+}
+- filter;
+@end
+@implementation DSATextSearch
+- filter {
+  int filteredPos = 0;
+  _documentNames[filteredPos] = 0; // storing into an element of array ivar. objc_assign_strongCast is needed.
+  inner.innerNames[filteredPos] = 0;
+  inner.inner_most.nestedDeeperNames[filteredPos] = 0;
+  inner.inner_most.arrI[3].is1[5] = 0;
+  inner.inner_most.arrI[3].is2[5] = 0;
+}
+@end
+
diff --git a/test/CodeGenObjC/objc2-write-barrier-3.m b/test/CodeGenObjC/objc2-write-barrier-3.m
new file mode 100644
index 000000000000..2fb416b79b2f
--- /dev/null
+++ b/test/CodeGenObjC/objc2-write-barrier-3.m
@@ -0,0 +1,47 @@
+// RUN: clang-cc -triple x86_64-apple-darwin10 -fobjc-gc -emit-llvm -o %t %s &&
+// RUN: grep objc_assign_ivar %t | count 3 &&
+// RUN: grep objc_assign_strongCast %t | count 6 &&
+// RUN: true
+
+struct Slice {
+    void *__strong * items;
+};
+
+typedef struct Slice Slice;
+
+@interface ISlice {
+@public
+    void *__strong * IvarItem;
+}
+@end
+
+typedef void (^observer_block_t)(id object);
+@interface Observer  {
+@public
+    observer_block_t block;
+}
+@end
+
+
+void foo (int i) {
+    // storing into an array of strong pointer types.
+    void *__strong* items;
+    items[i] = 0;
+
+    // storing indirectly into an array of strong pointer types.
+    void *__strong* *vitems;
+    *vitems[i] = 0;
+
+    Slice *slice;
+    slice->items = 0;
+    // storing into a struct element of an array of strong pointer types.
+    slice->items[i] = 0;
+
+    ISlice *islice;
+    islice->IvarItem = 0;
+    // Storing into an ivar of an array of strong pointer types.
+    islice->IvarItem[i] = (void*)0;
+
+    Observer *observer;
+    observer->block = 0;
+}
diff --git a/test/CodeGenObjC/objc2-write-barrier-4.m b/test/CodeGenObjC/objc2-write-barrier-4.m
new file mode 100644
index 000000000000..f96a233787b0
--- /dev/null
+++ b/test/CodeGenObjC/objc2-write-barrier-4.m
@@ -0,0 +1,28 @@
+// RUN: clang-cc -triple x86_64-apple-darwin10 -fobjc-gc -emit-llvm -o %t %s &&
+// RUN: grep objc_assign_global %t | count 3 &&
+// RUN: grep objc_assign_strongCast %t | count 2 &&
+// RUN: true
+
+@interface A
+@end
+
+typedef struct s0 {
+  A *a[4];
+} T;
+
+T g0;
+
+void f0(id x) {
+  g0.a[0] = x;
+}
+
+void f1(id x) {
+  ((T*) &g0)->a[0] = x;
+}
+
+void f2(unsigned idx)
+{
+   id *keys;
+   keys[idx] = 0;
+}
+
diff --git a/test/CodeGenObjC/objc2-write-barrier-5.m b/test/CodeGenObjC/objc2-write-barrier-5.m
new file mode 100644
index 000000000000..5b8f02cc1e16
--- /dev/null
+++ b/test/CodeGenObjC/objc2-write-barrier-5.m
@@ -0,0 +1,27 @@
+// RUN: clang-cc -triple x86_64-apple-darwin10 -fobjc-gc -emit-llvm -o %t %s &&
+// RUN: grep objc_assign_ivar %t | count 0 &&
+// RUN: grep objc_assign_strongCast %t | count 5 &&
+// RUN: true
+
+@interface TestUnarchiver 
+{
+	void  *allUnarchivedObjects;
+}
+@end
+
+@implementation TestUnarchiver
+
+struct unarchive_list {
+    int ifield;
+    id *list;
+};
+
+- (id)init {
+    (*((struct unarchive_list *)allUnarchivedObjects)).list = 0;
+    ((struct unarchive_list *)allUnarchivedObjects)->list = 0;
+    (**((struct unarchive_list **)allUnarchivedObjects)).list = 0;
+    (*((struct unarchive_list **)allUnarchivedObjects))->list = 0;
+    return 0;
+}
+
+@end
diff --git a/test/CodeGenObjC/objc2-write-barrier.m b/test/CodeGenObjC/objc2-write-barrier.m
new file mode 100644
index 000000000000..53fa10a7a75f
--- /dev/null
+++ b/test/CodeGenObjC/objc2-write-barrier.m
@@ -0,0 +1,114 @@
+// RUN: clang-cc -triple x86_64-apple-darwin10 -fnext-runtime -fobjc-gc -emit-llvm -o %t %s &&
+// RUN: grep -F '@objc_assign_global' %t  | count 21 &&
+// RUN: grep -F '@objc_assign_ivar' %t  | count 11 &&
+// RUN: true
+
+
+typedef const struct __CFDictionary * CFDictionaryRef;
+
+// callouts to these are generated with cc -fobjc-gc
+
+int GlobalAssigns;
+int IvarAssigns;
+int StrongCastAssigns;
+
+
+// The test case elements;
+@class NSObject;
+@class NSString;
+
+typedef struct {
+  id  element;
+  id elementArray[10];
+  __strong CFDictionaryRef cfElement;
+  __strong CFDictionaryRef cfElementArray[10];
+} struct_with_ids_t;
+
+@interface Foo  {
+@public
+// assignments to any/all of these fields should generate objc_assign_ivar
+  __strong CFDictionaryRef dict;
+  __strong CFDictionaryRef dictArray[3];
+  id ivar;
+  id array[10];
+  NSObject *nsobject;
+  NSString *stringArray[10];
+  struct_with_ids_t inner;
+}
+
+@end
+
+// assignments to these should generate objc_assign_global
+id GlobalId;
+id GlobalArray[20];
+NSObject *GlobalObject;
+NSObject *GlobalObjectArray[20];
+__strong CFDictionaryRef Gdict;
+__strong CFDictionaryRef Gdictarray[10];
+struct_with_ids_t GlobalStruct;
+struct_with_ids_t GlobalStructArray[10];
+
+
+// The test cases
+void *rhs = 0;
+
+#define ASSIGNTEST(expr, global) expr = rhs
+
+int testGlobals() {
+  // Everything in this function generates assign_global intercepts
+  int counter = 0;
+
+  static id staticGlobalId;
+  static id staticGlobalArray[20];
+  static NSObject *staticGlobalObject;
+  static NSObject *staticGlobalObjectArray[20];
+  static __strong CFDictionaryRef staticGdict;
+  static __strong CFDictionaryRef staticGdictarray[10];
+  static struct_with_ids_t staticGlobalStruct;
+  static struct_with_ids_t staticGlobalStructArray[10];
+
+  ASSIGNTEST(GlobalId, GlobalAssigns);				// objc_assign_global
+  ASSIGNTEST(GlobalArray[0], GlobalAssigns);			// objc_assign_global
+  ASSIGNTEST(GlobalObject, GlobalAssigns);			// objc_assign_global
+  ASSIGNTEST(GlobalObjectArray[0], GlobalAssigns);		// objc_assign_global
+  ASSIGNTEST(Gdict, GlobalAssigns);				// objc_assign_global
+  ASSIGNTEST(Gdictarray[1], GlobalAssigns);			// objc_assign_global
+
+  ASSIGNTEST(GlobalStruct.element, GlobalAssigns);		// objc_assign_global
+  ASSIGNTEST(GlobalStruct.elementArray[0], GlobalAssigns);	// objc_assign_global
+  ASSIGNTEST(GlobalStruct.cfElement, GlobalAssigns);		// objc_assign_global
+  ASSIGNTEST(GlobalStruct.cfElementArray[0], GlobalAssigns);	// objc_assign_global
+
+  ASSIGNTEST(staticGlobalId, GlobalAssigns);			// objc_assign_global
+  ASSIGNTEST(staticGlobalArray[0], GlobalAssigns);		// objc_assign_global
+  ASSIGNTEST(staticGlobalObject, GlobalAssigns);		// objc_assign_global
+  ASSIGNTEST(staticGlobalObjectArray[0], GlobalAssigns);	// objc_assign_global
+  ASSIGNTEST(staticGdict, GlobalAssigns);			// objc_assign_global
+  ASSIGNTEST(staticGdictarray[1], GlobalAssigns);		// objc_assign_global
+
+  ASSIGNTEST(staticGlobalStruct.element, GlobalAssigns);		// objc_assign_global
+  ASSIGNTEST(staticGlobalStruct.elementArray[0], GlobalAssigns);	// objc_assign_global
+  ASSIGNTEST(staticGlobalStruct.cfElement, GlobalAssigns);		// objc_assign_global
+  ASSIGNTEST(staticGlobalStruct.cfElementArray[0], GlobalAssigns);	// objc_assign_global
+
+  return counter;
+}
+
+
+int testIvars() {
+  Foo *foo;
+  int counter = 0;
+
+  ASSIGNTEST(foo->ivar, IvarAssigns);					// objc_assign_ivar
+  ASSIGNTEST(foo->dict, IvarAssigns);					// objc_assign_ivar
+  ASSIGNTEST(foo->dictArray[0], IvarAssigns);				// objc_assign_ivar
+  ASSIGNTEST(foo->array[0], IvarAssigns);				// objc_assign_ivar
+  ASSIGNTEST(foo->nsobject, IvarAssigns);				// objc_assign_ivar
+  ASSIGNTEST(foo->stringArray[0], IvarAssigns);				// objc_assign_ivar
+  ASSIGNTEST(foo->inner.element, IvarAssigns);				// objc_assign_ivar
+  ASSIGNTEST(foo->inner.elementArray[0], IvarAssigns);			// objc_assign_ivar
+  ASSIGNTEST(foo->inner.cfElement, IvarAssigns);			// objc_assign_ivar
+  ASSIGNTEST(foo->inner.cfElementArray[0], IvarAssigns);		// objc_assign_ivar
+
+  return counter;
+}
diff --git a/test/CodeGenObjC/object-incr-decr-1.m b/test/CodeGenObjC/object-incr-decr-1.m
new file mode 100644
index 000000000000..53311f7aa18c
--- /dev/null
+++ b/test/CodeGenObjC/object-incr-decr-1.m
@@ -0,0 +1,19 @@
+// RUN: clang-cc -triple i386-apple-darwin9 -fnext-runtime -emit-llvm %s -o %t
+
+@interface Foo 
+{
+	double d1,d3,d4;
+}
+@end
+
+Foo* foo()
+{
+  Foo *f;
+  
+  // Both of these crash clang nicely
+  ++f;
+  --f;
+ f--;
+ f++;
+ return f;
+}
diff --git a/test/CodeGenObjC/overloadable.m b/test/CodeGenObjC/overloadable.m
index 972dc4ed5895..7e9cc3d3b36d 100644
--- a/test/CodeGenObjC/overloadable.m
+++ b/test/CodeGenObjC/overloadable.m
@@ -4,7 +4,7 @@
 @class C;
 
 // RUN: grep _Z1fP11objc_object %t | count 1 && 
-void __attribute__((overloadable)) f(C *c) { }
+void __attribute__((overloadable)) f(id c) { }
 
 // RUN: grep _Z1fP1C %t | count 1
-void __attribute__((overloadable)) f(id c) { }
+void __attribute__((overloadable)) f(C *c) { }
diff --git a/test/CodeGenObjC/predefined-expr.m b/test/CodeGenObjC/predefined-expr.m
new file mode 100644
index 000000000000..b27bb3488a5a
--- /dev/null
+++ b/test/CodeGenObjC/predefined-expr.m
@@ -0,0 +1,90 @@
+// RUN: clang-cc -triple i386-apple-darwin9 %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: @"__func__.-[Foo instanceTest1]" = private constant [21 x i8] c"-[Foo instanceTest1]\00"
+// CHECK: @"__func__.-[Foo instanceTest2:]" = private constant [22 x i8] c"-[Foo instanceTest2:]\00"
+// CHECK: @"__func__.-[Foo instanceTest3:withB:]" = private constant [28 x i8] c"-[Foo instanceTest3:withB:]\00"
+// CHECK: @"__func__.-[Foo instanceTest4]" = private constant [21 x i8] c"-[Foo instanceTest4]\00"
+// CHECK: @"__func__.+[Foo classTest1]" = private constant [18 x i8] c"+[Foo classTest1]\00"
+// CHECK: @"__func__.+[Foo classTest2:]" = private constant [19 x i8] c"+[Foo classTest2:]\00"
+// CHECK: @"__func__.+[Foo classTest3:withB:]" = private constant [25 x i8] c"+[Foo classTest3:withB:]\00"
+// CHECK: @"__func__.+[Foo classTest4]" = private constant [18 x i8] c"+[Foo classTest4]\00"
+// CHECK: @"__func__.-[Foo(Category) instanceTestWithCategory]" = private constant [42 x i8] c"-[Foo(Category) instanceTestWithCategory]\00"
+// CHECK: @"__func__.+[Foo(Category) classTestWithCategory]" = private constant [39 x i8] c"+[Foo(Category) classTestWithCategory]\00"
+
+int printf(const char * _Format, ...);
+
+@interface Foo
+@end
+
+@implementation Foo
+
+- (void)instanceTest1 {
+  printf("__func__: %s\n", __func__);
+  printf("__FUNCTION__: %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__: %s\n\n", __PRETTY_FUNCTION__);
+}
+
+- (void)instanceTest2:(int)i {
+  printf("__func__: %s\n", __func__);
+  printf("__FUNCTION__: %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__: %s\n\n", __PRETTY_FUNCTION__);
+}
+
+- (void)instanceTest3:(int)a withB:(double)b {
+  printf("__func__: %s\n", __func__);
+  printf("__FUNCTION__: %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__: %s\n\n", __PRETTY_FUNCTION__);
+}
+
+- (int)instanceTest4 {
+  printf("__func__: %s\n", __func__);
+  printf("__FUNCTION__: %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__: %s\n\n", __PRETTY_FUNCTION__);
+  return 0;
+}
+
++ (void)classTest1 {
+  printf("__func__: %s\n", __func__);
+  printf("__FUNCTION__: %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__: %s\n\n", __PRETTY_FUNCTION__);
+}
+
++ (void)classTest2:(int)i {
+  printf("__func__: %s\n", __func__);
+  printf("__FUNCTION__: %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__: %s\n\n", __PRETTY_FUNCTION__);
+}
+
++ (void)classTest3:(int)a withB:(double)b {
+  printf("__func__: %s\n", __func__);
+  printf("__FUNCTION__: %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__: %s\n\n", __PRETTY_FUNCTION__);
+}
+
++ (int)classTest4 {
+  printf("__func__: %s\n", __func__);
+  printf("__FUNCTION__: %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__: %s\n\n", __PRETTY_FUNCTION__);
+  return 0;
+}
+
+@end
+
+@interface Foo (Category)
+@end
+
+@implementation Foo (Category)
+
+- (void)instanceTestWithCategory {
+  printf("__func__: %s\n", __func__);
+  printf("__FUNCTION__: %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__: %s\n\n", __PRETTY_FUNCTION__);
+}
+
++ (void)classTestWithCategory {
+  printf("__func__: %s\n", __func__);
+  printf("__FUNCTION__: %s\n", __FUNCTION__);
+  printf("__PRETTY_FUNCTION__: %s\n\n", __PRETTY_FUNCTION__);
+}
+
+@end
diff --git a/test/CodeGenObjC/property-agrr-getter.m b/test/CodeGenObjC/property-agrr-getter.m
index 0a1df123bffe..46205796936f 100644
--- a/test/CodeGenObjC/property-agrr-getter.m
+++ b/test/CodeGenObjC/property-agrr-getter.m
@@ -9,9 +9,30 @@ typedef struct {
 @end
 
 @implementation A
--(s0) f0{}
+-(s0) f0{ while (1) {} }
 - (unsigned) bar {
   return self.f0.f0;
 }
 @end
 
+
+typedef struct _NSSize {
+    float width;
+    float height;
+} NSSize;
+
+
+@interface AnObject
+{
+ NSSize size;
+}
+
+@property NSSize size;
+
+@end
+
+float f ()
+{
+  AnObject* obj;
+  return (obj.size).width;
+}
diff --git a/test/CodeGenObjC/property-setter-attr.m b/test/CodeGenObjC/property-setter-attr.m
index 390392415d73..5f0edf8271e7 100644
--- a/test/CodeGenObjC/property-setter-attr.m
+++ b/test/CodeGenObjC/property-setter-attr.m
@@ -1,4 +1,4 @@
-// RUN: clang-cc -emit-llvm -triple=i686-apple-darwin8 -o %t %s
+// RUN: clang-cc -emit-llvm -triple=i686-apple-darwin8 -o %t %s &&
 // RUN: grep -e "SiSetOtherThings:" %t
 
 @interface A 
diff --git a/test/CodeGenObjC/protocol-in-extended-class.m b/test/CodeGenObjC/protocol-in-extended-class.m
new file mode 100644
index 000000000000..87bda46faeaa
--- /dev/null
+++ b/test/CodeGenObjC/protocol-in-extended-class.m
@@ -0,0 +1,29 @@
+// RUN: clang-cc -triple x86_64-apple-darwin10 -S %s -o %t-64.s &&
+// RUN: FileCheck -check-prefix LP64 --input-file=%t-64.s %s &&
+// RUN: clang-cc -triple i386-apple-darwin -S %s -o %t-32.s &&
+// RUN: FileCheck -check-prefix LP32 --input-file=%t-32.s %s &&
+// RUN: true
+
+@protocol MyProtocol
+@end
+
+@protocol ExtendedProtocol
+@end
+
+@interface ItDoesntWork<MyProtocol> {
+}
+-(void) Meth;
+@end
+
+@interface ItDoesntWork() <MyProtocol, ExtendedProtocol>
+@end
+
+@implementation ItDoesntWork
+-(void) Meth {
+    ItDoesntWork <MyProtocol, ExtendedProtocol> *p = 0;
+ }
+@end
+
+// CHECK-LP64: l_OBJC_PROTOCOL_$_ExtendedProtocol:
+
+// CHECK-LP32: L_OBJC_PROTOCOL_ExtendedProtocol:
diff --git a/test/CodeGenObjC/protocols-lazy.m b/test/CodeGenObjC/protocols-lazy.m
index e91cc0aea836..a8f79026f780 100644
--- a/test/CodeGenObjC/protocols-lazy.m
+++ b/test/CodeGenObjC/protocols-lazy.m
@@ -26,7 +26,7 @@ void f1() { id x = @protocol(P3); }
 // RUN: grep OBJC_PROTOCOL_INSTANCE_METHODS_P4 %t | count 3 &&
 @protocol P4 -im1; @end
 @interface I0<P4> @end
-@implementation I0 -im1 {}; @end
+@implementation I0 -im1 { return 0; }; @end
 
 // Definition following forward reference.
 // RUN: grep OBJC_PROTOCOL_P5 %t | count 3  &&
@@ -42,7 +42,7 @@ void f2() { id x = @protocol(P5); } // This generates a forward
 // RUN: grep OBJC_PROTOCOL_INSTANCE_METHODS_P6 %t | count 3 &&
 @protocol P6 -im1; @end
 @interface I1<P6> @end
-@implementation I1 -im1 {}; @end
+@implementation I1 -im1 { return 0; }; @end
 void f3() { id x = @protocol(P6); }
 
 // RUN: true
diff --git a/test/CodeGenObjC/protocols.m b/test/CodeGenObjC/protocols.m
new file mode 100644
index 000000000000..4cfb83bf00e0
--- /dev/null
+++ b/test/CodeGenObjC/protocols.m
@@ -0,0 +1,50 @@
+// RUN: clang-cc -fnext-runtime -emit-llvm %s -o %t
+
+void p(const char*, ...);
+
+@interface Root
+-(int) conformsTo: (id) x;
+@end
+
+@protocol P0;
+
+@protocol P1
++(void) classMethodReq0;
+-(void) methodReq0;
+@optional
++(void) classMethodOpt1;
+-(void) methodOpt1;
+@required
++(void) classMethodReq2;
+-(void) methodReq2;
+@end
+
+@protocol P2
+//@property(readwrite) int x;
+@end
+
+@protocol P3<P1, P2>
+-(id <P1>) print0;
+-(void) print1;
+@end
+
+void foo(const id a) {
+  void *p = @protocol(P3);
+}
+
+int main() {
+  Protocol *P0 = @protocol(P0);
+  Protocol *P1 = @protocol(P1);
+  Protocol *P2 = @protocol(P2);
+  Protocol *P3 = @protocol(P3);
+
+#define Pbool(X) p(#X ": %s\n", X ? "yes" : "no");
+  Pbool([P0 conformsTo: P1]);
+  Pbool([P1 conformsTo: P0]);
+  Pbool([P1 conformsTo: P2]);
+  Pbool([P2 conformsTo: P1]);
+  Pbool([P3 conformsTo: P1]);
+  Pbool([P1 conformsTo: P3]);
+
+  return 0;
+}
diff --git a/test/CodeGenObjC/variadic-sends.m b/test/CodeGenObjC/variadic-sends.m
new file mode 100644
index 000000000000..8697feec5d6d
--- /dev/null
+++ b/test/CodeGenObjC/variadic-sends.m
@@ -0,0 +1,41 @@
+// RUN: clang-cc -triple i386-unknown-unknown -fnext-runtime -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-X86-32 %s &&
+// RUN: clang-cc -triple x86_64-unknown-unknown -fnext-runtime -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-X86-64 %s
+
+@interface A
+-(void) im0;
+-(void) im1: (int) x;
+-(void) im2: (int) x, ...;
+@end
+
+void f0(A *a) {
+  // CHECK-X86-32: call void bitcast (i8* (i8*, %struct.objc_selector*, ...)* @objc_msgSend to void (i8*, %struct.objc_selector*)*)
+  // CHECK-X86-64: call void bitcast (i8* (i8*, %struct.objc_selector*, ...)* @objc_msgSend to void (i8*, %struct.objc_selector*)*)
+  [a im0];
+}
+
+void f1(A *a) {
+  // CHECK-X86-32: call void bitcast (i8* (i8*, %struct.objc_selector*, ...)* @objc_msgSend to void (i8*, %struct.objc_selector*, i32)*)
+  // CHECK-X86-64: call void bitcast (i8* (i8*, %struct.objc_selector*, ...)* @objc_msgSend to void (i8*, %struct.objc_selector*, i32)*)
+  [a im1: 1];
+}
+
+void f2(A *a) {
+  // CHECK-X86-32: call void (i8*, %struct.objc_selector*, i32, i32, ...)* bitcast (i8* (i8*, %struct.objc_selector*, ...)* @objc_msgSend to void (i8*, %struct.objc_selector*, i32, i32, ...)*)
+  // CHECK-X86-64: call void (i8*, %struct.objc_selector*, i32, i32, ...)* bitcast (i8* (i8*, %struct.objc_selector*, ...)* @objc_msgSend to void (i8*, %struct.objc_selector*, i32, i32, ...)*)
+  [a im2: 1, 2];
+}
+
+@interface B : A @end
+@implementation B : A
+-(void) foo {
+  // CHECK-X86-32: call void bitcast (i8* (%struct._objc_super*, %struct.objc_selector*, ...)* @objc_msgSendSuper to void (%struct._objc_super*, %struct.objc_selector*, i32)*)
+  // CHECK-X86-64: call void bitcast (i8* (%struct._objc_super*, %struct.objc_selector*, ...)* @objc_msgSendSuper to void (%struct._objc_super*, %struct.objc_selector*, i32)*)
+  [super im1: 1];
+}
+-(void) bar {
+  // CHECK-X86-32: call void (%struct._objc_super*, %struct.objc_selector*, i32, i32, ...)* bitcast (i8* (%struct._objc_super*, %struct.objc_selector*, ...)* @objc_msgSendSuper to void (%struct._objc_super*, %struct.objc_selector*, i32, i32, ...)*)
+  // CHECK-X86-64: call void (%struct._objc_super*, %struct.objc_selector*, i32, i32, ...)* bitcast (i8* (%struct._objc_super*, %struct.objc_selector*, ...)* @objc_msgSendSuper to void (%struct._objc_super*, %struct.objc_selector*, i32, i32, ...)*)
+  [super im2: 1, 2];
+}
+
+@end
diff --git a/test/Coverage/targets.c b/test/Coverage/targets.c
index 5a547a53add9..5a87b4dcc554 100644
--- a/test/Coverage/targets.c
+++ b/test/Coverage/targets.c
@@ -1,18 +1,19 @@
-// RUN: clang-cc -g -triple i686-unknown-unknown -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple armv6-apple-darwin9 -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple armv6-unknown-unknown -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple bfin-unknown-unknown -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple i686-apple-darwin9 -emit-llvm -o %t %s &&
 // RUN: clang-cc -g -triple i686-pc-linux-gnu -emit-llvm -o %t %s &&
 // RUN: clang-cc -g -triple i686-unknown-dragonfly -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple i686-unknown-unknown -emit-llvm -o %t %s &&
 // RUN: clang-cc -g -triple i686-unknown-win32 -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple i686-apple-darwin9 -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple x86_64-unknown-unknown -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple x86_64-pc-linux-gnu -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple x86_64-apple-darwin9 -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple ppc-unknown-unknown -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple ppc-apple-darwin9 -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple ppc64-unknown-unknown -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple ppc64-apple-darwin9 -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple armv6-unknown-unknown -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple armv6-apple-darwin9 -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple sparc-unknown-unknown -emit-llvm -o %t %s &&
-// RUN: clang-cc -g -triple sparc-unknown-solaris -emit-llvm -o %t %s &&
 // RUN: clang-cc -g -triple pic16-unknown-unknown -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple powerpc-apple-darwin9 -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple powerpc-unknown-unknown -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple powerpc64-apple-darwin9 -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple powerpc64-unknown-unknown -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple sparc-unknown-solaris -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple sparc-unknown-unknown -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple x86_64-apple-darwin9 -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple x86_64-pc-linux-gnu -emit-llvm -o %t %s &&
+// RUN: clang-cc -g -triple x86_64-unknown-unknown -emit-llvm -o %t %s &&
 // RUN: true
diff --git a/test/Driver/arm-darwin-builtin.c b/test/Driver/arm-darwin-builtin.c
new file mode 100644
index 000000000000..5da8074ee3a7
--- /dev/null
+++ b/test/Driver/arm-darwin-builtin.c
@@ -0,0 +1,14 @@
+// FIXME: Disable pending PR4941.
+// RUX: clang -ccc-host-triple x86_64-apple-darwin9 -arch arm -### -fsyntax-only %s 2> %t &&
+// RUX: grep -- "-fno-builtin-strcat" %t &&
+// RUX: grep -- "-fno-builtin-strcpy" %t &&
+
+// FIXME: Disable pending PR4941.
+// RUX: clang -ccc-host-triple x86_64-apple-darwin9 -arch arm -### -fsyntax-only %s -fbuiltin-strcat -fbuiltin-strcpy 2> %t &&
+// RUX: not grep -- "-fno-builtin-strcat" %t &&
+// RUX: not grep -- "-fno-builtin-strcpy" %t &&
+
+// RUN: clang -ccc-no-clang -ccc-host-triple x86_64-apple-darwin9 -arch arm -### -fsyntax-only %s -fbuiltin-strcat -fbuiltin-strcpy 2> %t &&
+// RUN: not grep -- "-fno-builtin-strcat" %t &&
+// RUN: not grep -- "-fno-builtin-strcpy" %t
+
diff --git a/test/Driver/ast.c b/test/Driver/ast.c
new file mode 100644
index 000000000000..814b597bb19f
--- /dev/null
+++ b/test/Driver/ast.c
@@ -0,0 +1,26 @@
+// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-phases -emit-ast %s 2> %t &&
+// RUN: echo 'END' >> %t &&
+// RUN: FileCheck -check-prefix EMIT-AST-PHASES -input-file %t %s &&
+
+// EMIT-AST-PHASES: 0: input,
+// EMIT-AST-PHASES: , c
+// EMIT-AST-PHASES: 1: preprocessor, {0}, cpp-output
+// EMIT-AST-PHASES: 2: compiler, {1}, ast
+// EMIT-AST-PHASES-NOT: 3:
+// EMIT-AST-PHASES: END
+
+// RUN: touch %t.ast &&
+// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-phases -c %t.ast 2> %t &&
+// RUN: echo 'END' >> %t &&
+// RUN: FileCheck -check-prefix COMPILE-AST-PHASES -input-file %t %s
+
+// COMPILE-AST-PHASES: 0: input,
+// COMPILE-AST-PHASES: , ast
+// COMPILE-AST-PHASES: 1: compiler, {0}, assembler
+// COMPILE-AST-PHASES: 2: assembler, {1}, object
+// COMPILE-AST-PHASES-NOT: 3:
+// COMPILE-AST-PHASES: END
+
+// FIXME: There is a problem with compiling AST's in that the input language is
+// not availabe for use by other tools (for example, to automatically add
+// -lstdc++). We may need -x [objective-]c++-ast and all that goodness. :(
diff --git a/test/Driver/bindings.c b/test/Driver/bindings.c
index 3cac22c94be3..393739006bb7 100644
--- a/test/Driver/bindings.c
+++ b/test/Driver/bindings.c
@@ -30,7 +30,7 @@
 // RUN: grep '"clang", inputs: \[".*bindings.c"\], output: (nothing)' %t &&
 // RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-bindings -ccc-no-clang -fsyntax-only %s 2> %t &&
 // RUN: grep '"gcc::Compile", inputs: \[".*bindings.c"\], output: (nothing)' %t &&
-// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-bindings -fsyntax-only -x c++ %s 2> %t &&
+// RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-bindings -ccc-no-clang-cxx -fsyntax-only -x c++ %s 2> %t &&
 // RUN: grep '"gcc::Compile", inputs: \[".*bindings.c"\], output: (nothing)' %t &&
 // RUN: clang -ccc-host-triple i386-unknown-unknown -ccc-print-bindings -ccc-clang-cxx -fsyntax-only -x c++ %s 2> %t &&
 // RUN: grep '"clang", inputs: \[".*bindings.c"\], output: (nothing)' %t &&
@@ -39,12 +39,12 @@
 // RUN: grep '"clang", inputs: \[".*\.i"\], output: (nothing)' %t &&
 // RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-bindings -ccc-clang-archs i386 %s -S -arch ppc 2> %t &&
 // RUN: grep '"gcc::Compile", inputs: \[".*bindings.c"\], output: "bindings.s"' %t &&
-// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-bindings -ccc-clang-archs ppc %s -S -arch ppc 2> %t &&
+// RUN: clang -ccc-host-triple i386-apple-darwin9 -ccc-print-bindings -ccc-clang-archs powerpc %s -S -arch ppc 2> %t &&
 // RUN: grep '"clang", inputs: \[".*bindings.c"\], output: "bindings.s"' %t &&
 
 // RUN: clang -ccc-host-triple powerpc-unknown-unknown -ccc-print-bindings -ccc-clang-archs "" %s -S 2> %t &&
 // RUN: grep '"clang", inputs: \[".*bindings.c"\], output: "bindings.s"' %t &&
-// RUN: clang -ccc-host-triple powerpc-unknown-unknown -ccc-print-bindings %s -S 2> %t &&
+// RUN: clang -ccc-host-triple powerpc-unknown-unknown -ccc-print-bindings -ccc-clang-archs "i386" %s -S 2> %t &&
 // RUN: grep '"gcc::Compile", inputs: \[".*bindings.c"\], output: "bindings.s"' %t &&
 
 // Darwin bindings
diff --git a/test/Driver/clang-translation.c b/test/Driver/clang-translation.c
index ca60a8d8c6bc..e0b9e3ada6ec 100644
--- a/test/Driver/clang-translation.c
+++ b/test/Driver/clang-translation.c
@@ -1,4 +1,4 @@
-// RUN: clang -ccc-host-triple i386-unknown-unknown -### -S -O0 -Os %s -o %t.s -fverbose-asm 2> %t.log
+// RUN: clang -ccc-host-triple i386-unknown-unknown -### -S -O0 -Os %s -o %t.s -fverbose-asm 2> %t.log &&
 // RUN: grep '"-triple" "i386-unknown-unknown"' %t.log &&
 // RUN: grep '"-S"' %t.log &&
 // RUN: grep '"-disable-free"' %t.log &&
@@ -7,10 +7,10 @@
 // RUN: grep '"--unwind-tables=0"' %t.log &&
 // RUN: grep '"--fmath-errno=1"' %t.log &&
 // RUN: grep '"-Os"' %t.log &&
-// RUN: grep '"-o" .*clang-translation\.c\.out\.tmp\.s' %t.log &&
+// RUN: grep '"-o" .*clang-translation.*' %t.log &&
 // RUN: grep '"--asm-verbose"' %t.log &&
-// RUN: clang -ccc-host-triple i386-apple-darwin9 -### -S %s -o %t.s 2> %t.log
+// RUN: clang -ccc-host-triple i386-apple-darwin9 -### -S %s -o %t.s 2> %t.log &&
 // RUN: grep '"--mcpu=yonah"' %t.log &&
-// RUN: clang -ccc-host-triple x86_64-apple-darwin9 -### -S %s -o %t.s 2> %t.log
+// RUN: clang -ccc-host-triple x86_64-apple-darwin9 -### -S %s -o %t.s 2> %t.log &&
 // RUN: grep '"--mcpu=core2"' %t.log &&
 // RUN: true
diff --git a/test/Driver/darwin-arm.c b/test/Driver/darwin-arm.c
new file mode 100644
index 000000000000..8b4c23d55724
--- /dev/null
+++ b/test/Driver/darwin-arm.c
@@ -0,0 +1,4 @@
+// RUN: clang -ccc-host-triple i386-apple-darwin9 -arch arm -print-search-dirs | FileCheck %s
+
+// Check that we look in the relative libexec directory.
+// CHECK: {{programs: =.*/../libexec:}}
diff --git a/test/Driver/darwin-as.c b/test/Driver/darwin-as.c
new file mode 100644
index 000000000000..486dc2e79810
--- /dev/null
+++ b/test/Driver/darwin-as.c
@@ -0,0 +1,10 @@
+// RUN: clang -ccc-host-triple i386-apple-darwin10 -### -x assembler -c %s -static -dynamic 2>%t &&
+// RUN: FileCheck -check-prefix=STATIC_AND_DYNAMIC-32 --input-file %t %s &&
+
+// CHECK-STATIC_AND_DYNAMIC-32: as{{(.exe)?}}" "-arch" "i386" "-force_cpusubtype_ALL" "-static" "-o"
+
+// RUN: clang -ccc-host-triple x86_64-apple-darwin10 -### -x assembler -c %s -static 2>%t &&
+// RUN: FileCheck -check-prefix=STATIC-64 --input-file %t %s
+
+// CHECK-STATIC-64: as{{(.exe)?}}" "-arch" "x86_64" "-force_cpusubtype_ALL" "-o"
+
diff --git a/test/Driver/darwin-cc.c b/test/Driver/darwin-cc.c
index ac5d9a922d50..77193cda4441 100644
--- a/test/Driver/darwin-cc.c
+++ b/test/Driver/darwin-cc.c
@@ -1,4 +1,3 @@
-// RUN: unset MACOSX_DEPLOYMENT_TARGET &&
 // RUN: clang -ccc-no-clang -ccc-host-triple i386-apple-darwin10 -m32 -### -MD -g -fast -Q -dA -mkernel -ansi -aFOO -S -o /tmp/OUTPUTNAME -g0 -gfull -O2 -Werror -pedantic -Wmost -w -std=c99 -trigraphs -v -pg -fFOO -undef -Qn --param a=b -fmudflap -coverage -save-temps -nostdinc -I ARG0 -F ARG1 -I ARG2 -P -MF ARG3 -MG -MP -remap -g3 -H -D ARG4 -U ARG5 -A ARG6 -D ARG7 -U ARG8 -A ARG9 -include ARG10 -pthread %s 2> %t.log &&
 // RUN: grep ' ".*cc1" "-E" "-nostdinc" "-v" "-I" "ARG0" "-F" "ARG1" "-I" "ARG2" "-P" "-MD" "/tmp/OUTPUTNAME.d" "-MF" "ARG3" "-MG" "-MP" "-MQ" "/tmp/OUTPUTNAME" "-remap" "-dD" "-H" "-D__STATIC__" "-D_REENTRANT" "-D" "ARG4" "-U" "ARG5" "-A" "ARG6" "-D" "ARG7" "-U" "ARG8" "-A" "ARG9" "-include" "ARG10" ".*darwin-cc.c" "-D_MUDFLAP" "-include" "mf-runtime.h" "-mmacosx-version-min=10.6.0" "-m32" "-mkernel" "-mtune=core2" "-ansi" "-std=c99" "-trigraphs" "-Werror" "-pedantic" "-Wmost" "-w" "-fast" "-fno-eliminate-unused-debug-symbols" "-fFOO" "-fmudflap" "-O2" "-undef" "-fpch-preprocess" "-o" ".*darwin-cc.i"' %t.log &&
 // RUN: grep ' ".*cc1" "-fpreprocessed" ".*darwin-cc.i" "-O3" "-dumpbase" ".*darwin-cc.c" "-dA" "-mmacosx-version-min=10.6.0" "-m32" "-mkernel" "-mtune=core2" "-ansi" "-aFOO" "-auxbase-strip" "/tmp/OUTPUTNAME" "-g" "-g0" "-g" "-g3" "-O2" "-Werror" "-pedantic" "-Wmost" "-w" "-ansi" "-std=c99" "-trigraphs" "-version" "-p" "-fast" "-fno-eliminate-unused-debug-symbols" "-fFOO" "-fmudflap" "-undef" "-fno-ident" "-o" "/tmp/OUTPUTNAME" "--param" "a=b" "-fno-builtin" "-fno-merge-constants" "-fprofile-arcs" "-ftest-coverage"' %t.log &&
diff --git a/test/Driver/darwin-ld.c b/test/Driver/darwin-ld.c
index 2e6fc57bac59..d81605bbe93d 100644
--- a/test/Driver/darwin-ld.c
+++ b/test/Driver/darwin-ld.c
@@ -1,8 +1,7 @@
 // Check that ld gets arch_multiple.
 
-// RUN: unset MACOSX_DEPLOYMENT_TARGET &&
 // RUN: clang -ccc-host-triple i386-apple-darwin9 -arch i386 -arch x86_64 %s -### -o foo 2> %t.log &&
-// RUN: grep '".*ld" .*"-arch_multiple" "-final_output" "foo"' %t.log &&
+// RUN: grep '".*ld.*" .*"-arch_multiple" "-final_output" "foo"' %t.log &&
 
 // RUN: clang -ccc-host-triple i386-apple-darwin9 -### -filelist FOO -static 2> %t.log &&
 // RUN: grep '"-lcrt0.o" .*"-lgcc_static"' %t.log &&
@@ -33,8 +32,8 @@
 //
 // Note that at conception, this exactly matches gcc.
 
-// RUN: clang -ccc-host-triple i386-apple-darwin9 -### -A ARG0 -F ARG1 -L ARG2 -Mach -T ARG4 -X -Z -all_load -allowable_client ARG8 -bind_at_load -compatibility_version ARG11 -current_version ARG12 -d -dead_strip -dylib_file ARG14 -dylinker -dylinker_install_name ARG16 -dynamic -dynamiclib -e ARG19 -exported_symbols_list ARG20 -fexceptions -flat_namespace -fnested-functions -fopenmp -force_cpusubtype_ALL -fpie -fprofile-arcs -headerpad_max_install_names -image_base ARG29 -init ARG30 -install_name ARG31 -m ARG33 -miphoneos-version-min=2.0 -mmacosx-version-min=10.3.2 -multi_module -multiply_defined ARG37 -multiply_defined_unused ARG38 -no_dead_strip_inits_and_terms -nodefaultlibs -nofixprebinding -nomultidefs -noprebind -noseglinkedit -nostartfiles -nostdlib -object -pagezero_size ARG54 -pg -prebind -prebind_all_twolevel_modules -preload -r -read_only_relocs ARG55 -s -sectalign ARG57_0 ARG57_1 ARG57_2 -sectcreate ARG58_0 ARG58_1 ARG58_2 -sectobjectsymbols ARG59_0 ARG59_1 -sectorder ARG60_0 ARG60_1 ARG60_2 -seg1addr ARG61 -seg_addr_table ARG62 -seg_addr_table_filename ARG63 -segaddr ARG64_0 ARG64_1 -segcreate ARG65_0 ARG65_1 ARG65_2 -seglinkedit -segprot ARG67_0 ARG67_1 ARG67_2 -segs_read_FOO -segs_read_only_addr ARG69 -segs_read_write_addr ARG70 -shared-libgcc -single_module -static -static-libgcc -sub_library ARG77 -sub_umbrella ARG78 -t -twolevel_namespace -twolevel_namespace_hints -u ARG82 -umbrella ARG83 -undefined ARG84 -unexported_symbols_list ARG85 -w -weak_reference_mismatches ARG87 -whatsloaded -whyload -y -filelist FOO 2> %t.log &&
-// RUN: grep '".*ld" "-static" "-dylib" "-dylib_compatibility_version" "ARG11" "-dylib_current_version" "ARG12" "-arch" "i386" "-dylib_install_name" "ARG31" "-all_load" "-allowable_client" "ARG8" "-bind_at_load" "-dead_strip" "-no_dead_strip_inits_and_terms" "-dylib_file" "ARG14" "-dynamic" "-exported_symbols_list" "ARG20" "-flat_namespace" "-headerpad_max_install_names" "-image_base" "ARG29" "-init" "ARG30" "-macosx_version_min" "10.3.2" "-iphoneos_version_min" "2.0" "-nomultidefs" "-multi_module" "-single_module" "-multiply_defined" "ARG37" "-multiply_defined_unused" "ARG38" "-pie" "-prebind" "-noprebind" "-nofixprebinding" "-prebind_all_twolevel_modules" "-read_only_relocs" "ARG55" "-sectcreate" "ARG58_0" "ARG58_1" "ARG58_2" "-sectorder" "ARG60_0" "ARG60_1" "ARG60_2" "-seg1addr" "ARG61" "-segprot" "ARG67_0" "ARG67_1" "ARG67_2" "-segaddr" "ARG64_0" "ARG64_1" "-segs_read_only_addr" "ARG69" "-segs_read_write_addr" "ARG70" "-seg_addr_table" "ARG62" "-seg_addr_table_filename" "ARG63" "-sub_library" "ARG77" "-sub_umbrella" "ARG78" "-twolevel_namespace" "-twolevel_namespace_hints" "-umbrella" "ARG83" "-undefined" "ARG84" "-unexported_symbols_list" "ARG85" "-weak_reference_mismatches" "ARG87" "-X" "-y" "-w" "-pagezero_size" "ARG54" "-segs_read_FOO" "-seglinkedit" "-noseglinkedit" "-sectalign" "ARG57_0" "ARG57_1" "ARG57_2" "-sectobjectsymbols" "ARG59_0" "ARG59_1" "-segcreate" "ARG65_0" "ARG65_1" "ARG65_2" "-whyload" "-whatsloaded" "-dylinker_install_name" "ARG16" "-dylinker" "-Mach" "-d" "-s" "-t" "-Z" "-u" "ARG82" "-undefined" "ARG84" "-A" "ARG0" "-e" "ARG19" "-m" "ARG33" "-r" "-object" "-o" "a.out" "-L" "ARG2" "-lgomp" "-L/usr/lib/i686-apple-darwin9/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin9/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin9/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin9/4.2.1/../../../i686-apple-darwin9/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin9/4.2.1/../../.." "-filelist" "FOO" "-lgcov" "-allow_stack_execute" "-T" "ARG4" "-F" "ARG1"' %t.log &&
+// RUN: clang -ccc-host-triple i386-apple-darwin9 -### -A ARG0 -F ARG1 -L ARG2 -Mach -T ARG4 -X -Z -all_load -allowable_client ARG8 -bind_at_load -compatibility_version ARG11 -current_version ARG12 -d -dead_strip -dylib_file ARG14 -dylinker -dylinker_install_name ARG16 -dynamic -dynamiclib -e ARG19 -exported_symbols_list ARG20 -fexceptions -flat_namespace -fnested-functions -fopenmp -force_cpusubtype_ALL -fpie -fprofile-arcs -headerpad_max_install_names -image_base ARG29 -init ARG30 -install_name ARG31 -m ARG33 -miphoneos-version-min=2.0 -mmacosx-version-min=10.3.2 -multi_module -multiply_defined ARG37 -multiply_defined_unused ARG38 -no_dead_strip_inits_and_terms -nodefaultlibs -nofixprebinding -nomultidefs -noprebind -noseglinkedit -nostartfiles -nostdlib -pagezero_size ARG54 -pg -prebind -prebind_all_twolevel_modules -preload -r -read_only_relocs ARG55 -s -sectalign ARG57_0 ARG57_1 ARG57_2 -sectcreate ARG58_0 ARG58_1 ARG58_2 -sectobjectsymbols ARG59_0 ARG59_1 -sectorder ARG60_0 ARG60_1 ARG60_2 -seg1addr ARG61 -seg_addr_table ARG62 -seg_addr_table_filename ARG63 -segaddr ARG64_0 ARG64_1 -segcreate ARG65_0 ARG65_1 ARG65_2 -seglinkedit -segprot ARG67_0 ARG67_1 ARG67_2 -segs_read_FOO -segs_read_only_addr ARG69 -segs_read_write_addr ARG70 -shared-libgcc -single_module -static -static-libgcc -sub_library ARG77 -sub_umbrella ARG78 -t -twolevel_namespace -twolevel_namespace_hints -u ARG82 -umbrella ARG83 -undefined ARG84 -unexported_symbols_list ARG85 -w -weak_reference_mismatches ARG87 -whatsloaded -whyload -y -filelist FOO 2> %t.log &&
+// RUN: grep '".*ld.*" "-static" "-dylib" "-dylib_compatibility_version" "ARG11" "-dylib_current_version" "ARG12" "-arch" "i386" "-dylib_install_name" "ARG31" "-all_load" "-allowable_client" "ARG8" "-bind_at_load" "-dead_strip" "-no_dead_strip_inits_and_terms" "-dylib_file" "ARG14" "-dynamic" "-exported_symbols_list" "ARG20" "-flat_namespace" "-headerpad_max_install_names" "-image_base" "ARG29" "-init" "ARG30" "-macosx_version_min" "10.3.2" "-iphoneos_version_min" "2.0" "-nomultidefs" "-multi_module" "-single_module" "-multiply_defined" "ARG37" "-multiply_defined_unused" "ARG38" "-pie" "-prebind" "-noprebind" "-nofixprebinding" "-prebind_all_twolevel_modules" "-read_only_relocs" "ARG55" "-sectcreate" "ARG58_0" "ARG58_1" "ARG58_2" "-sectorder" "ARG60_0" "ARG60_1" "ARG60_2" "-seg1addr" "ARG61" "-segprot" "ARG67_0" "ARG67_1" "ARG67_2" "-segaddr" "ARG64_0" "ARG64_1" "-segs_read_only_addr" "ARG69" "-segs_read_write_addr" "ARG70" "-seg_addr_table" "ARG62" "-seg_addr_table_filename" "ARG63" "-sub_library" "ARG77" "-sub_umbrella" "ARG78" "-twolevel_namespace" "-twolevel_namespace_hints" "-umbrella" "ARG83" "-undefined" "ARG84" "-unexported_symbols_list" "ARG85" "-weak_reference_mismatches" "ARG87" "-X" "-y" "-w" "-pagezero_size" "ARG54" "-segs_read_FOO" "-seglinkedit" "-noseglinkedit" "-sectalign" "ARG57_0" "ARG57_1" "ARG57_2" "-sectobjectsymbols" "ARG59_0" "ARG59_1" "-segcreate" "ARG65_0" "ARG65_1" "ARG65_2" "-whyload" "-whatsloaded" "-dylinker_install_name" "ARG16" "-dylinker" "-Mach" "-d" "-s" "-t" "-Z" "-u" "ARG82" "-undefined" "ARG84" "-A" "ARG0" "-e" "ARG19" "-m" "ARG33" "-r" "-o" "a.out" "-L" "ARG2" "-lgomp" "-L/usr/lib/i686-apple-darwin9/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin9/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin9/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin9/4.2.1/../../../i686-apple-darwin9/4.2.1" "-L/usr/lib/gcc/i686-apple-darwin9/4.2.1/../../.." "-filelist" "FOO" "-lgcov" "-allow_stack_execute" "-T" "ARG4" "-F" "ARG1"' %t.log &&
 
 // Don't run dsymutil on a fat build of an executable.
 // RUN: clang -ccc-host-triple i386-apple-darwin9 -### -arch i386 -arch x86_64 -g %s 2> %t.log &&
diff --git a/test/Driver/default-toolchain.c b/test/Driver/default-toolchain.c
index 216394fe97d9..0e8a02679e8d 100644
--- a/test/Driver/default-toolchain.c
+++ b/test/Driver/default-toolchain.c
@@ -1,8 +1,8 @@
-// RUN: clang -ccc-host-triple i386-unknown-unknown -m64 -v 2> %t
+// RUN: clang -ccc-host-triple i386-unknown-unknown -m64 -v 2> %t &&
 // RUN: grep 'Target: x86_64-unknown-unknown' %t &&
 
-// RUN: clang -ccc-host-triple i386-apple-darwin9 -arch ppc -m64 -v 2> %t
+// RUN: clang -ccc-host-triple i386-apple-darwin9 -arch ppc -m64 -v 2> %t &&
 // RUN: grep 'Target: powerpc64-apple-darwin9' %t &&
 
-// RUN: clang -ccc-host-triple i386-apple-darwin9 -arch ppc64 -m32 -v 2> %t
+// RUN: clang -ccc-host-triple i386-apple-darwin9 -arch ppc64 -m32 -v 2> %t &&
 // RUN: grep 'Target: powerpc-apple-darwin9' %t
diff --git a/test/Driver/dragonfly.c b/test/Driver/dragonfly.c
index 5d7b0b0f0045..f0b09f7e239f 100644
--- a/test/Driver/dragonfly.c
+++ b/test/Driver/dragonfly.c
@@ -1,6 +1,8 @@
 // RUN: clang -ccc-host-triple amd64-pc-dragonfly %s -### 2> %t.log &&
-// RUN: grep 'clang-cc" "-triple" "x86_64-pc-dragonfly"' %t.log &&
-// RUN: grep 'as" "-o" ".*\.o" ".*\.s' %t.log &&
-// RUN: grep 'ld" "-dynamic-linker" ".*ld-elf.*" "-o" "a\.out" ".*crt1.o" ".*crti.o" "crtbegin.o" ".*\.o" "-L.*/gcc.*" .* "-lc" "-lgcc" ".*crtend.o" ".*crtn.o"' %t.log &&
-// RUN: true
+// RUN: FileCheck -input-file %t.log %s
+
+// CHECK: clang-cc{{.*}}" "-triple" "amd64-pc-dragonfly"
+// CHECK: as{{.*}}" "-o" "{{.*}}.o" "{{.*}}.s
+// CHECK: ld{{.*}}" "-dynamic-linker" "{{.*}}ld-elf.{{.*}}" "-o" "a.out" "{{.*}}crt1.o" "{{.*}}crti.o" "{{.*}}crtbegin.o" "{{.*}}.o" "-L{{.*}}/gcc{{.*}}" {{.*}} "-lc" "-lgcc" "{{.*}}crtend.o" "{{.*}}crtn.o"
+
 
diff --git a/test/Driver/freebsd.c b/test/Driver/freebsd.c
index 91258d9e5728..d50c85b749de 100644
--- a/test/Driver/freebsd.c
+++ b/test/Driver/freebsd.c
@@ -1,7 +1,7 @@
-// RUN: clang -ccc-clang-archs "" -ccc-host-triple ppc64-pc-freebsd8 %s -### 2> %t.log &&
+// RUN: clang -ccc-clang-archs "" -ccc-host-triple powerpc64-pc-freebsd8 %s -### 2> %t.log &&
 // RUN: cat %t.log &&
-// RUN: grep 'clang-cc" "-triple" "powerpc64-pc-freebsd8"' %t.log &&
-// RUN: grep 'as" "-o" ".*\.o" ".*\.s' %t.log &&
-// RUN: grep 'ld" "--eh-frame-hdr" "-dynamic-linker" ".*ld-elf.*" "-o" "a\.out" ".*crt1.o" ".*crti.o" "crtbegin.o" ".*\.o" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" ".*crtend.o" ".*crtn.o"' %t.log &&
-// RUN: true
+// RUN: FileCheck -input-file %t.log %s
 
+// CHECK: clang-cc{{.*}}" "-triple" "powerpc64-pc-freebsd8"
+// CHECK: as{{.*}}" "-o" "{{.*}}.o" "{{.*}}.s
+// CHECK: ld{{.*}}" "--eh-frame-hdr" "-dynamic-linker" "{{.*}}ld-elf{{.*}}" "-o" "a.out" "{{.*}}crt1.o" "{{.*}}crti.o" "{{.*}}crtbegin.o" "{{.*}}.o" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "-lc" "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed" "{{.*}}crtend.o" "{{.*}}crtn.o"
diff --git a/test/Driver/openbsd.c b/test/Driver/openbsd.c
index fd0d4fa21cd9..c73ef20d8045 100644
--- a/test/Driver/openbsd.c
+++ b/test/Driver/openbsd.c
@@ -1,6 +1,6 @@
 // RUN: clang -ccc-clang-archs "" -ccc-host-triple i686-pc-openbsd %s -### 2> %t.log &&
-// RUN: grep 'clang-cc" "-triple" "i386-pc-openbsd"' %t.log &&
-// RUN: grep 'as" "-o" ".*\.o" ".*\.s' %t.log &&
-// RUN: grep 'ld" "--eh-frame-hdr" "-dynamic-linker" ".*ld.so" "-o" "a\.out" ".*crt0.o" ".*crtbegin.o" ".*\.o" "-lc" ".*crtend.o"' %t.log &&
-// RUN: true
+// RUN: FileCheck -input-file %t.log %s
 
+// CHECK: clang-cc{{.*}}" "-triple" "i686-pc-openbsd"
+// CHECK: as{{.*}}" "-o" "{{.*}}.o" "{{.*}}.s
+// CHECK: ld{{.*}}" "-e" "__start" "--eh-frame-hdr" "-Bdynamic" "-dynamic-linker" "{{.*}}ld.so" "-o" "a.out" "{{.*}}crt0.o" "{{.*}}crtbegin.o" "{{.*}}.o" "-lgcc" "-lc" "-lgcc" "{{.*}}crtend.o"
diff --git a/test/Driver/pth.c b/test/Driver/pth.c
index 748053809a7c..5c83aea54ceb 100644
--- a/test/Driver/pth.c
+++ b/test/Driver/pth.c
@@ -1,8 +1,12 @@
 // Test transparent PTH support.
 
 // RUN: clang -ccc-pch-is-pth -x c-header %s -o %t.h.pth -### 2> %t.log &&
-// RUN: grep '".*/clang-cc" .* "-o" ".*\.h\.pth" "-x" "c-header" ".*pth\.c"' %t.log &&
+// RUN: FileCheck -check-prefix CHECK1 -input-file %t.log %s &&
+
+// CHECK1: "{{.*}}/clang-cc{{.*}}" {{.*}} "-o" "{{.*}}.h.pth" "-x" "c-header" "{{.*}}pth.c"
 
 // RUN: touch %t.h.pth &&
 // RUN: clang -ccc-pch-is-pth -E -include %t.h %s -### 2> %t.log &&
-// RUN: grep '".*/clang-cc" .*"-include-pth" ".*\.h\.pth" .*"-x" "c" ".*pth\.c"' %t.log
+// RUN: FileCheck -check-prefix CHECK2 -input-file %t.log %s
+
+// CHECK2: "{{.*}}/clang-cc{{.*}}" {{.*}}"-include-pth" "{{.*}}.h.pth" {{.*}}"-x" "c" "{{.*}}pth.c"
diff --git a/test/Driver/qa_override.c b/test/Driver/qa_override.c
index 0ff578c2a814..46e150c74fdc 100644
--- a/test/Driver/qa_override.c
+++ b/test/Driver/qa_override.c
@@ -1,4 +1,5 @@
-// RUN: env QA_OVERRIDE_GCC3_OPTIONS="+-Os +-Oz +-O +-O3 +-Oignore +a +b +c xb Xa Omagic ^-ccc-print-options  " clang x -O2 b -O3 2> %t &&
+// RUN: env QA_OVERRIDE_GCC3_OPTIONS="#+-Os +-Oz +-O +-O3 +-Oignore +a +b +c xb Xa Omagic ^-ccc-print-options  " clang x -O2 b -O3 2> %t &&
+// RUN: grep '### ' %t | count 0 &&
 // RUN: grep -F 'Option 0 - Name: "<input>", Values: {"x"}' %t &&
 // RUN: grep -F 'Option 1 - Name: "-O", Values: {"ignore"}' %t &&
 // RUN: grep -F 'Option 2 - Name: "-O", Values: {"magic"}' %t &&
diff --git a/test/Driver/redzone.c b/test/Driver/redzone.c
index 8709e71fb366..64729ac27717 100644
--- a/test/Driver/redzone.c
+++ b/test/Driver/redzone.c
@@ -1,6 +1,6 @@
-// RUN: clang -mno-red-zone %s -S -emit-llvm -o %t.log &&
-// RUN: grep 'noredzone' %t.log 
-// RUN: clang -mred-zone %s -S -emit-llvm -o %t.log &&
+// RUN: clang -ccc-host-triple i386-unknown-unknown -mno-red-zone %s -S -emit-llvm -o %t.log &&
+// RUN: grep 'noredzone' %t.log &&
+// RUN: clang -ccc-host-triple i386-unknown-unknown -mred-zone %s -S -emit-llvm -o %t.log &&
 // RUN: grep -v 'noredzone' %t.log 
 
 int foo() { return 42; }
diff --git a/test/Frontend/ast-codegen.c b/test/Frontend/ast-codegen.c
new file mode 100644
index 000000000000..1fe74d4fbeb4
--- /dev/null
+++ b/test/Frontend/ast-codegen.c
@@ -0,0 +1,12 @@
+// RUN: clang -emit-ast -o %t.ast %s &&
+// RUN: clang -emit-llvm -S -o - %t.ast | FileCheck %s
+
+// CHECK: module asm "foo"
+__asm__("foo");
+
+// CHECK: @g0 = common global i32 0, align 4
+int g0;
+
+// CHECK: define i32 @f0()
+int f0() {
+}
diff --git a/test/Frontend/ast-main.c b/test/Frontend/ast-main.c
new file mode 100644
index 000000000000..783140673899
--- /dev/null
+++ b/test/Frontend/ast-main.c
@@ -0,0 +1,8 @@
+// RUN: clang -emit-llvm -S -o %t1.ll -x c - < %s &&
+// RUN: clang -emit-ast -o %t.ast %s &&
+// RUN: clang -emit-llvm -S -o %t2.ll -x ast - < %t.ast &&
+// RUN: diff %t1.ll %t2.ll
+
+int main() {
+  return 0;
+}
diff --git a/test/Frontend/dependency-gen.c b/test/Frontend/dependency-gen.c
index 456ce947f091..4a1611aecff0 100644
--- a/test/Frontend/dependency-gen.c
+++ b/test/Frontend/dependency-gen.c
@@ -1,6 +1,6 @@
 // rdar://6533411
 // RUN: clang -MD -MF %t.d -c -x c -o %t.o /dev/null && 
-// RUN: grep '.*dependency-gen.c.out.tmp.o:' %t.d &&
+// RUN: grep '.*dependency-gen.*:' %t.d &&
 // RUN: grep '/dev/null' %t.d &&
 
 // RUN: clang -M -x c /dev/null -o %t.deps &&
diff --git a/test/Frontend/stdin.c b/test/Frontend/stdin.c
index 35fe45d35b40..5b719b2e1344 100644
--- a/test/Frontend/stdin.c
+++ b/test/Frontend/stdin.c
@@ -1,3 +1,3 @@
-// RUN: clang-cc -E - < /dev/null > %t
+// RUN: clang-cc -E - < /dev/null > %t &&
 // RUN: grep '<built-in>' %t
  
diff --git a/test/Index/c-index-api-test.m b/test/Index/c-index-api-test.m
new file mode 100644
index 000000000000..20d4d7b45afd
--- /dev/null
+++ b/test/Index/c-index-api-test.m
@@ -0,0 +1,224 @@
+// RUN: clang-cc -triple x86_64-apple-darwin10 -emit-pch -x objective-c %s -o %t.ast &&
+// RUN: c-index-test %t.ast all | FileCheck %s
+
+// CHECK: <invalid loc>:0:0: TypedefDecl=__int128_t:0:0 [Context=c-index-api-test.m]
+// CHECK: <invalid loc>:0:0: TypedefDecl=__uint128_t:0:0 [Context=c-index-api-test.m]
+// CHECK: <invalid loc>:0:0: StructDecl=objc_selector:0:0 [Context=c-index-api-test.m]
+// CHECK: <invalid loc>:0:0: TypedefDecl=SEL:0:0 [Context=c-index-api-test.m]
+// CHECK: <invalid loc>:0:0: ObjCInterfaceDecl=Protocol:0:0 [Context=c-index-api-test.m]
+// CHECK: <invalid loc>:0:0: TypedefDecl=id:0:0 [Context=c-index-api-test.m]
+// CHECK: <invalid loc>:0:0: TypedefDecl=Class:0:0 [Context=c-index-api-test.m]
+// CHECK: <built-in>:79:16: StructDecl=__va_list_tag:79:16 [Context=c-index-api-test.m]
+// CHECK: <built-in>:79:42: FieldDecl=gp_offset:79:42 [Context=__va_list_tag]
+// CHECK: <built-in>:79:63: FieldDecl=fp_offset:79:63 [Context=__va_list_tag]
+// CHECK: <built-in>:79:81: FieldDecl=overflow_arg_area:79:81 [Context=__va_list_tag]
+// CHECK: <built-in>:79:107: FieldDecl=reg_save_area:79:107 [Context=__va_list_tag]
+// CHECK: <built-in>:79:123: TypedefDecl=__va_list_tag:79:123 [Context=c-index-api-test.m]
+// CHECK: <built-in>:79:159: TypedefDecl=__builtin_va_list:79:159 [Context=c-index-api-test.m]
+// 
+
+@interface Foo 
+{
+}
+
+- foo;
++ fooC;
+
+@end
+
+@interface Bar : Foo 
+{
+}
+
+@end
+
+@interface Foo (FooCat)
+- (int) catMethodWithFloat:(float) fArg;
+- (float) floatMethod;
+@end
+
+@protocol Proto
+- pMethod;
+@end
+
+@protocol SubP <Proto>
+- spMethod;
+@end
+
+@interface Baz : Bar <SubP>
+{
+    int _anIVar;
+}
+
+- (Foo *) bazMethod;
+
+@end
+
+enum {
+  someEnum
+};
+
+// CHECK: c-index-api-test.m:20:12: ObjCInterfaceDecl=Foo:20:1 [Context=c-index-api-test.m]
+// CHECK: c-index-api-test.m:24:1: ObjCInstanceMethodDecl=foo:24:1 [Context=Foo]
+// CHECK: c-index-api-test.m:25:1: ObjCClassMethodDecl=fooC:25:1 [Context=Foo]
+// CHECK: c-index-api-test.m:29:12: ObjCInterfaceDecl=Bar:29:1 [Context=c-index-api-test.m]
+// CHECK: c-index-api-test.m:29:18: ObjCSuperClassRef=Foo:29:1 [Context=Bar]
+// CHECK: c-index-api-test.m:35:1: ObjCCategoryDecl=FooCat:35:1 [Context=c-index-api-test.m]
+// CHECK: c-index-api-test.m:20:1: ObjCClassRef=Foo:35:1 [Context=FooCat]
+// CHECK: c-index-api-test.m:36:1: ObjCInstanceMethodDecl=catMethodWithFloat::36:1 [Context=FooCat]
+// CHECK: c-index-api-test.m:37:1: ObjCInstanceMethodDecl=floatMethod:37:1 [Context=FooCat]
+// CHECK: c-index-api-test.m:40:1: ObjCProtocolDecl=Proto:40:1 [Context=c-index-api-test.m]
+// CHECK: c-index-api-test.m:41:1: ObjCInstanceMethodDecl=pMethod:41:1 [Context=Proto]
+// CHECK: c-index-api-test.m:44:1: ObjCProtocolDecl=SubP:44:1 [Context=c-index-api-test.m]
+// CHECK: c-index-api-test.m:40:1: ObjCProtocolRef=Proto:40:1 [Context=SubP]
+// CHECK: c-index-api-test.m:45:1: ObjCInstanceMethodDecl=spMethod:45:1 [Context=SubP]
+// CHECK: c-index-api-test.m:48:12: ObjCInterfaceDecl=Baz:48:1 [Context=c-index-api-test.m]
+// CHECK: c-index-api-test.m:48:18: ObjCSuperClassRef=Bar:48:1 [Context=Baz]
+// CHECK: c-index-api-test.m:44:1: ObjCProtocolRef=SubP:44:1 [Context=Baz]
+// CHECK: c-index-api-test.m:50:9: ObjCIvarDecl=_anIVar:50:9 [Context=Baz]
+// CHECK: c-index-api-test.m:53:1: ObjCInstanceMethodDecl=bazMethod:53:1 [Context=Baz]
+// CHECK: c-index-api-test.m:57:1: EnumDecl=:57:1 [Context=c-index-api-test.m]
+// CHECK: c-index-api-test.m:58:3: EnumConstantDecl=someEnum:58:3 [Context=]
+
+int main (int argc, const char * argv[]) {
+	Baz * bee;
+	id a = [bee foo];
+	id <SubP> c = [Foo fooC];
+	id <Proto> d;
+	d = c;
+	[d pMethod];
+	[bee catMethodWithFloat:[bee floatMethod]];
+  main(someEnum, (const char **)bee);
+}
+
+// CHECK: c-index-api-test.m:83:5: FunctionDefn=main [Context=c-index-api-test.m]
+// CHECK: c-index-api-test.m:83:15: ParmDecl=argc:83:15 [Context=main]
+// CHECK: c-index-api-test.m:83:34: ParmDecl=argv:83:34 [Context=main]
+// CHECK: c-index-api-test.m:84:8: VarDecl=bee:84:8 [Context=main]
+// CHECK: c-index-api-test.m:85:5: VarDecl=a:85:5 [Context=main]
+// CHECK: c-index-api-test.m:86:12: VarDecl=c:86:12 [Context=main]
+// CHECK: c-index-api-test.m:87:13: VarDecl=d:87:13 [Context=main]
+// CHECK: c-index-api-test.m:84:2: ObjCClassRef=Baz:84:8 [Context:Baz]
+// CHECK: c-index-api-test.m:84:3: ObjCClassRef=Baz:84:8 [Context:Baz]
+// CHECK: c-index-api-test.m:84:4: ObjCClassRef=Baz:84:8 [Context:Baz]
+// CHECK: c-index-api-test.m:84:6: VarDecl=bee:84:8 [Context:bee]
+// CHECK: c-index-api-test.m:84:8: VarDecl=bee:84:8 [Context:bee]
+// CHECK: c-index-api-test.m:84:9: VarDecl=bee:84:8 [Context:bee]
+// CHECK: c-index-api-test.m:84:10: VarDecl=bee:84:8 [Context:bee]
+// CHECK: <invalid loc>:85:2: TypedefDecl=id:0:0 [Context:id]
+// CHECK: <invalid loc>:85:3: TypedefDecl=id:0:0 [Context:id]
+// CHECK: c-index-api-test.m:85:5: VarDecl=a:85:5 [Context:a]
+// CHECK: c-index-api-test.m:85:6: VarDecl=a:85:5 [Context:a]
+// CHECK: c-index-api-test.m:85:7: VarDecl=a:85:5 [Context:a]
+// CHECK: c-index-api-test.m:85:8: VarDecl=a:85:5 [Context:a]
+// CHECK: c-index-api-test.m:85:9: ObjCSelectorRef=foo:24:1 [Context:a]
+// CHECK: c-index-api-test.m:85:10: VarRef=bee:84:8 [Context:a]
+// CHECK: c-index-api-test.m:85:11: VarRef=bee:84:8 [Context:a]
+// CHECK: c-index-api-test.m:85:12: VarRef=bee:84:8 [Context:a]
+// CHECK: c-index-api-test.m:85:13: ObjCSelectorRef=foo:24:1 [Context:a]
+// CHECK: c-index-api-test.m:85:14: ObjCSelectorRef=foo:24:1 [Context:a]
+// CHECK: c-index-api-test.m:85:15: ObjCSelectorRef=foo:24:1 [Context:a]
+// CHECK: c-index-api-test.m:85:16: ObjCSelectorRef=foo:24:1 [Context:a]
+// CHECK: c-index-api-test.m:85:17: ObjCSelectorRef=foo:24:1 [Context:a]
+// CHECK: <invalid loc>:86:2: TypedefDecl=id:0:0 [Context:id]
+// CHECK: <invalid loc>:86:3: TypedefDecl=id:0:0 [Context:id]
+// CHECK: c-index-api-test.m:86:5: VarDecl=c:86:12 [Context:c]
+// CHECK: c-index-api-test.m:86:6: ObjCProtocolRef=SubP:86:12 [Context:SubP]
+// CHECK: c-index-api-test.m:86:7: ObjCProtocolRef=SubP:86:12 [Context:SubP]
+// CHECK: c-index-api-test.m:86:8: ObjCProtocolRef=SubP:86:12 [Context:SubP]
+// CHECK: c-index-api-test.m:86:9: ObjCProtocolRef=SubP:86:12 [Context:SubP]
+// CHECK: c-index-api-test.m:86:10: VarDecl=c:86:12 [Context:c]
+// CHECK: c-index-api-test.m:86:12: VarDecl=c:86:12 [Context:c]
+// CHECK: c-index-api-test.m:86:13: VarDecl=c:86:12 [Context:c]
+// CHECK: c-index-api-test.m:86:14: VarDecl=c:86:12 [Context:c]
+// CHECK: c-index-api-test.m:86:15: VarDecl=c:86:12 [Context:c]
+// CHECK: c-index-api-test.m:86:16: ObjCSelectorRef=fooC:25:1 [Context:c]
+// CHECK: c-index-api-test.m:86:17: ObjCSelectorRef=fooC:25:1 [Context:c]
+// CHECK: c-index-api-test.m:86:18: ObjCSelectorRef=fooC:25:1 [Context:c]
+// CHECK: c-index-api-test.m:86:19: ObjCSelectorRef=fooC:25:1 [Context:c]
+// CHECK: c-index-api-test.m:86:20: ObjCSelectorRef=fooC:25:1 [Context:c]
+// CHECK: c-index-api-test.m:86:21: ObjCSelectorRef=fooC:25:1 [Context:c]
+// CHECK: c-index-api-test.m:86:22: ObjCSelectorRef=fooC:25:1 [Context:c]
+// CHECK: c-index-api-test.m:86:23: ObjCSelectorRef=fooC:25:1 [Context:c]
+// CHECK: c-index-api-test.m:86:24: ObjCSelectorRef=fooC:25:1 [Context:c]
+// CHECK: c-index-api-test.m:86:25: ObjCSelectorRef=fooC:25:1 [Context:c]
+// CHECK: <invalid loc>:87:2: TypedefDecl=id:0:0 [Context:id]
+// CHECK: <invalid loc>:87:3: TypedefDecl=id:0:0 [Context:id]
+// CHECK: c-index-api-test.m:87:5: VarDecl=d:87:13 [Context:d]
+// CHECK: c-index-api-test.m:87:6: ObjCProtocolRef=Proto:87:13 [Context:Proto]
+// CHECK: c-index-api-test.m:87:7: ObjCProtocolRef=Proto:87:13 [Context:Proto]
+// CHECK: c-index-api-test.m:87:8: ObjCProtocolRef=Proto:87:13 [Context:Proto]
+// CHECK: c-index-api-test.m:87:9: ObjCProtocolRef=Proto:87:13 [Context:Proto]
+// CHECK: c-index-api-test.m:87:10: ObjCProtocolRef=Proto:87:13 [Context:Proto]
+// CHECK: c-index-api-test.m:87:11: VarDecl=d:87:13 [Context:d]
+// CHECK: c-index-api-test.m:87:13: VarDecl=d:87:13 [Context:d]
+// CHECK: c-index-api-test.m:88:2: VarRef=d:87:13 [Context:main]
+// CHECK: c-index-api-test.m:88:6: VarRef=c:86:12 [Context:main]
+// CHECK: c-index-api-test.m:89:2: ObjCSelectorRef=pMethod:41:1 [Context:main]
+// CHECK: c-index-api-test.m:89:3: VarRef=d:87:13 [Context:main]
+// CHECK: c-index-api-test.m:89:4: ObjCSelectorRef=pMethod:41:1 [Context:main]
+// CHECK: c-index-api-test.m:89:5: ObjCSelectorRef=pMethod:41:1 [Context:main]
+// CHECK: c-index-api-test.m:89:6: ObjCSelectorRef=pMethod:41:1 [Context:main]
+// CHECK: c-index-api-test.m:89:7: ObjCSelectorRef=pMethod:41:1 [Context:main]
+// CHECK: c-index-api-test.m:89:8: ObjCSelectorRef=pMethod:41:1 [Context:main]
+// CHECK: c-index-api-test.m:89:9: ObjCSelectorRef=pMethod:41:1 [Context:main]
+// CHECK: c-index-api-test.m:89:10: ObjCSelectorRef=pMethod:41:1 [Context:main]
+// CHECK: c-index-api-test.m:89:11: ObjCSelectorRef=pMethod:41:1 [Context:main]
+// CHECK: c-index-api-test.m:89:12: ObjCSelectorRef=pMethod:41:1 [Context:main]
+// CHECK: c-index-api-test.m:90:2: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:3: VarRef=bee:84:8 [Context:main]
+// CHECK: c-index-api-test.m:90:4: VarRef=bee:84:8 [Context:main]
+// CHECK: c-index-api-test.m:90:5: VarRef=bee:84:8 [Context:main]
+// CHECK: c-index-api-test.m:90:6: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:7: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:8: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:9: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:10: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:11: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:12: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:13: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:14: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:15: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:16: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:17: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:18: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:19: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:20: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:21: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:22: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:23: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:24: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:25: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:90:26: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:27: VarRef=bee:84:8 [Context:main]
+// CHECK: c-index-api-test.m:90:28: VarRef=bee:84:8 [Context:main]
+// CHECK: c-index-api-test.m:90:29: VarRef=bee:84:8 [Context:main]
+// CHECK: c-index-api-test.m:90:30: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:31: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:32: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:33: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:34: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:35: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:36: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:37: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:38: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:39: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:40: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:41: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:42: ObjCSelectorRef=floatMethod:37:1 [Context:main]
+// CHECK: c-index-api-test.m:90:43: ObjCSelectorRef=catMethodWithFloat::36:1 [Context:main]
+// CHECK: c-index-api-test.m:91:3: FunctionRef=main:83:5 [Context:main]
+// CHECK: c-index-api-test.m:91:4: FunctionRef=main:83:5 [Context:main]
+// CHECK: c-index-api-test.m:91:5: FunctionRef=main:83:5 [Context:main]
+// CHECK: c-index-api-test.m:91:6: FunctionRef=main:83:5 [Context:main]
+// CHECK: c-index-api-test.m:91:8: EnumConstantRef=someEnum:58:3 [Context:main]
+// CHECK: c-index-api-test.m:91:9: EnumConstantRef=someEnum:58:3 [Context:main]
+// CHECK: c-index-api-test.m:91:10: EnumConstantRef=someEnum:58:3 [Context:main]
+// CHECK: c-index-api-test.m:91:11: EnumConstantRef=someEnum:58:3 [Context:main]
+// CHECK: c-index-api-test.m:91:12: EnumConstantRef=someEnum:58:3 [Context:main]
+// CHECK: c-index-api-test.m:91:13: EnumConstantRef=someEnum:58:3 [Context:main]
+// CHECK: c-index-api-test.m:91:14: EnumConstantRef=someEnum:58:3 [Context:main]
+// CHECK: c-index-api-test.m:91:15: EnumConstantRef=someEnum:58:3 [Context:main]
+// CHECK: c-index-api-test.m:91:33: VarRef=bee:84:8 [Context:main]
+// CHECK: c-index-api-test.m:91:34: VarRef=bee:84:8 [Context:main]
+// CHECK: c-index-api-test.m:91:35: VarRef=bee:84:8 [Context:main]
diff --git a/test/Index/comments.c b/test/Index/comments.c
index 7ad8fd7e1f49..689ce88e2213 100644
--- a/test/Index/comments.c
+++ b/test/Index/comments.c
@@ -1,15 +1,4 @@
-// RUN: clang-cc -emit-pch -o %t.ast %s &&
-// RUN: index-test %t.ast -point-at %s:22:6 | grep "starts here" &&
-// RUN: index-test %t.ast -point-at %s:22:6 | grep "block comment" &&
-// RUN: index-test %t.ast -point-at %s:28:6 | grep "BCPL" &&
-// RUN: index-test %t.ast -point-at %s:28:6 | grep "But" &&
-// RUN: index-test %t.ast -point-at %s:28:6 | grep "NOT" | count 0 &&
-// RUN: index-test %t.ast -point-at %s:30:6 | grep "member"
-
-
-
-
-
+// Run lines are sensitive to line numbers and come below the code.
 
 //! It all starts here.
 /*! It's a little odd to continue line this,
@@ -27,4 +16,19 @@ void f(int, int);
 /** But there are other blocks that are part of the comment, too. */
 void g(int);
 
-void h(int); ///< This is a member comment.
\ No newline at end of file
+void h(int); ///< This is a member comment.
+
+
+// RUN: clang-cc -emit-pch -o %t.ast %s &&
+
+// RUN: index-test %t.ast -point-at %s:11:6 > %t &&
+// RUN: grep "starts here" %t &&
+// RUN: grep "block comment" %t &&
+
+// RUN: index-test %t.ast -point-at %s:17:6 > %t &&
+// RUN: grep "BCPL" %t &&
+// RUN: grep "But" %t &&
+
+// RUN: index-test %t.ast -point-at %s:19:6 > %t &&
+// RUN: grep "NOT" %t | count 0 &&
+// RUN: grep "member" %t
diff --git a/test/Index/cxx-operator-overload.cpp b/test/Index/cxx-operator-overload.cpp
new file mode 100644
index 000000000000..9bda03ef8dc4
--- /dev/null
+++ b/test/Index/cxx-operator-overload.cpp
@@ -0,0 +1,28 @@
+// Run lines are sensitive to line numbers and come below the code.
+// FIXME: re-enable this when we can serialize more C++ ASTs
+class Cls {
+public:
+    Cls operator +(const Cls &RHS);
+};
+
+static void bar() {
+    Cls x1, x2, x3;
+    Cls x4 = x1 + x2 + x3;
+}
+
+Cls Cls::operator +(const Cls &RHS) { while (1) {} }
+
+// RUN: clang-cc -emit-pch %s -o %t.ast
+
+// RUNx: index-test %t.ast -point-at %s:10:17 -print-decls > %t &&
+// RUNx: cat %t | count 2 &&
+// RUNx: grep ':5:9,' %t &&
+// RUNx: grep ':13:10,' %t &&
+
+// Yep, we can show references of '+' plus signs that are overloaded, w00t!
+// RUNx: index-test %t.ast -point-at %s:5:15 -print-refs > %t &&
+// RUNx: cat %t | count 2 &&
+// RUNx: grep ':10:17,' %t &&
+// RUNx: grep ':10:22,' %t &&
+
+// RUNx: index-test %t.ast -point-at %s:10:14 | grep 'DeclRefExpr x1'
diff --git a/test/Index/find-decls.c b/test/Index/find-decls.c
new file mode 100644
index 000000000000..50a233d75ba5
--- /dev/null
+++ b/test/Index/find-decls.c
@@ -0,0 +1,25 @@
+// RUN: clang-cc -fblocks -emit-pch %S/t1.c -o %t1.ast &&
+// RUN: clang-cc -fblocks -emit-pch %S/t2.c -o %t2.ast &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/t1.c:8:7 -print-decls > %t &&
+// RUN: cat %t | count 3 &&
+// RUN: grep 'foo.h:4:6,' %t | count 2 && 
+// RUN: grep 't2.c:5:6,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/t1.c:5:47 -print-decls > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't1.c:5:12,' %t && 
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/t1.c:6:20 -print-decls > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't1.c:3:19,' %t &&
+
+// field test
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/t1.c:21:6 -print-decls > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't1.c:12:7,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/t1.c:22:21 -print-decls > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't1.c:16:7,' %t
diff --git a/test/Index/find-defs.c b/test/Index/find-defs.c
new file mode 100644
index 000000000000..0e63ae760047
--- /dev/null
+++ b/test/Index/find-defs.c
@@ -0,0 +1,18 @@
+// RUN: clang-cc -fblocks -emit-pch %S/t1.c -o %t1.ast &&
+// RUN: clang-cc -fblocks -emit-pch %S/t2.c -o %t2.ast &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/foo.h:1:14 -print-defs > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't2.c:3:5,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/foo.h:3:9 -print-defs > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't1.c:3:6,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/foo.h:4:9 -print-defs > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't2.c:5:6,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/t1.c:8:7 -print-defs > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't2.c:5:6,' %t
diff --git a/test/Index/find-refs.c b/test/Index/find-refs.c
new file mode 100644
index 000000000000..1b58b3752773
--- /dev/null
+++ b/test/Index/find-refs.c
@@ -0,0 +1,47 @@
+// RUN: clang-cc -fblocks -emit-pch %S/t1.c -o %t1.ast &&
+// RUN: clang-cc -fblocks -emit-pch %S/t2.c -o %t2.ast &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/foo.h:1:14 -print-refs > %t &&
+// RUN: cat %t | count 4 &&
+// RUN: grep 't1.c:4:19,' %t &&
+// RUN: grep 't1.c:28:40,' %t &&
+// RUN: grep 't2.c:6:3,' %t &&
+// RUN: grep 't2.c:7:12,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/foo.h:3:9 -print-refs > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't2.c:7:3,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/foo.h:4:9 -print-refs > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't1.c:8:3,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/t1.c:3:22 -print-refs > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't1.c:6:17,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/t1.c:4:11 -print-refs > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't1.c:6:5,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/t1.c:5:30 -print-refs > %t &&
+// RUN: cat %t | count 3 &&
+// RUN: grep 't1.c:5:27,' %t &&
+// RUN: grep 't1.c:5:44,' %t &&
+// RUN: grep 't1.c:6:26,' %t &&
+
+// field test
+
+// FIXME: References point at the start of MemberExpr, make them point at the field instead.
+// RUN: index-test %t1.ast %t2.ast -point-at %S/t1.c:12:7 -print-refs > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't1.c:21:3,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/t1.c:16:7 -print-refs > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't1.c:22:3,' %t &&
+
+// RUN: index-test %t1.ast %t2.ast -point-at %S/foo.h:7:11 -print-refs > %t &&
+// RUN: cat %t | count 2 &&
+// RUN: grep 't1.c:25:3,' %t &&
+// RUN: grep 't2.c:10:3,' %t
diff --git a/test/Index/foo.h b/test/Index/foo.h
new file mode 100644
index 000000000000..7670c00dfbfe
--- /dev/null
+++ b/test/Index/foo.h
@@ -0,0 +1,8 @@
+extern int global_var;
+
+void foo_func(int param1);
+void bar_func(void);
+
+struct MyStruct {
+  int field_var;
+};
diff --git a/test/Index/multiple-redecls.c b/test/Index/multiple-redecls.c
new file mode 100644
index 000000000000..6f1f75b02f39
--- /dev/null
+++ b/test/Index/multiple-redecls.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc -emit-pch %s -o %t.ast &&
+// RUN: index-test %t.ast -point-at %s:8:4 -print-decls | count 2 &&
+// RUN: index-test %t.ast -point-at %s:8:4 -print-defs | count 1
+
+static void foo(int x);
+
+static void bar(void) {
+  foo(10);
+}
+
+void foo(int x) { 
+}
diff --git a/test/Index/objc-decls.m b/test/Index/objc-decls.m
new file mode 100644
index 000000000000..1a8ab4b5577e
--- /dev/null
+++ b/test/Index/objc-decls.m
@@ -0,0 +1,16 @@
+// RUN: clang-cc -emit-pch %S/t1.m -o %t1.m.ast &&
+// RUN: clang-cc -emit-pch %S/t2.m -o %t2.m.ast &&
+
+// RUN: index-test %t1.m.ast %t2.m.ast -point-at %S/t1.m:12:12 -print-decls > %t &&
+// RUN: cat %t | count 2 &&
+// RUN: grep 'objc.h:2:9,' %t | count 2 && 
+
+// RUN: index-test %t1.m.ast %t2.m.ast -point-at %S/objc.h:5:13 -print-decls > %t &&
+// RUN: cat %t | count 3 &&
+// RUN: grep 'objc.h:5:1,' %t | count 2 &&
+// RUN: grep 't1.m:15:1,' %t | count 1 &&
+
+// RUN: index-test %t1.m.ast %t2.m.ast -point-at %S/objc.h:10:13 -print-decls > %t &&
+// RUN: cat %t | count 3 &&
+// RUN: grep 'objc.h:10:1,' %t | count 2 &&
+// RUN: grep 't2.m:11:1,' %t | count 1
diff --git a/test/Index/objc-message.m b/test/Index/objc-message.m
new file mode 100644
index 000000000000..45ce83876cfe
--- /dev/null
+++ b/test/Index/objc-message.m
@@ -0,0 +1,38 @@
+// RUN: clang-cc -emit-pch %S/t1.m -o %t1.m.ast &&
+// RUN: clang-cc -emit-pch %S/t2.m -o %t2.m.ast &&
+
+// RUN: index-test %t1.m.ast %t2.m.ast -point-at %S/objc.h:5:13 -print-refs > %t &&
+// RUN: cat %t | count 1 &&
+// RUN: grep 't1.m:6:3,' %t &&
+
+// RUN: index-test %t1.m.ast %t2.m.ast -point-at %S/objc.h:6:13 -print-refs > %t &&
+// RUN: cat %t | count 2 &&
+// RUN: grep 't1.m:7:3,' %t &&
+// RUN: grep 't2.m:7:3,' %t &&
+
+// RUN: index-test %t1.m.ast %t2.m.ast -point-at %S/objc.h:10:13 -print-refs > %t &&
+// RUN: cat %t | count 2 &&
+// RUN: grep 't1.m:6:3,' %t &&
+// RUN: grep 't2.m:6:3,' %t &&
+
+// RUN: index-test %t1.m.ast %t2.m.ast -point-at %S/t1.m:6:15 -print-decls > %t &&
+// RUN: cat %t | count 6 &&
+// RUN: grep 'objc.h:5:1,' %t | count 2 &&
+// RUN: grep 'objc.h:10:1,' %t | count 2 &&
+// RUN: grep 't1.m:15:1,' %t &&
+// RUN: grep 't2.m:11:1,' %t &&
+
+// RUN: index-test %t1.m.ast %t2.m.ast -point-at %S/t1.m:7:15 -print-decls > %t &&
+// RUN: cat %t | count 3 &&
+// RUN: grep 'objc.h:6:1,' %t | count 2 &&
+// RUN: grep 't1.m:18:1,' %t &&
+
+// RUN: index-test %t2.m.ast %t1.m.ast -point-at %S/t2.m:6:15 -print-decls > %t &&
+// RUN: cat %t | count 3 &&
+// RUN: grep 'objc.h:10:1,' %t | count 2 &&
+// RUN: grep 't2.m:11:1,' %t &&
+
+// RUN: index-test %t2.m.ast %t1.m.ast -point-at %S/t2.m:7:15 -print-decls > %t &&
+// RUN: cat %t | count 3 &&
+// RUN: grep 'objc.h:6:1,' %t | count 2 &&
+// RUN: grep 't1.m:18:1,' %t
diff --git a/test/Index/objc.h b/test/Index/objc.h
new file mode 100644
index 000000000000..c671addde59f
--- /dev/null
+++ b/test/Index/objc.h
@@ -0,0 +1,11 @@
+@interface Base {
+    int my_var;
+}
+-(int) my_var;
+-(void) my_method: (int)param;
++(void) my_method: (int)param;
+@end
+
+@interface Sub : Base
+-(void) my_method: (int)param;
+@end
diff --git a/test/Index/resolve-loc.c b/test/Index/resolve-loc.c
index d04b79b024ed..cae86f38dd6d 100644
--- a/test/Index/resolve-loc.c
+++ b/test/Index/resolve-loc.c
@@ -1,16 +1,4 @@
-// RUN: clang-cc -emit-pch %s -o %t.ast &&
-// RUN: index-test %t.ast -point-at %s:15:8 | grep top_var &&
-// RUN: index-test %t.ast -point-at %s:17:15 | grep top_func_decl &&
-// RUN: index-test %t.ast -point-at %s:17:25 | grep param1 &&
-// RUN: index-test %t.ast -point-at %s:19:17 | grep top_func_def &&
-// RUN: index-test %t.ast -point-at %s:19:23 | grep param2 &&
-// RUN: index-test %t.ast -point-at %s:20:10 | grep local_var1 &&
-// RUN: index-test %t.ast -point-at %s:21:15 | grep for_var &&
-// RUN: index-test %t.ast -point-at %s:21:43 | grep top_func_def &&
-// RUN: index-test %t.ast -point-at %s:21:43 | grep '++for_var' &&
-// RUN: index-test %t.ast -point-at %s:22:9 | grep local_var2 &&
-// RUN: index-test %t.ast -point-at %s:22:30 | grep local_var2 &&
-// RUN: index-test %t.ast -point-at %s:22:30 | grep 'for_var + 1'
+// Run lines are sensitive to line numbers and come below the code.
 
 int top_var;
 
@@ -22,3 +10,28 @@ void top_func_def(int param2) {
     int local_var2 = for_var + 1;
   }
 }
+
+struct S {
+  int field_var;
+};
+
+
+// RUN: clang-cc -emit-pch %s -o %t.ast &&
+// RUN: index-test %t.ast -point-at %s:3:8 | grep top_var &&
+// RUN: index-test %t.ast -point-at %s:5:15 | grep top_func_decl &&
+// RUN: index-test %t.ast -point-at %s:5:25 | grep param1 &&
+// RUN: index-test %t.ast -point-at %s:7:17 | grep top_func_def &&
+// RUN: index-test %t.ast -point-at %s:7:23 | grep param2 &&
+// RUN: index-test %t.ast -point-at %s:8:10 | grep local_var1 &&
+// RUN: index-test %t.ast -point-at %s:9:15 | grep for_var &&
+
+// RUN: index-test %t.ast -point-at %s:9:43 > %t &&
+// RUN: grep '++for_var' %t &&
+
+// RUN: index-test %t.ast -point-at %s:10:9 | grep local_var2 &&
+
+// RUN: index-test %t.ast -point-at %s:10:30 > %t &&
+// RUN: grep 'for_var + 1' %t &&
+
+// fields test.
+// RUN: index-test %t.ast -point-at %s:15:10 | grep field_var
diff --git a/test/Index/t1.c b/test/Index/t1.c
new file mode 100644
index 000000000000..45e04881244d
--- /dev/null
+++ b/test/Index/t1.c
@@ -0,0 +1,31 @@
+#include "foo.h"
+
+void foo_func(int param1) {
+  int local_var = global_var;
+  for (int for_var = 100; for_var < 500; ++for_var) {
+    local_var = param1 + for_var;
+  }
+  bar_func();
+}
+
+struct S1 {
+  int x;
+};
+
+struct S2 {
+  int x;
+};
+
+void field_test(void) {
+  struct S1 s1;
+  s1.x = 0;
+  ((struct S2 *)0)->x = 0;
+  
+  struct MyStruct ms;
+  ms.field_var = 10;
+}
+
+int (^CP)(int) = ^(int x) { return x * global_var; };
+
+// Suppress 'no run line' failure.
+// RUN: true
diff --git a/test/Index/t1.m b/test/Index/t1.m
new file mode 100644
index 000000000000..b2a7a3726d20
--- /dev/null
+++ b/test/Index/t1.m
@@ -0,0 +1,23 @@
+#include "objc.h"
+
+static void foo() {
+  Base *base;
+  int x = [base my_var];
+  [base my_method:x];
+  [Base my_method:x];
+}
+
+@implementation Base
+-(int) my_var {
+  return my_var;
+}
+
+-(void) my_method: (int)param {
+}
+
++(void) my_method: (int)param {
+}
+@end
+
+// Suppress 'no run line' failure.
+// RUN: true
diff --git a/test/Index/t2.c b/test/Index/t2.c
new file mode 100644
index 000000000000..bf52869ec8d9
--- /dev/null
+++ b/test/Index/t2.c
@@ -0,0 +1,14 @@
+#include "foo.h"
+
+int global_var = 10;
+
+void bar_func(void) {
+  global_var += 100;
+  foo_func(global_var);
+
+  struct MyStruct *ms;
+  ms->field_var = 10;
+}
+
+// Suppress 'no run line' failure.
+// RUN: true
diff --git a/test/Index/t2.m b/test/Index/t2.m
new file mode 100644
index 000000000000..00d2f1d92b05
--- /dev/null
+++ b/test/Index/t2.m
@@ -0,0 +1,16 @@
+#include "objc.h"
+
+static void foo() {
+  Sub *sub;
+  int x = [sub my_var];
+  [sub my_method:x];
+  [Sub my_method:x];
+}
+
+@implementation Sub
+-(void) my_method: (int)param {
+}
+@end
+
+// Suppress 'no run line' failure.
+// RUN: true
diff --git a/test/Lexer/11-27-2007-FloatLiterals.c b/test/Lexer/11-27-2007-FloatLiterals.c
index f3ea7cbaf9f4..ab3aba1a6eaf 100644
--- a/test/Lexer/11-27-2007-FloatLiterals.c
+++ b/test/Lexer/11-27-2007-FloatLiterals.c
@@ -1,5 +1,9 @@
-// RUN: clang-cc %s -emit-llvm -o - | grep 0x3BFD83C940000000 | count 2 &&
-// RUN: clang-cc %s -emit-llvm -o - | grep 2.000000e+32 | count 2
+// RUN: clang-cc %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: 0x3BFD83C940000000
+// CHECK: 2.000000e+{{[0]*}}32
+// CHECK: 0x3BFD83C940000000
+// CHECK: 2.000000e+{{[0]*}}32
 
 float  F  = 1e-19f;
 double D  = 2e32;
diff --git a/test/Lexer/comment-escape.c b/test/Lexer/comment-escape.c
index c568cd611f1b..c46145715843 100644
--- a/test/Lexer/comment-escape.c
+++ b/test/Lexer/comment-escape.c
@@ -2,5 +2,5 @@
 // rdar://6757323
 // foo \
 
-#define	blork 32
+#define blork 32
 
diff --git a/test/Lexer/dollar-idents.c b/test/Lexer/dollar-idents.c
index 7635ea112eb7..f5c33b1f4368 100644
--- a/test/Lexer/dollar-idents.c
+++ b/test/Lexer/dollar-idents.c
@@ -1,5 +1,5 @@
 // RUN: clang-cc -dump-tokens %s 2> %t &&
-// RUN: grep "identifier '\$A'" %t
+// RUN: grep "identifier '\$A'" %t &&
 // RUN: clang-cc -dump-tokens -x assembler-with-cpp %s 2> %t &&
 // RUN: grep "identifier 'A'" %t
 // PR3808
diff --git a/test/Makefile b/test/Makefile
index 271f46fdd6dc..8543d431442b 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -2,7 +2,14 @@ LEVEL = ../../..
 include $(LEVEL)/Makefile.common
 
 # Test in all immediate subdirectories if unset.
-TESTDIRS ?= $(shell echo $(PROJ_SRC_DIR)/*/)
+ifdef TESTSUITE
+TESTDIRS := $(TESTSUITE:%=$(PROJ_SRC_DIR)/%)
+else
+TESTDIRS ?= $(PROJ_SRC_DIR)
+endif
+
+# 'lit' wants objdir paths, so it will pick up the lit.site.cfg.
+TESTDIRS := $(TESTDIRS:$(PROJ_SRC_DIR)%=$(PROJ_OBJ_DIR)%)
 
 ifndef TESTARGS
 ifdef VERBOSE
@@ -12,9 +19,28 @@ TESTARGS = -s
 endif
 endif
 
-all::
+ifdef VG
+  VGARG="--vg"
+else
+  VGARG=
+endif
+
+all:: lit.site.cfg
 	@ echo '--- Running clang tests for $(TARGET_TRIPLE) ---'
-	@ PATH=$(ToolDir):$(LLVM_SRC_ROOT)/test/Scripts:$$PATH VG=$(VG) ../utils/test/MultiTestRunner.py $(TESTARGS) $(TESTDIRS)
+	@ $(PYTHON) $(LLVM_SRC_ROOT)/utils/lit/lit.py \
+	  $(TESTARGS) $(TESTDIRS) $(VGARG)
+
+FORCE:
+
+lit.site.cfg: FORCE
+	@echo "Making Clang 'lit.site.cfg' file..."
+	@sed -e "s#@LLVM_SOURCE_DIR@#$(LLVM_SRC_ROOT)#g" \
+	     -e "s#@LLVM_BINARY_DIR@#$(LLVM_OBJ_ROOT)#g" \
+	     -e "s#@LLVM_TOOLS_DIR@#$(ToolDir)#g" \
+	     -e "s#@LLVM_LIBS_DIR@#$(LibDir)#g" \
+	     -e "s#@CLANG_SOURCE_DIR@#$(PROJ_SRC_DIR)/..#g" \
+	     -e "s#@CLANG_BINARY_DIR@#$(PROJ_OBJ_DIR)/..#g" \
+	     $(PROJ_SRC_DIR)/lit.site.cfg.in > $@
 
 clean::
 	@ rm -rf Output/
diff --git a/test/Misc/diag-mapping2.c b/test/Misc/diag-mapping2.c
index 7e0d7742a9fe..c5fd7fff81f6 100644
--- a/test/Misc/diag-mapping2.c
+++ b/test/Misc/diag-mapping2.c
@@ -12,7 +12,10 @@
 // RUN: clang-cc %s -Werror=#warnings 2>&1 | grep "error:" &&
 
 // -Wno-error= overrides -Werror.  rdar://3158301
-// RUN: clang-cc %s -Werror -Wno-error=#warnings 2>&1 | grep "warning:"
+// RUN: clang-cc %s -Werror -Wno-error=#warnings 2>&1 | grep "warning:" &&
+
+// -Wno-error overrides -Werror.  PR4715
+// RUN: clang-cc %s -Werror -Wno-error 2>&1 | grep "warning:"
 
 #warning foo
 
diff --git a/test/PCH/cxx-method.cpp b/test/PCH/cxx-method.cpp
new file mode 100644
index 000000000000..144406e7bdaf
--- /dev/null
+++ b/test/PCH/cxx-method.cpp
@@ -0,0 +1,7 @@
+// RUN: clang-cc -emit-pch %s -o %t
+
+struct S {
+  void m(int x);
+};
+
+void S::m(int x) { }
diff --git a/test/PCH/libroot/usr/include/reloc.h b/test/PCH/libroot/usr/include/reloc.h
new file mode 100644
index 000000000000..04eeacba8ff5
--- /dev/null
+++ b/test/PCH/libroot/usr/include/reloc.h
@@ -0,0 +1,15 @@
+#ifndef RELOC_H
+#define RELOC_H
+
+#include <reloc2.h>
+
+
+
+
+
+
+
+// Line number 13 below is important
+int x = 2;
+
+#endif // RELOC_H
diff --git a/test/PCH/libroot/usr/include/reloc2.h b/test/PCH/libroot/usr/include/reloc2.h
new file mode 100644
index 000000000000..995415ce95bc
--- /dev/null
+++ b/test/PCH/libroot/usr/include/reloc2.h
@@ -0,0 +1,15 @@
+#ifndef RELOC2_H
+#define RELOC2_H
+#include <stddef.h>
+
+
+
+
+
+
+
+
+
+// Line number below is important!
+int y = 2;
+#endif // RELOC2_H
diff --git a/test/PCH/method_pool.h b/test/PCH/method_pool.h
index f7af9044d92d..80858360d725 100644
--- a/test/PCH/method_pool.h
+++ b/test/PCH/method_pool.h
@@ -22,8 +22,7 @@
 @end
 
 @implementation TestMethodPool1
-+ alloc {
-}
++ alloc { return 0; }
 
 - (double)instMethod:(int)foo {
   return foo;
diff --git a/test/PCH/objc_exprs.m b/test/PCH/objc_exprs.m
index eb1ae434a7e0..48966f36f33a 100644
--- a/test/PCH/objc_exprs.m
+++ b/test/PCH/objc_exprs.m
@@ -6,7 +6,7 @@
 // RUN: clang-cc -fblocks -include-pch %t -fsyntax-only -verify %s 
 
 // Expressions
-int *A1 = (objc_string)0;   // expected-warning {{'struct objc_object *'}}
+int *A1 = (objc_string)0;   // expected-warning {{aka 'id'}}
 
 char A2 = (objc_encode){};  // expected-error {{not a compile-time constant}} \
                                expected-warning {{char [2]}}
@@ -15,8 +15,7 @@ int *A3 = (objc_protocol)0; // expected-warning {{aka 'Protocol *'}}
 
 
 // Types.
-int *T0 = (objc_id_protocol_ty)0; // expected-error {{not a compile-time constant}} \
-                                     expected-warning {{aka 'id<foo>'}}
+int *T0 = (objc_id_protocol_ty)0; // expected-warning {{aka 'id<foo>'}}
 
 int *T1 = (objc_interface_ty)0; // expected-warning {{aka 'itf *'}}
 int *T2 = (objc_qual_interface_ty)0; // expected-warning {{aka 'itf<foo> *'}}
diff --git a/test/PCH/pr4489.c b/test/PCH/pr4489.c
index 696da5bbb483..7730819e9213 100644
--- a/test/PCH/pr4489.c
+++ b/test/PCH/pr4489.c
@@ -1,7 +1,8 @@
 // RUN: clang -x c-header -o %t.pch %s &&
 // RUN: clang -include %t -x c /dev/null -emit-llvm -S -o -
 // PR 4489: Crash with PCH
-
+// PR 4492: Crash with PCH (round two)
+// PR 4509: Crash with PCH (round three)
 typedef struct _IO_FILE FILE;
 extern int fprintf (struct _IO_FILE *__restrict __stream,
                     __const char *__restrict __format, ...);
@@ -17,4 +18,23 @@ int x(void)
 void y(void) {
   extern char z;
   fprintf (0, "a");
+}
+
+struct y0 { int i; } y0[1] = {};
+
+void x0(void)
+{
+  extern char z0;
+  fprintf (0, "a");
+}
+
+void x1(void)
+{
+  fprintf (0, "asdf");
+}
+
+void y1(void)
+{
+  extern char e;
+  fprintf (0, "asdf");
 }
\ No newline at end of file
diff --git a/test/PCH/reloc.c b/test/PCH/reloc.c
new file mode 100644
index 000000000000..b08187fdb8d8
--- /dev/null
+++ b/test/PCH/reloc.c
@@ -0,0 +1,14 @@
+// RUN: clang-cc -emit-pch -o %t --relocatable-pch -isysroot %S/libroot %S/libroot/usr/include/reloc.h &&
+// RUN: clang-cc -include-pch %t -isysroot %S/libroot %s -verify &&
+// RUN: not clang-cc -include-pch %t %s
+
+#include <reloc.h>
+
+int x = 2; // expected-error{{redefinition}}
+int y = 5; // expected-error{{redefinition}}
+
+
+
+
+// expected-note{{previous definition}}
+// expected-note{{previous definition}}
diff --git a/test/Parser/CompoundStmtScope.c b/test/Parser/CompoundStmtScope.c
index 6a404aa3a2c6..90e3d24a32f5 100644
--- a/test/Parser/CompoundStmtScope.c
+++ b/test/Parser/CompoundStmtScope.c
@@ -1,6 +1,6 @@
 // RUN: clang-cc -fsyntax-only -verify %s
 
-int foo() {
+void foo() {
   {
     typedef float X;
   }
diff --git a/test/Parser/MicrosoftExtensions.c b/test/Parser/MicrosoftExtensions.c
index 6f5622e93932..572ac44d1f40 100644
--- a/test/Parser/MicrosoftExtensions.c
+++ b/test/Parser/MicrosoftExtensions.c
@@ -9,22 +9,22 @@ __declspec(noalias) __declspec(restrict) void * __cdecl xxx( void * _Memory );
 typedef __w64 unsigned long ULONG_PTR, *PULONG_PTR;
 void * __ptr64 PtrToPtr64(const void *p)
 {
-    return((void * __ptr64) (unsigned __int64) (ULONG_PTR)p );
+  return((void * __ptr64) (unsigned __int64) (ULONG_PTR)p );
 }
-__forceinline InterlockedBitTestAndSet (long *Base, long Bit)  // expected-warning {{type specifier missing, defaults to 'int'}}
+void __forceinline InterlockedBitTestAndSet (long *Base, long Bit)
 {
-    __asm {
-           mov eax, Bit
-           mov ecx, Base
-           lock bts [ecx], eax
-           setc al
-    };
+  __asm {
+    mov eax, Bit
+    mov ecx, Base
+    lock bts [ecx], eax
+    setc al
+  };
 }
 
 void *_alloca(int);
 
 void foo() {
-	__declspec(align(16)) int *buffer = (int *)_alloca(9);
+  __declspec(align(16)) int *buffer = (int *)_alloca(9);
 }
 
 typedef bool (__stdcall __stdcall *blarg)(int);
diff --git a/test/Parser/argument_redef.c b/test/Parser/argument_redef.c
index 1a43178a40cd..fd22c465e5c6 100644
--- a/test/Parser/argument_redef.c
+++ b/test/Parser/argument_redef.c
@@ -1,6 +1,6 @@
 /* RUN: clang-cc -fsyntax-only -verify %s
 */
 
-int foo(int A) { /* expected-note {{previous definition is here}} */
+void foo(int A) { /* expected-note {{previous definition is here}} */
   int A; /* expected-error {{redefinition of 'A'}} */
 }
diff --git a/test/Parser/bad-control.c b/test/Parser/bad-control.c
index 6e59667c3549..0bdd179af215 100644
--- a/test/Parser/bad-control.c
+++ b/test/Parser/bad-control.c
@@ -1,9 +1,9 @@
 /* RUN: clang-cc -fsyntax-only -verify %s
 */
-int foo() { 
+void foo() { 
   break; /* expected-error {{'break' statement not in loop or switch statement}} */
 }
 
-int foo2() { 
+void foo2() { 
   continue; /* expected-error {{'continue' statement not in loop statement}} */
 }
diff --git a/test/Parser/cxx-ambig-paren-expr.cpp b/test/Parser/cxx-ambig-paren-expr.cpp
index 1712d849d516..324f6b5f9f88 100644
--- a/test/Parser/cxx-ambig-paren-expr.cpp
+++ b/test/Parser/cxx-ambig-paren-expr.cpp
@@ -5,9 +5,9 @@ void f() {
   int x, *px;
   
   // Type id.
-  (T())x;    // expected-error {{used type 'T ()'}}
-  (T())+x;   // expected-error {{used type 'T ()'}}
-  (T())*px;  // expected-error {{used type 'T ()'}}
+  (T())x;    // expected-error {{cast from 'int' to 'T ()'}}
+  (T())+x;   // expected-error {{cast from 'int' to 'T ()'}}
+  (T())*px;  // expected-error {{cast from 'int' to 'T ()'}}
   
   // Expression.
   x = (T());
diff --git a/test/Parser/cxx-friend.cpp b/test/Parser/cxx-friend.cpp
index ea30ddcbd0a8..14b31af761d3 100644
--- a/test/Parser/cxx-friend.cpp
+++ b/test/Parser/cxx-friend.cpp
@@ -1,4 +1,4 @@
-// RUN: clang-cc -fsyntax-only %s
+// RUN: clang-cc -fsyntax-only -verify %s
 
 class C {
   friend class D;
@@ -6,12 +6,27 @@ class C {
 
 class A {
 public:
-	void f();
+  void f();
+};
+
+friend int x; // expected-error {{'friend' used outside of class}}
+
+friend class D {}; // expected-error {{'friend' used outside of class}}
+
+union U {
+  int u1;
 };
 
 class B {
   // 'A' here should refer to the declaration above.  
   friend class A;
 
- void f(A *a) { a->f(); }
+  friend C; // expected-error {{must specify 'class' to befriend}}
+  friend U; // expected-error {{must specify 'union' to befriend}}
+  friend int; // expected-error {{friends can only be classes or functions}}
+
+  friend void myfunc();
+
+  void f(A *a) { a->f(); }
 };
+
diff --git a/test/Parser/cxx-member-initializers.cpp b/test/Parser/cxx-member-initializers.cpp
new file mode 100644
index 000000000000..bebb5c5e40d1
--- /dev/null
+++ b/test/Parser/cxx-member-initializers.cpp
@@ -0,0 +1,10 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+struct x {
+  x() : a(4) ; // expected-error {{expected '{'}}
+};
+
+struct y {
+  int a;
+  y() : a(4) ; // expected-error {{expected '{'}}
+};
diff --git a/test/Parser/cxx-template-decl.cpp b/test/Parser/cxx-template-decl.cpp
index 695501879098..9309b72a556e 100644
--- a/test/Parser/cxx-template-decl.cpp
+++ b/test/Parser/cxx-template-decl.cpp
@@ -2,16 +2,17 @@
 
 // Errors
 export class foo { };   // expected-error {{expected template}}
-template  x;            // expected-error {{C++ requires a type specifier for all declarations}}
-export template x;      // expected-error {{expected '<' after 'template'}} \
-                        // expected-note {{exported templates are unsupported}} \
-// expected-error {{C++ requires a type specifier for all declarations}}
-// See Sema::ParsedFreeStandingDeclSpec about the double diagnostic. This is
-// because ParseNonTypeTemplateParameter starts parsing a DeclSpec.
+template  x;            // expected-error {{C++ requires a type specifier for all declarations}} \
+                        // expected-error {{does not refer}}
+export template x;      // expected-error {{expected '<' after 'template'}}
+export template<class T> class x0; // expected-note {{exported templates are unsupported}}
 template < ;            // expected-error {{parse error}} expected-error {{declaration does not declare anything}}
-template <template X> struct Err1; // expected-error {{expected '<' after 'template'}}
-template <template <typename> > struct Err2;       // expected-error {{expected 'class' before '>'}}
-template <template <typename> Foo> struct Err3;    // expected-error {{expected 'class' before 'Foo'}}
+template <template X> struct Err1; // expected-error {{expected '<' after 'template'}} \
+// expected-error{{extraneous}}
+template <template <typename> > struct Err2;       // expected-error {{expected 'class' before '>'}} \
+// expected-error{{extraneous}}
+template <template <typename> Foo> struct Err3;    // expected-error {{expected 'class' before 'Foo'}} \
+// expected-error{{extraneous}}
 
 // Template function declarations
 template <typename T> void foo();
@@ -53,7 +54,7 @@ template <typename T, typename U> struct B { };
 
 // Template parameter shadowing
 template<typename T, // expected-note{{template parameter is declared here}}
-	 typename T> // expected-error{{declaration of 'T' shadows template parameter}}
+         typename T> // expected-error{{declaration of 'T' shadows template parameter}}
   void shadow1();
 
 template<typename T> // expected-note{{template parameter is declared here}}
diff --git a/test/Parser/cxx-using-declaration.cpp b/test/Parser/cxx-using-declaration.cpp
index de0e6f162a76..212a7d89f877 100644
--- a/test/Parser/cxx-using-declaration.cpp
+++ b/test/Parser/cxx-using-declaration.cpp
@@ -1,45 +1,47 @@
-// RUN: clang-cc -fsyntax-only -verify %s

-

-namespace A {

-    int VA;

-    void FA() {}

-    struct SA { int V; };

-}

-

-using A::VA;

-using A::FA;

-using typename A::SA;

-

-void main()

-{

-    VA = 1;

-    FA();

-    SA x;   //Still needs handling.

-}

-

-struct B {

-    void f(char){};

-    void g(char){};

-};

-struct D : B {

-    using B::f;

-    void f(int);

-    void g(int);

-};

-void D::f(int) { f('c'); } // calls B::f(char)

-void D::g(int) { g('c'); } // recursively calls D::g(int)

-

-namespace E {

-    template <typename TYPE> int funcE(TYPE arg) { return(arg); }

-}

-

-using E::funcE<int>; // expected-error{{use of template specialization in using directive not allowed}}

-

-namespace F {

-    struct X;

-}

-

-using F::X;

-// Should have some errors here.  Waiting for implementation.

-void X(int);

-struct X *x;

+// FIXME: Disabled, appears to have undefined behavior, and needs to be updated to match new warnings.
+// RUN: true
+// RUNX: clang-cc -fsyntax-only -verify %s
+
+namespace A {
+    int VA;
+    void FA() {}
+    struct SA { int V; };
+}
+
+using A::VA;
+using A::FA;
+using typename A::SA;
+
+void main()
+{
+    VA = 1;
+    FA();
+    SA x;   //Still needs handling.
+}
+
+struct B {
+    void f(char){};
+    void g(char){};
+};
+struct D : B {
+    using B::f;
+    void f(int);
+    void g(int);
+};
+void D::f(int) { f('c'); } // calls B::f(char)
+void D::g(int) { g('c'); } // recursively calls D::g(int)
+
+namespace E {
+    template <typename TYPE> int funcE(TYPE arg) { return(arg); }
+}
+
+using E::funcE<int>; // expected-error{{use of template specialization in using directive not allowed}}
+
+namespace F {
+    struct X;
+}
+
+using F::X;
+// Should have some errors here.  Waiting for implementation.
+void X(int);
+struct X *x;
diff --git a/test/Parser/declarators.c b/test/Parser/declarators.c
index 26e8027d1078..da8327a1e834 100644
--- a/test/Parser/declarators.c
+++ b/test/Parser/declarators.c
@@ -18,7 +18,7 @@ int *A;
 
 struct str;
 
-int test2(int *P, int A) {
+void test2(int *P, int A) {
   struct str;
 
   // Hard case for array decl, not Array[*].
@@ -26,11 +26,11 @@ int test2(int *P, int A) {
 }
 
 typedef int atype;
-int test3(x, 
-          atype         /* expected-error {{unexpected type name 'atype': expected identifier}} */
-         ) int x, atype; {}
+void test3(x, 
+           atype         /* expected-error {{unexpected type name 'atype': expected identifier}} */
+          ) int x, atype; {}
 
-int test4(x, x) int x; {} /* expected-error {{redefinition of parameter 'x'}} */
+void test4(x, x) int x; {} /* expected-error {{redefinition of parameter 'x'}} */
 
 
 // PR3031
diff --git a/test/Parser/implicit-casts.c b/test/Parser/implicit-casts.c
index e7d20980da47..3e8f599047c4 100644
--- a/test/Parser/implicit-casts.c
+++ b/test/Parser/implicit-casts.c
@@ -15,6 +15,7 @@ void test2() {
 int test3() {
   int a[2];
   a[0] = test3; // expected-warning{{incompatible pointer to integer conversion assigning 'int ()', expected 'int'}}
+  return 0;
 }
 short x; void test4(char c) { x += c; }
 int y; void test5(char c) { y += c; }
diff --git a/test/Parser/objc-messaging-neg-1.m b/test/Parser/objc-messaging-neg-1.m
index a1ec116fb7b4..0344566aa87a 100644
--- a/test/Parser/objc-messaging-neg-1.m
+++ b/test/Parser/objc-messaging-neg-1.m
@@ -1,7 +1,6 @@
 // RUN: clang-cc -fsyntax-only -verify %s
 
-int main()
-   {
-     id a;
-     [a bla:0 6:7]; // expected-error {{expected ']'}}
-   }
+int main() {
+  id a;
+  [a bla:0 6:7]; // expected-error {{expected ']'}}
+}
diff --git a/test/Parser/pointer_promotion.c b/test/Parser/pointer_promotion.c
index 0254828e0f02..3226eabbf53d 100644
--- a/test/Parser/pointer_promotion.c
+++ b/test/Parser/pointer_promotion.c
@@ -1,6 +1,6 @@
 // RUN: clang-cc -fsyntax-only -verify %s
 
-int test() {
+void test() {
   void *vp;
   int *ip;
   char *cp;
@@ -15,4 +15,3 @@ int test() {
   if (sint < ip) {} // expected-warning {{comparison between pointer and integer ('int' and 'int *')}}
   if (ip == cp) {} // expected-warning {{comparison of distinct pointer types ('int *' and 'char *')}}
 }
-
diff --git a/test/Parser/pragma-weak.c b/test/Parser/pragma-weak.c
index 355a95487b97..dca0f8dd4c15 100644
--- a/test/Parser/pragma-weak.c
+++ b/test/Parser/pragma-weak.c
@@ -10,7 +10,7 @@ int x;
 extern int z;
 /* expected-warning {{expected identifier in '#pragma weak'}}*/ #pragma weak z = =
 /* expected-warning {{expected identifier in '#pragma weak'}}*/ #pragma weak z =
-#pragma weak z = y
+/* expected-warning {{weak identifier 'y' never declared}} */ #pragma weak z = y
 
 extern int a;
 /* expected-warning {{extra tokens at end of '#pragma weak'}}*/ #pragma weak a b
diff --git a/test/Parser/recovery.c b/test/Parser/recovery.c
index 89eac564a329..43d3e2d8a69d 100644
--- a/test/Parser/recovery.c
+++ b/test/Parser/recovery.c
@@ -8,10 +8,10 @@ float test2241[2] = {
 
 
 // Testcase derived from PR2692
-static char *f (char * (*g) (char **, int), char **p, ...) {
-    char *s;
-    va_list v;                              // expected-error {{identifier}}
-    s = g (p, __builtin_va_arg(v, int));    // expected-error {{identifier}}
+static void f (char * (*g) (char **, int), char **p, ...) {
+  char *s;
+  va_list v;                              // expected-error {{identifier}}
+  s = g (p, __builtin_va_arg(v, int));    // expected-error {{identifier}}
 }
 
 
@@ -20,7 +20,7 @@ static char *f (char * (*g) (char **, int), char **p, ...) {
 
 
 // rdar://6094870
-int test(int a) {
+void test(int a) {
   struct { int i; } x;
   
   if (x.hello)   // expected-error {{no member named 'hello'}}
@@ -61,7 +61,7 @@ struct S A = {
 };
 
 // rdar://6248081
-int test6248081() { 
+void test6248081() { 
   [10]  // expected-error {{expected expression}}
 }
 
diff --git a/test/Parser/statements.c b/test/Parser/statements.c
index b95c23fb28b0..25e06a27bd13 100644
--- a/test/Parser/statements.c
+++ b/test/Parser/statements.c
@@ -1,24 +1,24 @@
 // RUN: clang-cc -fsyntax-only -verify %s
 
-int test1() {
+void test1() {
   { ; {  ;;}} ;;
 }
 
-int test2() {
+void test2() {
   if (0) { if (1) {} } else { }
 
   do { } while (0); 
   
   while (0) while(0) do ; while(0);
 
-  for (0;0;0)
+  for ((void)0;0;(void)0)
     for (;;)
-      for (9;0;2)
+      for ((void)9;0;(void)2)
         ;
-  for (int X = 0; 0; 0);
+  for (int X = 0; 0; (void)0);
 }
 
-int test3() {
+void test3() {
     switch (0) {
     
     case 4:
@@ -30,7 +30,7 @@ int test3() {
   }
 }
 
-int test4() {
+void test4() {
   if (0);  // expected-warning {{if statement has empty body}}
   
   int X;  // declaration in a block.
diff --git a/test/Parser/top-level-semi-cxx0x.cpp b/test/Parser/top-level-semi-cxx0x.cpp
new file mode 100644
index 000000000000..e83fd9e8dbd7
--- /dev/null
+++ b/test/Parser/top-level-semi-cxx0x.cpp
@@ -0,0 +1,15 @@
+// RUN: clang-cc -fsyntax-only -pedantic -std=c++0x -verify %s
+
+void foo();
+
+void bar() { };
+
+void wibble();
+
+;
+
+namespace Blah {
+  void f() { };
+  
+  void g();
+}
diff --git a/test/Preprocessor/assembler-with-cpp.c b/test/Preprocessor/assembler-with-cpp.c
index 2e84ed1a6b07..f7706ca676ce 100644
--- a/test/Preprocessor/assembler-with-cpp.c
+++ b/test/Preprocessor/assembler-with-cpp.c
@@ -40,7 +40,7 @@
 // rdar://6709206
 // RUN: grep "5: expanded (" %t &&
 #define M4 expanded
-#define	M5() M4 ## (
+#define M5() M4 ## (
 
 5: M5()
 
diff --git a/test/Preprocessor/macro-multiline.c b/test/Preprocessor/macro-multiline.c
index eb15668ce31f..ba988253b272 100644
--- a/test/Preprocessor/macro-multiline.c
+++ b/test/Preprocessor/macro-multiline.c
@@ -1,4 +1,4 @@
-// RUN: clang -E %s "-DX=A
+// RUN: clang -E %s "-DX=A &&
 // RUN: THIS_SHOULD_NOT_EXIST_IN_THE_OUTPUT" > %t &&
 // RUN: grep "GOOD: A" %t &&
 // RUN: not grep THIS_SHOULD_NOT_EXIST_IN_THE_OUTPUT %t
diff --git a/test/Preprocessor/macro_fn_comma_swallow.c b/test/Preprocessor/macro_fn_comma_swallow.c
index e985138a5c44..d39d4e7841d5 100644
--- a/test/Preprocessor/macro_fn_comma_swallow.c
+++ b/test/Preprocessor/macro_fn_comma_swallow.c
@@ -1,7 +1,7 @@
 // Test the GNU comma swallowing extension.
 // RUN: clang-cc %s -E | grep 'foo{A, }' && 
 // RUN: clang-cc %s -E | grep 'fo2{A,}' && 
-// RUN: clang-cc %s -E | grep '{foo}'
+// RUN: clang-cc %s -E | grep '{foo}' &&
 
 #define X(Y) foo{A, Y}
 X()
diff --git a/test/Preprocessor/macro_paste_mscomment.c b/test/Preprocessor/macro_paste_mscomment.c
index b0fc57101c64..d6ead91068cf 100644
--- a/test/Preprocessor/macro_paste_mscomment.c
+++ b/test/Preprocessor/macro_paste_mscomment.c
@@ -1,5 +1,5 @@
-// RUN: clang-cc -P -E -fms-extensions %s | sed '/^#.\+/d' | tr -d '\n' |
-// RUN:   grep '^int foo;int bar;int baz;$' | count 1
+// RUN: clang-cc -P -E -fms-extensions %s | sed '/^#.\+/d' | tr -d '\n' > %t &&
+// RUN: grep '^int foo;int bar;int baz;$' %t | count 1
 // This horrible stuff should preprocess into (other than whitespace):
 //   int foo;
 //   int bar;
diff --git a/test/Preprocessor/non_fragile_feature.m b/test/Preprocessor/non_fragile_feature.m
new file mode 100644
index 000000000000..cb6bc012f1c2
--- /dev/null
+++ b/test/Preprocessor/non_fragile_feature.m
@@ -0,0 +1,8 @@
+// RUN: clang-cc -fobjc-nonfragile-abi %s
+#ifndef __has_feature
+#error Should have __has_feature
+#endif
+
+#if !__has_feature(objc_nonfragile_abi)
+#error Non-fragile ABI used for compilation but feature macro not set.
+#endif
diff --git a/test/Preprocessor/non_fragile_feature1.m b/test/Preprocessor/non_fragile_feature1.m
new file mode 100644
index 000000000000..59f665b54649
--- /dev/null
+++ b/test/Preprocessor/non_fragile_feature1.m
@@ -0,0 +1,8 @@
+// RUN: clang-cc -triple i386-unknown-unknown %s
+#ifndef __has_feature
+#error Should have __has_feature
+#endif
+
+#if __has_feature(objc_nonfragile_abi)
+#error Non-fragile ABI not used for compilation but feature macro set.
+#endif
diff --git a/test/Preprocessor/pushable-diagnostics.c b/test/Preprocessor/pushable-diagnostics.c
new file mode 100644
index 000000000000..fe55122d66cd
--- /dev/null
+++ b/test/Preprocessor/pushable-diagnostics.c
@@ -0,0 +1,17 @@
+// RUN: clang-cc -fsyntax-only -verify -pedantic %s
+
+#pragma clang diagnostic pop // expected-warning{{pragma diagnostic pop could not pop, no matching push}}
+
+#pragma clang diagnostic puhs // expected-warning{{pragma diagnostic expected 'error', 'warning', 'ignored', 'fatal' 'push', or 'pop'}}
+
+char a = 'df'; // expected-warning{{multi-character character constant}}
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmultichar"
+
+char b = 'df'; // no warning.
+#pragma clang diagnostic pop
+
+char c = 'df';  // expected-warning{{multi-character character constant}}
+
+#pragma clang diagnostic pop // expected-warning{{pragma diagnostic pop could not pop, no matching push}}
diff --git a/test/Rewriter/id-test-3.m b/test/Rewriter/id-test-3.m
index ad1e76decf80..7e4cc51d7357 100644
--- a/test/Rewriter/id-test-3.m
+++ b/test/Rewriter/id-test-3.m
@@ -10,5 +10,5 @@
 
 @implementation INTF
 - (id<P>)IMeth { return [(id<P>)self Meth: (id<P>)0]; }
-- (id<P>) Meth : (id<P>) Arg {}
+- (id<P>) Meth : (id<P>) Arg { return 0; }
 @end
diff --git a/test/Rewriter/method-encoding-1.m b/test/Rewriter/method-encoding-1.m
index 25dccbf75084..05df60291e02 100644
--- a/test/Rewriter/method-encoding-1.m
+++ b/test/Rewriter/method-encoding-1.m
@@ -11,8 +11,8 @@
 @end
 
 @implementation Intf
-- (char *) MyMeth : (double) arg1 : (char *[12]) arg2{}
+- (char *) MyMeth : (double) arg1 : (char *[12]) arg2{ return 0; }
 - (void) MyProtoMeth : (int **) arg1 : (void*) arg2 {}
 + (void) MyProtoMeth : (int **) arg1 : (void*) arg2 {}
-- (id) address:(void *)location with:(unsigned **)arg2{}
+- (id) address:(void *)location with:(unsigned **)arg2{ return 0; }
 @end
diff --git a/test/Rewriter/rewrite-foreach-4.m b/test/Rewriter/rewrite-foreach-4.m
index 774f9a0b75c8..5c831ea18b20 100644
--- a/test/Rewriter/rewrite-foreach-4.m
+++ b/test/Rewriter/rewrite-foreach-4.m
@@ -9,7 +9,7 @@
 {
         return 0;
 }
-- (id) allKeys {}
+- (id) allKeys { return 0; }
 @end
 
 @interface MyList (BasicTest)
diff --git a/test/Rewriter/rewrite-foreach-5.m b/test/Rewriter/rewrite-foreach-5.m
index d0d12444a3e7..d03f6ce84df6 100644
--- a/test/Rewriter/rewrite-foreach-5.m
+++ b/test/Rewriter/rewrite-foreach-5.m
@@ -9,7 +9,7 @@
 {
         return 0;
 }
-- (id) allKeys {}
+- (id) allKeys { return 0; }
 @end
 
 @interface MyList (BasicTest)
diff --git a/test/Sema/address_spaces.c b/test/Sema/address_spaces.c
index b79799f0230c..d9d23edb3cf4 100644
--- a/test/Sema/address_spaces.c
+++ b/test/Sema/address_spaces.c
@@ -4,7 +4,11 @@
 #define _AS2 __attribute__((address_space(2)))
 #define _AS3 __attribute__((address_space(3)))
 
-void foo(_AS3 float *a) {
+void bar(_AS2 int a); // expected-error {{parameter may not be qualified with an address space}}
+
+void foo(_AS3 float *a, 
+         _AS1 float b) // expected-error {{parameter may not be qualified with an address space}}
+{
   _AS2 *x;// expected-warning {{type specifier missing, defaults to 'int'}}
   _AS1 float * _AS2 *B;
 
@@ -15,7 +19,13 @@ void foo(_AS3 float *a) {
   _AS1 int array[5];  // expected-error {{automatic variable qualified with an address space}}
   _AS1 int arrarr[5][5]; // expected-error {{automatic variable qualified with an address space}}
 
-  *a = 5.0f;
+  __attribute__((address_space(-1))) int *_boundsA; // expected-error {{address space is negative}}
+  __attribute__((address_space(0xFFFFFF))) int *_boundsB;
+  __attribute__((address_space(0x1000000))) int *_boundsC; // expected-error {{address space is larger than the maximum supported}}
+  // chosen specifically to overflow 32 bits and come out reasonable
+  __attribute__((address_space(4294967500))) int *_boundsD; // expected-error {{address space is larger than the maximum supported}}
+
+  *a = 5.0f + b;
 }
 
 struct _st {
@@ -27,6 +37,6 @@ struct _st {
 __attribute__((address_space(256))) void * * const base = 0;
 void * get_0(void) {
   return base[0];  // expected-error {{illegal implicit cast between two pointers with different address spaces}} \
-                      expected-warning {{returning 'void __attribute__((address_space(256)))*' discards qualifiers, expected 'void *'}}
+                      expected-warning {{returning 'void __attribute__((address_space(256))) *' discards qualifiers, expected 'void *'}}
 }
 
diff --git a/test/Sema/align-arm-apcs.c b/test/Sema/align-arm-apcs.c
new file mode 100644
index 000000000000..924ba9034d8b
--- /dev/null
+++ b/test/Sema/align-arm-apcs.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc -triple arm-unknown-unknown -target-abi=apcs-gnu -fsyntax-only -verify %s
+
+struct s0 { double f0; int f1; };
+char chk0[__alignof__(struct s0) == 4 ? 1 : -1]; 
diff --git a/test/Sema/altivec-init.c b/test/Sema/altivec-init.c
new file mode 100644
index 000000000000..6185186903b0
--- /dev/null
+++ b/test/Sema/altivec-init.c
@@ -0,0 +1,16 @@
+// RUN: clang-cc %s -faltivec -verify -pedantic -fsyntax-only -fblocks=0
+
+typedef int v4 __attribute((vector_size(16)));
+typedef short v8 __attribute((vector_size(16)));
+
+v8 foo(void) { 
+  v8 a;
+  v4 b;
+  a = (v8){4, 2}; // expected-error {{too few elements in vector initialization (expected 8 elements, have 2)}}
+  b = (v4)(5, 6, 7, 8, 9); // expected-warning {{excess elements in vector initializer}}
+  b = (v4)(5, 6, 8, 8.0f);
+  return (v8){0, 1, 2, 3, 1, 2, 3, 4};
+
+  // FIXME: test that (type)(fn)(args) still works with -faltivec
+  // FIXME: test that c++ overloaded commas still work -faltivec
+}
diff --git a/test/Sema/arg-scope-c99.c b/test/Sema/arg-scope-c99.c
index b5b1c8a812c1..1d81410b8d01 100644
--- a/test/Sema/arg-scope-c99.c
+++ b/test/Sema/arg-scope-c99.c
@@ -1,2 +1,2 @@
 // RUN: clang-cc -fsyntax-only -std=c99 -verify %s
-int bb(int sz, int ar[sz][sz]) { }
+void bb(int sz, int ar[sz][sz]) { }
diff --git a/test/Sema/arg-scope.c b/test/Sema/arg-scope.c
index c1cc7e112f88..d5e59603cfbf 100644
--- a/test/Sema/arg-scope.c
+++ b/test/Sema/arg-scope.c
@@ -1,5 +1,5 @@
 // RUN: clang-cc -fsyntax-only -verify %s
-int aa(int b, int x[sizeof b]) {}
+void aa(int b, int x[sizeof b]) {}
 
 void foo(int i, int A[i]) {}
 
diff --git a/test/Sema/array-constraint.c b/test/Sema/array-constraint.c
index 5a09e20ecbff..6407b5daf56a 100644
--- a/test/Sema/array-constraint.c
+++ b/test/Sema/array-constraint.c
@@ -45,7 +45,7 @@ typedef int TA[I]; // expected-error {{variable length array declaration not all
 
 void strFunc(char *);
 const char staticAry[] = "test";
-int checkStaticAry() { 
+void checkStaticAry() { 
   strFunc(staticAry); // expected-warning{{passing 'char const [5]' discards qualifiers, expected 'char *'}}
 }
 
diff --git a/test/Sema/array-init.c b/test/Sema/array-init.c
index 50148a83ae13..c78fd29a89c1 100644
--- a/test/Sema/array-init.c
+++ b/test/Sema/array-init.c
@@ -144,12 +144,11 @@ int xx_sizecheck[(sizeof(xx) / sizeof(char)) == 5? 1 : -1];
 static char const yy[5] = "test";
 static char const zz[3] = "test"; // expected-warning{{initializer-string for char array is too long}}
 
-void charArrays()
-{
-	static char const test[] = "test";
-        int test_sizecheck[(sizeof(test) / sizeof(char)) == 5? 1 : -1];
-	static char const test2[] = { "weird stuff" };
-	static char const test3[] = { "test", "excess stuff" }; // expected-warning{{excess elements in char array initializer}}
+void charArrays() {
+  static char const test[] = "test";
+  int test_sizecheck[(sizeof(test) / sizeof(char)) == 5? 1 : -1];
+  static char const test2[] = { "weird stuff" };
+  static char const test3[] = { "test", "excess stuff" }; // expected-warning{{excess elements in char array initializer}}
 
   char* cp[] = { "Hello" };
 
@@ -219,10 +218,10 @@ void varArray() {
 }
 
 // PR2151
-int emptyInit() {struct {} x[] = {6};} //expected-warning{{empty struct extension}} expected-error{{initializer for aggregate with no elements}}
+void emptyInit() {struct {} x[] = {6};} //expected-warning{{empty struct extension}} expected-error{{initializer for aggregate with no elements}}
 
-int noNamedInit() {
-struct {int:5;} x[] = {6}; //expected-error{{initializer for aggregate with no elements}}
+void noNamedInit() {
+  struct {int:5;} x[] = {6}; //expected-error{{initializer for aggregate with no elements}}
 }
 struct {int a; int:5;} noNamedImplicit[] = {1,2,3};
 int noNamedImplicitCheck[sizeof(noNamedImplicit) == 3 * sizeof(*noNamedImplicit) ? 1 : -1];
@@ -230,15 +229,15 @@ int noNamedImplicitCheck[sizeof(noNamedImplicit) == 3 * sizeof(*noNamedImplicit)
 
 // ptrs are constant
 struct soft_segment_descriptor {
-	long ssd_base;
+  long ssd_base;
 };
 static int dblfault_tss;
 
 union uniao { int ola; } xpto[1];
 
 struct soft_segment_descriptor gdt_segs[] = {
-	{(long) &dblfault_tss},
-	{ (long)xpto},
+  {(long) &dblfault_tss},
+  { (long)xpto},
 };
 
 static void sppp_ipv6cp_up();
diff --git a/test/Sema/attr-decl-after-definition.c b/test/Sema/attr-decl-after-definition.c
new file mode 100644
index 000000000000..c1d1b536fc69
--- /dev/null
+++ b/test/Sema/attr-decl-after-definition.c
@@ -0,0 +1,19 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+void foo();
+void foo() __attribute__((unused));
+void foo() __attribute__((unused));
+void foo(){} // expected-note {{previous definition is here}}
+void foo() __attribute__((constructor)); // expected-warning {{must precede definition}}
+void foo();
+
+int bar;
+extern int bar;
+int bar;
+int bar __attribute__((weak));
+int bar __attribute__((used));
+extern int bar __attribute__((weak));
+int bar = 0; // expected-note {{previous definition is here}}
+int bar __attribute__((weak)); // expected-warning {{must precede definition}}
+int bar;
+
diff --git a/test/Sema/attr-deprecated.c b/test/Sema/attr-deprecated.c
index 6597bad4b572..e15381e4c6d1 100644
--- a/test/Sema/attr-deprecated.c
+++ b/test/Sema/attr-deprecated.c
@@ -21,7 +21,7 @@ int a() {
 // test if attributes propagate to variables
 extern int var;
 int w() {
-	return var; // expected-warning {{'var' is deprecated}}
+  return var; // expected-warning {{'var' is deprecated}}
 }
 
 int old_fn() __attribute__ ((deprecated));
diff --git a/test/Sema/attr-format_arg.c b/test/Sema/attr-format_arg.c
index 6f953155f8c8..0830951acc89 100644
--- a/test/Sema/attr-format_arg.c
+++ b/test/Sema/attr-format_arg.c
@@ -1,3 +1,5 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
 #include <stdio.h>
 
 const char* f(const char *s) __attribute__((format_arg(1)));
diff --git a/test/Sema/attr-malloc.c b/test/Sema/attr-malloc.c
new file mode 100644
index 000000000000..1adcf074a499
--- /dev/null
+++ b/test/Sema/attr-malloc.c
@@ -0,0 +1,25 @@
+// RUN: clang-cc -verify -fsyntax-only %s &&
+// RUN: clang-cc -emit-llvm -o %t %s &&
+
+#include <stdlib.h>
+
+int no_vars __attribute((malloc)); // expected-warning {{functions returning a pointer type}}
+
+void  returns_void  (void) __attribute((malloc)); // expected-warning {{functions returning a pointer type}}
+int   returns_int   (void) __attribute((malloc)); // expected-warning {{functions returning a pointer type}}
+int * returns_intptr(void) __attribute((malloc)); // no-warning
+typedef int * iptr;
+iptr  returns_iptr  (void) __attribute((malloc)); // no-warning
+
+__attribute((malloc)) void *(*f)(); //  expected-warning{{'malloc' attribute only applies to functions returning a pointer type}}
+__attribute((malloc)) int (*g)(); // expected-warning{{'malloc' attribute only applies to functions returning a pointer type}}
+
+__attribute((malloc))
+void * xalloc(unsigned n) { return malloc(n); } // no-warning
+// RUN: grep 'define noalias .* @xalloc(' %t &&
+
+#define malloc_like __attribute((__malloc__))
+void * xalloc2(unsigned) malloc_like;
+void * xalloc2(unsigned n) { return malloc(n); }
+// RUN: grep 'define noalias .* @xalloc2(' %t
+
diff --git a/test/Sema/attr-noreturn.c b/test/Sema/attr-noreturn.c
index d1417f093ffb..b83eb94e0582 100644
--- a/test/Sema/attr-noreturn.c
+++ b/test/Sema/attr-noreturn.c
@@ -4,7 +4,7 @@ static void (*fp0)(void) __attribute__((noreturn));
 
 static void __attribute__((noreturn)) f0(void) {
   fatal();
-}
+} // expected-warning {{function declared 'noreturn' should not return}}
 
 // On K&R
 int f1() __attribute__((noreturn));
@@ -25,3 +25,11 @@ void f4() {
   return;  // expected-warning {{function 'f4' declared 'noreturn' should not return}}
 }
 
+// PR4685
+extern void f5 (unsigned long) __attribute__ ((__noreturn__));
+
+void
+f5 (unsigned long size)
+{
+  
+}
diff --git a/test/Sema/attr-section.c b/test/Sema/attr-section.c
new file mode 100644
index 000000000000..c61ed80cbf7a
--- /dev/null
+++ b/test/Sema/attr-section.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc -verify -fsyntax-only -triple x86_64-apple-darwin9 %s
+
+int x __attribute__((section(
+   42)));  // expected-error {{argument to section attribute was not a string literal}}
+
+
+// rdar://4341926
+int y __attribute__((section(
+   "sadf"))); // expected-error {{mach-o section specifier requires a segment and section separated by a comma}}
+
diff --git a/test/Sema/attr-weak.c b/test/Sema/attr-weak.c
index b79e1e7dfca7..4532cccf98d9 100644
--- a/test/Sema/attr-weak.c
+++ b/test/Sema/attr-weak.c
@@ -5,9 +5,11 @@ extern int g1 __attribute__((weak_import));
 int g2 __attribute__((weak));
 int g3 __attribute__((weak_import)); // expected-warning {{'weak_import' attribute cannot be specified on a definition}}
 int __attribute__((weak_import)) g4(void);
-int __attribute__((weak_import)) g5(void) { 
+void __attribute__((weak_import)) g5(void) { 
 }
 
 struct __attribute__((weak)) s0 {}; // expected-warning {{'weak' attribute only applies to variable and function types}}
 struct __attribute__((weak_import)) s1 {}; // expected-warning {{'weak_import' attribute only applies to variable and function types}}
 
+static int x __attribute__((weak)); // expected-error {{weak declaration of 'x' must be public}}
+
diff --git a/test/Sema/bitfield-promote-int-16bit.c b/test/Sema/bitfield-promote-int-16bit.c
new file mode 100644
index 000000000000..12d47205e87d
--- /dev/null
+++ b/test/Sema/bitfield-promote-int-16bit.c
@@ -0,0 +1,25 @@
+// RUN: clang-cc -fsyntax-only -verify %s -triple pic16-unknown-unknown
+
+// Check that int-sized unsigned bit-fields promote to unsigned int
+// on targets where sizeof(unsigned short) == sizeof(unsigned int)
+
+enum E { ec1, ec2, ec3 };
+struct S {
+  enum E          e : 16;
+  unsigned short us : 16;
+  unsigned long ul1 :  8;
+  unsigned long ul2 : 16;
+} s;
+
+__typeof(s.e + s.e) x_e;
+unsigned x_e;
+
+__typeof(s.us + s.us) x_us;
+unsigned x_us;
+
+__typeof(s.ul1 + s.ul1) x_ul1;
+signed x_ul1;
+
+__typeof(s.ul2 + s.ul2) x_ul2;
+unsigned x_ul2;
+
diff --git a/test/Sema/bitfield-promote.c b/test/Sema/bitfield-promote.c
new file mode 100644
index 000000000000..066f5d78e715
--- /dev/null
+++ b/test/Sema/bitfield-promote.c
@@ -0,0 +1,34 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+struct {unsigned x : 2;} x;
+__typeof__((x.x+=1)+1) y;
+__typeof__(x.x<<1) y;
+int y;
+
+
+struct { int x : 8; } x1;
+long long y1;
+__typeof__(((long long)x1.x + 1)) y1;
+
+
+// Check for extensions: variously sized unsigned bit-fields fitting
+// into a signed int promote to signed int.
+enum E { ec1, ec2, ec3 };
+struct S {
+  enum E          e : 2;
+  unsigned short us : 4;
+  unsigned long long ul1 : 8;
+  unsigned long long ul2 : 50;
+} s;
+
+__typeof(s.e + s.e) x_e;
+int x_e;
+
+__typeof(s.us + s.us) x_us;
+int x_us;
+
+__typeof(s.ul1 + s.ul1) x_ul1;
+int x_ul1;
+
+__typeof(s.ul2 + s.ul2) x_ul2;
+unsigned long long x_ul2;
+
diff --git a/test/Sema/bitfield.c b/test/Sema/bitfield.c
index 655f74121a32..581af6d0c5ea 100644
--- a/test/Sema/bitfield.c
+++ b/test/Sema/bitfield.c
@@ -21,7 +21,7 @@ struct a {
   int g : (_Bool)1;
   
   // PR4017  
-  char : 10;      // expected-error {{size of anonymous bitfield exceeds size of its type (8 bits)}}
+  char : 10;      // expected-error {{size of anonymous bit-field exceeds size of its type (8 bits)}}
   unsigned : -2;  // expected-error {{anonymous bit-field has negative width (-2)}}
   float : 12;     // expected-error {{anonymous bit-field has non-integral type 'float'}}
 };
diff --git a/test/Sema/block-args.c b/test/Sema/block-args.c
index 27bee77da6c6..3a58735f23a3 100644
--- a/test/Sema/block-args.c
+++ b/test/Sema/block-args.c
@@ -22,7 +22,7 @@ void test() {
   ^(int x, ...){return 5;}(arg, arg);   // Explicit varargs, ok.
 }
 
-int main(int argc) {
+int main(int argc, char** argv) {
   ^(int argCount) {
     argCount = 3;
   }(argc);
diff --git a/test/Sema/block-call.c b/test/Sema/block-call.c
index c42b642337ca..893a8f61da8d 100644
--- a/test/Sema/block-call.c
+++ b/test/Sema/block-call.c
@@ -5,51 +5,47 @@ int (^IFP) ();
 int (^II) (int);
 int main() {
   int (*FPL) (int) = FP; // C doesn't consider this an error.
-  
+
   // For Blocks, the ASTContext::typesAreBlockCompatible() makes sure this is an error.
   int (^PFR) (int) = IFP; // OK
-	PFR = II;	// OK
-
-	int (^IFP) () = PFR; // OK
-
+  PFR = II;       // OK
 
-	const int (^CIC) () = IFP; // expected-error {{incompatible block pointer types initializing 'int (^)()', expected 'int const (^)()'}}
+  int (^IFP) () = PFR; // OK
 
 
-	const int (^CICC) () = CIC;
+  const int (^CIC) () = IFP; // expected-error {{incompatible block pointer types initializing 'int (^)()', expected 'int const (^)()'}}
 
-	int * const (^IPCC) () = 0;
+  const int (^CICC) () = CIC;
 
-	int * const (^IPCC1) () = IPCC; 
+  int * const (^IPCC) () = 0;
 
-	int * (^IPCC2) () = IPCC;	// expected-error {{incompatible block pointer types initializing 'int *const (^)()', expected 'int *(^)()'}}
+  int * const (^IPCC1) () = IPCC;
 
-	int (^IPCC3) (const int) = PFR;
+  int * (^IPCC2) () = IPCC;       // expected-error {{incompatible block pointer types initializing 'int *const (^)()', expected 'int *(^)()'}}
 
+  int (^IPCC3) (const int) = PFR;
 
-	int (^IPCC4) (int, char (^CArg) (double));
+  int (^IPCC4) (int, char (^CArg) (double));
 
+  int (^IPCC5) (int, char (^CArg) (double)) = IPCC4;
 
-	int (^IPCC5) (int, char (^CArg) (double)) = IPCC4;
+  int (^IPCC6) (int, char (^CArg) (float))  = IPCC4; // expected-error {{incompatible block pointer types initializing 'int (^)(int, char (^)(double))', expected 'int (^)(int, char (^)(float))'}}
 
-	int (^IPCC6) (int, char (^CArg) (float))  = IPCC4; // expected-error {{incompatible block pointer types initializing 'int (^)(int, char (^)(double))', expected 'int (^)(int, char (^)(float))'}}
-
-	IPCC2 = 0;
-	IPCC2 = 1; // expected-error {{invalid conversion assigning integer 'int', expected block pointer 'int *(^)()'}}
-	int (^x)() = 0;
-	int (^y)() = 3;   // expected-error {{invalid conversion initializing integer 'int', expected block pointer 'int (^)()'}}
-	int a = 1;
-	int (^z)() = a+4;   // expected-error {{invalid conversion initializing integer 'int', expected block pointer 'int (^)()'}}
+  IPCC2 = 0;
+  IPCC2 = 1; // expected-error {{invalid conversion assigning integer 'int', expected block pointer 'int *(^)()'}}
+  int (^x)() = 0;
+  int (^y)() = 3;   // expected-error {{invalid conversion initializing integer 'int', expected block pointer 'int (^)()'}}
+  int a = 1;
+  int (^z)() = a+4;   // expected-error {{invalid conversion initializing integer 'int', expected block pointer 'int (^)()'}}
 }
 
 int blah() {
-	int (^IFP) (float);
-	char (^PCP)(double, double, char);
+  int (^IFP) (float);
+  char (^PCP)(double, double, char);
 
-	IFP(1.0);
-	IFP (1.0, 2.0);	// expected-error {{too many arguments to block call}}
+  IFP(1.0);
+  IFP (1.0, 2.0); // expected-error {{too many arguments to block call}}
 
-	char ch = PCP(1.0, 2.0, 'a');
-	return PCP(1.0, 2.0);	// expected-error {{too few arguments to block}}
+  char ch = PCP(1.0, 2.0, 'a');
+  return PCP(1.0, 2.0);   // expected-error {{too few arguments to block}}
 }
-
diff --git a/test/Sema/block-literal.c b/test/Sema/block-literal.c
index 19d476fc294f..9f5022dc6387 100644
--- a/test/Sema/block-literal.c
+++ b/test/Sema/block-literal.c
@@ -8,40 +8,40 @@ int printf(const char*, ...);
 
 typedef void (^T) (void);
 
-void takeclosure(T);
+void takeblock(T);
 int takeintint(int (^C)(int)) { return C(4); }
 
 T somefunction() {
-	if (^{ })
-	  nothing();
+  if (^{ })
+    nothing();
 
-	noop = ^{};
+  noop = ^{};
 
-	noop = ^{printf("\nClosure\n"); };
+  noop = ^{printf("\nClosure\n"); };
 
-	I(^{ });
+  I(^{ });
 
-	return ^{printf("\nClosure\n"); };
+  return ^{printf("\nClosure\n"); };
 }
 void test2() {
-	int x = 4;
+  int x = 4;
 
-	takeclosure(^{ printf("%d\n", x); });
+  takeblock(^{ printf("%d\n", x); });
 
   while (1) {
-	  takeclosure(^{ 
-      break;  // expected-error {{'break' statement not in loop or switch statement}}
-	    continue; // expected-error {{'continue' statement not in loop statement}}
-	    while(1) break;  // ok
-      goto foo; // expected-error {{goto not allowed}}
-    });
+    takeblock(^{ 
+        break;  // expected-error {{'break' statement not in loop or switch statement}}
+        continue; // expected-error {{'continue' statement not in loop statement}}
+        while(1) break;  // ok
+        goto foo; // expected-error {{goto not allowed}}
+      });
     break;
-	}
+  }
 
-foo:
-	takeclosure(^{ x = 4; });  // expected-error {{variable is not assignable (missing __block type specifier)}}
+  foo:
+  takeblock(^{ x = 4; });  // expected-error {{variable is not assignable (missing __block type specifier)}}
   __block y = 7;    // expected-warning {{type specifier missing, defaults to 'int'}}
-  takeclosure(^{ y = 8; });
+  takeblock(^{ y = 8; });
 }
 
 
@@ -59,11 +59,11 @@ void myfunc(int (^block)(int)) {}
 void myfunc3(const int *x);
 
 void test5() {
-    int a;
+  int a;
 
-    myfunc(^(int abcd) {
-        myfunc3(&a);
-        return 1;
+  myfunc(^(int abcd) {
+      myfunc3(&a);
+      return 1;
     });
 }
 
@@ -86,39 +86,3 @@ typedef void (^void_block_t)(void);
 static const void_block_t myBlock = ^{ };
 
 static const void_block_t myBlock2 = ^ void(void) { }; 
-
-#if 0
-// Old syntax. FIXME: convert/test.
-void test_byref() {
-  int i;
-  
-  X = ^{| g |};  // error {{use of undeclared identifier 'g'}}
-
-  X = ^{| i,i,i | };
-
-  X = ^{|i| i = 0; };
-
-}
-
-// TODO: global closures someday.
-void *A = ^{};
-void *B = ^(int){ A = 0; };
-
-
-// Closures can not take return types at this point.
-void test_retvals() {
-  // Explicit return value.
-  ^int{};   // error {{closure with explicit return type requires argument list}}
-  X = ^void(){};
-
-  // Optional specification of return type.
-  X = ^char{ return 'x'; };  // error {{closure with explicit return type requires argument list}}
-
-  X = ^/*missing declspec*/ *() { return (void*)0; };
-  X = ^void*() { return (void*)0; };
-  
-  //X = ^char(short c){ if (c) return c; else return (int)4; };
-  
-}
-
-#endif
diff --git a/test/Sema/block-misc.c b/test/Sema/block-misc.c
index 294c295c5f8c..8661fd8a5227 100644
--- a/test/Sema/block-misc.c
+++ b/test/Sema/block-misc.c
@@ -4,37 +4,37 @@ void donotwarn();
 int (^IFP) ();
 int (^II) (int);
 int test1() {
-  int (^PFR) (int) = 0;	// OK
-  PFR = II;	// OK
+  int (^PFR) (int) = 0; // OK
+  PFR = II;             // OK
 
-  if (PFR == II)	// OK
+  if (PFR == II)        // OK
     donotwarn();
 
-  if (PFR == IFP) // OK
+  if (PFR == IFP)       // OK
     donotwarn();
 
   if (PFR == (int (^) (int))IFP) // OK
     donotwarn();
 
-  if (PFR == 0) // OK
+  if (PFR == 0)         // OK
     donotwarn();
 
-  if (PFR)	// OK
+  if (PFR)              // OK
     donotwarn();
 
-  if (!PFR)	// OK
+  if (!PFR)             // OK
     donotwarn();
 
-  return PFR != IFP;	// OK
+  return PFR != IFP;    // OK
 }
 
 int test2(double (^S)()) {
   double (^I)(int)  = (void*) S;
-  (void*)I = (void *)S; 	// expected-error {{assignment to cast is illegal, lvalue casts are not supported}}
+  (void*)I = (void *)S; // expected-error {{assignment to cast is illegal, lvalue casts are not supported}}
 
   void *pv = I;
 
-  pv = S;		
+  pv = S;
 
   I(1);
 
@@ -44,7 +44,7 @@ int test2(double (^S)()) {
 int^ x; // expected-error {{block pointer to non-function type is invalid}}
 int^^ x1; // expected-error {{block pointer to non-function type is invalid}} expected-error {{block pointer to non-function type is invalid}}
 
-int test3() {
+void test3() {
   char *^ y; // expected-error {{block pointer to non-function type is invalid}}
 }
 
@@ -114,7 +114,7 @@ void test11(int i) {
 
 void (^test12f)(void);
 void test12() {
-  test12f = ^test12f;	// expected-error {{type name requires a specifier or qualifier}} expected-error {{expected expression}}
+  test12f = ^test12f;  // expected-error {{type name requires a specifier or qualifier}} expected-error {{expected expression}}
 }
 
 // rdar://6808730
@@ -144,7 +144,7 @@ void foo(long (^comp)()) {
 
 void (^test15f)(void);
 void test15() {
-  foo(^{ return LESS; });	// expected-error {{incompatible block pointer types passing 'int (^)(void)', expected 'long (^)()'}}
+  foo(^{ return LESS; }); // expected-error {{incompatible block pointer types passing 'int (^)(void)', expected 'long (^)()'}}
 }
 
 __block int test16i;  // expected-error {{__block attribute not allowed, only allowed on local variables}}
@@ -185,3 +185,16 @@ void test18() {
   void (^const  blockA)(void) = ^{ };
   blockA = ^{ }; // expected-error {{read-only variable is not assignable}}
 }
+
+// rdar://7072507
+int test19() {
+  goto L0;       // expected-error {{illegal goto into protected scope}}
+  
+  __block int x; // expected-note {{jump bypasses setup of __block variable}}
+L0:
+  x = 0;
+  ^(){ ++x; }();
+  return x;
+}
+
+
diff --git a/test/Sema/block-printf-attribute-1.c b/test/Sema/block-printf-attribute-1.c
index ce30b8e855b7..4941ae7bc679 100644
--- a/test/Sema/block-printf-attribute-1.c
+++ b/test/Sema/block-printf-attribute-1.c
@@ -1,15 +1,12 @@
 // RUN: clang-cc %s -fsyntax-only -verify -fblocks
 
-int main()
-{
-        void (^b) (int arg, const char * format, ...) __attribute__ ((__format__ (__printf__, 1, 3))) =   // expected-error {{format argument not a string type}}
-						^ __attribute__ ((__format__ (__printf__, 1, 3))) (int arg, const char * format, ...) {}; // expected-error {{format argument not a string type}}
+int main() {
+  void (^b) (int arg, const char * format, ...) __attribute__ ((__format__ (__printf__, 1, 3))) =   // expected-error {{format argument not a string type}}
+    ^ __attribute__ ((__format__ (__printf__, 1, 3))) (int arg, const char * format, ...) {}; // expected-error {{format argument not a string type}}
  
-        void (^z) (int arg, const char * format, ...) __attribute__ ((__format__ (__printf__, 2, 3))) = ^ __attribute__ ((__format__ (__printf__, 2, 3))) (int arg, const char * format, ...) {};
-
-        // FIXME: argument type poking not yet supportted.
-	z(1, "%s", 1); /* { dg-warning "format \\'\%s\\' expects type \\'char \\*\\'\, but argument 3 has type \\'int\\'" } */
-	z(1, "%s", "HELLO"); // OK
+  void (^z) (int arg, const char * format, ...) __attribute__ ((__format__ (__printf__, 2, 3))) = ^ __attribute__ ((__format__ (__printf__, 2, 3))) (int arg, const char * format, ...) {};
 
+  // FIXME: argument type poking not yet supportted.
+  z(1, "%s", 1); /* { dg-warning "format \\'\%s\\' expects type \\'char \\*\\'\, but argument 3 has type \\'int\\'" } */
+  z(1, "%s", "HELLO"); // OK
 }
-
diff --git a/test/Sema/block-return-1.c b/test/Sema/block-return-1.c
new file mode 100644
index 000000000000..2da87351e4f5
--- /dev/null
+++ b/test/Sema/block-return-1.c
@@ -0,0 +1,6 @@
+// RUN: clang-cc -fsyntax-only %s -verify -fblocks
+
+int j;
+void foo() {
+  ^ (void) { if (j) return 1; }(); // expected-error {{control may reach end of non-void block}}
+}
diff --git a/test/Sema/block-return-2.c b/test/Sema/block-return-2.c
new file mode 100644
index 000000000000..d389f4e4ffcc
--- /dev/null
+++ b/test/Sema/block-return-2.c
@@ -0,0 +1,5 @@
+// RUN: clang-cc -fsyntax-only %s -verify -fblocks
+
+void foo() {
+  ^ (void) __attribute__((noreturn)) { }(); // expected-error {{block declared 'noreturn' should not return}}
+}
diff --git a/test/Sema/block-return-3.c b/test/Sema/block-return-3.c
new file mode 100644
index 000000000000..e7e9342e02f4
--- /dev/null
+++ b/test/Sema/block-return-3.c
@@ -0,0 +1,5 @@
+// RUN: clang-cc -fsyntax-only %s -verify -fblocks
+
+void foo() {
+  ^ int (void) { }(); // expected-error {{control reaches end of non-void block}}
+}
diff --git a/test/Sema/block-return.c b/test/Sema/block-return.c
index 87f4040be9d0..98a72731d672 100644
--- a/test/Sema/block-return.c
+++ b/test/Sema/block-return.c
@@ -31,7 +31,7 @@ CL foo() {
       return (float)1.0;
     else
       if (2)
-	return (double)2.0;
+        return (double)2.0;
     return 1;
   };
   char *(^B)(void) = ^{
@@ -66,7 +66,7 @@ int foo3() {
     Boolean (*value_equal)(uintptr_t, uintptr_t) = 0;
             
     cb.isEqual = ^(const CFBasicHash *table, uintptr_t stack_value_or_key1, uintptr_t stack_value_or_key2, Boolean is_key) {
-    	return (Boolean)(uintptr_t)INVOKE_CALLBACK2(value_equal, (uintptr_t)stack_value_or_key1, (uintptr_t)stack_value_or_key2);
+      return (Boolean)(uintptr_t)INVOKE_CALLBACK2(value_equal, (uintptr_t)stack_value_or_key1, (uintptr_t)stack_value_or_key2);
     };
 }
 
@@ -91,6 +91,8 @@ bptr foo5(int j) {
   if (j)
     return ^{ ^{ i=0; }(); };  // expected-error {{returning block that lives on the local stack}}
   return ^{ i=0; };  // expected-error {{returning block that lives on the local stack}}
+  return (^{ i=0; });  // expected-error {{returning block that lives on the local stack}}
+  return (void*)(^{ i=0; });  // expected-error {{returning block that lives on the local stack}}
 }
 
 int (*funcptr3[5])(long);
diff --git a/test/Sema/block-sentinel-attribute.c b/test/Sema/block-sentinel-attribute.c
index a7d4df108ea7..5628a2c7801f 100644
--- a/test/Sema/block-sentinel-attribute.c
+++ b/test/Sema/block-sentinel-attribute.c
@@ -2,24 +2,23 @@
 
 void (^e) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (1,1)));
 
-int main()
-{
-        void (^bbad) (int arg, const char * format) __attribute__ ((__sentinel__)) ; // expected-warning {{sentinel' attribute only supported for variadic blocks}}
-        void (^b) (int arg, const char * format, ...) __attribute__ ((__sentinel__)) =  // expected-note {{block has been explicitly marked sentinel here}}
-						^ __attribute__ ((__sentinel__)) (int arg, const char * format, ...) {};
-        void (^z) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (2))) = ^ __attribute__ ((__sentinel__ (2))) (int arg, const char * format, ...) {}; // expected-note {{block has been explicitly marked sentinel here}}
+int main() {
+  void (^bbad) (int arg, const char * format) __attribute__ ((__sentinel__)) ; // expected-warning {{sentinel' attribute only supported for variadic blocks}}
+  void (^b) (int arg, const char * format, ...) __attribute__ ((__sentinel__)) =  // expected-note {{block has been explicitly marked sentinel here}}
+    ^ __attribute__ ((__sentinel__)) (int arg, const char * format, ...) {};
+  void (^z) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (2))) = ^ __attribute__ ((__sentinel__ (2))) (int arg, const char * format, ...) {}; // expected-note {{block has been explicitly marked sentinel here}}
 
 
-        void (^y) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (5))) = ^ __attribute__ ((__sentinel__ (5))) (int arg, const char * format, ...) {}; // expected-note {{block has been explicitly marked sentinel here}}
+  void (^y) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (5))) = ^ __attribute__ ((__sentinel__ (5))) (int arg, const char * format, ...) {}; // expected-note {{block has been explicitly marked sentinel here}}
 
-	b(1, "%s", (void*)0);	// OK
-	b(1, "%s", 0);  // expected-warning {{missing sentinel in block call}}
-	z(1, "%s",4 ,1,0);  // expected-warning {{missing sentinel in block call}}
-	z(1, "%s", (void*)0, 1, 0);	// OK
+  b(1, "%s", (void*)0); // OK
+  b(1, "%s", 0);  // expected-warning {{missing sentinel in block call}}
+  z(1, "%s",4 ,1,0);  // expected-warning {{missing sentinel in block call}}
+  z(1, "%s", (void*)0, 1, 0); // OK
 
-	y(1, "%s", 1,2,3,4,5,6,7);  // expected-warning {{missing sentinel in block call}}
+  y(1, "%s", 1,2,3,4,5,6,7);  // expected-warning {{missing sentinel in block call}}
 
-	y(1, "%s", (void*)0,3,4,5,6,7);	// OK
+  y(1, "%s", (void*)0,3,4,5,6,7); // OK
 
 }
 
diff --git a/test/Sema/builtin-prefetch.c b/test/Sema/builtin-prefetch.c
index 6b39e75d5257..bf28277acb81 100644
--- a/test/Sema/builtin-prefetch.c
+++ b/test/Sema/builtin-prefetch.c
@@ -1,6 +1,6 @@
 // RUN: clang-cc -fsyntax-only -verify %s
 
-int foo() {
+void foo() {
   int a;
   __builtin_prefetch(&a);
   __builtin_prefetch(&a, 1);
diff --git a/test/Sema/builtin-unary-fp.c b/test/Sema/builtin-unary-fp.c
new file mode 100644
index 000000000000..70c7a297fbe3
--- /dev/null
+++ b/test/Sema/builtin-unary-fp.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc %s -fsyntax-only -verify -pedantic
+void check(int);
+void a() {
+  check(__builtin_isfinite(1.0f));
+  check(__builtin_isinf(1.0));
+  check(__builtin_isinf_sign(1.0L));
+  check(__builtin_isnan(1.0f));
+  check(__builtin_isnormal(1.0f));
+  check(__builtin_isfinite(1)); // expected-error{{requires argument of floating point type}}
+  check(__builtin_isinf()); // expected-error{{too few arguments}}
+  check(__builtin_isnan(1,2)); // expected-error{{too many arguments}}
+}
diff --git a/test/Sema/builtins.c b/test/Sema/builtins.c
index 78b75624ea24..e133d626ee52 100644
--- a/test/Sema/builtins.c
+++ b/test/Sema/builtins.c
@@ -34,10 +34,40 @@ void test7() {
 
 // atomics.
 
-unsigned char test9(short v) {
+void test9(short v) {
   unsigned i, old;
   
   old = __sync_fetch_and_add();  // expected-error {{too few arguments to function call}}
   old = __sync_fetch_and_add(&old);  // expected-error {{too few arguments to function call}}
   old = __sync_fetch_and_add((int**)0, 42i); // expected-warning {{imaginary constants are an extension}}
 }
+
+
+// rdar://7236819
+void test10(void) __attribute__((noreturn));
+
+void test10(void) {
+  __asm__("int3");  
+  __builtin_unreachable();
+ 
+  // No warning about falling off the end of a noreturn function.
+}
+
+void test11(int X) {
+  switch (X) {  
+  case __builtin_eh_return_data_regno(0):  // constant foldable.
+    break;
+  }
+
+  __builtin_eh_return_data_regno(X);  // expected-error {{not an integer constant expression}}
+}
+
+// PR5062
+void test12(void) __attribute__((__noreturn__));
+void test12(void) {
+  __builtin_trap();  // no warning because trap is noreturn.
+}
+
+void test_unknown_builtin(int a, int b) {
+  __builtin_foo(a, b); // expected-error{{use of unknown builtin}}
+}
diff --git a/test/Sema/c89-2.c b/test/Sema/c89-2.c
index 723bd7c18d88..50c5f4e5a840 100644
--- a/test/Sema/c89-2.c
+++ b/test/Sema/c89-2.c
@@ -1,7 +1,5 @@
-/* RUN: not clang-cc %s -std=c89 -pedantic-errors
+/* RUN: clang-cc %s -std=c89 -pedantic-errors -verify
  */
 
-/* We can't put expected-warning lines on #if lines. */
-
-#if 1LL				/* expected-warning {{long long}} */
+#if 1LL        /* expected-error {{long long}} */
 #endif
diff --git a/test/Sema/c89.c b/test/Sema/c89.c
index e7585c31926c..fc50ebed6631 100644
--- a/test/Sema/c89.c
+++ b/test/Sema/c89.c
@@ -25,7 +25,7 @@ void test3(int i) {
   int A[i];        /* expected-warning {{variable length array}} */
 }
 
-int test4 = 0LL;		/* expected-warning {{long long}} */
+int test4 = 0LL;   /* expected-warning {{long long}} */
 
 /* PR1999 */
 void test5(register);
@@ -36,7 +36,7 @@ int *__restrict;  /* expected-error {{expected identifier}} */
 
 
 /* Implicit int, always ok */
-test6() {}
+test6() { return 0; }
 
 /* PR2012 */
 test7;  /* expected-warning {{declaration specifier missing, defaulting to 'int'}} */
diff --git a/test/Sema/compare.c b/test/Sema/compare.c
index 51f77317385c..87131bb62183 100644
--- a/test/Sema/compare.c
+++ b/test/Sema/compare.c
@@ -3,11 +3,11 @@
 int test(char *C) { // nothing here should warn.
   return C != ((void*)0);
   return C != (void*)0;
-  return C != 0;
+  return C != 0;  
+  return C != 1;  // expected-warning {{comparison between pointer and integer ('char *' and 'int')}}
 }
 
-int equal(char *a, const char *b)
-{
+int equal(char *a, const char *b) {
     return a == b;
 }
 
@@ -16,16 +16,21 @@ int arrays(char (*a)[5], char(*b)[10], char(*c)[5]) {
   return a == b; // expected-warning {{comparison of distinct pointer types}}
 }
 
-int pointers(int *a)
-{
-  return a > 0; // expected-warning {{ordered comparison between pointer and integer}}
+int pointers(int *a) {
+  return a > 0; // expected-warning {{ordered comparison between pointer and zero ('int *' and 'int') is an extension}}
+  return a > 42; // expected-warning {{ordered comparison between pointer and integer ('int *' and 'int')}}
   return a > (void *)0; // expected-warning {{comparison of distinct pointer types}}
 }
 
-int function_pointers(int (*a)(int), int (*b)(int))
-{
+int function_pointers(int (*a)(int), int (*b)(int), void (*c)(int)) {
   return a > b; // expected-warning {{ordered comparison of function pointers}}
   return function_pointers > function_pointers; // expected-warning {{ordered comparison of function pointers}}
+  return a > c; // expected-warning {{comparison of distinct pointer types}}
   return a == (void *) 0;
-  return a == (void *) 1; // expected-warning {{comparison of distinct pointer types}}
+  return a == (void *) 1; // expected-warning {{equality comparison between function pointer and void pointer}}
+}
+
+int void_pointers(void* foo) {
+  return foo == (void*) 0;
+  return foo == (void*) 1;
 }
diff --git a/test/Sema/complex-int.c b/test/Sema/complex-int.c
index 5977b4d1e0cb..6c660899e8a1 100644
--- a/test/Sema/complex-int.c
+++ b/test/Sema/complex-int.c
@@ -44,9 +44,8 @@ TestPairs(7); TestPairs(8);
 // rdar://6097730
 void test3(_Complex int *x) {
   *x = ~*x;
-}		
+}
 
 void test4(_Complex float *x) {
   *x = ~*x;
-}		
-
+}
diff --git a/test/Sema/conditional.c b/test/Sema/conditional.c
index 1c7486a6133e..9f48c349c964 100644
--- a/test/Sema/conditional.c
+++ b/test/Sema/conditional.c
@@ -4,12 +4,10 @@ const char* test1 = 1 ? "i" : 1 == 1 ? "v" : "r";
 
 void _efree(void *ptr);
 
-int _php_stream_free1()
-{
-	return (1 ? free(0) : _efree(0)); // expected-error {{incompatible type returning 'void', expected 'int'}}
+int _php_stream_free1() {
+  return (1 ? free(0) : _efree(0)); // expected-error {{incompatible type returning 'void', expected 'int'}}
 }
 
-int _php_stream_free2()
-{
-	return (1 ? _efree(0) : free(0));  // expected-error {{incompatible type returning 'void', expected 'int'}}
+int _php_stream_free2() {
+  return (1 ? _efree(0) : free(0));  // expected-error {{incompatible type returning 'void', expected 'int'}}
 }
diff --git a/test/Sema/darwin-align-cast.c b/test/Sema/darwin-align-cast.c
index 09808b5af2e8..fed898319157 100644
--- a/test/Sema/darwin-align-cast.c
+++ b/test/Sema/darwin-align-cast.c
@@ -8,10 +8,10 @@ struct cmsghdr {};
 
 #if 0
 This code below comes from the following system headers:
-sys/socket.h:#define	CMSG_SPACE(l)		(__DARWIN_ALIGN(sizeof(struct  
+sys/socket.h:#define CMSG_SPACE(l) (__DARWIN_ALIGN(sizeof(struct  
 cmsghdr)) + __DARWIN_ALIGN(l))
 
-i386/_param.h:#define	__DARWIN_ALIGN(p)	((__darwin_size_t)((char *)(p)  
+i386/_param.h:#define __DARWIN_ALIGN(p) ((__darwin_size_t)((char *)(p)  
 + __DARWIN_ALIGNBYTES) &~ __DARWIN_ALIGNBYTES)
 #endif
 
@@ -19,5 +19,6 @@ ssize_t sendFileDescriptor(int fd, void *data, size_t nbytes, int sendfd) {
   union {
     char control[(((__darwin_size_t)((char *)(sizeof(struct cmsghdr)) + (sizeof(__darwin_size_t) - 1)) &~ (sizeof(__darwin_size_t) - 1)) + ((__darwin_size_t)((char *)(sizeof(int)) + (sizeof(__darwin_size_t) - 1)) &~ (sizeof(__darwin_size_t) - 1)))];
   } control_un;
+  return 0;
 }
 
diff --git a/test/Sema/decl-type-merging.c b/test/Sema/decl-type-merging.c
index 1b789a142ade..1a8601298e9a 100644
--- a/test/Sema/decl-type-merging.c
+++ b/test/Sema/decl-type-merging.c
@@ -6,11 +6,11 @@ int testx[(sizeof(x) == sizeof(int) * 10) ? 1 : -1];
 
 int (*a)(int (*x)[10], int (*y)[]);
 int (*a)(int (*x)[], int (*y)[5]);
-int b() {
-int x[10], y[5];
-a(&x, &y);
-a(&y, &y); // expected-warning {{incompatible pointer}}
-a(&x, &x); // expected-warning {{incompatible pointer}}
+void b() {
+  int x[10], y[5];
+  a(&x, &y);
+  a(&y, &y); // expected-warning {{incompatible pointer}}
+  a(&x, &x); // expected-warning {{incompatible pointer}}
 }
 
 
diff --git a/test/Sema/enum.c b/test/Sema/enum.c
index adb937551237..31649e0ae9ed 100644
--- a/test/Sema/enum.c
+++ b/test/Sema/enum.c
@@ -43,7 +43,7 @@ void test4() {
     ;
   (_Bool)ve2;  // expected-error {{arithmetic or pointer type is required}}
 
-  for (; ;ve2)
+  for (; ;ve2) // expected-warning {{expression result unused}}
     ;
   (void)ve2;
   ve2;         // expected-warning {{expression result unused}}
diff --git a/test/Sema/exprs.c b/test/Sema/exprs.c
index 3fd1437da880..69a2320397fd 100644
--- a/test/Sema/exprs.c
+++ b/test/Sema/exprs.c
@@ -60,9 +60,9 @@ int test8(void) {
 struct f { int x : 4;  float y[]; };
 int test9(struct f *P) {
   int R;
-  R = __alignof(P->x);  // expected-error {{invalid application of '__alignof' to bitfield}}
+  R = __alignof(P->x);  // expected-error {{invalid application of '__alignof' to bit-field}}
   R = __alignof(P->y);   // ok.
-  R = sizeof(P->x); // expected-error {{invalid application of 'sizeof' to bitfield}}
+  R = sizeof(P->x); // expected-error {{invalid application of 'sizeof' to bit-field}}
   return R;
 }
 
@@ -94,15 +94,12 @@ void test13(
   P = ^(){}; // expected-error {{blocks support disabled - compile with -fblocks}}
 }
 
-
-// rdar://6326239 - Vector comparisons are not fully trusted yet, until the
-// backend is known to work, just unconditionally reject them.
 void test14() {
   typedef long long __m64 __attribute__((__vector_size__(8)));
   typedef short __v4hi __attribute__((__vector_size__(8)));
 
+  // Ok.
   __v4hi a;
-  __m64 mask = (__m64)((__v4hi)a >  // expected-error {{comparison of vector types ('__v4hi' and '__v4hi') not supported yet}}
-                      (__v4hi)a);
+  __m64 mask = (__m64)((__v4hi)a > (__v4hi)a);
 }
 
diff --git a/test/Sema/floating-point-compare.c b/test/Sema/floating-point-compare.c
index 763a8f4b86b4..9888105518d9 100644
--- a/test/Sema/floating-point-compare.c
+++ b/test/Sema/floating-point-compare.c
@@ -13,11 +13,11 @@ int f3(float x) {
 }
 
 int f4(float x) {
-	return x == 0.0; // no-warning {{comparing}}
+  return x == 0.0; // no-warning {{comparing}}
 }
 
 int f5(float x) {
-	return x == __builtin_inf(); // no-warning
+  return x == __builtin_inf(); // no-warning
 }
 
 int f7(float x) {
diff --git a/test/Sema/format-attr-pr4470.c b/test/Sema/format-attr-pr4470.c
index cba3adf1d6de..c03c573b7274 100644
--- a/test/Sema/format-attr-pr4470.c
+++ b/test/Sema/format-attr-pr4470.c
@@ -1,6 +1,7 @@
 // RUN: clang-cc -fsyntax-only -verify -Wformat=2 %s
 
 #include <stdio.h>
+#include <stdarg.h>
 
 const char *foo(const char *format) __attribute__((format_arg(1)));
 
diff --git a/test/Sema/format-attribute-printf0.c b/test/Sema/format-attribute-printf0.c
new file mode 100644
index 000000000000..fa7eafd52fb8
--- /dev/null
+++ b/test/Sema/format-attribute-printf0.c
@@ -0,0 +1,26 @@
+//RUN: clang-cc -fsyntax-only -verify %s
+
+#include <stdarg.h>
+
+// same as format(printf(...))...
+void a2(const char *a, ...)    __attribute__((format(printf0, 1,2))); // no-error
+void b2(const char *a, ...)    __attribute__((format(printf0, 1,1))); // expected-error {{'format' attribute parameter 3 is out of bounds}}
+void c2(const char *a, ...)    __attribute__((format(printf0, 0,2))); // expected-error {{'format' attribute parameter 2 is out of bounds}}
+void d2(const char *a, int c)  __attribute__((format(printf0, 1,2))); // expected-error {{format attribute requires variadic function}}
+void e2(char *str, int c, ...) __attribute__((format(printf0, 2,3))); // expected-error {{format argument not a string type}}
+
+// FreeBSD usage
+#define __printf0like(fmt,va) __attribute__((__format__(__printf0__,fmt,va)))
+void null(int i, const char *a, ...) __printf0like(2,0); // no-error
+void null(int i, const char *a, ...) {
+  if (a)
+    (void)0/* vprintf(...) would go here */;
+}
+
+void callnull(void){
+  null(0,        0); // no error
+  null(0, (char*)0); // no error
+  null(0, (void*)0); // no error
+  null(0,  (int*)0); // expected-warning {{incompatible pointer types}}
+}
+
diff --git a/test/Sema/freemain.c b/test/Sema/freemain.c
new file mode 100644
index 000000000000..a2364df259bf
--- /dev/null
+++ b/test/Sema/freemain.c
@@ -0,0 +1,9 @@
+// RUN: clang-cc -fsyntax-only -verify -ffreestanding %s
+
+// Tests that -ffreestanding disables all special treatment of main().
+
+void* allocate(long size);
+
+void* main(void* context, long size) {
+  if (context) return allocate(size);
+} // expected-warning {{control may reach end of non-void function}}
diff --git a/test/Sema/function-pointer-sentinel-attribute.c b/test/Sema/function-pointer-sentinel-attribute.c
index 0de02fa5363c..6d3fb1718076 100644
--- a/test/Sema/function-pointer-sentinel-attribute.c
+++ b/test/Sema/function-pointer-sentinel-attribute.c
@@ -2,22 +2,19 @@
 
 void (*e) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (1,1)));
 
-int main()
-{
-        void (*b) (int arg, const char * format, ...) __attribute__ ((__sentinel__));  // expected-note {{function has been explicitly marked sentinel here}}
-        void (*z) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (2))); // expected-note {{function has been explicitly marked sentinel here}}
+int main() {
+  void (*b) (int arg, const char * format, ...) __attribute__ ((__sentinel__));  // expected-note {{function has been explicitly marked sentinel here}}
+  void (*z) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (2))); // expected-note {{function has been explicitly marked sentinel here}}
 
 
-        void (*y) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (5))); // expected-note {{function has been explicitly marked sentinel here}}
+  void (*y) (int arg, const char * format, ...) __attribute__ ((__sentinel__ (5))); // expected-note {{function has been explicitly marked sentinel here}}
 
-	b(1, "%s", (void*)0);	// OK
-	b(1, "%s", 0);  // expected-warning {{missing sentinel in function call}}
-	z(1, "%s",4 ,1,0);  // expected-warning {{missing sentinel in function call}}
-	z(1, "%s", (void*)0, 1, 0);	// OK
+  b(1, "%s", (void*)0); // OK
+  b(1, "%s", 0);  // expected-warning {{missing sentinel in function call}}
+  z(1, "%s",4 ,1,0);  // expected-warning {{missing sentinel in function call}}
+  z(1, "%s", (void*)0, 1, 0); // OK
 
-	y(1, "%s", 1,2,3,4,5,6,7);  // expected-warning {{missing sentinel in function call}}
-
-	y(1, "%s", (void*)0,3,4,5,6,7);	// OK
+  y(1, "%s", 1,2,3,4,5,6,7);  // expected-warning {{missing sentinel in function call}}
 
+  y(1, "%s", (void*)0,3,4,5,6,7); // OK
 }
-
diff --git a/test/Sema/function-sentinel-attr.c b/test/Sema/function-sentinel-attr.c
index 66304796127f..b33b4a063ce2 100644
--- a/test/Sema/function-sentinel-attr.c
+++ b/test/Sema/function-sentinel-attr.c
@@ -18,7 +18,7 @@ int main ()
   foo1(1, 0) ; // expected-warning {{missing sentinel in function call}}
   foo5(1, NULL, 2);  // OK
   foo5(1,2,NULL, 1); // OK
-  foo5(1, NULL, 2, 1);	// expected-warning {{missing sentinel in function call}}
+  foo5(1, NULL, 2, 1); // expected-warning {{missing sentinel in function call}}
 
   foo6(1,2,3,4,5,6,7); // expected-warning {{missing sentinel in function call}}
   foo6(1,NULL,3,4,5,6,7); // OK
diff --git a/test/Sema/function.c b/test/Sema/function.c
index c9d8630c47f6..e7a37f1a2fc1 100644
--- a/test/Sema/function.c
+++ b/test/Sema/function.c
@@ -87,3 +87,5 @@ unknown_type t19(int* P) {   // expected-error {{unknown type name 'unknown_type
   P = P+1;  // no warning.
 }
 
+// missing ',' before '...'
+void t20(int i...) { } // expected-error {{requires a comma}}
diff --git a/test/Sema/heinous-extensions-on.c b/test/Sema/heinous-extensions-on.c
index 480b1b41e906..a56f1f6f625c 100644
--- a/test/Sema/heinous-extensions-on.c
+++ b/test/Sema/heinous-extensions-on.c
@@ -1,10 +1,9 @@
 // RUN: clang-cc %s -verify -fheinous-gnu-extensions
 
-int foo() {
-        int a;
-        // PR3788
-        asm("nop" : : "m"((int)(a))); // expected-warning {{cast in a inline asm context requiring an l-value}}
-        // PR3794
-        asm("nop" : "=r"((unsigned)a)); // expected-warning {{cast in a inline asm context requiring an l-value}}
+void foo() {
+  int a;
+  // PR3788
+  asm("nop" : : "m"((int)(a))); // expected-warning {{cast in a inline asm context requiring an l-value}}
+  // PR3794
+  asm("nop" : "=r"((unsigned)a)); // expected-warning {{cast in a inline asm context requiring an l-value}}
 }
-
diff --git a/test/Sema/implicit-builtin-redecl.c b/test/Sema/implicit-builtin-redecl.c
index cd99b5455318..36513bafb050 100644
--- a/test/Sema/implicit-builtin-redecl.c
+++ b/test/Sema/implicit-builtin-redecl.c
@@ -12,3 +12,15 @@ void *calloc(int, int, int); // expected-warning{{incompatible redeclaration of
 void f1(void) { 
   calloc(0, 0, 0);
 }
+
+void f2() {
+  int index = 1;
+}
+
+static int index;
+
+int f3() {
+  return index << 2;
+}
+
+typedef int rindex;
\ No newline at end of file
diff --git a/test/Sema/implicit-int.c b/test/Sema/implicit-int.c
index 04b27a8f0ea9..5190bdbf934b 100644
--- a/test/Sema/implicit-int.c
+++ b/test/Sema/implicit-int.c
@@ -1,6 +1,7 @@
 // RUN: clang-cc -fsyntax-only %s -verify -pedantic
 
 foo() { // expected-warning {{type specifier missing, defaults to 'int'}}
+  return 0;
 }
 
 y;  // expected-warning {{type specifier missing, defaults to 'int'}}
@@ -11,19 +12,19 @@ void f((x));  // expected-warning {{type specifier missing, defaults to 'int'}}
 
 // PR3702
 #define PAD(ms10) { \
-	register i; \
+    register i;     \
 }
 
-#define ILPAD() PAD((NROW - tt.tt_row) * 10)	/* 1 ms per char */
+#define ILPAD() PAD((NROW - tt.tt_row) * 10) /* 1 ms per char */
 
 void
 h19_insline(n)  // expected-warning {{parameter 'n' was not declared, defaulting to type 'int'}}
 {
-	ILPAD();  // expected-warning {{type specifier missing, defaults to 'int'}}
+  ILPAD();  // expected-warning {{type specifier missing, defaults to 'int'}}
 }
 
 struct foo {
- __extension__ __attribute__((packed)) x : 4; // expected-warning {{type specifier missing, defaults to 'int'}}
+ __extension__ __attribute__((packed)) x : 4;
 };
 
 
diff --git a/test/Sema/incomplete-call.c b/test/Sema/incomplete-call.c
index aedfe50bbfdd..15d97683c5a0 100644
--- a/test/Sema/incomplete-call.c
+++ b/test/Sema/incomplete-call.c
@@ -2,12 +2,12 @@
 
 struct foo; // expected-note 3 {{forward declaration of 'struct foo'}}
 
-struct foo a();
+struct foo a(); // expected-note {{'a' declared here}}
 void b(struct foo);
 void c();
 
 void func() {
-  a(); // expected-error{{return type of called function ('struct foo') is incomplete}}
+  a(); // expected-error{{calling 'a' with incomplete return type 'struct foo'}}
   b(*(struct foo*)0); // expected-error{{argument type 'struct foo' is incomplete}}
   c(*(struct foo*)0); // expected-error{{argument type 'struct foo' is incomplete}}
 }
diff --git a/test/Sema/incomplete-decl.c b/test/Sema/incomplete-decl.c
index eb93e8e38031..6a6ba753f3fe 100644
--- a/test/Sema/incomplete-decl.c
+++ b/test/Sema/incomplete-decl.c
@@ -1,12 +1,13 @@
 // RUN: clang-cc -fsyntax-only -verify %s
 
-struct foo; // expected-note 4 {{forward declaration of 'struct foo'}}
+struct foo; // expected-note 5 {{forward declaration of 'struct foo'}}
 
 void b;  // expected-error {{variable has incomplete type 'void'}}
 struct foo f; // expected-error{{tentative definition has type 'struct foo' that is never completed}}
 
 static void c; // expected-error {{variable has incomplete type 'void'}}
-static struct foo g;  // expected-error {{variable has incomplete type 'struct foo'}}
+static struct foo g;  // expected-warning {{tentative definition of variable with internal linkage has incomplete non-array type 'struct foo'}} \
+    expected-error{{tentative definition has type 'struct foo' that is never completed}}
 
 extern void d;
 extern struct foo e;
diff --git a/test/Sema/pragma-pack-4.c b/test/Sema/pragma-pack-4.c
new file mode 100644
index 000000000000..f6f107da742b
--- /dev/null
+++ b/test/Sema/pragma-pack-4.c
@@ -0,0 +1,19 @@
+// RUN: clang-cc -triple i686-apple-darwin9 %s -fsyntax-only -verify &&
+// RUN: clang-cc -triple x86_64-apple-darwin9 %s -fsyntax-only -verify
+
+// rdar://problem/7095436
+#pragma pack(4)
+
+struct s0 {
+  long long a __attribute__((aligned(8)));
+  long long b __attribute__((aligned(8)));
+  unsigned int c __attribute__((aligned(8)));
+  int d[12];
+};
+
+struct s1 {
+  int a[15];
+  struct s0 b;
+};
+
+int arr0[((sizeof(struct s1) % 64) == 0) ? 1 : -1];
diff --git a/test/Sema/pragma-unused.c b/test/Sema/pragma-unused.c
index fe8bf8608bc3..8b9498962646 100644
--- a/test/Sema/pragma-unused.c
+++ b/test/Sema/pragma-unused.c
@@ -16,7 +16,7 @@ void f2(void) {
 }
 
 void f3(void) {
-  #pragma unused(x) // expected-error{{use of undeclared identifier 'x'}}
+  #pragma unused(x) // expected-warning{{undeclared variable 'x' used as an argument for '#pragma unused'}}
 }
 
 void f4(void) {
@@ -26,7 +26,7 @@ void f4(void) {
 
 int k;
 void f5(void) {
-  #pragma unused(k) // expected-warning{{only local variables can be arguments to '#pragma unused' - ignored}}
+  #pragma unused(k) // expected-warning{{only local variables can be arguments to '#pragma unused'}}
 }
 
 void f6(void) {
@@ -36,3 +36,8 @@ void f6(void) {
   }
 }
 
+void f7() {
+  int y;
+  #pragma unused(undeclared, undefined, y) // expected-warning{{undeclared variable 'undeclared' used as an argument for '#pragma unused'}} expected-warning{{undeclared variable 'undefined' used as an argument for '#pragma unused'}}
+}
+
diff --git a/test/Sema/predefined-function.c b/test/Sema/predefined-function.c
index e8ccb3636b8e..c8d17f0078e6 100644
--- a/test/Sema/predefined-function.c
+++ b/test/Sema/predefined-function.c
@@ -8,31 +8,30 @@ int eli(float b); // expected-note {{previous declaration is here}}
 int b(int c) {return 1;}
 
 int foo();
-int foo()
-{
-    int eli(int (int)); // expected-error {{conflicting types for 'eli'}}
-    eli(b); // expected-error{{incompatible type passing}}
-	return 0;	
+int foo() {
+  int eli(int (int)); // expected-error {{conflicting types for 'eli'}}
+  eli(b); // expected-error{{incompatible type passing}}
+  return 0;
 }
 
 int bar();
 int bar(int i) // expected-note {{previous definition is here}}
 {
-	return 0;
+  return 0;
 }
 int bar() // expected-error {{redefinition of 'bar'}} 
 {
-	return 0;
+  return 0;
 }
 
 int foobar(int); // note {{previous declaration is here}}
 int foobar() // error {{conflicting types for 'foobar'}}
 {
-	return 0;
+  return 0;
 }
 
 int wibble(); // expected-note {{previous declaration is here}}
 float wibble() // expected-error {{conflicting types for 'wibble'}}
 {
-	return 0.0f;
+  return 0.0f;
 }
diff --git a/test/Sema/promote-int-16bit.c b/test/Sema/promote-int-16bit.c
new file mode 100644
index 000000000000..fbd1215d90d2
--- /dev/null
+++ b/test/Sema/promote-int-16bit.c
@@ -0,0 +1,6 @@
+// RUN: clang-cc -fsyntax-only -verify %s -triple pic16-unknown-unknown
+
+// Check that unsigned short promotes to unsigned int on targets where
+// sizeof(unsigned short) == sizeof(unsigned int)
+__typeof(1+(unsigned short)1) x;
+unsigned x;
diff --git a/test/Sema/redefinition.c b/test/Sema/redefinition.c
index 26c90c8e6d4f..9339bb935f6c 100644
--- a/test/Sema/redefinition.c
+++ b/test/Sema/redefinition.c
@@ -1,7 +1,7 @@
 // RUN: clang-cc %s -fsyntax-only -verify
-int f(int a) { } // expected-note {{previous definition is here}}
+int f(int a) { return 0; } // expected-note {{previous definition is here}}
 int f(int);
-int f(int a) { } // expected-error {{redefinition of 'f'}}
+int f(int a) { return 0; } // expected-error {{redefinition of 'f'}}
 
 // <rdar://problem/6097326>
 int foo(x) {
diff --git a/test/Sema/return-noreturn.c b/test/Sema/return-noreturn.c
new file mode 100644
index 000000000000..e2452f407f4f
--- /dev/null
+++ b/test/Sema/return-noreturn.c
@@ -0,0 +1,29 @@
+// RUN: clang-cc %s -fsyntax-only -verify -fblocks -Wmissing-noreturn
+
+int j;
+void test1() { // expected-warning {{function could be attribute 'noreturn'}}
+  ^ (void) { while (1) { } }(); // expected-warning {{block could be attribute 'noreturn'}}
+  ^ (void) { if (j) while (1) { } }();
+  while (1) { }
+}
+
+void test2() {
+  if (j) while (1) { }
+}
+
+__attribute__((__noreturn__))
+void test2_positive() {
+  if (j) while (1) { }
+} // expected-warning{{function declared 'noreturn' should not return}}
+
+
+// This test case illustrates that we don't warn about the missing return
+// because the function is marked noreturn and there is an infinite loop.
+extern int foo_test_3();
+__attribute__((__noreturn__)) void* test3(int arg) {
+  while (1) foo_test_3();
+}
+
+__attribute__((__noreturn__)) void* test3_positive(int arg) {
+  while (0) foo_test_3();
+} // expected-warning{{function declared 'noreturn' should not return}}
diff --git a/test/Sema/return.c b/test/Sema/return.c
index d96cede68a61..64def306ebc8 100644
--- a/test/Sema/return.c
+++ b/test/Sema/return.c
@@ -1,4 +1,4 @@
-// RUN: clang-cc %s -fsyntax-only -verify
+// RUN: clang-cc %s -fsyntax-only -verify -fblocks
 
 // clang emits the following warning by default.
 // With GCC, -pedantic, -Wreturn-type or -Wall are required to produce the 
@@ -10,3 +10,211 @@ int t14() {
 void t15() {
   return 1; // expected-warning {{void function 't15' should not return a value}}
 }
+
+int unknown();
+
+void test0() {
+}
+
+int test1() {
+} // expected-warning {{control reaches end of non-void function}}
+
+int test2() {
+  a: goto a;
+}
+
+int test3() {
+  goto a;
+  a: ;
+} // expected-warning {{control reaches end of non-void function}}
+
+
+void halt() {
+  a: goto a;
+}
+
+void halt2() __attribute__((noreturn));
+
+int test4() {
+  halt2();
+}
+
+int test5() {
+  halt2(), (void)1;
+}
+
+int test6() {
+  1, halt2();
+}
+
+int j;
+int unknown_nohalt() {
+  return j;
+}
+
+int test7() {
+  unknown();
+} // expected-warning {{control reaches end of non-void function}}
+
+int test8() {
+  (void)(1 + unknown());
+} // expected-warning {{control reaches end of non-void function}}
+
+int halt3() __attribute__((noreturn));
+
+int test9() {
+  (void)(halt3() + unknown());
+}
+
+int test10() {
+  (void)(unknown() || halt3());
+} // expected-warning {{control may reach end of non-void function}}
+
+int test11() {
+  (void)(unknown() && halt3());
+} // expected-warning {{control may reach end of non-void function}}
+
+int test12() {
+  (void)(halt3() || unknown());
+}
+
+int test13() {
+  (void)(halt3() && unknown());
+}
+
+int test14() {
+  (void)(1 || unknown());
+} // expected-warning {{control reaches end of non-void function}}
+
+int test15() {
+  (void)(0 || unknown());
+} // expected-warning {{control reaches end of non-void function}}
+
+int test16() {
+  (void)(0 && unknown());
+} // expected-warning {{control reaches end of non-void function}}
+
+int test17() {
+  (void)(1 && unknown());
+} // expected-warning {{control reaches end of non-void function}}
+
+int test18() {
+  (void)(unknown_nohalt() && halt3());
+} // expected-warning {{control may reach end of non-void function}}
+
+int test19() {
+  (void)(unknown_nohalt() && unknown());
+} // expected-warning {{control reaches end of non-void function}}
+
+int test20() {
+  int i;
+  if (i)
+    return 0;
+  else if (0)
+    return 2;
+} // expected-warning {{control may reach end of non-void function}}
+
+int test21() {
+  int i;
+  if (i)
+    return 0;
+  else if (1)
+    return 2;
+}
+
+int test22() {
+  int i;
+  switch (i) default: ;
+} // expected-warning {{control reaches end of non-void function}}
+
+int test23() {
+  int i;
+  switch (i) {
+  case 0:
+    return 0;
+  case 2:
+    return 2;
+  }
+} // expected-warning {{control may reach end of non-void function}}
+
+int test24() {
+  int i;
+  switch (i) {
+    case 0:
+    return 0;
+  case 2:
+    return 2;
+  default:
+    return -1;
+  }
+}
+
+int test25() {
+  1 ? halt3() : unknown();
+}
+
+int test26() {
+  0 ? halt3() : unknown();
+} // expected-warning {{control reaches end of non-void function}}
+
+int j;
+void (*fptr)() __attribute__((noreturn));
+int test27() {
+  switch (j) {
+  case 1:
+    do { } while (1);
+    break;
+  case 2:
+    for (;;) ;
+    break;
+  case 3:
+    for (;1;) ;
+    for (;0;) {
+      goto done;
+    }
+    return 1;
+  case 4:    
+    while (0) { goto done; }
+    return 1;
+  case 5:
+    while (1) { return 1; }
+    break;
+  case 6:
+    fptr();
+    break;
+  default:
+    return 1;
+  }
+  done: ;
+}
+
+// PR4624
+void test28() __attribute__((noreturn));
+void test28(x) { while (1) { } }
+
+void exit(int);
+int test29() {
+  exit(1);
+}
+
+#include <setjmp.h>
+jmp_buf test30_j;
+int test30() {
+  if (j)
+    longjmp(test30_j, 1);
+  else
+    _longjmp(test30_j, 1);
+}
+
+typedef void test31_t(int status);
+void test31(test31_t *callback __attribute__((noreturn)));
+
+void test32() {
+  ^ (void) { while (1) { } }();
+  ^ (void) { if (j) while (1) { } }();
+  while (1) { }
+}
+
+void test33() {
+  if (j) while (1) { }
+}
diff --git a/test/Sema/shift.c b/test/Sema/shift.c
index 5acbe12ac33e..2516d1b86107 100644
--- a/test/Sema/shift.c
+++ b/test/Sema/shift.c
@@ -1,6 +1,40 @@
-// RUN: clang-cc -fsyntax-only %s
+// RUN: clang-cc -Wall -fsyntax-only -verify %s
+
+#include <limits.h>
+
+enum {
+  X = 1 << 0,
+  Y = 1 << 1,
+  Z = 1 << 2
+};
 
 void test() {
   char c;
-  c <<= 14;
+
+  c = 0 << 0;
+  c = 0 << 1;
+  c = 1 << 0;
+  c = 1 << -0;
+  c = 1 >> -0;
+  c = 1 << -1; // expected-warning {{shift count is negative}}
+  c = 1 >> -1; // expected-warning {{shift count is negative}}
+  c = 1 << c;
+  c <<= 0;
+  c >>= 0;
+  c <<= 1;
+  c >>= 1;
+  c <<= -1; // expected-warning {{shift count is negative}}
+  c >>= -1; // expected-warning {{shift count is negative}}
+  c <<= 999999; // expected-warning {{shift count >= width of type}}
+  c >>= 999999; // expected-warning {{shift count >= width of type}}
+  c <<= CHAR_BIT; // expected-warning {{shift count >= width of type}}
+  c >>= CHAR_BIT; // expected-warning {{shift count >= width of type}}
+  c <<= CHAR_BIT+1; // expected-warning {{shift count >= width of type}}
+  c >>= CHAR_BIT+1; // expected-warning {{shift count >= width of type}}
+  (void)((long)c << CHAR_BIT);
 }
+
+#define a 0
+#define ashift 8
+enum { b = (a << ashift) };
+
diff --git a/test/Sema/static-init.c b/test/Sema/static-init.c
index cd495568ca3f..510f3ab099af 100644
--- a/test/Sema/static-init.c
+++ b/test/Sema/static-init.c
@@ -11,11 +11,11 @@ _Bool t = &t;
 
 
 union bar {
-	int i;
+  int i;
 };
 
 struct foo {
-	unsigned ptr;
+  unsigned ptr;
 };
 
 union bar u[1];
diff --git a/test/Sema/struct-decl.c b/test/Sema/struct-decl.c
index 2c0945f9f86b..a5a299bf09b2 100644
--- a/test/Sema/struct-decl.c
+++ b/test/Sema/struct-decl.c
@@ -1,26 +1,26 @@
 // RUN: clang-cc -fsyntax-only -verify %s
 // PR3459
 struct bar {
-	char n[1];
+  char n[1];
 };
 
 struct foo {
-	char name[(int)&((struct bar *)0)->n];
-	char name2[(int)&((struct bar *)0)->n - 1]; //expected-error{{array size is negative}}
+  char name[(int)&((struct bar *)0)->n];
+  char name2[(int)&((struct bar *)0)->n - 1]; //expected-error{{array size is negative}}
 };
 
 // PR3430
 struct s {
-        struct st {
-                int v;
-        } *ts;
+  struct st {
+    int v;
+  } *ts;
 };
 
 struct st;
 
 int foo() {
-        struct st *f;
-        return f->v + f[0].v;
+  struct st *f;
+  return f->v + f[0].v;
 }
 
 // PR3642, PR3671
@@ -29,8 +29,8 @@ struct pppoe_tag {
  char tag_data[];
 };
 struct datatag {
- struct pppoe_tag hdr; //expected-warning{{field 'hdr' with variable sized type 'struct pppoe_tag' not at the end of a struct or class is a GNU extension}}
- char data;
+  struct pppoe_tag hdr; //expected-warning{{field 'hdr' with variable sized type 'struct pppoe_tag' not at the end of a struct or class is a GNU extension}}
+  char data;
 };
 
 
diff --git a/test/Sema/tentative-decls.c b/test/Sema/tentative-decls.c
index e3c893c77718..c94af1160b89 100644
--- a/test/Sema/tentative-decls.c
+++ b/test/Sema/tentative-decls.c
@@ -2,7 +2,7 @@
 
 // PR3310
 struct a x1; // expected-note 2{{forward declaration of 'struct a'}}
-static struct a x2; // expected-error{{variable has incomplete type 'struct a'}}
+static struct a x2; // expected-warning{{tentative definition of variable with internal linkage has incomplete non-array type 'struct a'}}
 struct a x3[10]; // expected-error{{array has incomplete element type 'struct a'}}
 struct a {int x;};
 static struct a x2_okay;
diff --git a/test/Sema/transparent-union-pointer.c b/test/Sema/transparent-union-pointer.c
index ea761f17e7d6..a58bd42f821f 100644
--- a/test/Sema/transparent-union-pointer.c
+++ b/test/Sema/transparent-union-pointer.c
@@ -1,14 +1,14 @@
 // RUN: clang-cc %s -fsyntax-only -verify
 
 typedef union   {
-	union wait *__uptr;
-	int *__iptr;
+  union wait *__uptr;
+  int *__iptr;
 } __WAIT_STATUS __attribute__ ((__transparent_union__));
 
 extern int wait (__WAIT_STATUS __stat_loc);
 
 void fastcgi_cleanup() {
-	int status = 0;
-	wait(&status);
+  int status = 0;
+  wait(&status);
 }
 
diff --git a/test/Sema/type-spec-struct-union.c b/test/Sema/type-spec-struct-union.c
index 2b68b7877318..003efb14620b 100644
--- a/test/Sema/type-spec-struct-union.c
+++ b/test/Sema/type-spec-struct-union.c
@@ -57,7 +57,7 @@ struct bar_baz {
   } mode;
   int             nowrap;
 };
-int 
+void
 wizbiz_quxPoof(z)
   z_foop       z;
 {
diff --git a/test/Sema/unused-expr.c b/test/Sema/unused-expr.c
index 9c231e960a2a..acf488706f7e 100644
--- a/test/Sema/unused-expr.c
+++ b/test/Sema/unused-expr.c
@@ -25,7 +25,7 @@ void bar(volatile int *VP, int *P, int A,
   __real__ VC;
   
   // We know this can't change errno because of -fno-math-errno.
-  sqrt(A);  // expected-warning {{expression result unused}}
+  sqrt(A);  // expected-warning {{ignoring return value of function declared with const attribute}}
 }
 
 extern void t1();
@@ -43,4 +43,56 @@ void nowarn(unsigned char* a, unsigned char* b)
 {
   unsigned char c = 1;
   *a |= c, *b += c;
+
+
+  // PR4633
+  int y, x;
+  ((void)0), y = x;
+}
+
+void t4(int a) {
+  int b = 0;
+
+  if (a)
+    b == 1; // expected-warning{{expression result unused}}
+  else
+    b == 2; // expected-warning{{expression result unused}}
+    
+  while (1)
+    b == 3; // expected-warning{{expression result unused}}
+
+  do
+    b == 4; // expected-warning{{expression result unused}}
+  while (1);
+  
+  for (;;)
+    b == 5; // expected-warning{{expression result unused}}
+    
+  for (b == 1;;) {} // expected-warning{{expression result unused}}
+  for (;b == 1;) {}
+  for (;;b == 1) {} // expected-warning{{expression result unused}}
 }
+
+// rdar://7186119
+int t5f(void) __attribute__((warn_unused_result));
+void t5() {
+  t5f();   // expected-warning {{ignoring return value of function declared with warn_unused_result}}
+}
+
+
+int fn1() __attribute__ ((warn_unused_result));
+int fn2() __attribute__ ((pure));
+int fn3() __attribute__ ((const));
+// rdar://6587766
+int t6() {
+  if (fn1() < 0 || fn2(2,1) < 0 || fn3(2) < 0)  // no warnings
+    return -1;
+  
+  fn1();  // expected-warning {{ignoring return value of function declared with warn_unused_result attribute}}
+  fn2(92, 21);  // expected-warning {{ignoring return value of function declared with pure attribute}}
+  fn3(42);  // expected-warning {{ignoring return value of function declared with const attribute}}
+  return 0;
+}
+
+int t7 __attribute__ ((warn_unused_result)); // expected-warning {{warning: 'warn_unused_result' attribute only applies to function types}}
+
diff --git a/test/Sema/va_arg_x86_64.c b/test/Sema/va_arg_x86_64.c
index 680abb714b91..61ac97b7d451 100644
--- a/test/Sema/va_arg_x86_64.c
+++ b/test/Sema/va_arg_x86_64.c
@@ -8,9 +8,8 @@ char* foo(char *fmt, __builtin_va_list ap)
 
 // PR2692
 typedef __builtin_va_list va_list;
-static char *f (char * (*g) (char **, int), char **p, ...) {
-    char *s;
-    va_list v;
-    s = g (p, __builtin_va_arg(v, int));
+static void f (char * (*g) (char **, int), char **p, ...) {
+  char *s;
+  va_list v;
+  s = g (p, __builtin_va_arg(v, int));
 }
-
diff --git a/test/Sema/vector-cast.c b/test/Sema/vector-cast.c
index 9460cac6d187..8c607aad073e 100644
--- a/test/Sema/vector-cast.c
+++ b/test/Sema/vector-cast.c
@@ -20,7 +20,7 @@ void f()
 type 't1' and scalar type 'char *'}}
   v1 = (t1)(long long)10;
   v1 = (t1)(short)10; // -expected-error {{invalid conversion between vector \
-type 't1' and integer type 'int' of different size}}
+type 't1' and integer type 'short' of different size}}
   
   long long r1 = (long long)v1;
   short r2 = (short)v1; // -expected-error {{invalid conversion between vector \
diff --git a/test/Sema/warn-char-subscripts.c b/test/Sema/warn-char-subscripts.c
new file mode 100644
index 000000000000..c6fd78cc1f74
--- /dev/null
+++ b/test/Sema/warn-char-subscripts.c
@@ -0,0 +1,64 @@
+// RUN: clang-cc -Wchar-subscripts -fsyntax-only -verify %s
+
+void t1() {
+  int array[1] = { 0 };
+  char subscript = 0;
+  int val = array[subscript]; // expected-warning{{array subscript is of type 'char'}}
+}
+
+void t2() {
+  int array[1] = { 0 };
+  char subscript = 0;
+  int val = subscript[array]; // expected-warning{{array subscript is of type 'char'}}
+}
+
+void t3() {
+  int *array = 0;
+  char subscript = 0;
+  int val = array[subscript]; // expected-warning{{array subscript is of type 'char'}}
+}
+
+void t4() {
+  int *array = 0;
+  char subscript = 0;
+  int val = subscript[array]; // expected-warning{{array subscript is of type 'char'}}
+}
+
+char returnsChar();
+void t5() {
+  int *array = 0;
+  int val = array[returnsChar()]; // expected-warning{{array subscript is of type 'char'}}
+}
+
+void t6() {
+  int array[1] = { 0 };
+  signed char subscript = 0;
+  int val = array[subscript]; // no warning for explicit signed char
+}
+
+void t7() {
+  int array[1] = { 0 };
+  unsigned char subscript = 0;
+  int val = array[subscript]; // no warning for unsigned char
+}
+
+typedef char CharTy;
+void t8() {
+  int array[1] = { 0 };
+  CharTy subscript = 0;
+  int val = array[subscript]; // expected-warning{{array subscript is of type 'char'}}
+}
+
+typedef signed char SignedCharTy;
+void t9() {
+  int array[1] = { 0 };
+  SignedCharTy subscript = 0;
+  int val = array[subscript]; // no warning for explicit signed char
+}
+
+typedef unsigned char UnsignedCharTy;
+void t10() {
+  int array[1] = { 0 };
+  UnsignedCharTy subscript = 0;
+  int val = array[subscript]; // no warning for unsigned char
+}
diff --git a/test/Sema/warn-unused-variables.c b/test/Sema/warn-unused-variables.c
new file mode 100644
index 000000000000..fd225436be82
--- /dev/null
+++ b/test/Sema/warn-unused-variables.c
@@ -0,0 +1,19 @@
+// RUN: clang-cc -fsyntax-only -Wunused-variable -verify %s
+
+struct s0 {
+	unsigned int	i;
+};
+
+int proto(int a, int b);
+
+void f0(void) {
+	int	a __attribute__((unused)),
+		b; // expected-warning{{unused}}
+	return;
+}
+
+void f1(void) {
+	int	i;
+	(void)sizeof(i);
+	return;
+}
diff --git a/test/Sema/x86-intrinsics-headers.c b/test/Sema/x86-intrinsics-headers.c
new file mode 100644
index 000000000000..dd7dd5caf017
--- /dev/null
+++ b/test/Sema/x86-intrinsics-headers.c
@@ -0,0 +1,24 @@
+// RUN: clang -fsyntax-only %s &&
+// RUN: clang -fsyntax-only -fno-lax-vector-conversions %s &&
+// RUN: clang -fsyntax-only -x c++ %s
+
+#if defined(i386) || defined(__x86_64__)
+
+#  if defined(__MMX__)
+#include <emmintrin.h>
+#include <mm_malloc.h>
+#  endif
+
+#  if defined(__SSE__)
+#include <xmmintrin.h>
+#  endif
+
+#  if defined(__SSE3__)
+#include <pmmintrin.h>
+#  endif
+
+#  if defined(__SSSE3__)
+#include <tmmintrin.h>
+#  endif
+
+#endif
diff --git a/test/SemaCXX/PR5086-ambig-resolution-enum.cpp b/test/SemaCXX/PR5086-ambig-resolution-enum.cpp
new file mode 100644
index 000000000000..838bc6f3c716
--- /dev/null
+++ b/test/SemaCXX/PR5086-ambig-resolution-enum.cpp
@@ -0,0 +1,13 @@
+// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x
+
+class C {
+public:
+        enum E { e1=0 };
+        const char * fun1(int , enum E) const;
+        int fun1(unsigned, const char *) const;
+};
+
+void foo(const C& rc) {
+        enum {BUFLEN = 128 };
+        const char *p = rc.fun1(BUFLEN - 2, C::e1);
+}
diff --git a/test/SemaCXX/abstract.cpp b/test/SemaCXX/abstract.cpp
index dc764da5322b..e14304a26fe3 100644
--- a/test/SemaCXX/abstract.cpp
+++ b/test/SemaCXX/abstract.cpp
@@ -9,7 +9,7 @@
 #endif
 
 class C {
-    virtual void f() = 0; // expected-note {{pure virtual function 'f'}}
+  virtual void f() = 0; // expected-note {{pure virtual function 'f'}}
 };
 
 static_assert(__is_abstract(C), "C has a pure virtual function");
@@ -20,7 +20,7 @@ class D : C {
 static_assert(__is_abstract(D), "D inherits from an abstract class");
 
 class E : D {
-    virtual void f();
+  virtual void f();
 };
 
 static_assert(!__is_abstract(E), "E inherits from an abstract class but implements f");
@@ -38,8 +38,8 @@ struct S {
 void t3(const C&);
 
 void f() {
-    C(); // expected-error {{allocation of an object of abstract type 'C'}}
-    t3(C()); // expected-error {{allocation of an object of abstract type 'C'}}
+  C(); // expected-error {{allocation of an object of abstract type 'C'}}
+  t3(C()); // expected-error {{allocation of an object of abstract type 'C'}}
 }
 
 C e1[2]; // expected-error {{variable type 'C' is an abstract class}}
@@ -54,17 +54,17 @@ typedef void (*Func)(C); // expected-error {{parameter type 'C' is an abstract c
 void t6(Func);
 
 class F {
-    F a() { } // expected-error {{return type 'F' is an abstract class}}
+  F a() { while (1) {} } // expected-error {{return type 'F' is an abstract class}}
     
-    class D {
-        void f(F c); // expected-error {{parameter type 'F' is an abstract class}}
-    };
+  class D {
+    void f(F c); // expected-error {{parameter type 'F' is an abstract class}}
+  };
 
-    union U {
-        void u(F c); // expected-error {{parameter type 'F' is an abstract class}}
-    };
+  union U {
+    void u(F c); // expected-error {{parameter type 'F' is an abstract class}}
+  };
     
-    virtual void f() = 0; // expected-note {{pure virtual function 'f'}}
+  virtual void f() = 0; // expected-note {{pure virtual function 'f'}}
 };
 
 class Abstract;
@@ -72,50 +72,47 @@ class Abstract;
 void t7(Abstract a); // expected-error {{parameter type 'Abstract' is an abstract class}}
 
 void t8() {
-    void h(Abstract a); // expected-error {{parameter type 'Abstract' is an abstract class}}
+  void h(Abstract a); // expected-error {{parameter type 'Abstract' is an abstract class}}
 }
 
 namespace N {
-    void h(Abstract a); // expected-error {{parameter type 'Abstract' is an abstract class}}
+void h(Abstract a); // expected-error {{parameter type 'Abstract' is an abstract class}}
 }
 
 class Abstract {
- virtual void f() = 0; // expected-note {{pure virtual function 'f'}}
+  virtual void f() = 0; // expected-note {{pure virtual function 'f'}}
 };
 
 // <rdar://problem/6854087>
 class foo {
 public:
-	virtual foo *getFoo() = 0;
+  virtual foo *getFoo() = 0;
 };
 
 class bar : public foo {
 public:
-	virtual bar *getFoo();
+  virtual bar *getFoo();
 };
 
 bar x;
 
 // <rdar://problem/6902298>
-class A
-{
+class A {
 public:
-	virtual void release() = 0;
-	virtual void release(int count) = 0;
-	virtual void retain() = 0;
+  virtual void release() = 0;
+  virtual void release(int count) = 0;
+  virtual void retain() = 0;
 };
 
-class B : public A
-{
+class B : public A {
 public:
-	virtual void release();
-	virtual void release(int count);
-	virtual void retain();
+  virtual void release();
+  virtual void release(int count);
+  virtual void retain();
 };
 
-void foo(void)
-{
-	B b;
+void foo(void) {
+  B b;
 }
 
 struct K {
diff --git a/test/SemaCXX/access-control-check.cpp b/test/SemaCXX/access-control-check.cpp
new file mode 100644
index 000000000000..fb124a932a12
--- /dev/null
+++ b/test/SemaCXX/access-control-check.cpp
@@ -0,0 +1,16 @@
+// RUN: clang-cc -fsyntax-only -faccess-control -verify %s
+
+class M {
+  int iM;
+};
+
+class P {
+  int iP;
+  int PPR();
+};
+
+class N : M,P {
+  N() {}
+  // FIXME. No access violation is reported in method call or member access.
+  int PR() { return iP + PPR(); }
+};
diff --git a/test/SemaCXX/addr-of-overloaded-function.cpp b/test/SemaCXX/addr-of-overloaded-function.cpp
index 9c9f0e19ef3c..80ea02bafd41 100644
--- a/test/SemaCXX/addr-of-overloaded-function.cpp
+++ b/test/SemaCXX/addr-of-overloaded-function.cpp
@@ -23,7 +23,34 @@ int g1(char);
 int g2(int);
 int g2(double);
 
+template<typename T> T g3(T);
+int g3(int);
+int g3(char);
+
 void g_test() {
   g(g1);
   g(g2); // expected-error{{call to 'g' is ambiguous; candidates are:}}
+  g(g3);
 }
+
+template<typename T> T h1(T);
+template<typename R, typename A1> R h1(A1);
+int h1(char);
+
+void ha(int (*fp)(int));
+void hb(int (*fp)(double));
+
+void h_test() {
+  ha(h1);
+  hb(h1);
+}
+
+struct A { };
+void f(void (*)(A *));
+
+struct B
+{
+  void g() { f(d); }
+  void d(void *);
+  static void d(A *);
+};
diff --git a/test/SemaCXX/ambig-user-defined-conversions.cpp b/test/SemaCXX/ambig-user-defined-conversions.cpp
new file mode 100644
index 000000000000..94598f0e8ef2
--- /dev/null
+++ b/test/SemaCXX/ambig-user-defined-conversions.cpp
@@ -0,0 +1,52 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// Test1
+struct BASE { 
+  operator int &(); // expected-note {{candidate function}}
+}; 
+struct BASE1 { 
+  operator int &(); // expected-note {{candidate function}}
+}; 
+
+struct B : public BASE, BASE1 { 
+
+}; 
+
+extern B f(); 
+
+B b1;
+void func(const int ci, const char cc); // expected-note {{candidate function}}
+void func(const char ci, const B b); // expected-note {{candidate function}}
+void func(const B b, const int ci); // expected-note {{candidate function}}
+
+const int Test1() {
+  func(b1, f()); // expected-error {{call to 'func' is ambiguous}}
+  return f(); // expected-error {{conversion from 'struct B' to 'int const' is ambiguous}}
+}
+
+
+// Test2
+struct E;
+struct A { 
+  A (E&); 
+};
+
+struct E { 
+  operator A (); 
+};
+
+struct C { 
+  C (E&);  
+};
+
+void f1(A);	// expected-note {{candidate function}}
+void f1(C);	// expected-note {{candidate function}}
+
+void Test2()
+{
+	E b;
+	f1(b);  // expected-error {{call to 'f1' is ambiguous}}	
+                // ambiguous because b -> C via constructor and
+                // b → A via constructor or conversion function.
+}
+
diff --git a/test/SemaCXX/ambiguous-builtin-unary-operator.cpp b/test/SemaCXX/ambiguous-builtin-unary-operator.cpp
new file mode 100644
index 000000000000..042546af6902
--- /dev/null
+++ b/test/SemaCXX/ambiguous-builtin-unary-operator.cpp
@@ -0,0 +1,18 @@
+// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x
+
+struct A {
+  operator int&();
+};
+
+struct B {
+  operator long&();
+};
+
+struct C : B, A { };
+
+void test(C c) {
+  ++c; // expected-error {{use of overloaded operator '++' is ambiguous}}\
+       // expected-note 4 {{built-in candidate operator ++ (}}
+}
+
+
diff --git a/test/SemaCXX/arrow-operator.cpp b/test/SemaCXX/arrow-operator.cpp
new file mode 100644
index 000000000000..9c46e96afc0b
--- /dev/null
+++ b/test/SemaCXX/arrow-operator.cpp
@@ -0,0 +1,22 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+struct T { 
+  void f();
+};
+
+struct A {
+  T* operator->(); // expected-note{{candidate function}}
+};
+
+struct B {
+  T* operator->(); // expected-note{{candidate function}}
+};
+
+struct C : A, B {
+};
+
+struct D : A { };
+
+void f(C &c, D& d) {
+  c->f(); // expected-error{{use of overloaded operator '->' is ambiguous}}
+  d->f();
+}
\ No newline at end of file
diff --git a/test/SemaCXX/attr-after-definition.cpp b/test/SemaCXX/attr-after-definition.cpp
new file mode 100644
index 000000000000..2ef5acfbc0f1
--- /dev/null
+++ b/test/SemaCXX/attr-after-definition.cpp
@@ -0,0 +1,9 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+struct X { };
+struct Y { };
+
+bool f0(X) { return true; } // expected-note{{definition}}
+bool f1(X) { return true; }
+
+__attribute__ ((__visibility__("hidden"))) bool f0(X); // expected-warning{{attribute}}
+__attribute__ ((__visibility__("hidden"))) bool f1(Y);
diff --git a/test/SemaCXX/attr-deprecated.cpp b/test/SemaCXX/attr-deprecated.cpp
new file mode 100644
index 000000000000..54f8b5b57fcd
--- /dev/null
+++ b/test/SemaCXX/attr-deprecated.cpp
@@ -0,0 +1,66 @@
+// RUN: clang-cc %s -verify -fsyntax-only
+class A {
+  void f() __attribute__((deprecated));
+  void g(A* a);
+  void h(A* a) __attribute__((deprecated));
+
+  int b __attribute__((deprecated));
+};
+
+void A::g(A* a)
+{
+  f(); // expected-warning{{'f' is deprecated}}
+  a->f(); // expected-warning{{'f' is deprecated}}
+  
+  (void)b; // expected-warning{{'b' is deprecated}}
+  (void)a->b; // expected-warning{{'b' is deprecated}}
+}
+
+void A::h(A* a)
+{
+  f();
+  a->f();
+  
+  (void)b;
+  (void)a->b;
+}
+
+struct B {
+  virtual void f() __attribute__((deprecated));
+  void g();
+};
+
+void B::g() {
+  f();
+  B::f(); // expected-warning{{'f' is deprecated}}
+}
+
+struct C : B {
+  virtual void f();
+  void g();
+};
+
+void C::g() {
+  f();
+  C::f();
+  B::f(); // expected-warning{{'f' is deprecated}}
+}
+
+void f(B* b, C *c) {
+  b->f();
+  b->B::f(); // expected-warning{{'f' is deprecated}}
+  
+  c->f();
+  c->C::f();
+  c->B::f(); // expected-warning{{'f' is deprecated}}
+}
+
+struct D {
+  virtual void f() __attribute__((deprecated));
+};
+
+void D::f() { }
+
+void f(D* d) {
+  d->f();
+}
diff --git a/test/SemaCXX/attr-format.cpp b/test/SemaCXX/attr-format.cpp
new file mode 100644
index 000000000000..369099a84800
--- /dev/null
+++ b/test/SemaCXX/attr-format.cpp
@@ -0,0 +1,8 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+struct S {
+  static void f(const char*, ...) __attribute__((format(printf, 1, 2)));
+
+  // GCC has a hidden 'this' argument in member functions which is why
+  // the format argument is argument 2 here.
+  void g(const char*, ...) __attribute__((format(printf, 2, 3)));
+};
diff --git a/test/SemaCXX/auto-cxx0x.cpp b/test/SemaCXX/auto-cxx0x.cpp
index 33156ef23d2e..aa92bbe4f1f1 100644
--- a/test/SemaCXX/auto-cxx0x.cpp
+++ b/test/SemaCXX/auto-cxx0x.cpp
@@ -1,5 +1,5 @@
 // RUN: clang-cc -fsyntax-only -verify %s -std=c++0x
 void f() {
-  auto int a; // expected-error{{cannot combine with previous 'auto' declaration specifier}}
+  auto int a; // expected-error{{cannot combine with previous 'auto' declaration specifier}} // expected-error{{declaration of variable 'a' with type 'auto' requires an initializer}}
   int auto b; // expected-error{{cannot combine with previous 'int' declaration specifier}}
 }
diff --git a/test/SemaCXX/builtin-ptrtomember-ambig.cpp b/test/SemaCXX/builtin-ptrtomember-ambig.cpp
new file mode 100644
index 000000000000..7e20af35394b
--- /dev/null
+++ b/test/SemaCXX/builtin-ptrtomember-ambig.cpp
@@ -0,0 +1,24 @@
+// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x
+
+struct A {};
+
+struct R {
+    operator const A*();
+};
+
+
+struct B  : R {
+    operator A*();
+};
+
+struct C : B {
+
+};
+
+
+void foo(C c, int A::* pmf) {
+       				// FIXME. Why so many built-in candidates?
+	int i = c->*pmf; 	// expected-error {{use of overloaded operator '->*' is ambiguous}} \
+				// expected-note 40 {{built-in candidate operator ->* ('struct A}}
+}
+
diff --git a/test/SemaCXX/builtin-ptrtomember-overload-1.cpp b/test/SemaCXX/builtin-ptrtomember-overload-1.cpp
new file mode 100644
index 000000000000..27ca6dc77897
--- /dev/null
+++ b/test/SemaCXX/builtin-ptrtomember-overload-1.cpp
@@ -0,0 +1,46 @@
+// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x
+
+struct A {};
+struct E {};
+
+struct R {
+    operator A*();
+    operator E*();	// expected-note{{candidate function}}
+};
+
+
+struct S {
+    operator A*();
+    operator E*();	// expected-note{{candidate function}}
+};
+
+struct B  : R {
+    operator A*();
+};
+
+struct C : B {
+
+};
+
+void foo(C c, int A::* pmf) {
+	int i = c->*pmf; 
+}
+
+struct B1  : R, S {
+    operator A*();
+};
+
+struct C1 : B1 {
+
+};
+
+void foo1(C1 c1, int A::* pmf) {
+        int i = c1->*pmf;
+        c1->*pmf = 10;
+}
+
+void foo1(C1 c1, int E::* pmf) {
+        // FIXME. Error reporting needs much improvement here.
+        int i = c1->*pmf;	// expected-error {{left hand operand to ->* must be a pointer to class compatible with the right hand operand, but is 'struct C1'}} \
+                                // expected-note {{because of ambiguity in conversion of 'struct C1' to 'struct E *'}}
+}
diff --git a/test/SemaCXX/builtin-ptrtomember-overload.cpp b/test/SemaCXX/builtin-ptrtomember-overload.cpp
new file mode 100644
index 000000000000..718e981805aa
--- /dev/null
+++ b/test/SemaCXX/builtin-ptrtomember-overload.cpp
@@ -0,0 +1,18 @@
+// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x
+
+struct A {};
+
+struct B {
+	operator A*();
+};
+
+struct C : B {
+
+};
+
+
+void foo(C c, B b, int A::* pmf) {
+	int j = c->*pmf; 
+	int i = b->*pmf;
+}
+
diff --git a/test/SemaCXX/c99.cpp b/test/SemaCXX/c99.cpp
new file mode 100644
index 000000000000..b0ee056ef379
--- /dev/null
+++ b/test/SemaCXX/c99.cpp
@@ -0,0 +1,8 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+void f0(int i) {
+  char array[i]; // expected-error{{variable length arrays}}
+}
+
+void f1(int i[static 5]) { // expected-error{{C99}}
+}
diff --git a/test/SemaCXX/cast-conversion.cpp b/test/SemaCXX/cast-conversion.cpp
new file mode 100644
index 000000000000..cbc24aef28d5
--- /dev/null
+++ b/test/SemaCXX/cast-conversion.cpp
@@ -0,0 +1,21 @@
+// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x
+
+struct R {
+  R(int);
+};
+
+struct A {
+  A(R);
+};
+
+struct B {
+  B(A);
+};
+
+int main () {
+  B(10);	// expected-error {{functional-style cast from 'int' to 'struct B' is not allowed}}
+  (B)10;	// expected-error {{C-style cast from 'int' to 'struct B' is not allowed}}
+  static_cast<B>(10);	// expected-error {{static_cast from 'int' to 'struct B' is not allowed}} \\
+			// expected-warning {{expression result unused}}
+}
+
diff --git a/test/SemaCXX/cast-explicit-ctor.cpp b/test/SemaCXX/cast-explicit-ctor.cpp
new file mode 100644
index 000000000000..62134ae658db
--- /dev/null
+++ b/test/SemaCXX/cast-explicit-ctor.cpp
@@ -0,0 +1,6 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+struct B { explicit B(bool); };
+void f() { 
+  (void)(B)true;
+  (void)B(true); 
+}
diff --git a/test/SemaCXX/class-base-member-init.cpp b/test/SemaCXX/class-base-member-init.cpp
index c38c3d3337e7..2092847bc02d 100644
--- a/test/SemaCXX/class-base-member-init.cpp
+++ b/test/SemaCXX/class-base-member-init.cpp
@@ -7,9 +7,9 @@ public:
 
 struct D : S {
   D() : b1(0), b2(1), b1(0), S(), S() {} // expected-error {{multiple initializations given for non-static member 'b1'}} \
-					 // expected-note {{previous initialization is here}} \
-					 // expected-error {{multiple initializations given for base 'class S'}} \
-					 // expected-note {{previous initialization is here}}
+                                         // expected-note {{previous initialization is here}}                  \
+                                         // expected-error {{multiple initializations given for base 'class S'}} \
+                                         // expected-note {{previous initialization is here}}
 
   int b1;
   int b2;
diff --git a/test/SemaCXX/class-layout.cpp b/test/SemaCXX/class-layout.cpp
new file mode 100644
index 000000000000..56f41bfbdb93
--- /dev/null
+++ b/test/SemaCXX/class-layout.cpp
@@ -0,0 +1,49 @@
+// RUN: clang-cc -triple x86_64-unknown-unknown %s -fsyntax-only -verify 
+
+#define SA(n, p) int a##n[(p) ? 1 : -1]
+
+struct A {
+  int a;
+  char b;
+};
+
+SA(0, sizeof(A) == 8);
+
+struct B : A {
+  char c;
+};
+
+SA(1, sizeof(B) == 12);
+
+struct C {
+// Make fields private so C won't be a POD type.
+private:
+  int a;
+  char b;
+};
+
+SA(2, sizeof(C) == 8);
+
+struct D : C {
+  char c;
+};
+
+SA(3, sizeof(D) == 8);
+
+struct __attribute__((packed)) E {
+  char b;
+  int a;
+};
+
+SA(4, sizeof(E) == 5);
+
+struct __attribute__((packed)) F : E {
+  char d;
+};
+
+SA(5, sizeof(F) == 6);
+
+struct G { G(); };
+struct H : G { };
+
+SA(6, sizeof(H) == 1);
diff --git a/test/SemaCXX/class-names.cpp b/test/SemaCXX/class-names.cpp
index a5569c0c767b..da9014574d2c 100644
--- a/test/SemaCXX/class-names.cpp
+++ b/test/SemaCXX/class-names.cpp
@@ -5,7 +5,7 @@ C c;
 
 void D(int);
 
-class D {}; // expected-note {{previous use is here}}
+class D {};
 
 void foo()
 {
@@ -13,7 +13,7 @@ void foo()
   class D d;
 }
 
-class D; 
+class D; // expected-note {{previous use is here}}
 
 enum D; // expected-error {{use of 'D' with tag type that does not match previous declaration}}
 
diff --git a/test/SemaCXX/composite-pointer-type.cpp b/test/SemaCXX/composite-pointer-type.cpp
index b4a5c884f755..ebc40c14b743 100644
--- a/test/SemaCXX/composite-pointer-type.cpp
+++ b/test/SemaCXX/composite-pointer-type.cpp
@@ -25,3 +25,11 @@ void f1(volatile Base *b, Derived1 *d1, const Derived2 *d2) {
   if (d1 == d2) // expected-error{{comparison of distinct}}
     return;
 }
+
+// PR4691
+int ptrcmp1(void *a, int *b) {
+  return a < b;
+}
+int ptrcmp2(long *a, int *b) {
+  return a < b; // expected-error{{distinct}}
+}
\ No newline at end of file
diff --git a/test/SemaCXX/conditional-expr.cpp b/test/SemaCXX/conditional-expr.cpp
index 3f4d7159a0f8..fea3324b5fd5 100644
--- a/test/SemaCXX/conditional-expr.cpp
+++ b/test/SemaCXX/conditional-expr.cpp
@@ -170,11 +170,13 @@ void test()
     i1 ? &MixedFields::ci : &MixedFieldsDerived::i;
   const volatile int (MixedFields::*mp2) =
     i1 ? &MixedFields::ci : &MixedFields::cvi;
-  i1 ? &MixedFields::ci : &MixedFields::vi; // expected-error {{incompatible operand types}}
+  (void)(i1 ? &MixedFields::ci : &MixedFields::vi);
   // Conversion of primitives does not result in an lvalue.
   &(i1 ? i1 : d1); // expected-error {{address expression must be an lvalue or a function designator}}
 
-
+  (void)&(i1 ? flds.b1 : flds.i1); // expected-error {{address of bit-field requested}}
+  (void)&(i1 ? flds.i1 : flds.b1); // expected-error {{address of bit-field requested}}
+  
   // Note the thing that this does not test: since DR446, various situations
   // *must* create a separate temporary copy of class objects. This can only
   // be properly tested at runtime, though.
diff --git a/test/SemaCXX/constructor-initializer.cpp b/test/SemaCXX/constructor-initializer.cpp
index a180d907f1b7..b86a27d66d98 100644
--- a/test/SemaCXX/constructor-initializer.cpp
+++ b/test/SemaCXX/constructor-initializer.cpp
@@ -1,7 +1,8 @@
-// RUN: clang-cc -fsyntax-only -verify %s
+// RUN: clang-cc -Wreorder -fsyntax-only -verify %s
 class A { 
   int m;
    A() : A::m(17) { } // expected-error {{member initializer 'm' does not name a non-static data member or base class}}
+   A(int);
 };
 
 class B : public A { 
@@ -26,7 +27,7 @@ public:
 
 class E : public D, public B { 
 public:
-  E() : B(), D() { } // expected-error{{base class initializer 'B' names both a direct base class and an inherited virtual base class}}
+  E() : B(), D() { } // expected-error{{base class initializer 'class B' names both a direct base class and an inherited virtual base class}}
 };
 
 
@@ -64,7 +65,7 @@ struct S : Y, virtual X {
 };
 
 struct Z : S { 
-  Z() : S(), X(), E()  {} // expected-error {{type 'class E' is not a direct or virtual base of 'Z'}}
+  Z() : X(), S(), E()  {} // expected-error {{type 'class E' is not a direct or virtual base of 'Z'}}
 };
 
 class U { 
@@ -85,11 +86,39 @@ struct Derived : Base, Base1, virtual V {
 
 struct Current : Derived {
   int Derived;
-  Current() : Derived(1), ::Derived(),
+  Current() : Derived(1), ::Derived(), // expected-warning {{member 'Derived' will be initialized after}} \
+                                       // expected-note {{base '::Derived'}} \
+                                       // expected-warning {{base class '::Derived' will be initialized after}}
                           ::Derived::Base(), // expected-error {{type '::Derived::Base' is not a direct or virtual base of 'Current'}}
                            Derived::Base1(), // expected-error {{type 'Derived::Base1' is not a direct or virtual base of 'Current'}}
-                           Derived::V(),
+                           Derived::V(), // expected-note {{base 'Derived::V'}}
                            ::NonExisting(), // expected-error {{member initializer 'NonExisting' does not name a non-static data member or}}
                            INT::NonExisting()  {} // expected-error {{expected a class or namespace}} \
-						  // expected-error {{member initializer 'NonExisting' does not name a non-static data member or}}
+                                                  // expected-error {{member initializer 'NonExisting' does not name a non-static data member or}}
+};
+
+                        // FIXME. This is bad message!
+struct M {              // expected-note {{candidate function}} \
+                        // expected-note {{candidate function}}
+  M(int i, int j);      // expected-note {{candidate function}} \
+                        // // expected-note {{candidate function}}
+};
+
+struct N : M  {
+  N() : M(1),        // expected-error {{no matching constructor for initialization of 'M'}}
+        m1(100) {  } // expected-error {{no matching constructor for initialization of 'm1'}}
+  M m1;
+};
+
+struct P : M  { // expected-error {{default constructor for 'struct M' is missing in initialization of base class}}
+  P()  {  }
+  M m; // expected-error {{default constructor for 'struct M' is missing in initialization of member}}
+};
+
+struct Q {
+  Q() : f1(1,2),       // expected-error {{Too many arguments for member initializer 'f1'}}
+        pf(0.0)  { }   // expected-error {{incompatible type passing 'double', expected 'float *'}}
+  float f1;
+
+  float *pf;
 };
diff --git a/test/SemaCXX/constructor.cpp b/test/SemaCXX/constructor.cpp
index 8f289a2b1e96..5ce595cdcece 100644
--- a/test/SemaCXX/constructor.cpp
+++ b/test/SemaCXX/constructor.cpp
@@ -58,3 +58,29 @@ void y() {
   a z; z.b(x);
 }
 }
+
+namespace A {
+  struct S {
+    S();
+    S(int);
+    void f1();
+    void f2();
+    operator int ();
+    ~S();
+  };
+}
+
+A::S::S() {}
+
+void A::S::f1() {}
+
+struct S {};
+
+A::S::S(int) {}
+
+void A::S::f2() {}
+
+A::S::operator int() { return 1; }
+
+A::S::~S() {}
+
diff --git a/test/SemaCXX/conversion-delete-expr.cpp b/test/SemaCXX/conversion-delete-expr.cpp
new file mode 100644
index 000000000000..708289c362dc
--- /dev/null
+++ b/test/SemaCXX/conversion-delete-expr.cpp
@@ -0,0 +1,109 @@
+// RUN: clang-cc -fsyntax-only -verify -std=c++0x %s
+
+// Test1
+struct B {
+  operator char *(); // expected-note {{candidate function}}
+};
+
+struct D : B {
+  operator int *(); // expected-note {{candidate function}}
+};
+
+void f (D d)
+{
+   delete d; // expected-error {{ambiguous conversion of delete expression of type 'struct D' to a pointer}}
+}
+
+// Test2
+struct B1 {
+  operator int *();
+};
+
+struct D1 : B1 {
+  operator int *();
+};
+
+void f1 (D1 d)
+{
+   delete d;
+}
+
+// Test3
+struct B2 {
+  operator const int *();	// expected-note {{candidate function}}
+};
+
+struct D2 : B2 {
+  operator int *();	// expected-note {{candidate function}}
+};
+
+void f2 (D2 d)
+{
+   delete d; // expected-error {{ambiguous conversion of delete expression of type 'struct D2' to a pointer}}
+}
+
+// Test4
+struct B3 {
+  operator const int *();	// expected-note {{candidate function}}
+};
+
+struct A3 {
+  operator const int *();	// expected-note {{candidate function}}
+};
+
+struct D3 : A3, B3 {
+};
+
+void f3 (D3 d)
+{
+   delete d; // expected-error {{mbiguous conversion of delete expression of type 'struct D3' to a pointer}}
+}
+
+// Test5
+struct X {
+   operator int();
+   operator int*();
+};
+
+void f4(X x) { delete x; delete x; }
+
+// Test6
+struct X1 {
+   operator int();
+   operator int*();
+   template<typename T> operator T*() const; // converts to any pointer!
+};
+
+void f5(X1 x) { delete x; }  // OK. In selecting a conversion to pointer function, template convesions are skipped.
+
+// Test7
+struct Base {
+   operator int*();	
+};
+
+struct Derived : Base {
+   // not the same function as Base's non-const operator int()
+   operator int*() const;
+};
+
+void foo6(const Derived cd, Derived d) {
+	// overload resolution selects Derived::operator int*() const;
+	delete cd;
+	delete d;	
+}
+
+// Test8
+struct BB {
+   template<typename T> operator T*() const;
+};
+
+struct DD : BB {
+   template<typename T> operator T*() const; // hides base conversion
+   operator int *() const;
+};
+
+void foo7 (DD d)
+{
+        // OK. In selecting a conversion to pointer function, template convesions are skipped.
+	delete d;
+}
diff --git a/test/SemaCXX/conversion-function.cpp b/test/SemaCXX/conversion-function.cpp
index 1ca1e689eab0..6182678e3113 100644
--- a/test/SemaCXX/conversion-function.cpp
+++ b/test/SemaCXX/conversion-function.cpp
@@ -64,3 +64,32 @@ struct Flip {
   operator Flop() const;
 };
 Flop flop = Flip(); // expected-error {{cannot initialize 'flop' with an rvalue of type 'struct Flip'}}
+
+// This tests that we don't add the second conversion declaration to the list of user conversions
+struct C {
+  operator const char *() const;
+};
+
+C::operator const char*() const { return 0; }
+
+void f(const C& c) {
+  const char* v = c;
+}
+
+// Test. Conversion in base class is visible in derived class.
+class XB { 
+public:
+  operator int(); // expected-note {{candidate function}}
+};
+
+class Yb : public XB { 
+public:
+  operator char(); // expected-note {{candidate function}}
+};
+
+void f(Yb& a) {
+  if (a) { } // expected-error {{conversion from 'class Yb' to 'bool' is ambiguous}}
+  int i = a; // OK. calls XB::operator int();
+  char ch = a;  // OK. calls Yb::operator char();
+}
+
diff --git a/test/SemaCXX/copy-assignment.cpp b/test/SemaCXX/copy-assignment.cpp
index 6e5012f5a7a1..413e4d193367 100644
--- a/test/SemaCXX/copy-assignment.cpp
+++ b/test/SemaCXX/copy-assignment.cpp
@@ -11,7 +11,7 @@ struct ConvertibleToConstA {
 };
 
 struct B {
-  B& operator=(B&);
+  B& operator=(B&);  // expected-note 4 {{candidate function}}
 };
 
 struct ConvertibleToB {
diff --git a/test/SemaCXX/copy-constructor-error.cpp b/test/SemaCXX/copy-constructor-error.cpp
new file mode 100644
index 000000000000..2e42fcc3b1cd
--- /dev/null
+++ b/test/SemaCXX/copy-constructor-error.cpp
@@ -0,0 +1,13 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+struct S { // expected-note {{candidate function}} 
+   S (S);  // expected-error {{copy constructor must pass its first argument by reference}} \\
+           // expected-note {{candidate function}}
+};
+
+S f();
+
+void g() { 
+  S a( f() );  // expected-error {{call to constructor of 'a' is ambiguous}}
+}
+
diff --git a/test/SemaCXX/cstyle-cast.cpp b/test/SemaCXX/cstyle-cast.cpp
new file mode 100644
index 000000000000..9c47df927e7b
--- /dev/null
+++ b/test/SemaCXX/cstyle-cast.cpp
@@ -0,0 +1,231 @@
+// RUN: clang-cc -fsyntax-only -verify -faccess-control %s
+
+struct A {};
+
+// ----------- const_cast --------------
+
+typedef char c;
+typedef c *cp;
+typedef cp *cpp;
+typedef cpp *cppp;
+typedef cppp &cpppr;
+typedef const cppp &cpppcr;
+typedef const char cc;
+typedef cc *ccp;
+typedef volatile ccp ccvp;
+typedef ccvp *ccvpp;
+typedef const volatile ccvpp ccvpcvp;
+typedef ccvpcvp *ccvpcvpp;
+typedef int iar[100];
+typedef iar &iarr;
+typedef int (*f)(int);
+
+void t_cc()
+{
+  ccvpcvpp var = 0;
+  // Cast away deep consts and volatiles.
+  char ***var2 = (cppp)(var);
+  char ***const &var3 = var2;
+  // Const reference to reference.
+  char ***&var4 = (cpppr)(var3);
+  // Drop reference. Intentionally without qualifier change.
+  char *** var5 = (cppp)(var4);
+  const int ar[100] = {0};
+  // Array decay. Intentionally without qualifier change.
+  int *pi = (int*)(ar);
+  f fp = 0;
+  // Don't misidentify fn** as a function pointer.
+  f *fpp = (f*)(&fp);
+  int const A::* const A::*icapcap = 0;
+  int A::* A::* iapap = (int A::* A::*)(icapcap);
+}
+
+// ----------- static_cast -------------
+
+struct B : public A {};             // Single public base.
+struct C1 : public virtual B {};    // Single virtual base.
+struct C2 : public virtual B {};
+struct D : public C1, public C2 {}; // Diamond
+struct E : private A {};            // Single private base.
+struct F : public C1 {};            // Single path to B with virtual.
+struct G1 : public B {};
+struct G2 : public B {};
+struct H : public G1, public G2 {}; // Ambiguous path to B.
+
+enum Enum { En1, En2 };
+enum Onom { On1, On2 };
+
+struct Co1 { operator int(); };
+struct Co2 { Co2(int); };
+struct Co3 { };
+struct Co4 { Co4(Co3); operator Co3(); };
+
+// Explicit implicits
+void t_529_2()
+{
+  int i = 1;
+  (void)(float)(i);
+  double d = 1.0;
+  (void)(float)(d);
+  (void)(int)(d);
+  (void)(char)(i);
+  (void)(unsigned long)(i);
+  (void)(int)(En1);
+  (void)(double)(En1);
+  (void)(int&)(i);
+  (void)(const int&)(i);
+
+  int ar[1];
+  (void)(const int*)(ar);
+  (void)(void (*)())(t_529_2);
+
+  (void)(void*)(0);
+  (void)(void*)((int*)0);
+  (void)(volatile const void*)((const int*)0);
+  (void)(A*)((B*)0);
+  (void)(A&)(*((B*)0));
+  (void)(const B*)((C1*)0);
+  (void)(B&)(*((C1*)0));
+  (void)(A*)((D*)0);
+  (void)(const A&)(*((D*)0));
+  (void)(int B::*)((int A::*)0);
+  (void)(void (B::*)())((void (A::*)())0);
+  (void)(A*)((E*)0); // C-style cast ignores access control
+  (void)(void*)((const int*)0); // const_cast appended
+
+  (void)(int)(Co1());
+  (void)(Co2)(1);
+  (void)(Co3)((Co4)(Co3()));
+
+  // Bad code below
+  //(void)(A*)((H*)0); // {{static_cast from 'struct H *' to 'struct A *' is not allowed}}
+}
+
+// Anything to void
+void t_529_4()
+{
+  (void)(1);
+  (void)(t_529_4);
+}
+
+// Static downcasts
+void t_529_5_8()
+{
+  (void)(B*)((A*)0);
+  (void)(B&)(*((A*)0));
+  (void)(const G1*)((A*)0);
+  (void)(const G1&)(*((A*)0));
+  (void)(B*)((const A*)0); // const_cast appended
+  (void)(B&)(*((const A*)0)); // const_cast appended
+  (void)(E*)((A*)0); // access control ignored
+  (void)(E&)(*((A*)0)); // access control ignored
+
+  // Bad code below
+
+  (void)(C1*)((A*)0); // expected-error {{cannot cast 'struct A *' to 'struct C1 *' via virtual base 'struct B'}}
+  (void)(C1&)(*((A*)0)); // expected-error {{cannot cast 'struct A' to 'struct C1 &' via virtual base 'struct B'}}
+  (void)(D*)((A*)0); // expected-error {{cannot cast 'struct A *' to 'struct D *' via virtual base 'struct B'}}
+  (void)(D&)(*((A*)0)); // expected-error {{cannot cast 'struct A' to 'struct D &' via virtual base 'struct B'}}
+  (void)(H*)((A*)0); // expected-error {{ambiguous cast from base 'struct A' to derived 'struct H':\n    struct A -> struct B -> struct G1 -> struct H\n    struct A -> struct B -> struct G2 -> struct H}}
+  (void)(H&)(*((A*)0)); // expected-error {{ambiguous cast from base 'struct A' to derived 'struct H':\n    struct A -> struct B -> struct G1 -> struct H\n    struct A -> struct B -> struct G2 -> struct H}}
+
+  // TODO: Test DR427. This requires user-defined conversions, though.
+}
+
+// Enum conversions
+void t_529_7()
+{
+  (void)(Enum)(1);
+  (void)(Enum)(1.0);
+  (void)(Onom)(En1);
+
+  // Bad code below
+
+  (void)(Enum)((int*)0); // expected-error {{C-style cast from 'int *' to 'enum Enum' is not allowed}}
+}
+
+// Void pointer to object pointer
+void t_529_10()
+{
+  (void)(int*)((void*)0);
+  (void)(const A*)((void*)0);
+  (void)(int*)((const void*)0); // const_cast appended
+}
+
+// Member pointer upcast.
+void t_529_9()
+{
+  (void)(int A::*)((int B::*)0);
+
+  // Bad code below
+  (void)(int A::*)((int H::*)0); // expected-error {{ambiguous conversion from pointer to member of derived class 'struct H'}}
+  (void)(int A::*)((int F::*)0); // expected-error {{conversion from pointer to member of class 'struct F'}}
+}
+
+// -------- reinterpret_cast -----------
+
+enum test { testval = 1 };
+struct structure { int m; };
+typedef void (*fnptr)();
+
+// Test conversion between pointer and integral types, as in p3 and p4.
+void integral_conversion()
+{
+  void *vp = (void*)(testval);
+  long l = (long)(vp);
+  (void)(float*)(l);
+  fnptr fnp = (fnptr)(l);
+  (void)(char)(fnp); // expected-error {{cast from pointer to smaller type 'char' loses information}}
+  (void)(long)(fnp);
+}
+
+void pointer_conversion()
+{
+  int *p1 = 0;
+  float *p2 = (float*)(p1);
+  structure *p3 = (structure*)(p2);
+  typedef int **ppint;
+  ppint *deep = (ppint*)(p3);
+  (void)(fnptr*)(deep);
+}
+
+void constness()
+{
+  int ***const ipppc = 0;
+  int const *icp = (int const*)(ipppc);
+  (void)(int*)(icp); // const_cast appended
+  int const *const **icpcpp = (int const* const**)(ipppc); // const_cast appended
+  int *ip = (int*)(icpcpp);
+  (void)(int const*)(ip);
+  (void)(int const* const* const*)(ipppc);
+}
+
+void fnptrs()
+{
+  typedef int (*fnptr2)(int);
+  fnptr fp = 0;
+  (void)(fnptr2)(fp);
+  void *vp = (void*)(fp);
+  (void)(fnptr)(vp);
+}
+
+void refs()
+{
+  long l = 0;
+  char &c = (char&)(l);
+  // Bad: from rvalue
+  (void)(int&)(&c); // expected-error {{C-style cast from rvalue to reference type 'int &'}}
+}
+
+void memptrs()
+{
+  const int structure::*psi = 0;
+  (void)(const float structure::*)(psi);
+  (void)(int structure::*)(psi); // const_cast appended
+
+  void (structure::*psf)() = 0;
+  (void)(int (structure::*)())(psf);
+
+  (void)(void (structure::*)())(psi); // expected-error {{C-style cast from 'int const struct structure::*' to 'void (struct structure::*)()' is not allowed}}
+  (void)(int structure::*)(psf); // expected-error {{C-style cast from 'void (struct structure::*)()' to 'int struct structure::*' is not allowed}}
+}
diff --git a/test/SemaCXX/dcl_ambig_res.cpp b/test/SemaCXX/dcl_ambig_res.cpp
index 57bf4095afd0..495a6e6e42c8 100644
--- a/test/SemaCXX/dcl_ambig_res.cpp
+++ b/test/SemaCXX/dcl_ambig_res.cpp
@@ -50,7 +50,7 @@ void foo5()
 void foo6() 
 { 
   (void)(int(1)); //expression 
-  (void)(int())1; // expected-error{{used type}}
+  (void)(int())1; // expected-error{{to 'int ()'}}
 } 
 
 // [dcl.ambig.res]p7:
@@ -64,3 +64,10 @@ void foo7() {
 
 void h7(int *(C7[10])) { } // expected-note{{previous}}
 void h7(int *(*_fp)(C7 _parm[10])) { } // expected-error{{redefinition}}
+
+struct S5 {
+  static bool const value = false;
+};
+int foo8() {
+  int v(int(S5::value)); // expected-warning{{disambiguated}} expected-error{{parameter declarator cannot be qualified}}
+}
diff --git a/test/SemaCXX/dcl_init_aggr.cpp b/test/SemaCXX/dcl_init_aggr.cpp
index 10c15ccc9061..20b787a22526 100644
--- a/test/SemaCXX/dcl_init_aggr.cpp
+++ b/test/SemaCXX/dcl_init_aggr.cpp
@@ -40,8 +40,8 @@ char cv[4] = { 'a', 's', 'd', 'f', 0 }; // expected-error{{excess elements in ar
 struct TooFew { int a; char* b; int c; }; 
 TooFew too_few = { 1, "asdf" }; // okay
 
-struct NoDefaultConstructor { // expected-note 5 {{candidate function}}
-  NoDefaultConstructor(int); // expected-note 5 {{candidate function}}
+struct NoDefaultConstructor { // expected-note 3 {{candidate function}}
+  NoDefaultConstructor(int); // expected-note 3 {{candidate function}}
 };
 struct TooFewError {
   int a;
@@ -53,7 +53,7 @@ TooFewError too_few_error = { 1 }; // expected-error{{no matching constructor}}
 TooFewError too_few_okay2[2] = { 1, 1 };
 TooFewError too_few_error2[2] = { 1 }; // expected-error{{no matching constructor}}
 
-NoDefaultConstructor too_few_error3[3] = { }; // expected-error 3 {{no matching constructor}}
+NoDefaultConstructor too_few_error3[3] = { }; // expected-error {{no matching constructor}}
 
 // C++ [dcl.init.aggr]p8
 struct Empty { };
diff --git a/test/SemaCXX/decl-expr-ambiguity.cpp b/test/SemaCXX/decl-expr-ambiguity.cpp
index 05e25e9bb868..8d34a9ee7df9 100644
--- a/test/SemaCXX/decl-expr-ambiguity.cpp
+++ b/test/SemaCXX/decl-expr-ambiguity.cpp
@@ -12,14 +12,14 @@ void f() {
   __typeof(int)(a,5)<<a; // expected-error {{function-style cast to a builtin type can only take one argument}}
   void(a), ++a; // expected-warning {{expression result unused}}
   if (int(a)+1) {}
-  for (int(a)+1;;) {}
+  for (int(a)+1;;) {} // expected-warning {{expression result unused}}
   a = sizeof(int()+1);
   a = sizeof(int(1));
   typeof(int()+1) a2; // expected-error {{extension used}}
   (int(1)); // expected-warning {{expression result unused}}
 
   // type-id
-  (int())1; // expected-error {{used type 'int ()' where arithmetic or pointer type is required}}
+  (int())1; // expected-error {{C-style cast from 'int' to 'int ()' is not allowed}}
 
   // Declarations.
   int fd(T(a)); // expected-warning {{parentheses were disambiguated as a function declarator}}
diff --git a/test/SemaCXX/decl-init-ref.cpp b/test/SemaCXX/decl-init-ref.cpp
new file mode 100644
index 000000000000..d7db647cd11a
--- /dev/null
+++ b/test/SemaCXX/decl-init-ref.cpp
@@ -0,0 +1,26 @@
+// RUN: clang-cc -fsyntax-only -verify -std=c++0x %s
+
+struct A {};    
+
+struct BASE {
+  operator A(); // expected-note {{candidate function}}
+};
+
+struct BASE1 {
+ operator A();  // expected-note {{candidate function}}
+};
+
+class B : public BASE , public BASE1
+{
+  public:
+  B();
+} b;
+
+extern B f();
+
+const int& ri = (void)0; // expected-error {{invalid initialization of reference of type 'int const &' from expression of type 'void'}}
+
+int main() {
+        const A& rca = f(); // expected-error {{rvalue reference cannot bind to lvalue due to multiple conversion functions}}
+        A& ra = f(); // expected-error {{non-const lvalue reference to type 'struct A' cannot be initialized with a temporary of type 'class B'}}
+}
diff --git a/test/SemaCXX/decltype-crash.cpp b/test/SemaCXX/decltype-crash.cpp
new file mode 100644
index 000000000000..b56a7f602987
--- /dev/null
+++ b/test/SemaCXX/decltype-crash.cpp
@@ -0,0 +1,7 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+int& a();
+
+void f() {
+  decltype(a()) c; // expected-error {{no matching function for call to 'decltype'}}
+}
diff --git a/test/SemaCXX/decltype-this.cpp b/test/SemaCXX/decltype-this.cpp
new file mode 100644
index 000000000000..fc001063c510
--- /dev/null
+++ b/test/SemaCXX/decltype-this.cpp
@@ -0,0 +1,15 @@
+// RUN: clang-cc -fsyntax-only -verify -std=c++0x %t 
+template<typename T, typename U> struct is_same {
+  static const bool value = false;
+};
+
+template<typename T> struct is_same<T, T> {
+  static const bool value = true;
+};
+
+struct S {
+  void f() { static_assert(is_same<decltype(this), S*>::value, ""); }
+  void g() const { static_assert(is_same<decltype(this), const S*>::value, ""); }
+  void h() volatile { static_assert(is_same<decltype(this), volatile S*>::value, ""); }
+  void i() const volatile { static_assert(is_same<decltype(this), const volatile S*>::value, ""); }
+};
diff --git a/test/SemaCXX/default-argument-temporaries.cpp b/test/SemaCXX/default-argument-temporaries.cpp
new file mode 100644
index 000000000000..232351dcff3d
--- /dev/null
+++ b/test/SemaCXX/default-argument-temporaries.cpp
@@ -0,0 +1,11 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+struct B { B(void* = 0); };
+
+struct A {
+  A(B b = B()) { }
+};
+
+void f() {
+  (void)B();
+  (void)A();
+}
diff --git a/test/SemaCXX/default-assignment-operator.cpp b/test/SemaCXX/default-assignment-operator.cpp
index 090ba3c3ca80..e627fefdef6d 100644
--- a/test/SemaCXX/default-assignment-operator.cpp
+++ b/test/SemaCXX/default-assignment-operator.cpp
@@ -26,7 +26,7 @@ Z z2;
 
 // Test1
 void f(X x, const X cx) {
-  x = cx;	// expected-note {{synthesized method is first required here}}
+  x = cx;  // expected-note {{synthesized method is first required here}}
   x = cx;
   z1 = z2;
 }
@@ -36,8 +36,7 @@ class T {};
 T t1;
 T t2;
 
-void g()
-{
+void g() {
   t1 = t2;
 }
 
@@ -51,8 +50,7 @@ public:
 class W : V {};
 W w1, w2;
 
-void h()
-{
+void h() {
   w1 = w2;
 }
 
@@ -67,8 +65,22 @@ public:
 class D1 : B1 {};
 D1 d1, d2;
 
-void i()
-{
-	d1 = d2;
+void i() {
+  d1 = d2;
+}
+
+// Test5
+
+class E1 { // expected-error{{cannot define the implicit default assignment operator for 'class E1', because non-static const member 'a' can't use default assignment operator}}
+public:
+  const int a; // expected-note{{declared at}}
+  E1() : a(0) {}  
+
+};
+
+E1 e1, e2;
+
+void j() {
+  e1 = e2; // expected-note{{synthesized method is first required here}}
 }
 
diff --git a/test/SemaCXX/default-constructor-initializers.cpp b/test/SemaCXX/default-constructor-initializers.cpp
index 24c53839622c..6cbb978dbb99 100644
--- a/test/SemaCXX/default-constructor-initializers.cpp
+++ b/test/SemaCXX/default-constructor-initializers.cpp
@@ -11,16 +11,16 @@ struct X2  : X1 {  // expected-note {{'struct X2' declared here}} \
 
 struct X3 : public X2 {
 };
-X3 x3;  // expected-error {{cannot define the implicit default constructor for 'struct X3', because member 'struct X2' does not have any default constructor}}
+X3 x3;  // expected-error {{cannot define the implicit default constructor for 'struct X3', because base class 'struct X2' does not have any default constructor}}
 
 
 struct X4 {
-  X2 x2; 
+  X2 x2; 	// expected-note {{member is declared here}}
   X2 & rx2; // expected-note {{declared at}}
 };
 
-X4 x4; // expected-error {{cannot define the implicit default constructor for 'struct X4', because base class 'struct X2' does not have any default constructor}} \
-       // expected-error {{cannot define the implicit default constructor for 'struct X4', because reference member rx2 cannot be default-initialized}}
+X4 x4; // expected-error {{cannot define the implicit default constructor for 'struct X4', because member's type 'struct X2' does not have any default constructor}} \
+       // expected-error {{cannot define the implicit default constructor for 'struct X4', because reference member 'rx2' cannot be default-initialized}}
 
 
 struct Y1 { // has no implicit default constructor
@@ -46,11 +46,11 @@ Y4 y4;
 
 
 struct Z1 {
-        int& z; // expected-note {{declared at}}
-  	const int c1; // expected-note {{declared at}}
-  	volatile int v1;
+  int& z;       // expected-note {{declared at}}
+  const int c1; // expected-note {{declared at}}
+  volatile int v1;
 };
 
-Z1 z1;  // expected-error {{cannot define the implicit default constructor for 'struct Z1', because reference member z cannot be default-initialized}} \
-        // expected-error {{cannot define the implicit default constructor for 'struct Z1', because const member c1 cannot be default-initialized}}
+Z1 z1;  // expected-error {{cannot define the implicit default constructor for 'struct Z1', because reference member 'z' cannot be default-initialized}} \
+        // expected-error {{cannot define the implicit default constructor for 'struct Z1', because const member 'c1' cannot be default-initialized}}
 
diff --git a/test/SemaCXX/default2.cpp b/test/SemaCXX/default2.cpp
index edbd6b3e206a..183452070da4 100644
--- a/test/SemaCXX/default2.cpp
+++ b/test/SemaCXX/default2.cpp
@@ -24,20 +24,8 @@ int f1(int i, int i, int j) { // expected-error {{redefinition of parameter 'i'}
 int x;
 void g(int x, int y = x); // expected-error {{default argument references parameter 'x'}}
 
-void h()
-{
-   int i;
-   extern void h2(int x = sizeof(i)); // expected-error {{default argument references local variable 'i' of enclosing function}}
-}
-
 void g2(int x, int y, int z = x + y); // expected-error {{default argument references parameter 'x'}} expected-error {{default argument references parameter 'y'}}
 
-void nondecl(int (*f)(int x = 5)) // {expected-error {{default arguments can only be specified}}}
-{
-  void (*f2)(int = 17)  // {expected-error {{default arguments can only be specified}}}
-    = (void (*)(int = 42))f; // {expected-error {{default arguments can only be specified}}}
-}
-
 class X {
   void f(X* x = this); // expected-error{{invalid use of 'this' outside of a nonstatic member function}}
 
@@ -82,10 +70,6 @@ struct Y {
   };
 
   static int b; 
-
-  int (*f)(int = 17); // expected-error{{default arguments can only be specified for parameters in a function declaration}}
-
-  void mem8(int (*fp)(int) = (int (*)(int = 17))0); // expected-error{{default arguments can only be specified for parameters in a function declaration}}
 }; 
 
 int Y::mem3(int i = b) { return i; } // OK; use X::b
@@ -127,3 +111,9 @@ class C2 {
   static void g(int = f()); // expected-error{{use of default argument to function 'f' that is declared later in class 'C2'}}
   static int f(int = 10); // expected-note{{default argument declared here}}
 };
+
+// Make sure we actually parse the default argument for an inline definition
+class XX {
+  void A(int length = -1 ) {  } 
+  void B() { A(); }
+};
diff --git a/test/SemaCXX/deleted-function.cpp b/test/SemaCXX/deleted-function.cpp
index 8064ed349b08..637b2b1b2d5c 100644
--- a/test/SemaCXX/deleted-function.cpp
+++ b/test/SemaCXX/deleted-function.cpp
@@ -18,7 +18,7 @@ void ov(double) = delete; // expected-note {{candidate function has been explici
 struct WithDel {
   WithDel() = delete; // expected-note {{candidate function has been explicitly deleted}}
   void fn() = delete; // expected-note {{function has been explicitly marked deleted here}}
-  operator int() = delete;
+  operator int() = delete; 
   void operator +(int) = delete;
 
   int i = delete; // expected-error {{only functions can have deleted definitions}}
diff --git a/test/SemaCXX/destructor.cpp b/test/SemaCXX/destructor.cpp
index f544db0b1b6e..790a401ae99c 100644
--- a/test/SemaCXX/destructor.cpp
+++ b/test/SemaCXX/destructor.cpp
@@ -40,8 +40,9 @@ struct F {
   ~F(); // expected-error {{destructor cannot be redeclared}}
 };
 
-~; // expected-error {{expected class name}}
-~undef(); // expected-error {{expected class name}}
+~; // expected-error {{expected the class name after '~' to name a destructor}}
+~undef(); // expected-error {{expected the class name after '~' to name a destructor}}
+~operator+(int, int);  // expected-error {{expected the class name after '~' to name a destructor}}
 ~F(){} // expected-error {{destructor must be a non-static member function}}
 
 struct G {
@@ -54,3 +55,9 @@ G::~G() { }
 struct H {
   ~H(void) { } 
 };
+
+struct X {};
+
+struct Y {
+  ~X(); // expected-error {{expected the class name after '~' to name the enclosing class}}
+};
diff --git a/test/SemaCXX/direct-initializer.cpp b/test/SemaCXX/direct-initializer.cpp
index 149b65c8d71d..a9e2b2bb6e45 100644
--- a/test/SemaCXX/direct-initializer.cpp
+++ b/test/SemaCXX/direct-initializer.cpp
@@ -34,3 +34,17 @@ void g() {
 
   Z z; // expected-error{{no matching constructor for initialization of 'z'}}
 }
+
+struct Base {
+   operator int*() const; 
+};
+
+struct Derived : Base {
+   operator int*(); 
+};
+
+void foo(const Derived cd, Derived d) {
+        int *pi = cd;	// expected-error {{incompatible type initializing 'struct Derived const', expected 'int *'}}
+        int *ppi = d; 
+
+}
diff --git a/test/SemaCXX/empty-class-layout.cpp b/test/SemaCXX/empty-class-layout.cpp
new file mode 100644
index 000000000000..8b54ea1c66f2
--- /dev/null
+++ b/test/SemaCXX/empty-class-layout.cpp
@@ -0,0 +1,68 @@
+// RUN: clang-cc -triple x86_64-unknown-unknown %s -fsyntax-only -verify 
+
+#define SA(n, p) int a##n[(p) ? 1 : -1]
+
+struct A { int a; };
+SA(0, sizeof(A) == 4);
+
+struct B { };
+SA(1, sizeof(B) == 1);
+
+struct C : A, B { };
+SA(2, sizeof(C) == 4);
+
+struct D { };
+struct E : D { };
+struct F : E { };
+
+struct G : E, F { };
+SA(3, sizeof(G) == 2);
+
+struct Empty { Empty(); };
+
+struct I : Empty { 
+  Empty e;
+};
+SA(4, sizeof(I) == 2);
+
+struct J : Empty { 
+  Empty e[2];
+};
+SA(5, sizeof(J) == 3);
+
+template<int N> struct Derived : Empty, Derived<N - 1> { 
+};
+template<> struct Derived<0> : Empty { };
+
+struct S1 : virtual Derived<10> { 
+  Empty e;
+};
+SA(6, sizeof(S1) == 24);
+
+struct S2 : virtual Derived<10> { 
+  Empty e[2];
+};
+SA(7, sizeof(S2) == 24);
+
+struct S3 {
+  Empty e;
+};
+
+struct S4 : Empty, S3 { 
+};
+SA(8, sizeof(S4) == 2);
+
+struct S5 : S3, Empty {};
+SA(9, sizeof(S5) == 2);
+
+struct S6 : S5 { };
+SA(10, sizeof(S6) == 2);
+
+struct S7 : Empty {
+  void *v;
+};
+SA(11, sizeof(S7) == 8);
+
+struct S8 : Empty, A {
+};
+SA(12, sizeof(S8) == 4);
diff --git a/test/SemaCXX/enum.cpp b/test/SemaCXX/enum.cpp
index 9668c84693d3..db256812ab80 100644
--- a/test/SemaCXX/enum.cpp
+++ b/test/SemaCXX/enum.cpp
@@ -14,14 +14,13 @@ void f() {
 
 // <rdar://problem/6502934>
 typedef enum Foo {
-	A = 0,
-	B = 1
+  A = 0,
+  B = 1
 } Foo;
-	
-	
+
 void bar() {
-	Foo myvar = A;
-	myvar = B;
+  Foo myvar = A;
+  myvar = B;
 }
 
 /// PR3688
@@ -32,7 +31,7 @@ struct s1 {
 enum e1 { YES, NO };
 
 static enum e1 badfunc(struct s1 *q) {
-  return q->bar(); // expected-error{{return type of called function ('enum s1::e1') is incomplete}}
+  return q->bar(); // expected-error{{calling function with incomplete return type 'enum s1::e1'}}
 }
 
 enum e2; // expected-error{{ISO C++ forbids forward references to 'enum' types}}
diff --git a/test/SemaCXX/exception-spec.cpp b/test/SemaCXX/exception-spec.cpp
index 5eba26e70c6f..9b2a07d79654 100644
--- a/test/SemaCXX/exception-spec.cpp
+++ b/test/SemaCXX/exception-spec.cpp
@@ -24,7 +24,7 @@ void (**j)() throw(int); // expected-error {{not allowed beyond a single}}
 // Pointer to function returning pointer to pointer to function with spec
 void (**(*h())())() throw(int); // expected-error {{not allowed beyond a single}}
 
-struct Incomplete;
+struct Incomplete; // expected-note 3 {{forward declaration}}
 
 // Exception spec must not have incomplete types, or pointers to them, except
 // void.
@@ -61,3 +61,127 @@ void r7() throw(float); // expected-error {{exception specification in declarati
 // Top-level const doesn't matter.
 void r8() throw(int);
 void r8() throw(const int);
+
+// Multiple appearances don't matter.
+void r9() throw(int, int);
+void r9() throw(int, int);
+
+struct A
+{
+};
+
+struct B1 : A
+{
+};
+
+struct B2 : A
+{
+};
+
+struct D : B1, B2
+{
+};
+
+struct P : private A
+{
+};
+
+struct Base
+{
+  virtual void f1() throw();
+  virtual void f2();
+  virtual void f3() throw(...);
+  virtual void f4() throw(int, float);
+
+  virtual void f5() throw(int, float);
+  virtual void f6() throw(A);
+  virtual void f7() throw(A, int, float);
+  virtual void f8();
+
+  virtual void g1() throw(); // expected-note {{overridden virtual function is here}}
+  virtual void g2() throw(int); // expected-note {{overridden virtual function is here}}
+  virtual void g3() throw(A); // expected-note {{overridden virtual function is here}}
+  virtual void g4() throw(B1); // expected-note {{overridden virtual function is here}}
+  virtual void g5() throw(A); // expected-note {{overridden virtual function is here}}
+};
+struct Derived : Base
+{
+  virtual void f1() throw();
+  virtual void f2() throw(...);
+  virtual void f3();
+  virtual void f4() throw(float, int);
+
+  virtual void f5() throw(float);
+  virtual void f6() throw(B1);
+  virtual void f7() throw(B1, B2, int);
+  virtual void f8() throw(B2, B2, int, float, char, double, bool);
+
+  virtual void g1() throw(int); // expected-error {{exception specification of overriding function is more lax}}
+  virtual void g2(); // expected-error {{exception specification of overriding function is more lax}}
+  virtual void g3() throw(D); // expected-error {{exception specification of overriding function is more lax}}
+  virtual void g4() throw(A); // expected-error {{exception specification of overriding function is more lax}}
+  virtual void g5() throw(P); // expected-error {{exception specification of overriding function is more lax}}
+};
+
+// Some functions to play with below.
+void s1() throw();
+void s2() throw(int);
+void s3() throw(A);
+void s4() throw(B1);
+void s5() throw(D);
+void s6();
+void s7() throw(int, float);
+void (*s8())() throw(B1); // s8 returns a pointer to function with spec
+void s9(void (*)() throw(B1)); // s9 takes pointer to function with spec
+
+void fnptrs()
+{
+  // Assignment and initialization of function pointers.
+  void (*t1)() throw() = &s1;    // valid
+  t1 = &s2;                      // expected-error {{not superset}} expected-error {{incompatible type}}
+  t1 = &s3;                      // expected-error {{not superset}} expected-error {{incompatible type}}
+  void (&t2)() throw() = s2;     // expected-error {{not superset}}
+  void (*t3)() throw(int) = &s2; // valid
+  void (*t4)() throw(A) = &s1;   // valid
+  t4 = &s3;                      // valid
+  t4 = &s4;                      // valid
+  t4 = &s5;                      // expected-error {{not superset}} expected-error {{incompatible type}}
+  void (*t5)() = &s1;            // valid
+  t5 = &s2;                      // valid
+  t5 = &s6;                      // valid
+  t5 = &s7;                      // valid
+  t1 = t3;                       // expected-error {{not superset}} expected-error {{incompatible type}}
+  t3 = t1;                       // valid
+  void (*t6)() throw(B1);
+  t6 = t4;                       // expected-error {{not superset}} expected-error {{incompatible type}}
+  t4 = t6;                       // valid
+  t5 = t1;                       // valid
+  t1 = t5;                       // expected-error {{not superset}} expected-error {{incompatible type}}
+
+  // return types and arguments must match exactly, no inheritance allowed
+  void (*(*t7)())() throw(B1) = &s8;       // valid
+  void (*(*t8)())() throw(A) = &s8;        // expected-error {{return types differ}} expected-error {{incompatible type}}
+  void (*(*t9)())() throw(D) = &s8;        // expected-error {{return types differ}} expected-error {{incompatible type}}
+  void (*t10)(void (*)() throw(B1)) = &s9; // valid   expected-warning{{disambiguated}}
+  void (*t11)(void (*)() throw(A)) = &s9;  // expected-error {{argument types differ}} expected-error {{incompatible type}} expected-warning{{disambiguated}}
+  void (*t12)(void (*)() throw(D)) = &s9;  // expected-error {{argument types differ}} expected-error {{incompatible type}} expected-warning{{disambiguated}}
+}
+
+// Member function stuff
+
+struct Str1 { void f() throw(int); }; // expected-note {{previous declaration}}
+void Str1::f() // expected-error {{does not match previous declaration}}
+{
+}
+
+void mfnptr()
+{
+  void (Str1::*pfn1)() throw(int) = &Str1::f; // valid
+  void (Str1::*pfn2)() = &Str1::f; // valid
+  void (Str1::*pfn3)() throw() = &Str1::f; // expected-error {{not superset}} expected-error {{incompatible type}}
+}
+
+// Don't suppress errors in template instantiation.
+template <typename T> struct TEx; // expected-note {{template is declared here}}
+
+void tf() throw(TEx<int>); // expected-error {{implicit instantiation of undefined template}}
diff --git a/test/SemaCXX/friend-class-nodecl.cpp b/test/SemaCXX/friend-class-nodecl.cpp
new file mode 100644
index 000000000000..de12eaf741c5
--- /dev/null
+++ b/test/SemaCXX/friend-class-nodecl.cpp
@@ -0,0 +1,10 @@
+// RUN: clang-cc -ast-print %s -o %t &&
+// RUN: not grep '^ *class B' %t
+
+// Tests that the tag decls in friend declarations aren't added to the
+// declaring class's decl chain.
+
+class A {
+  friend class B;
+};
+
diff --git a/test/SemaCXX/function-overloaded-redecl.cpp b/test/SemaCXX/function-overloaded-redecl.cpp
new file mode 100644
index 000000000000..4d8e57c1b9fe
--- /dev/null
+++ b/test/SemaCXX/function-overloaded-redecl.cpp
@@ -0,0 +1,10 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+typedef const int cInt;
+
+void f (int); 
+void f (const int);  // redecl
+
+void f (int) {  }    // expected-note {{previous definition is here}}
+void f (cInt) { }    // expected-error {{redefinition of 'f'}}
+
diff --git a/test/SemaCXX/functional-cast.cpp b/test/SemaCXX/functional-cast.cpp
index 0be7ddb53ae8..142dba7b13f7 100644
--- a/test/SemaCXX/functional-cast.cpp
+++ b/test/SemaCXX/functional-cast.cpp
@@ -1,4 +1,6 @@
-// RUN: clang-cc -fsyntax-only -verify %s
+// RUN: clang-cc -fsyntax-only -verify -faccess-control %s
+
+// ------------ not interpreted as C-style cast ------------
 
 struct SimpleValueInit {
   int i;
@@ -25,3 +27,293 @@ void test_cxx_function_cast_multi() {
   (void)NoValueInit(0, 0, 0); // expected-error{{no matching constructor for initialization}}
   (void)int(1, 2); // expected-error{{function-style cast to a builtin type can only take one argument}}
 }
+
+
+// ------------------ everything else --------------------
+
+struct A {};
+
+// ----------- const_cast --------------
+
+typedef char c;
+typedef c *cp;
+typedef cp *cpp;
+typedef cpp *cppp;
+typedef cppp &cpppr;
+typedef const cppp &cpppcr;
+typedef const char cc;
+typedef cc *ccp;
+typedef volatile ccp ccvp;
+typedef ccvp *ccvpp;
+typedef const volatile ccvpp ccvpcvp;
+typedef ccvpcvp *ccvpcvpp;
+typedef int iar[100];
+typedef iar &iarr;
+typedef int (*f)(int);
+
+void t_cc()
+{
+  ccvpcvpp var = 0;
+  // Cast away deep consts and volatiles.
+  char ***var2 = cppp(var);
+  char ***const &var3 = var2;
+  // Const reference to reference.
+  char ***&var4 = cpppr(var3);
+  // Drop reference. Intentionally without qualifier change.
+  char *** var5 = cppp(var4);
+  const int ar[100] = {0};
+  // Array decay. Intentionally without qualifier change.
+  typedef int *intp;
+  int *pi = intp(ar);
+  f fp = 0;
+  // Don't misidentify fn** as a function pointer.
+  typedef f *fp_t;
+  f *fpp = fp_t(&fp);
+  int const A::* const A::*icapcap = 0;
+  typedef int A::* A::*iapap_t;
+  iapap_t iapap = iapap_t(icapcap);
+}
+
+// ----------- static_cast -------------
+
+struct B : public A {};             // Single public base.
+struct C1 : public virtual B {};    // Single virtual base.
+struct C2 : public virtual B {};
+struct D : public C1, public C2 {}; // Diamond
+struct E : private A {};            // Single private base.
+struct F : public C1 {};            // Single path to B with virtual.
+struct G1 : public B {};
+struct G2 : public B {};
+struct H : public G1, public G2 {}; // Ambiguous path to B.
+
+enum Enum { En1, En2 };
+enum Onom { On1, On2 };
+
+struct Co1 { operator int(); };
+struct Co2 { Co2(int); };
+struct Co3 { };
+struct Co4 { Co4(Co3); operator Co3(); };
+
+// Explicit implicits
+void t_529_2()
+{
+  int i = 1;
+  (void)float(i);
+  double d = 1.0;
+  (void)float(d);
+  (void)int(d);
+  (void)char(i);
+  typedef unsigned long ulong;
+  (void)ulong(i);
+  (void)int(En1);
+  (void)double(En1);
+  typedef int &intr;
+  (void)intr(i);
+  typedef const int &cintr;
+  (void)cintr(i);
+
+  int ar[1];
+  typedef const int *cintp;
+  (void)cintp(ar);
+  typedef void (*pfvv)();
+  (void)pfvv(t_529_2);
+
+  typedef void *voidp;
+  (void)voidp(0);
+  (void)voidp((int*)0);
+  typedef volatile const void *vcvoidp;
+  (void)vcvoidp((const int*)0);
+  typedef A *Ap;
+  (void)Ap((B*)0);
+  typedef A &Ar;
+  (void)Ar(*((B*)0));
+  typedef const B *cBp;
+  (void)cBp((C1*)0);
+  typedef B &Br;
+  (void)Br(*((C1*)0));
+  (void)Ap((D*)0);
+  typedef const A &cAr;
+  (void)cAr(*((D*)0));
+  typedef int B::*Bmp;
+  (void)Bmp((int A::*)0);
+  typedef void (B::*Bmfp)();
+  (void)Bmfp((void (A::*)())0);
+  (void)Ap((E*)0); // functional-style cast ignores access control
+  (void)voidp((const int*)0); // const_cast appended
+
+  (void)int(Co1());
+  (void)Co2(1);
+  (void)Co3((Co4)(Co3()));
+
+  // Bad code below
+  //(void)(A*)((H*)0); // {{static_cast from 'struct H *' to 'struct A *' is not allowed}}
+}
+
+// Anything to void
+void t_529_4()
+{
+  void(1);
+  (void(t_529_4));
+}
+
+// Static downcasts
+void t_529_5_8()
+{
+  typedef B *Bp;
+  (void)Bp((A*)0);
+  typedef B &Br;
+  (void)Br(*((A*)0));
+  typedef const G1 *cG1p;
+  (void)cG1p((A*)0);
+  typedef const G1 &cG1r;
+  (void)cG1r(*((A*)0));
+  (void)Bp((const A*)0); // const_cast appended
+  (void)Br(*((const A*)0)); // const_cast appended
+  typedef E *Ep;
+  (void)Ep((A*)0); // access control ignored
+  typedef E &Er;
+  (void)Er(*((A*)0)); // access control ignored
+
+  // Bad code below
+
+  typedef C1 *C1p;
+  (void)C1p((A*)0); // expected-error {{cannot cast 'struct A *' to 'C1p' (aka 'struct C1 *') via virtual base 'struct B'}}
+  typedef C1 &C1r;
+  (void)C1r(*((A*)0)); // expected-error {{cannot cast 'struct A' to 'C1r' (aka 'struct C1 &') via virtual base 'struct B'}}
+  typedef D *Dp;
+  (void)Dp((A*)0); // expected-error {{cannot cast 'struct A *' to 'Dp' (aka 'struct D *') via virtual base 'struct B'}}
+  typedef D &Dr;
+  (void)Dr(*((A*)0)); // expected-error {{cannot cast 'struct A' to 'Dr' (aka 'struct D &') via virtual base 'struct B'}}
+  typedef H *Hp;
+  (void)Hp((A*)0); // expected-error {{ambiguous cast from base 'struct A' to derived 'struct H':\n    struct A -> struct B -> struct G1 -> struct H\n    struct A -> struct B -> struct G2 -> struct H}}
+  typedef H &Hr;
+  (void)Hr(*((A*)0)); // expected-error {{ambiguous cast from base 'struct A' to derived 'struct H':\n    struct A -> struct B -> struct G1 -> struct H\n    struct A -> struct B -> struct G2 -> struct H}}
+
+  // TODO: Test DR427. This requires user-defined conversions, though.
+}
+
+// Enum conversions
+void t_529_7()
+{
+  (void)Enum(1);
+  (void)Enum(1.0);
+  (void)Onom(En1);
+
+  // Bad code below
+
+  (void)Enum((int*)0); // expected-error {{functional-style cast from 'int *' to 'enum Enum' is not allowed}}
+}
+
+// Void pointer to object pointer
+void t_529_10()
+{
+  typedef int *intp;
+  (void)intp((void*)0);
+  typedef const A *cAp;
+  (void)cAp((void*)0);
+  (void)intp((const void*)0); // const_cast appended
+}
+
+// Member pointer upcast.
+void t_529_9()
+{
+  typedef int A::*Amp;
+  (void)Amp((int B::*)0);
+
+  // Bad code below
+  (void)Amp((int H::*)0); // expected-error {{ambiguous conversion from pointer to member of derived class 'struct H'}}
+  (void)Amp((int F::*)0); // expected-error {{conversion from pointer to member of class 'struct F'}}
+}
+
+// -------- reinterpret_cast -----------
+
+enum test { testval = 1 };
+struct structure { int m; };
+typedef void (*fnptr)();
+
+// Test conversion between pointer and integral types, as in p3 and p4.
+void integral_conversion()
+{
+  typedef void *voidp;
+  void *vp = voidp(testval);
+  long l = long(vp);
+  typedef float *floatp;
+  (void)floatp(l);
+  fnptr fnp = fnptr(l);
+  (void)char(fnp); // expected-error {{cast from pointer to smaller type 'char' loses information}}
+  (void)long(fnp);
+}
+
+void pointer_conversion()
+{
+  int *p1 = 0;
+  typedef float *floatp;
+  float *p2 = floatp(p1);
+  typedef structure *structurep;
+  structure *p3 = structurep(p2);
+  typedef int **ppint;
+  typedef ppint *pppint;
+  ppint *deep = pppint(p3);
+  typedef fnptr fnptrp;
+  (void)fnptrp(deep);
+}
+
+void constness()
+{
+  int ***const ipppc = 0;
+  typedef int const *icp_t;
+  int const *icp = icp_t(ipppc);
+  typedef int *intp;
+  (void)intp(icp); // const_cast appended
+  typedef int const *const ** intcpcpp;
+  intcpcpp icpcpp = intcpcpp(ipppc); // const_cast appended
+  int *ip = intp(icpcpp);
+  (void)icp_t(ip);
+  typedef int const *const *const *intcpcpcp;
+  (void)intcpcpcp(ipppc);
+}
+
+void fnptrs()
+{
+  typedef int (*fnptr2)(int);
+  fnptr fp = 0;
+  (void)fnptr2(fp);
+  typedef void *voidp;
+  void *vp = voidp(fp);
+  (void)fnptr(vp);
+}
+
+void refs()
+{
+  long l = 0;
+  typedef char &charr;
+  char &c = charr(l);
+  // Bad: from rvalue
+  typedef int &intr;
+  (void)intr(&c); // expected-error {{functional-style cast from rvalue to reference type 'intr' (aka 'int &')}}
+}
+
+void memptrs()
+{
+  const int structure::*psi = 0;
+  typedef const float structure::*structurecfmp;
+  (void)structurecfmp(psi);
+  typedef int structure::*structureimp;
+  (void)structureimp(psi); // const_cast appended
+
+  void (structure::*psf)() = 0;
+  typedef int (structure::*structureimfp)();
+  (void)structureimfp(psf);
+
+  typedef void (structure::*structurevmfp)();
+  (void)structurevmfp(psi); // expected-error {{functional-style cast from 'int const struct structure::*' to 'structurevmfp' (aka 'void (struct structure::*)()') is not allowed}}
+  (void)structureimp(psf); // expected-error {{functional-style cast from 'void (struct structure::*)()' to 'structureimp' (aka 'int struct structure::*') is not allowed}}
+}
+
+// ---------------- misc ------------------
+
+void crash_on_invalid_1()
+{
+  typedef itn Typo; // expected-error {{unknown type name 'itn'}}
+  (void)Typo(1); // used to crash
+}
diff --git a/test/SemaCXX/i-c-e-cxx.cpp b/test/SemaCXX/i-c-e-cxx.cpp
index 32d04e2da40b..785ea0efa401 100644
--- a/test/SemaCXX/i-c-e-cxx.cpp
+++ b/test/SemaCXX/i-c-e-cxx.cpp
@@ -4,3 +4,13 @@
 
 const int c = 10;
 int ar[c];
+
+struct X0 {
+  static const int value = static_cast<int>(4.0);
+};
+
+void f() {
+  if (const int value = 17) {
+    int array[value];
+  }
+}
diff --git a/test/SemaCXX/illegal-member-initialization.cpp b/test/SemaCXX/illegal-member-initialization.cpp
new file mode 100644
index 000000000000..2d7c73d68a3f
--- /dev/null
+++ b/test/SemaCXX/illegal-member-initialization.cpp
@@ -0,0 +1,22 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+struct A {
+   A() : value(), cvalue() { } // expected-error {{cannot initialize the member to null in default constructor because reference member 'value' cannot be null-initialized}} \
+                               // expected-error {{constructor for 'struct A' must explicitly initialize the reference member 'value'}}
+   int &value; // expected-note{{declared at}} {{expected-note{{declared at}}
+   const int cvalue;
+};
+
+struct B {
+};
+
+struct X {
+   X() { }      // expected-error {{constructor for 'struct X' must explicitly initialize the reference member 'value'}} \
+                // expected-error {{constructor for 'struct X' must explicitly initialize the const member 'cvalue'}} \
+                // expected-error {{constructor for 'struct X' must explicitly initialize the reference member 'b'}} \
+                // expected-error {{constructor for 'struct X' must explicitly initialize the const member 'cb'}}
+   int &value; // expected-note{{declared at}}
+   const int cvalue; // expected-note{{declared at}}
+   B& b; // expected-note{{declared at}}
+   const B cb; // expected-note{{declared at}}
+};
diff --git a/test/SemaCXX/incomplete-call.cpp b/test/SemaCXX/incomplete-call.cpp
new file mode 100644
index 000000000000..6134189f0a9a
--- /dev/null
+++ b/test/SemaCXX/incomplete-call.cpp
@@ -0,0 +1,38 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+struct A; // expected-note 13 {{forward declaration of 'struct A'}}
+
+A f(); // expected-note {{note: 'f' declared here}}
+
+struct B {
+  A f(); // expected-note {{'f' declared here}}
+  A operator()(); // expected-note 2 {{'operator()' declared here}}
+  operator A(); // expected-note {{'operator A' declared here}}
+  A operator!(); // expected-note 2 {{'operator!' declared here}}
+  A operator++(int); // expected-note {{'operator++' declared here}}
+  A operator[](int); // expected-note {{'operator[]' declared here}}
+  A operator+(int); // expected-note {{'operator+' declared here}}
+  A operator->(); // expected-note {{'operator->' declared here}}
+};
+
+void g() {
+  f(); // expected-error {{calling 'f' with incomplete return type 'struct A'}}
+
+  typedef A (*Func)();
+  Func fp;
+  fp(); // expected-error {{calling function with incomplete return type 'struct A'}}
+  ((Func)0)();  // expected-error {{calling function with incomplete return type 'struct A'}}  
+  
+  B b;
+  b.f(); // expected-error {{calling 'f' with incomplete return type 'struct A'}}
+  
+  b.operator()(); // expected-error {{calling 'operator()' with incomplete return type 'struct A'}}
+  b.operator A(); // expected-error {{calling 'operator A' with incomplete return type 'struct A'}}
+  b.operator!(); // expected-error {{calling 'operator!' with incomplete return type 'struct A'}}
+  
+  !b; // expected-error {{calling 'operator!' with incomplete return type 'struct A'}}
+  b(); // expected-error {{calling 'operator()' with incomplete return type 'struct A'}}
+  b++; // expected-error {{calling 'operator++' with incomplete return type 'struct A'}}
+  b[0]; // expected-error {{calling 'operator[]' with incomplete return type 'struct A'}}
+  b + 1; // expected-error {{calling 'operator+' with incomplete return type 'struct A'}}
+  b->f(); // expected-error {{calling 'operator->' with incomplete return type 'struct A'}}
+}
diff --git a/test/SemaCXX/inherit.cpp b/test/SemaCXX/inherit.cpp
index eaad97cc82a0..069e30d0cdfa 100644
--- a/test/SemaCXX/inherit.cpp
+++ b/test/SemaCXX/inherit.cpp
@@ -10,7 +10,7 @@ class B3 : virtual virtual A { }; // expected-error{{duplicate 'virtual' in base
 class C : public B1, private B2 { };
 
 
-class D;		// expected-note {{forward declaration of 'class D'}}
+class D;                // expected-note {{forward declaration of 'class D'}}
 
 class E : public D { }; // expected-error{{base class has incomplete type}}
 
diff --git a/test/SemaCXX/invalid-member-expr.cpp b/test/SemaCXX/invalid-member-expr.cpp
new file mode 100644
index 000000000000..90932ed65e31
--- /dev/null
+++ b/test/SemaCXX/invalid-member-expr.cpp
@@ -0,0 +1,21 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+class X {};
+
+void test() {
+  X x;
+
+  x.int; // expected-error{{expected identifier}}
+  x.~int(); // expected-error{{expected identifier}}
+  x.operator; // expected-error{{missing type specifier after 'operator'}}
+  x.operator typedef; // expected-error{{missing type specifier after 'operator'}}
+}
+
+void test2() {
+  X *x;
+
+  x->int; // expected-error{{expected identifier}}
+  x->~int(); // expected-error{{expected identifier}}
+  x->operator; // expected-error{{missing type specifier after 'operator'}}
+  x->operator typedef; // expected-error{{missing type specifier after 'operator'}}
+}
diff --git a/test/SemaCXX/invalid-template-specifier.cpp b/test/SemaCXX/invalid-template-specifier.cpp
new file mode 100644
index 000000000000..a3f081ff60b5
--- /dev/null
+++ b/test/SemaCXX/invalid-template-specifier.cpp
@@ -0,0 +1,12 @@
+// RUN: clang-cc %s -verify -fsyntax-only
+// PR4809
+// This test is primarily checking that this doesn't crash, not the particular
+// diagnostics.
+
+const template basic_istream<char>; // expected-error {{expected unqualified-id}}
+
+namespace S {}
+template <class X> class Y {
+  void x() { S::template y<char>(1); } // expected-error {{does not refer to a template}} \
+                                       // expected-error {{no member named 'y'}}
+};
diff --git a/test/SemaCXX/libstdcxx_is_pod_hack.cpp b/test/SemaCXX/libstdcxx_is_pod_hack.cpp
new file mode 100644
index 000000000000..df064bc6a0fa
--- /dev/null
+++ b/test/SemaCXX/libstdcxx_is_pod_hack.cpp
@@ -0,0 +1,7 @@
+// RUN: clang-cc -fsyntax-only %s
+
+template<typename T>
+struct __is_pod {
+};
+
+__is_pod<int> ipi;
diff --git a/test/SemaCXX/linkage-spec.cpp b/test/SemaCXX/linkage-spec.cpp
index 864953e9f9c2..b4c72f557d2a 100644
--- a/test/SemaCXX/linkage-spec.cpp
+++ b/test/SemaCXX/linkage-spec.cpp
@@ -25,3 +25,11 @@ extern "C" int const bar;
 // <rdar://problem/6895431>
 extern "C" struct bar d;
 extern struct bar e;
+
+extern "C++" {
+  namespace N0 {
+    struct X0 {
+      int foo(int x) { return x; }
+    };
+  }
+}
\ No newline at end of file
diff --git a/test/SemaCXX/member-expr-static.cpp b/test/SemaCXX/member-expr-static.cpp
index b6495a852041..2fa7e0781c1e 100644
--- a/test/SemaCXX/member-expr-static.cpp
+++ b/test/SemaCXX/member-expr-static.cpp
@@ -2,20 +2,18 @@
 typedef void (*thread_continue_t)();
 
 extern "C" {
-extern void kernel_thread_start(thread_continue_t continuation);
-extern void pure_c(void);
+  extern void kernel_thread_start(thread_continue_t continuation);
+  extern void pure_c(void);
 }
 
-class _IOConfigThread
-{
+class _IOConfigThread {
 public:
-    static void main( void );
+  static void main( void );
 };
 
 
-void foo( void )
-{
-	kernel_thread_start(&_IOConfigThread::main);
-	kernel_thread_start((thread_continue_t)&_IOConfigThread::main);
-	kernel_thread_start(&pure_c);
+void foo( void ) {
+  kernel_thread_start(&_IOConfigThread::main);
+  kernel_thread_start((thread_continue_t)&_IOConfigThread::main);
+  kernel_thread_start(&pure_c);
 }
diff --git a/test/SemaCXX/member-name-lookup.cpp b/test/SemaCXX/member-name-lookup.cpp
index 9fcd922ddf7d..e95641b4bf9c 100644
--- a/test/SemaCXX/member-name-lookup.cpp
+++ b/test/SemaCXX/member-name-lookup.cpp
@@ -146,3 +146,13 @@ struct HasAnotherMemberType : HasMemberType1, HasMemberType2 {
 struct UsesAmbigMemberType : HasMemberType1, HasMemberType2 {
   type t; // expected-error{{member 'type' found in multiple base classes of different types}}
 };
+
+struct X0 {
+  struct Inner {
+    static const int m;
+  };
+  
+  static const int n = 17;
+};
+
+const int X0::Inner::m = n;
diff --git a/test/SemaCXX/member-operator-expr.cpp b/test/SemaCXX/member-operator-expr.cpp
new file mode 100644
index 000000000000..4d0e00fd6010
--- /dev/null
+++ b/test/SemaCXX/member-operator-expr.cpp
@@ -0,0 +1,29 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+class X {
+public:
+  int operator++();
+  operator int();
+};
+
+void test() {
+  X x;
+  int i;
+
+  i = x.operator++();
+  i = x.operator int();
+  x.operator--(); // expected-error{{no member named 'operator--'}}
+  x.operator float(); // expected-error{{no member named 'operator float'}}
+  x.operator; // expected-error{{missing type specifier after 'operator'}}
+}
+
+void test2() {
+  X *x;
+  int i;
+
+  i = x->operator++();
+  i = x->operator int();
+  x->operator--(); // expected-error{{no member named 'operator--'}}
+  x->operator float(); // expected-error{{no member named 'operator float'}}
+  x->operator; // expected-error{{missing type specifier after 'operator'}}
+}
diff --git a/test/SemaCXX/member-pointer.cpp b/test/SemaCXX/member-pointer.cpp
index 3b106d5576fe..d13b16e6d672 100644
--- a/test/SemaCXX/member-pointer.cpp
+++ b/test/SemaCXX/member-pointer.cpp
@@ -40,6 +40,14 @@ void f() {
 
   // Conversion to member of base.
   pdi1 = pdid; // expected-error {{incompatible type assigning 'int struct D::*', expected 'int struct A::*'}}
+  
+  // Comparisons
+  int (A::*pf2)(int, int);
+  int (D::*pf3)(int, int) = 0;
+  bool b1 = (pf == pf2); (void)b1;
+  bool b2 = (pf != pf2); (void)b2;
+  bool b3 = (pf == pf3); (void)b3;
+  bool b4 = (pf != 0); (void)b4;
 }
 
 struct TheBase
@@ -91,7 +99,7 @@ void h() {
   int i = phm->*pi;
   (void)&(hm.*pi);
   (void)&(phm->*pi);
-  (void)&((&hm)->*pi); // expected-error {{address expression must be an lvalue or a function designator}}
+  (void)&((&hm)->*pi); 
 
   void (HasMembers::*pf)() = &HasMembers::f;
   (hm.*pf)();
diff --git a/test/SemaCXX/missing-members.cpp b/test/SemaCXX/missing-members.cpp
new file mode 100644
index 000000000000..28ad9a04e790
--- /dev/null
+++ b/test/SemaCXX/missing-members.cpp
@@ -0,0 +1,36 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+namespace A {
+  namespace B {
+    class C { };
+    struct S { };
+    union U { };
+  }
+}
+
+void f() {
+  A::B::i; // expected-error {{no member named 'i' in namespace 'A::B'}}
+  A::B::C::i; // expected-error {{no member named 'i' in 'class A::B::C'}}
+  ::i; // expected-error {{no member named 'i' in the global namespace}}
+}
+
+namespace B {
+  class B { };
+}
+
+void g() {
+  A::B::D::E; // expected-error {{no member named 'D' in namespace 'A::B'}}
+  B::B::C::D; // expected-error {{no member named 'C' in 'class B::B'}}
+  ::C::D; // expected-error {{no member named 'C' in the global namespace}}
+}
+
+int A::B::i = 10; // expected-error {{no member named 'i' in namespace 'A::B'}}
+int A::B::C::i = 10; // expected-error {{no member named 'i' in 'class A::B::C'}}
+int A::B::S::i = 10; // expected-error {{no member named 'i' in 'struct A::B::S'}}
+int A::B::U::i = 10; // expected-error {{no member named 'i' in 'union A::B::U'}}
+
+using A::B::D; // expected-error {{no member named 'D' in namespace 'A::B'}}
+
+struct S : A::B::C { 
+  using A::B::C::f; // expected-error {{no member named 'f' in 'class A::B::C'}}
+  
+};
diff --git a/test/SemaCXX/namespace.cpp b/test/SemaCXX/namespace.cpp
index 696ea818f657..5ed6ba50ce1b 100644
--- a/test/SemaCXX/namespace.cpp
+++ b/test/SemaCXX/namespace.cpp
@@ -8,7 +8,8 @@ void f() { A = 0; } // expected-error {{unexpected namespace name 'A': expected
 int A; // expected-error {{redefinition of 'A' as different kind of symbol}}
 class A; // expected-error {{redefinition of 'A' as different kind of symbol}}
 
-class B {}; // expected-note {{previous definition is here}}
+class B {}; // expected-note {{previous definition is here}} \
+            // FIXME: ugly expected-note{{candidate function}}
 
 void C(); // expected-note {{previous definition is here}}
 namespace C {} // expected-error {{redefinition of 'C' as different kind of symbol}}
@@ -66,4 +67,4 @@ namespace foo {
 
 static foo::x  test1;  // ok
 
-static foo::X  test2;  // typo: expected-error {{unknown type name 'X'}}
+static foo::X  test2;  // typo: expected-error {{no type named 'X' in}}
diff --git a/test/SemaCXX/nested-name-spec.cpp b/test/SemaCXX/nested-name-spec.cpp
index 8fff8a2b2cbc..5178557030b7 100644
--- a/test/SemaCXX/nested-name-spec.cpp
+++ b/test/SemaCXX/nested-name-spec.cpp
@@ -13,8 +13,8 @@ namespace A {
 }
 
 A:: ; // expected-error {{expected unqualified-id}}
-::A::ax::undef ex3; // expected-error {{expected a class or namespace}} expected-error {{unknown type name 'undef'}}
-A::undef1::undef2 ex4; // expected-error {{no member named 'undef1'}} expected-error {{unknown type name 'undef2'}}
+::A::ax::undef ex3; // expected-error {{no member named}}
+A::undef1::undef2 ex4; // expected-error {{no member named 'undef1'}}
 
 int A::C::Ag1() { return 0; }
 
@@ -35,9 +35,9 @@ class C2 {
   int x;
 };
 
-void C2::m() const { } // expected-error{{out-of-line definition does not match any declaration in 'C2'}}
+void C2::m() const { } // expected-error{{out-of-line definition of 'm' does not match any declaration in 'class C2'}}
 
-void C2::f(int) { } // expected-error{{out-of-line definition does not match any declaration in 'C2'}}
+void C2::f(int) { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'class C2'}}
 
 void C2::m() {
   x = 0;
@@ -125,7 +125,7 @@ class Operators {
   operator bool();
 };
 
-Operators Operators::operator+(const Operators&) { // expected-error{{out-of-line definition does not match any declaration in 'Operators'}}
+Operators Operators::operator+(const Operators&) { // expected-error{{out-of-line definition of 'operator+' does not match any declaration in 'class Operators'}}
   Operators ops;
   return ops;
 }
@@ -143,13 +143,13 @@ namespace A {
   void g(int&); // expected-note{{member declaration nearly matches}}
 } 
 
-void A::f() {} // expected-error{{out-of-line definition does not match any declaration in 'A'}}
+void A::f() {} // expected-error{{out-of-line definition of 'f' does not match any declaration in namespace 'A'}}
 
-void A::g(const int&) { } // expected-error{{out-of-line definition does not match any declaration in 'A'}}
+void A::g(const int&) { } // expected-error{{out-of-line definition of 'g' does not match any declaration in namespace 'A'}}
 
 struct Struct { };
 
-void Struct::f() { } // expected-error{{out-of-line definition does not match any declaration in 'Struct'}}
+void Struct::f() { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'struct Struct'}}
 
 void global_func(int);
 void global_func2(int);
@@ -166,13 +166,16 @@ void N::f() { } // okay
 
 struct Y;  // expected-note{{forward declaration of 'struct Y'}}
 Y::foo y; // expected-error{{incomplete type 'struct Y' named in nested name specifier}} \
-         // expected-error{{unknown type name 'foo'}}
+         // expected-error{{no type named 'foo' in}}
 
 X::X() : a(5) { } // expected-error{{use of undeclared identifier 'X'}} \
       // expected-error{{C++ requires a type specifier for all declarations}} \
       // expected-error{{only constructors take base initializers}}
 
-
+struct foo_S {
+  static bool value;
+};
+bool (foo_S::value);
 
 
 namespace somens {
diff --git a/test/SemaCXX/new-delete.cpp b/test/SemaCXX/new-delete.cpp
index f890bf56e36b..c67a3f653900 100644
--- a/test/SemaCXX/new-delete.cpp
+++ b/test/SemaCXX/new-delete.cpp
@@ -38,10 +38,11 @@ void good_news()
   ia4 *pai = new (int[3][4]);
   pi = ::new int;
   U *pu = new (ps) U;
-  // FIXME: Inherited functions are not looked up currently.
-  //V *pv = new (ps) V;
+  V *pv = new (ps) V;
   
   pi = new (S(1.0f, 2)) int;
+  
+  (void)new int[true];
 }
 
 struct abstract {
@@ -95,3 +96,43 @@ void bad_deletes()
   delete (T*)0; // expected-warning {{deleting pointer to incomplete type}}
   ::S::delete (int*)0; // expected-error {{expected unqualified-id}}
 }
+
+struct X0 { };
+
+struct X1 {
+  operator int*();
+  operator float();
+};
+
+struct X2 {
+  operator int*(); // expected-note {{candidate function}}
+  operator float*(); // expected-note {{candidate function}}
+};
+
+void test_delete_conv(X0 x0, X1 x1, X2 x2) {
+  delete x0; // expected-error{{cannot delete}}
+  delete x1;
+  delete x2; // expected-error{{ambiguous conversion of delete expression of type 'struct X2' to a pointer}}
+}
+
+// PR4782
+class X3 {
+public:
+  static void operator delete(void * mem, unsigned long size);
+};
+
+class X4 {
+public:
+  static void release(X3 *x);
+  static void operator delete(void * mem, unsigned long size);
+};
+
+
+void X4::release(X3 *x) {
+  delete x;
+}
+
+class X5 {
+public:
+  void Destroy() const { delete this; }
+};
diff --git a/test/SemaCXX/overload-value-dep-arg.cpp b/test/SemaCXX/overload-value-dep-arg.cpp
new file mode 100644
index 000000000000..1e94d5a30136
--- /dev/null
+++ b/test/SemaCXX/overload-value-dep-arg.cpp
@@ -0,0 +1,13 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+class C {
+  C(void*);
+};
+
+int f(const C&);
+int f(unsigned long);
+
+template<typename T> int f(const T* t) {
+  return f(reinterpret_cast<unsigned long>(t));
+}
+
diff --git a/test/SemaCXX/overloaded-builtin-operators.cpp b/test/SemaCXX/overloaded-builtin-operators.cpp
index 2a6c24a6778a..0284b2929b3c 100644
--- a/test/SemaCXX/overloaded-builtin-operators.cpp
+++ b/test/SemaCXX/overloaded-builtin-operators.cpp
@@ -20,11 +20,21 @@ struct Enum2 {
   operator E2();
 };
 
+
+struct X { 
+  void f();
+};
+
+typedef void (X::*pmf)();
+struct Xpmf {
+  operator pmf();
+};
+
 yes& islong(long);
 yes& islong(unsigned long); // FIXME: shouldn't be needed
 no& islong(int);
 
-void f(Short s, Long l, Enum1 e1, Enum2 e2) {
+void f(Short s, Long l, Enum1 e1, Enum2 e2, Xpmf pmf) {
   // C++ [over.built]p8
   int i1 = +e1;
   int i2 = -e2;
@@ -37,6 +47,10 @@ void f(Short s, Long l, Enum1 e1, Enum2 e2) {
   (void)static_cast<yes&>(islong(s + l));
   (void)static_cast<no&>(islong(s + s));
 
+  // C++ [over.built]p16
+  (void)(pmf == &X::f);
+  (void)(pmf == 0);
+  
   // C++ [over.built]p17
   (void)static_cast<yes&>(islong(s % l));
   (void)static_cast<yes&>(islong(l << s));
@@ -45,7 +59,7 @@ void f(Short s, Long l, Enum1 e1, Enum2 e2) {
   // FIXME: should pass (void)static_cast<no&>(islong(e1 % e2));
 }
 
-struct ShortRef {
+struct ShortRef { // expected-note{{candidate function}}
   operator short&();
 };
 
@@ -53,7 +67,15 @@ struct LongRef {
   operator volatile long&();
 };
 
-void g(ShortRef sr, LongRef lr) {
+struct XpmfRef { // expected-note{{candidate function}}
+  operator pmf&();
+};
+
+struct E2Ref {
+  operator E2&();
+};
+
+void g(ShortRef sr, LongRef lr, E2Ref e2_ref, XpmfRef pmf_ref) {
   // C++ [over.built]p3
   short s1 = sr++;
 
@@ -64,6 +86,14 @@ void g(ShortRef sr, LongRef lr) {
   short& sr1 = (sr *= lr);
   volatile long& lr1 = (lr *= sr);
 
+  // C++ [over.built]p20:
+  E2 e2r2;
+  e2r2 = e2_ref;
+  
+  pmf &pmr = (pmf_ref = &X::f); // expected-error{{no viable overloaded '='}}
+  pmf pmr2;
+  pmr2 = pmf_ref;
+               
   // C++ [over.built]p22
   short& sr2 = (sr %= lr);
   volatile long& lr2 = (lr <<= sr);
diff --git a/test/SemaCXX/overloaded-operator.cpp b/test/SemaCXX/overloaded-operator.cpp
index 916d753a3ff5..8f71ad538138 100644
--- a/test/SemaCXX/overloaded-operator.cpp
+++ b/test/SemaCXX/overloaded-operator.cpp
@@ -28,12 +28,12 @@ void g(Y y, Z z) {
 }
 
 struct A {
-  bool operator==(Z&); // expected-note{{candidate function}}
+  bool operator==(Z&); // expected-note 2{{candidate function}}
 };
 
 A make_A();
 
-bool operator==(A&, Z&); // expected-note{{candidate function}}
+bool operator==(A&, Z&); // expected-note 2{{candidate function}}
 
 void h(A a, const A ac, Z z) {
   make_A() == z;
@@ -155,7 +155,7 @@ typedef INTREF Func1(FLOAT, double);
 typedef float& Func2(int, double);
 
 struct ConvertToFunc {
-  operator Func1*(); // expected-note{{conversion candidate of type 'INTREF (*)(FLOAT, double)'}}
+  operator Func1*(); // expected-note{{conversion candidate of type 'INTREF (*)(float, double)'}}
   operator Func2&(); // expected-note{{conversion candidate of type 'float &(&)(int, double)'}}
   void operator()();
 };
@@ -209,3 +209,34 @@ namespace M {
     (void)(x + x);
   }
 }
+
+struct AA { bool operator!=(AA&); };
+struct BB : AA {};
+bool x(BB y, BB z) { return y != z; }
+
+
+struct AX { 
+  AX& operator ->();	 // expected-note {{declared at}}
+  int b;
+}; 
+
+void m() {
+  AX a; 
+  a->b = 0; // expected-error {{circular pointer delegation detected}}
+}
+
+struct CircA {
+  struct CircB& operator->(); // expected-note {{declared at}}
+  int val;
+};
+struct CircB {
+  struct CircC& operator->(); // expected-note {{declared at}}
+};
+struct CircC {
+  struct CircA& operator->(); // expected-note {{declared at}}
+};
+
+void circ() {
+  CircA a;
+  a->val = 0; // expected-error {{circular pointer delegation detected}}
+}
diff --git a/test/SemaCXX/primary-base.cpp b/test/SemaCXX/primary-base.cpp
new file mode 100644
index 000000000000..62f9087bd91d
--- /dev/null
+++ b/test/SemaCXX/primary-base.cpp
@@ -0,0 +1,11 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+class A { virtual void f(); };
+class B : virtual A { };
+
+class C : B { };
+
+// Since A is already a primary base class, C should be the primary base class of F.
+class F : virtual A, virtual C { };
+
+int sa[sizeof(F) == sizeof(A) ? 1 : -1];
+
diff --git a/test/SemaCXX/pseudo-destructors.cpp b/test/SemaCXX/pseudo-destructors.cpp
new file mode 100644
index 000000000000..1f05e81df530
--- /dev/null
+++ b/test/SemaCXX/pseudo-destructors.cpp
@@ -0,0 +1,40 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+struct A {};
+
+enum Foo { F };
+typedef Foo Bar;
+
+typedef int Integer;
+
+void g();
+
+namespace N {
+  typedef Foo Wibble;
+}
+
+void f(A* a, Foo *f, int *i) {
+  a->~A();
+  a->A::~A();
+  
+  a->~foo(); // expected-error{{identifier 'foo' in pseudo-destructor expression does not name a type}}
+  
+  // FIXME: the type printed below isn't wonderful
+  a->~Bar(); // expected-error{{no member named}}
+  
+  f->~Bar();
+  f->~Foo();
+  i->~Bar(); // expected-error{{does not match}}
+  
+  g().~Bar(); // expected-error{{non-scalar}}
+  
+  f->::~Bar();
+  f->N::~Wibble();
+  
+  f->::~Bar(17, 42); // expected-error{{cannot have any arguments}}
+}
+
+typedef int Integer;
+
+void destroy_without_call(int *ip) {
+  ip->~Integer; // expected-error{{called immediately}}
+}
\ No newline at end of file
diff --git a/test/SemaCXX/qual-id-test.cpp b/test/SemaCXX/qual-id-test.cpp
new file mode 100644
index 000000000000..ecb6aa9b3592
--- /dev/null
+++ b/test/SemaCXX/qual-id-test.cpp
@@ -0,0 +1,140 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+namespace A
+{
+    namespace B
+    {
+        struct base // expected-note{{object type}}
+        {
+            void x() {}
+            void y() {}
+        };
+    }
+
+    struct member
+    {
+        void foo();
+    };
+
+    struct middleman
+    {
+        member * operator->() { return 0; }
+    };
+
+    struct sub : B::base
+    {
+        void x() {}
+        middleman operator->() { return middleman(); }
+    };
+}
+
+struct bad
+{
+  int x();
+};
+
+namespace C
+{
+    void fun()
+    {
+        A::sub a;
+
+        a.x();
+    
+        a.sub::x();
+        a.base::x();
+
+        a.B::base::x(); // expected-error{{use of undeclared identifier 'B'}}
+
+        a.A::sub::x();
+        a.A::B::base::x();
+
+        a.bad::x(); // expected-error{{type 'struct bad' is not a direct or virtual base of ''struct A::sub''}}
+
+        a->foo();
+        a->member::foo();
+        a->A::member::foo();
+    }
+
+    void fun2()
+    {
+        A::sub *a;
+
+        a->x();
+
+        a->sub::x();
+        a->base::x();
+
+        a->B::base::x(); // expected-error{{use of undeclared identifier 'B'}}
+
+        a->A::sub::x();
+        a->A::B::base::x();
+
+        a->bad::x(); // expected-error{{type 'struct bad' is not a direct or virtual base of ''struct A::sub''}}
+
+        (*a)->foo();
+        (*a)->member::foo();
+        (*a)->A::member::foo();
+    }
+
+    void fun3()
+    {
+        int i;
+        i.foo(); // expected-error{{member reference base type 'int' is not a structure or union}}
+    }
+
+    void fun4a() {
+      A::sub *a;
+      
+      typedef A::member base; // expected-note{{current scope}}
+      a->base::x(); // expected-error{{ambiguous}}      
+    }
+
+    void fun4b() {
+      A::sub *a;
+      
+      typedef A::B::base base;
+      a->base::x();
+    }
+  
+    template<typename T>
+    void fun5()
+    {
+        T a;
+        a.x();
+        a->foo();
+
+        a.A::sub::x();
+        a.A::B::base::x();
+        a->A::member::foo();
+
+        a.bad::x(); // expected-error{{direct or virtual}}
+    }
+
+  void test_fun5() {
+    fun5<A::sub>(); // expected-note{{instantiation}}
+  }
+  
+  template<typename T>
+  void fun6() {
+    T a;
+    a.sub::x();
+    a.base::x();
+    a->member::foo();
+    a.B::base::x(); // expected-error{{use of undeclared identifier 'B'}}
+   }
+  
+  void test_fun6() {
+    fun6<A::sub>(); // expected-note{{instantiation}}
+  }
+  
+}
+
+// PR4703
+struct a {
+  int a;
+  static int sa;
+};
+
+a a;
+
+int a::sa = a.a;
diff --git a/test/SemaCXX/ref-init-ambiguous.cpp b/test/SemaCXX/ref-init-ambiguous.cpp
new file mode 100644
index 000000000000..dda1ead7b622
--- /dev/null
+++ b/test/SemaCXX/ref-init-ambiguous.cpp
@@ -0,0 +1,28 @@
+// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x
+
+enum E2 { };
+
+struct A { 
+  operator E2&(); // expected-note 3 {{candidate function}}
+};
+
+struct B { 
+  operator E2&(); // expected-note 3 {{candidate function}}
+};
+
+struct C : B, A { 
+};
+
+void test(C c) {
+	const E2 &e2 = c; // expected-error {{reference initialization of type 'enum E2 const &' with initializer of type 'struct C' is ambiguous}}
+}
+
+void foo(const E2 &);
+
+const E2 & re(C c) {
+    foo(c); // expected-error {{reference initialization of type 'enum E2 const &' with initializer of type 'struct C' is ambiguous}}
+
+    return c; // expected-error {{reference initialization of type 'enum E2 const &' with initializer of type 'struct C' is ambiguous}}
+}
+
+
diff --git a/test/SemaCXX/references.cpp b/test/SemaCXX/references.cpp
index 9067a8661d7c..e03abf4300a3 100644
--- a/test/SemaCXX/references.cpp
+++ b/test/SemaCXX/references.cpp
@@ -87,3 +87,18 @@ void test8(int& const,// expected-error{{'const' qualifier may not be applied to
 
   typedef intref const intref_c; // okay. FIXME: how do we verify that this is the same type as intref?
 }
+
+
+class string {
+  char *Data;
+  unsigned Length;
+public:
+  string(); 
+  ~string();
+};
+
+string getInput();
+
+void test9() {
+  string &s = getInput(); // expected-error{{lvalue reference}}
+}
diff --git a/test/SemaCXX/return.cpp b/test/SemaCXX/return.cpp
new file mode 100644
index 000000000000..03b0ddb87965
--- /dev/null
+++ b/test/SemaCXX/return.cpp
@@ -0,0 +1,18 @@
+// RUN: clang-cc %s -fsyntax-only -verify
+
+int test1() {
+  throw;
+}
+
+// PR5071
+template<typename T> T f() { }
+
+template<typename T>
+void g(T t) {
+  return t * 2; // okay
+}
+
+template<typename T>
+T h() {
+  return 17;
+}
diff --git a/test/SemaCXX/static-array-member.cpp b/test/SemaCXX/static-array-member.cpp
new file mode 100644
index 000000000000..dac70cd2eabf
--- /dev/null
+++ b/test/SemaCXX/static-array-member.cpp
@@ -0,0 +1,18 @@
+// RUN: clang-cc -fsyntax-only %s
+
+struct X0 {
+  static int array[];
+  
+  int x;
+  int y;
+};
+
+int X0::array[sizeof(X0) * 2];
+
+template<typename T, int N>
+struct X1 {
+  static T array[];
+};
+
+template<typename T, int N>
+T X1<T, N>::array[N];
diff --git a/test/SemaCXX/static-cast-complete-type.cpp b/test/SemaCXX/static-cast-complete-type.cpp
new file mode 100644
index 000000000000..83583a5adf8e
--- /dev/null
+++ b/test/SemaCXX/static-cast-complete-type.cpp
@@ -0,0 +1,13 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+template<typename T> struct S {
+  S(int);
+};
+
+struct T; // expected-note{{forward declaration of 'struct T'}}
+
+void f() {
+  S<int> s0 = static_cast<S<int> >(0);
+  S<void*> s1 = static_cast<S<void*> >(00);
+
+  (void)static_cast<T>(10); // expected-error{{'struct T' is an incomplete type}}
+}
diff --git a/test/SemaCXX/static-cast.cpp b/test/SemaCXX/static-cast.cpp
index b5c515d5e161..8db8e33b93ce 100644
--- a/test/SemaCXX/static-cast.cpp
+++ b/test/SemaCXX/static-cast.cpp
@@ -1,11 +1,11 @@
-// RUN: clang-cc -fsyntax-only -verify %s
+// RUN: clang-cc -fsyntax-only -verify -faccess-control %s
 
 struct A {};
 struct B : public A {};             // Single public base.
 struct C1 : public virtual B {};    // Single virtual base.
 struct C2 : public virtual B {};
 struct D : public C1, public C2 {}; // Diamond
-struct E : private A {};            // Single private base.
+struct E : private A {};            // Single private base. expected-note 2 {{'private' inheritance specifier here}}
 struct F : public C1 {};            // Single path to B with virtual.
 struct G1 : public B {};
 struct G2 : public B {};
@@ -14,6 +14,11 @@ struct H : public G1, public G2 {}; // Ambiguous path to B.
 enum Enum { En1, En2 };
 enum Onom { On1, On2 };
 
+struct Co1 { operator int(); };
+struct Co2 { Co2(int); };
+struct Co3 { };
+struct Co4 { Co4(Co3); operator Co3(); };
+
 // Explicit implicits
 void t_529_2()
 {
@@ -45,7 +50,9 @@ void t_529_2()
   (void)static_cast<int B::*>((int A::*)0);
   (void)static_cast<void (B::*)()>((void (A::*)())0);
 
-  // TODO: User-defined conversions
+  (void)static_cast<int>(Co1());
+  (void)static_cast<Co2>(1);
+  (void)static_cast<Co3>(static_cast<Co4>(Co3()));
 
   // Bad code below
 
@@ -80,11 +87,10 @@ void t_529_5_8()
   (void)static_cast<D&>(*((A*)0)); // expected-error {{cannot cast 'struct A' to 'struct D &' via virtual base 'struct B'}}
   (void)static_cast<B*>((const A*)0); // expected-error {{static_cast from 'struct A const *' to 'struct B *' casts away constness}}
   (void)static_cast<B&>(*((const A*)0)); // expected-error {{static_cast from 'struct A const' to 'struct B &' casts away constness}}
-  // Accessibility is not yet tested
-  //(void)static_cast<E*>((A*)0); // {{static_cast from 'struct A *' to 'struct E *' is not allowed}}
-  //(void)static_cast<E&>(*((A*)0)); // {{static_cast from 'struct A' to 'struct E &' is not allowed}}
-  (void)static_cast<H*>((A*)0); // expected-error {{ambiguous static_cast from base 'struct A' to derived 'struct H':\n    struct A -> struct B -> struct G1 -> struct H\n    struct A -> struct B -> struct G2 -> struct H}}
-  (void)static_cast<H&>(*((A*)0)); // expected-error {{ambiguous static_cast from base 'struct A' to derived 'struct H':\n    struct A -> struct B -> struct G1 -> struct H\n    struct A -> struct B -> struct G2 -> struct H}}
+  (void)static_cast<E*>((A*)0); // expected-error {{cannot cast 'struct A' to 'struct E' due to inaccessible}}
+  (void)static_cast<E&>(*((A*)0)); // expected-error {{cannot cast 'struct A' to 'struct E' due to inaccessible}}
+  (void)static_cast<H*>((A*)0); // expected-error {{ambiguous cast from base 'struct A' to derived 'struct H':\n    struct A -> struct B -> struct G1 -> struct H\n    struct A -> struct B -> struct G2 -> struct H}}
+  (void)static_cast<H&>(*((A*)0)); // expected-error {{ambiguous cast from base 'struct A' to derived 'struct H':\n    struct A -> struct B -> struct G1 -> struct H\n    struct A -> struct B -> struct G2 -> struct H}}
   (void)static_cast<E*>((B*)0); // expected-error {{static_cast from 'struct B *' to 'struct E *' is not allowed}}
   (void)static_cast<E&>(*((B*)0)); // expected-error {{non-const lvalue reference to type 'struct E' cannot be initialized with a value of type 'struct B'}}
 
diff --git a/test/SemaCXX/static-initializers.cpp b/test/SemaCXX/static-initializers.cpp
index 3d92a532ae1a..a651243df7ef 100644
--- a/test/SemaCXX/static-initializers.cpp
+++ b/test/SemaCXX/static-initializers.cpp
@@ -1,12 +1,10 @@
 // RUN: clang-cc -fsyntax-only -verify %s 
-int f()
-{
-	return 10;
+int f() {
+  return 10;
 }
 
-void g()
-{
-	static int a = f();
+void g() {
+  static int a = f();
 }
 
 static int b = f();
diff --git a/test/SemaCXX/type-traits-incomplete.cpp b/test/SemaCXX/type-traits-incomplete.cpp
new file mode 100644
index 000000000000..ac8ec452b93f
--- /dev/null
+++ b/test/SemaCXX/type-traits-incomplete.cpp
@@ -0,0 +1,7 @@
+// RUN: clang-cc -fsyntax-only -verify %s 
+
+struct S; // expected-note{{forward declaration of 'struct S'}}
+
+void f() {
+  __is_pod(S); // expected-error{{incomplete type 'struct S' used in type trait expression}}
+}
diff --git a/test/SemaCXX/type-traits.cpp b/test/SemaCXX/type-traits.cpp
index 1a2e329b2a44..340c0ae4899b 100644
--- a/test/SemaCXX/type-traits.cpp
+++ b/test/SemaCXX/type-traits.cpp
@@ -7,14 +7,23 @@ struct NonPOD { NonPOD(int); };
 // PODs
 enum Enum { EV };
 struct POD { Enum e; int i; float f; NonPOD* p; };
+struct Empty {};
+typedef Empty EmptyAr[10];
 typedef int Int;
 typedef Int IntAr[10];
 class Statics { static int priv; static NonPOD np; };
+union EmptyUnion {};
+union Union { int i; float f; };
+struct HasFunc { void f (); };
+struct HasOp { void operator *(); };
+struct HasConv { operator int(); };
+struct HasAssign { void operator =(int); };
 
 // Not PODs
 struct Derives : POD {};
+struct DerivesEmpty : Empty {};
 struct HasCons { HasCons(int); };
-struct HasAssign { HasAssign operator =(const HasAssign&); };
+struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); };
 struct HasDest { ~HasDest(); };
 class  HasPriv { int priv; };
 class  HasProt { protected: int prot; };
@@ -22,6 +31,8 @@ struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} };
 struct HasNonPOD { NonPOD np; };
 struct HasVirt { virtual void Virt() {}; };
 typedef Derives NonPODAr[10];
+typedef HasVirt VirtAr[10];
+union NonPODUnion { int i; Derives n; };
 
 void is_pod()
 {
@@ -31,10 +42,17 @@ void is_pod()
   int t04[T(__is_pod(Int))];
   int t05[T(__is_pod(IntAr))];
   int t06[T(__is_pod(Statics))];
+  int t07[T(__is_pod(Empty))];
+  int t08[T(__is_pod(EmptyUnion))];
+  int t09[T(__is_pod(Union))];
+  int t10[T(__is_pod(HasFunc))];
+  int t11[T(__is_pod(HasOp))];
+  int t12[T(__is_pod(HasConv))];
+  int t13[T(__is_pod(HasAssign))];
 
   int t21[F(__is_pod(Derives))];
   int t22[F(__is_pod(HasCons))];
-  int t23[F(__is_pod(HasAssign))];
+  int t23[F(__is_pod(HasCopyAssign))];
   int t24[F(__is_pod(HasDest))];
   int t25[F(__is_pod(HasPriv))];
   int t26[F(__is_pod(HasProt))];
@@ -42,9 +60,40 @@ void is_pod()
   int t28[F(__is_pod(HasNonPOD))];
   int t29[F(__is_pod(HasVirt))];
   int t30[F(__is_pod(NonPODAr))];
+  int t31[F(__is_pod(DerivesEmpty))];
+ // int t32[F(__is_pod(NonPODUnion))];
+}
+
+typedef Empty EmptyAr[10];
+struct Bit0 { int : 0; };
+struct Bit0Cons { int : 0; Bit0Cons(); };
+struct BitOnly { int x : 3; };
+//struct DerivesVirt : virtual POD {};
+
+void is_empty()
+{
+  int t01[T(__is_empty(Empty))];
+  int t02[T(__is_empty(DerivesEmpty))];
+  int t03[T(__is_empty(HasCons))];
+  int t04[T(__is_empty(HasCopyAssign))];
+  int t05[T(__is_empty(HasDest))];
+  int t06[T(__is_empty(HasFunc))];
+  int t07[T(__is_empty(HasOp))];
+  int t08[T(__is_empty(HasConv))];
+  int t09[T(__is_empty(HasAssign))];
+  int t10[T(__is_empty(Bit0))];
+  int t11[T(__is_empty(Bit0Cons))];
+
+  int t21[F(__is_empty(Int))];
+  int t22[F(__is_empty(POD))];
+  int t23[F(__is_empty(EmptyUnion))];
+  int t24[F(__is_empty(EmptyAr))];
+  int t25[F(__is_empty(HasRef))];
+  int t26[F(__is_empty(HasVirt))];
+  int t27[F(__is_empty(BitOnly))];
+//  int t27[F(__is_empty(DerivesVirt))];
 }
 
-union Union { int i; float f; };
 typedef Derives ClassType;
 
 void is_class()
@@ -92,7 +141,7 @@ void is_enum()
   int t17[F(__is_enum(ClassType))];
 }
 
-struct Polymorph { virtual void f(); };
+typedef HasVirt Polymorph;
 struct InheritPolymorph : Polymorph {};
 
 void is_polymorphic()
@@ -109,3 +158,95 @@ void is_polymorphic()
   int t17[F(__is_polymorphic(ClassType))];
   int t18[F(__is_polymorphic(Enum))];
 }
+
+typedef Int& IntRef;
+typedef const IntAr ConstIntAr;
+typedef ConstIntAr ConstIntArAr[4];
+
+struct HasCopy {
+  HasCopy(HasCopy& cp);
+};
+
+void has_trivial_default_constructor() {
+  int t01[T(__has_trivial_constructor(Int))];
+  int t02[T(__has_trivial_constructor(IntAr))];
+  int t03[T(__has_trivial_constructor(Union))];
+  int t04[T(__has_trivial_constructor(UnionAr))];
+  int t05[T(__has_trivial_constructor(POD))];
+  int t06[T(__has_trivial_constructor(Derives))];
+  int t07[T(__has_trivial_constructor(ConstIntAr))];
+  int t08[T(__has_trivial_constructor(ConstIntArAr))];
+  int t09[T(__has_trivial_constructor(HasDest))];
+  int t10[T(__has_trivial_constructor(HasPriv))];
+  int t11[F(__has_trivial_constructor(HasCons))];
+  int t12[F(__has_trivial_constructor(HasRef))];
+  int t13[F(__has_trivial_constructor(HasCopy))];
+  int t14[F(__has_trivial_constructor(IntRef))];
+  int t15[T(__has_trivial_constructor(HasCopyAssign))];
+  int t16[T(__has_trivial_constructor(const Int))];
+  int t17[T(__has_trivial_constructor(NonPODAr))];
+  int t18[F(__has_trivial_constructor(VirtAr))];
+}
+
+void has_trivial_copy_constructor() {
+  int t01[T(__has_trivial_copy(Int))];
+  int t02[T(__has_trivial_copy(IntAr))];
+  int t03[T(__has_trivial_copy(Union))];
+  int t04[T(__has_trivial_copy(UnionAr))];
+  int t05[T(__has_trivial_copy(POD))];
+  int t06[T(__has_trivial_copy(Derives))];
+  int t07[T(__has_trivial_copy(ConstIntAr))];
+  int t08[T(__has_trivial_copy(ConstIntArAr))];
+  int t09[T(__has_trivial_copy(HasDest))];
+  int t10[T(__has_trivial_copy(HasPriv))];
+  int t11[T(__has_trivial_copy(HasCons))];
+  int t12[T(__has_trivial_copy(HasRef))];
+  int t13[F(__has_trivial_copy(HasCopy))];
+  int t14[T(__has_trivial_copy(IntRef))];
+  int t15[T(__has_trivial_copy(HasCopyAssign))];
+  int t16[T(__has_trivial_copy(const Int))];
+  int t17[F(__has_trivial_copy(NonPODAr))];
+  int t18[F(__has_trivial_copy(VirtAr))];
+}
+
+void has_trivial_copy_assignment() {
+  int t01[T(__has_trivial_assign(Int))];
+  int t02[T(__has_trivial_assign(IntAr))];
+  int t03[T(__has_trivial_assign(Union))];
+  int t04[T(__has_trivial_assign(UnionAr))];
+  int t05[T(__has_trivial_assign(POD))];
+  int t06[T(__has_trivial_assign(Derives))];
+  int t07[F(__has_trivial_assign(ConstIntAr))];
+  int t08[F(__has_trivial_assign(ConstIntArAr))];
+  int t09[T(__has_trivial_assign(HasDest))];
+  int t10[T(__has_trivial_assign(HasPriv))];
+  int t11[T(__has_trivial_assign(HasCons))];
+  int t12[T(__has_trivial_assign(HasRef))];
+  int t13[T(__has_trivial_assign(HasCopy))];
+  int t14[F(__has_trivial_assign(IntRef))];
+  int t15[F(__has_trivial_assign(HasCopyAssign))];
+  int t16[F(__has_trivial_assign(const Int))];
+  int t17[F(__has_trivial_assign(NonPODAr))];
+  int t18[F(__has_trivial_assign(VirtAr))];
+}
+
+void has_trivial_destructor() {
+  int t01[T(__has_trivial_destructor(Int))];
+  int t02[T(__has_trivial_destructor(IntAr))];
+  int t03[T(__has_trivial_destructor(Union))];
+  int t04[T(__has_trivial_destructor(UnionAr))];
+  int t05[T(__has_trivial_destructor(POD))];
+  int t06[T(__has_trivial_destructor(Derives))];
+  int t07[T(__has_trivial_destructor(ConstIntAr))];
+  int t08[T(__has_trivial_destructor(ConstIntArAr))];
+  int t09[F(__has_trivial_destructor(HasDest))];
+  int t10[T(__has_trivial_destructor(HasPriv))];
+  int t11[T(__has_trivial_destructor(HasCons))];
+  int t12[T(__has_trivial_destructor(HasRef))];
+  int t13[T(__has_trivial_destructor(HasCopy))];
+  int t14[T(__has_trivial_destructor(IntRef))];
+  int t15[T(__has_trivial_destructor(HasCopyAssign))];
+  int t16[T(__has_trivial_destructor(const Int))];
+  int t17[T(__has_trivial_destructor(NonPODAr))];
+  int t18[T(__has_trivial_destructor(VirtAr))];
+}
diff --git a/test/SemaCXX/unknown-type-name.cpp b/test/SemaCXX/unknown-type-name.cpp
new file mode 100644
index 000000000000..054212951338
--- /dev/null
+++ b/test/SemaCXX/unknown-type-name.cpp
@@ -0,0 +1,29 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// PR3990
+namespace N {
+  struct Wibble {
+  };
+
+  typedef Wibble foo;
+}
+using namespace N;
+
+foo::bar x; // expected-error{{no type named 'bar' in 'struct N::Wibble'}}
+
+void f() {
+  foo::bar  = 4; // expected-error{{no member named 'bar' in 'struct N::Wibble'}}
+}
+
+template<typename T>
+struct A {
+  typedef T type;
+  
+  type f();
+};
+
+template<typename T>
+A<T>::type g(T t) { return t; } // expected-error{{missing 'typename'}}
+
+template<typename T>
+A<T>::type A<T>::f() { return type(); } // expected-error{{missing 'typename'}}
diff --git a/test/SemaCXX/unreachable-catch-clauses.cpp b/test/SemaCXX/unreachable-catch-clauses.cpp
new file mode 100644
index 000000000000..c8b642e7ab53
--- /dev/null
+++ b/test/SemaCXX/unreachable-catch-clauses.cpp
@@ -0,0 +1,14 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+class BaseEx {};
+class Ex1: public BaseEx {};
+typedef Ex1 Ex2;
+
+void f();
+
+void test()
+try {}
+catch (BaseEx &e) { f(); }
+catch (Ex1 &e) { f(); } // expected-note {{for type class Ex1 &}}
+catch (Ex2 &e) { f(); } // expected-warning {{exception of type Ex2 & will be caught by earlier handler}}
+
diff --git a/test/SemaCXX/using-decl-1.cpp b/test/SemaCXX/using-decl-1.cpp
index 2459f251deb2..37e101e221ea 100644
--- a/test/SemaCXX/using-decl-1.cpp
+++ b/test/SemaCXX/using-decl-1.cpp
@@ -6,3 +6,14 @@ namespace std {
   using ::f;
   inline void f() { return f(true); }
 }
+
+namespace M {
+  void f(float);
+}
+
+namespace N {
+  using M::f;
+  void f(int) { } // expected-note{{previous}}
+  
+  void f(int) { } // expected-error{{redefinition}}
+}
diff --git a/test/SemaCXX/using-decl-templates.cpp b/test/SemaCXX/using-decl-templates.cpp
new file mode 100644
index 000000000000..1a53704c1e68
--- /dev/null
+++ b/test/SemaCXX/using-decl-templates.cpp
@@ -0,0 +1,36 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T> struct A {
+  void f() { }
+  struct N { };
+};
+
+template<typename T> struct B : A<T> {
+  using A<T>::f;
+  using A<T>::N;
+  
+  using A<T>::foo; // expected-error{{no member named 'foo'}}
+  using A<double>::f; // expected-error{{using declaration refers into 'A<double>::', which is not a base class of 'B'}}
+};
+
+B<int> a; // expected-note{{in instantiation of template class 'struct B<int>' requested here}}
+
+template<typename T> struct C : A<T> {
+  using A<T>::f;
+  
+  void f() { };
+};
+
+template <typename T> struct D : A<T> {
+  using A<T>::f;
+  
+  void f();
+};
+
+template<typename T> void D<T>::f() { }
+
+template<typename T> struct E : A<T> {
+  using A<T>::f;
+
+  void g() { f(); }
+};
diff --git a/test/SemaCXX/value-dependent-exprs.cpp b/test/SemaCXX/value-dependent-exprs.cpp
new file mode 100644
index 000000000000..c70f895d2bf9
--- /dev/null
+++ b/test/SemaCXX/value-dependent-exprs.cpp
@@ -0,0 +1,47 @@
+// RUN: clang-cc -verify %s
+
+template <unsigned I>
+class C0 {
+  static const int iv0 = 1 << I;
+
+  enum {
+    A = I,
+    B = I + 1
+  };
+
+  struct s0 {
+    int a : I;
+    int b[I];
+  };
+
+  // FIXME: I'm unclear where the right place to handle this is.
+#if 0
+  void f0(int *p) {
+    if (p == I) {
+    }
+  }
+#endif
+
+#if 0
+  // FIXME: Not sure whether we care about these.
+  void f1(int *a)
+    __attribute__((nonnull(1 + I)))
+    __attribute__((constructor(1 + I)))
+    __attribute__((destructor(1 + I)))
+    __attribute__((sentinel(1 + I, 2 + I))),
+    __attribute__((reqd_work_group_size(1 + I, 2 + I, 3 + I))),
+    __attribute__((format_arg(1 + I))),
+    __attribute__((aligned(1 + I))),
+    __attribute__((regparm(1 + I)));
+
+  typedef int int_a0 __attribute__((address_space(1 + B)));
+#endif
+
+#if 0
+  // FIXME: This doesn't work. PR4996.
+  int f2() {
+    return __builtin_choose_expr(I, 1, 2);
+  }
+#endif
+
+};
diff --git a/test/SemaCXX/vararg-non-pod.cpp b/test/SemaCXX/vararg-non-pod.cpp
index 1c5fe74a154d..390f58b1b7b3 100644
--- a/test/SemaCXX/vararg-non-pod.cpp
+++ b/test/SemaCXX/vararg-non-pod.cpp
@@ -51,6 +51,18 @@ void t4()
 
   D d;
   
-  d(10, c); // expected-warning{{Line 48: cannot pass object of non-POD type 'class C' through variadic method; call will abort at runtime}}
+  d(10, c); // expected-warning{{cannot pass object of non-POD type 'class C' through variadic method; call will abort at runtime}}
   d(10, version);
 }
+
+class E {
+  E(int, ...);
+};
+
+void t5()
+{
+  C c(10);
+  
+  E e(10, c); // expected-warning{{cannot pass object of non-POD type 'class C' through variadic constructor; call will abort at runtime}}
+  (void)E(10, c); // expected-warning{{cannot pass object of non-POD type 'class C' through variadic constructor; call will abort at runtime}}
+}
\ No newline at end of file
diff --git a/test/SemaCXX/vector-casts.cpp b/test/SemaCXX/vector-casts.cpp
new file mode 100644
index 000000000000..5b08043545fa
--- /dev/null
+++ b/test/SemaCXX/vector-casts.cpp
@@ -0,0 +1,40 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+typedef int __v2si __attribute__((__vector_size__(8)));
+typedef short __v4hi __attribute__((__vector_size__(8)));
+typedef short __v8hi __attribute__((__vector_size__(16)));
+
+struct S { };
+
+void f() {
+  __v2si v2si;
+  __v4hi v4hi;
+  __v8hi v8hi;
+  unsigned long long ll;
+  unsigned char c;
+  S s;
+  
+  (void)reinterpret_cast<__v2si>(v4hi);
+  (void)(__v2si)v4hi;
+  (void)reinterpret_cast<__v4hi>(v2si);
+  (void)(__v4hi)v2si;
+  (void)reinterpret_cast<unsigned long long>(v2si);
+  (void)(unsigned long long)v2si;
+  (void)reinterpret_cast<__v2si>(ll);
+  (void)(__v2si)(ll);
+
+  (void)reinterpret_cast<S>(v2si); // expected-error {{reinterpret_cast from '__v2si' to 'struct S' is not allowed}}
+  (void)(S)v2si; // expected-error {{C-style cast from '__v2si' to 'struct S' is not allowed}}
+  (void)reinterpret_cast<__v2si>(s); // expected-error {{reinterpret_cast from 'struct S' to '__v2si' is not allowed}}
+  (void)(__v2si)s; // expected-error {{C-style cast from 'struct S' to '__v2si' is not allowed}}
+  
+  (void)reinterpret_cast<unsigned char>(v2si); // expected-error {{reinterpret_cast from vector '__v2si' to scalar 'unsigned char' of different size}}
+  (void)(unsigned char)v2si; // expected-error {{C-style cast from vector '__v2si' to scalar 'unsigned char' of different size}}
+  (void)reinterpret_cast<__v2si>(c); // expected-error {{reinterpret_cast from scalar 'unsigned char' to vector '__v2si' of different size}}
+
+  (void)reinterpret_cast<__v8hi>(v4hi); // expected-error {{reinterpret_cast from vector '__v4hi' to vector '__v8hi' of different size}}
+  (void)(__v8hi)v4hi; // expected-error {{C-style cast from vector '__v4hi' to vector '__v8hi' of different size}}
+  (void)reinterpret_cast<__v4hi>(v8hi); // expected-error {{reinterpret_cast from vector '__v8hi' to vector '__v4hi' of different size}}
+  (void)(__v4hi)v8hi; // expected-error {{C-style cast from vector '__v8hi' to vector '__v4hi' of different size}}
+}
+
+
diff --git a/test/SemaCXX/warn-assignment-condition.cpp b/test/SemaCXX/warn-assignment-condition.cpp
new file mode 100644
index 000000000000..3b9f3066a16b
--- /dev/null
+++ b/test/SemaCXX/warn-assignment-condition.cpp
@@ -0,0 +1,65 @@
+// RUN: clang-cc -fsyntax-only -Wparentheses -verify %s
+
+struct A {
+  int foo();
+  friend A operator+(const A&, const A&);
+  operator bool();
+};
+
+void test() {
+  int x, *p;
+  A a, b;
+
+  // With scalars.
+  if (x = 7) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  if ((x = 7)) {}
+  do {
+  } while (x = 7); // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  do {
+  } while ((x = 7));
+  while (x = 7) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  while ((x = 7)) {}
+  for (; x = 7; ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  for (; (x = 7); ) {}
+
+  if (p = p) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  if ((p = p)) {}
+  do {
+  } while (p = p); // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  do {
+  } while ((p = p));
+  while (p = p) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  while ((p = p)) {}
+  for (; p = p; ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  for (; (p = p); ) {}
+
+  // Initializing variables (shouldn't warn).
+  if (int y = x) {}
+  while (int y = x) {}
+  if (A y = a) {}
+  while (A y = a) {}
+
+  // With temporaries.
+  if (x = (b+b).foo()) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  if ((x = (b+b).foo())) {}
+  do {
+  } while (x = (b+b).foo()); // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  do {
+  } while ((x = (b+b).foo()));
+  while (x = (b+b).foo()) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  while ((x = (b+b).foo())) {}
+  for (; x = (b+b).foo(); ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  for (; (x = (b+b).foo()); ) {}
+
+  // With a user-defined operator.
+  if (a = b + b) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  if ((a = b + b)) {}
+  do {
+  } while (a = b + b); // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  do {
+  } while ((a = b + b));
+  while (a = b + b) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  while ((a = b + b)) {}
+  for (; a = b + b; ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}}
+  for (; (a = b + b); ) {}
+}
diff --git a/test/SemaCXX/warn-char-subscripts.cpp b/test/SemaCXX/warn-char-subscripts.cpp
new file mode 100644
index 000000000000..1c06db91c3f7
--- /dev/null
+++ b/test/SemaCXX/warn-char-subscripts.cpp
@@ -0,0 +1,21 @@
+// RUN: clang-cc -Wchar-subscripts -fsyntax-only -verify %s
+
+template<typename T>
+void t1() {
+  int array[1] = { 0 };
+  T subscript = 0;
+  int val = array[subscript]; // expected-warning{{array subscript is of type 'char'}}
+}
+
+template<typename T>
+void t2() {
+  int array[1] = { 0 };
+  T subscript = 0;
+  int val = subscript[array]; // expected-warning{{array subscript is of type 'char'}}
+}
+
+void test() {
+  t1<char>(); // expected-note {{in instantiation of function template specialization 't1<char>' requested here}}
+  t2<char>(); // expected-note {{in instantiation of function template specialization 't2<char>' requested here}}
+}
+
diff --git a/test/SemaCXX/warn-for-var-in-else.cpp b/test/SemaCXX/warn-for-var-in-else.cpp
index 3368da223a48..f73c60689446 100644
--- a/test/SemaCXX/warn-for-var-in-else.cpp
+++ b/test/SemaCXX/warn-for-var-in-else.cpp
@@ -8,6 +8,7 @@ int foo() {
     return X;
   } else {
     do_something(X); // expected-warning{{'X' is always zero in this context}}
+    return 0;
   }
 }
 
diff --git a/test/SemaCXX/warn-reorder-ctor-initialization.cpp b/test/SemaCXX/warn-reorder-ctor-initialization.cpp
new file mode 100644
index 000000000000..bfce588b570a
--- /dev/null
+++ b/test/SemaCXX/warn-reorder-ctor-initialization.cpp
@@ -0,0 +1,89 @@
+// RUN: clang-cc  -fsyntax-only -Wreorder -verify %s
+
+struct BB {};
+
+struct BB1 {};
+
+class complex : public BB, BB1 { 
+public: 
+  complex() : s2(1),  // expected-warning {{member 's2' will be initialized after}}
+              s1(1) , // expected-note {{field s1}} 
+              s3(3),  // expected-warning {{member 's3' will be initialized after}} 
+              BB1(),   // expected-note {{base 'struct BB1'}}  \
+                      // expected-warning {{base class 'struct BB1' will be initialized after}}
+              BB() {}  // expected-note {{base 'struct BB'}}
+  int s1;
+  int s2;
+  int s3;
+}; 
+
+
+// testing virtual bases.
+
+
+struct V { 
+  V();
+};
+
+struct A : public virtual V { 
+  A(); 
+};
+
+struct B : public virtual V {
+  B(); 
+};
+
+struct Diamond : public A, public B {
+  Diamond() : A(), B() {}
+};
+
+
+struct C : public A, public B, private virtual V { 
+  C() { }
+};
+
+
+struct D : public A, public B { 
+  D()  : A(), V() {   } // expected-warning {{base class 'struct A' will be initialized after}} \
+                        // expected-note {{base 'struct V'}}
+};
+
+
+struct E : public A, public B, private virtual V { 
+  E()  : A(), V() {  } // expected-warning {{base class 'struct A' will be initialized after}} \
+                       // expected-note {{base 'struct V'}}
+};
+
+
+struct A1  { 
+  A1(); 
+};
+
+struct B1 {
+  B1();
+};
+
+struct F : public A1, public B1, private virtual V { 
+  F()  : A1(), V() {  } // expected-warning {{base class 'struct A1' will be initialized after}} \
+                        // expected-note {{base 'struct V'}}
+};
+
+struct X : public virtual A, virtual V, public virtual B {
+  X(): A(), V(), B() {} // expected-warning {{base class 'struct A' will be initialized after}} \
+                        // expected-note {{base 'struct V'}}
+};
+
+class Anon {
+  int c; union {int a,b;}; int d;
+  Anon() : c(10), b(1), d(2) {}
+};
+class Anon2 {
+  int c; union {int a,b;}; int d;
+  Anon2() : c(2),
+            d(10), // expected-warning {{member 'd' will be initialized after}}
+            b(1) {} // expected-note {{field b}}
+};
+class Anon3 {
+  union {int a,b;};
+  Anon3() : b(1) {}
+};
diff --git a/test/SemaCXX/warn-unused-variables.cpp b/test/SemaCXX/warn-unused-variables.cpp
new file mode 100644
index 000000000000..d8b9a00ad6de
--- /dev/null
+++ b/test/SemaCXX/warn-unused-variables.cpp
@@ -0,0 +1,6 @@
+// RUN: clang -fsyntax-only -Wunused-variable -verify %s
+
+template<typename T> void f() {
+	T t;
+	t = 17;
+}
diff --git a/test/SemaCXX/wchar_t.cpp b/test/SemaCXX/wchar_t.cpp
index fc258da7d1a6..cb85bc3ae729 100644
--- a/test/SemaCXX/wchar_t.cpp
+++ b/test/SemaCXX/wchar_t.cpp
@@ -7,3 +7,7 @@ void f(wchar_t p) {
   signed wchar_t z; // expected-warning {{'wchar_t' cannot be signed or unsigned}}
   ++x;
 }
+
+// PR4502
+wchar_t const c = L'c';
+int a[c == L'c' ? 1 : -1];
diff --git a/test/SemaObjC/access-property-getter.m b/test/SemaObjC/access-property-getter.m
index 50a301688905..225d63b0173c 100644
--- a/test/SemaObjC/access-property-getter.m
+++ b/test/SemaObjC/access-property-getter.m
@@ -31,5 +31,6 @@
 - (id)harvestPredictivelyProcessedOutputFiles
 {
      _outputStream.release;
+     return 0;
 }
 @end
diff --git a/test/SemaObjC/attr-malloc.m b/test/SemaObjC/attr-malloc.m
new file mode 100644
index 000000000000..6cd6be00a8cf
--- /dev/null
+++ b/test/SemaObjC/attr-malloc.m
@@ -0,0 +1,16 @@
+// RUN: clang-cc -verify -fsyntax-only -fblocks %s
+
+@interface TestAttrMallocOnMethods {}
+- (id) test1 __attribute((malloc)); //  expected-warning {{functions returning a pointer type}}
+- (int) test2 __attribute((malloc)); //  expected-warning {{functions returning a pointer type}}
+@end
+
+id bar(void) __attribute((malloc)); // no-warning
+
+typedef void (^bptr)(void);
+bptr baz(void) __attribute((malloc)); // no-warning
+
+__attribute((malloc)) id (*f)(); //  expected-warning {{functions returning a pointer type}}
+__attribute((malloc)) bptr (*g)(); //  expected-warning {{functions returning a pointer type}}
+__attribute((malloc)) void *(^h)(); //  expected-warning {{functions returning a pointer type}}
+
diff --git a/test/SemaObjC/block-explicit-return-type.m b/test/SemaObjC/block-explicit-return-type.m
new file mode 100644
index 000000000000..cfe72de39523
--- /dev/null
+++ b/test/SemaObjC/block-explicit-return-type.m
@@ -0,0 +1,77 @@
+// RUN: clang-cc -fsyntax-only %s -verify -fblocks
+// FIXME: should compile
+// Test for blocks with explicit return type specified.
+
+typedef float * PF;
+float gf;
+
+@interface NSView
+  - (id) some_method_that_returns_id;
+@end
+
+NSView *some_object;
+
+void some_func (NSView * (^) (id));
+
+typedef struct dispatch_item_s *dispatch_item_t;
+typedef void (^completion_block_t)(void);
+
+typedef double (^myblock)(int);
+double test(myblock I);
+
+int main() {
+  __block int x = 1;
+  __block int y = 2;
+
+  (void)^void *{ return 0; };
+
+  (void)^float(float y){ return y; };
+
+  (void)^double (float y, double d) {
+    if (y)
+      return d;
+    else
+      return y;
+  };
+
+  const char * (^chb) (int flag, const char *arg, char *arg1) = ^ const char * (int flag, const char *arg, char *arg1) {
+    if (flag)
+      return 0;
+    if (flag == 1)
+      return arg;
+    else if (flag == 2)
+      return "";
+    return arg1; 
+  };
+
+  (void)^PF { return &gf; };
+
+  some_func(^ NSView * (id whatever) { return [some_object some_method_that_returns_id]; });
+
+  double res = test(^(int z){x = y+z; return (double)z; });
+}
+
+void func() {
+  completion_block_t X;
+
+  completion_block_t (^blockx)(dispatch_item_t) = ^completion_block_t (dispatch_item_t item) {
+    return X;
+  };
+
+  completion_block_t (^blocky)(dispatch_item_t) = ^(dispatch_item_t item) {
+    return X;
+  };
+
+  blockx = blocky;
+}
+
+
+// intent: block taking int returning block that takes char,int and returns int
+int (^(^block)(double x))(char, short);
+
+void foo() {
+   int one = 1;
+   block = ^(double x){ return ^(char c, short y) { return one + c + y; };};  // expected-error {{returning block that lives on the local stack}}
+   // or:
+   block = ^(double x){ return ^(char c, short y) { return one + (int)c + y; };};  // expected-error {{returning block that lives on the local stack}}
+}
diff --git a/test/SemaObjC/blocks.m b/test/SemaObjC/blocks.m
index 6dab289ae9f2..aecdfd1f5e4e 100644
--- a/test/SemaObjC/blocks.m
+++ b/test/SemaObjC/blocks.m
@@ -44,3 +44,14 @@ void foo8() {
   P = ^itf() {};          // expected-error {{Objective-C interface type 'itf' cannot be returned by value}}
   P = ^itf{};             // expected-error {{Objective-C interface type 'itf' cannot be returned by value}}
 }
+
+
+int foo9() {
+  typedef void (^DVTOperationGroupScheduler)();
+  id _suboperationSchedulers;
+
+  for (DVTOperationGroupScheduler scheduler in _suboperationSchedulers) {
+            ;
+        }
+
+}
diff --git a/test/SemaObjC/call-super-2.m b/test/SemaObjC/call-super-2.m
index 92bec27c6783..a481cffd2886 100644
--- a/test/SemaObjC/call-super-2.m
+++ b/test/SemaObjC/call-super-2.m
@@ -40,8 +40,8 @@ id objc_getClass(const char *s);
 {
    int i = [(id <Func>)self class_func0];
    i += [(id <Func>)super class_func0];    // expected-error {{cannot cast 'super' (it isn't an expression)}}
-   i += [(Class <Func>)self class_func0];  // expected-error {{protocol qualified 'Class' is unsupported}}
-   return i + [(Class <Func>)super class_func0]; // expected-error {{protocol qualified 'Class' is unsupported}} // expected-error {{cannot cast 'super' (it isn't an expression)}}
+   i += [(Class <Func>)self class_func0];  // 
+   return i + [(Class <Func>)super class_func0]; // // expected-error {{cannot cast 'super' (it isn't an expression)}}
 }
 + (int) class_func3
 {
diff --git a/test/SemaObjC/category-1.m b/test/SemaObjC/category-1.m
index 6ae775848e78..dcbda42cd136 100644
--- a/test/SemaObjC/category-1.m
+++ b/test/SemaObjC/category-1.m
@@ -53,4 +53,23 @@
 @implementation XCRemoteComputerManager
 @end
 
+@implementation XCRemoteComputerManager(x) // expected-note {{previous definition is here}}
+@end
+
+@implementation XCRemoteComputerManager(x) // expected-error {{reimplementation of category 'x' for class 'XCRemoteComputerManager'}}
+@end
+
+// <rdar://problem/7249233>
+
+@protocol MultipleCat_P
+-(void) im0;
+@end
+
+@interface MultipleCat_I @end
+
+@interface MultipleCat_I()  @end
 
+@interface MultipleCat_I() <MultipleCat_P>  @end
+
+@implementation MultipleCat_I // expected-warning {{incomplete implementation}}, expected-warning {{method definition for 'im0' not found}}
+@end
diff --git a/test/SemaObjC/category-method-lookup-2.m b/test/SemaObjC/category-method-lookup-2.m
index 76048cc2f74c..15da63783fee 100644
--- a/test/SemaObjC/category-method-lookup-2.m
+++ b/test/SemaObjC/category-method-lookup-2.m
@@ -17,6 +17,7 @@ typedef struct objc_class *Class;
 
 - instanceMethod {
   [[self class] classMethod];
+  return 0;
 }
 
 @end
diff --git a/test/SemaObjC/class-bitfield.m b/test/SemaObjC/class-bitfield.m
index 01b532464c28..82209121b183 100644
--- a/test/SemaObjC/class-bitfield.m
+++ b/test/SemaObjC/class-bitfield.m
@@ -20,7 +20,7 @@
 }
 @end
 
-@interface WithBitfields: Base {
+@interface WithBitFields: Base {
   void *isa; // expected-note {{previous definition is here}}
   unsigned a: 5;
   signed b: 4;
@@ -28,10 +28,10 @@
 }
 @end
 
-@implementation WithBitfields {
+@implementation WithBitFields {
   char *isa;  // expected-error {{instance variable 'isa' has conflicting type: 'char *' vs 'void *'}}
   unsigned a: 5;  
   signed b: 4; 
-  int c: 3;  // expected-error {{instance variable 'c' has conflicting bitfield width}}
+  int c: 3;  // expected-error {{instance variable 'c' has conflicting bit-field width}}
 }
 @end
diff --git a/test/SemaObjC/class-getter-using-dotsyntax.m b/test/SemaObjC/class-getter-using-dotsyntax.m
new file mode 100644
index 000000000000..ba42590c3419
--- /dev/null
+++ b/test/SemaObjC/class-getter-using-dotsyntax.m
@@ -0,0 +1,39 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+typedef struct objc_class *Class;
+
+struct objc_class {
+    Class isa;
+};
+
+typedef struct objc_object {
+    Class isa;
+} *id;
+
+@interface XCActivityLogSection 
++ (unsigned)serializationFormatVersion;
++ (unsigned)sectionByDeserializingData;
++ (Class)retursClass;
+@end
+
+@implementation XCActivityLogSection
+
++ (unsigned)serializationFormatVersion
+{
+
+    return 0;
+}
++ (unsigned)sectionByDeserializingData {
+    unsigned version;
+    return self.serializationFormatVersion;
+}
+
++ (Class)retursClass {
+    Class version;
+    // FIXIT. (*version).isa does not work. Results in compiler error.
+    return version->isa;
+}
+
+@end
+
+
diff --git a/test/SemaObjC/class-impl-1.m b/test/SemaObjC/class-impl-1.m
index 5a67bef3d605..09ad1556c035 100644
--- a/test/SemaObjC/class-impl-1.m
+++ b/test/SemaObjC/class-impl-1.m
@@ -9,7 +9,7 @@ typedef int INTF3; // expected-note {{previous definition is here}}
 @interface INTF  : OBJECT
 @end
 
-@implementation INTF @end 
+@implementation INTF @end // expected-note {{previous definition is here}}
 
 @implementation INTF //  expected-error {{reimplementation of class 'INTF'}}
 @end
diff --git a/test/SemaObjC/compatible-protocol-qualified-types.m b/test/SemaObjC/compatible-protocol-qualified-types.m
index 3c27b5f0d3cd..71f00542b1c6 100644
--- a/test/SemaObjC/compatible-protocol-qualified-types.m
+++ b/test/SemaObjC/compatible-protocol-qualified-types.m
@@ -70,6 +70,7 @@ extern NSString * const XCActiveSelectionLevel;
 
 - (NSTextStorage *)contents {
  [_contents setDelegate:self]; // expected-warning {{incompatible type sending 'SKTText *', expected 'id<NSTextStorageDelegate>'}}
+ return 0;
 }
 
 @end
diff --git a/test/SemaObjC/comptypes-1.m b/test/SemaObjC/comptypes-1.m
index 8717bd09eb84..df0785bf89e1 100644
--- a/test/SemaObjC/comptypes-1.m
+++ b/test/SemaObjC/comptypes-1.m
@@ -66,9 +66,7 @@ int main()
 
   /* Any comparison between 'MyClass *' and anything which is not an 'id'
      must generate a warning.  */
-  /* FIXME: GCC considers this a warning ("comparison of distinct pointer types"). */
-  /* There is a corresponding FIXME in ASTContext::mergeTypes() */
-  if (obj_p == obj_c) foo() ;
+  if (obj_p == obj_c) foo() ; // expected-warning {{comparison of distinct pointer types ('id<MyProtocol>' and 'MyClass *')}}
 
   if (obj_c == obj_cp) foo() ; // expected-warning {{comparison of distinct pointer types ('MyClass *' and 'MyOtherClass *')}} 
   if (obj_cp == obj_c) foo() ; // expected-warning {{comparison of distinct pointer types ('MyOtherClass *' and 'MyClass *')}}
diff --git a/test/SemaObjC/comptypes-3.m b/test/SemaObjC/comptypes-3.m
index 2d8f19d806a7..0506bce7ad1a 100644
--- a/test/SemaObjC/comptypes-3.m
+++ b/test/SemaObjC/comptypes-3.m
@@ -42,8 +42,8 @@ int main()
   obj_ac = obj_b;  // expected-warning {{incompatible type assigning 'id<MyProtocolB>', expected 'id<MyProtocolAC>'}}
   obj_ac = obj_ab; // expected-warning {{incompatible type assigning 'id<MyProtocolAB>', expected 'id<MyProtocolAC>'}}
 
-  if (obj_a == obj_b) foo (); // expected-warning {{invalid operands to binary expression ('id<MyProtocolA>' and 'id<MyProtocolB>')}}
-  if (obj_b == obj_a) foo (); // expected-warning {{invalid operands to binary expression ('id<MyProtocolB>' and 'id<MyProtocolA>')}}
+  if (obj_a == obj_b) foo (); // expected-warning {{comparison of distinct pointer types ('id<MyProtocolA>' and 'id<MyProtocolB>')}}
+  if (obj_b == obj_a) foo (); // expected-warning {{comparison of distinct pointer types ('id<MyProtocolB>' and 'id<MyProtocolA>')}}
 
   if (obj_a == obj_ab) foo (); /* Ok */
   if (obj_ab == obj_a) foo (); /* Ok */ 
@@ -54,11 +54,11 @@ int main()
   if (obj_b == obj_ab) foo (); /* Ok */ 
   if (obj_ab == obj_b) foo (); /* Ok */ 
 
-  if (obj_b == obj_ac) foo (); // expected-warning {{invalid operands to binary expression ('id<MyProtocolB>' and 'id<MyProtocolAC>')}} 
-  if (obj_ac == obj_b) foo (); // expected-warning {{invalid operands to binary expression ('id<MyProtocolAC>' and 'id<MyProtocolB>')}} 
+  if (obj_b == obj_ac) foo (); // expected-warning {{comparison of distinct pointer types ('id<MyProtocolB>' and 'id<MyProtocolAC>')}} 
+  if (obj_ac == obj_b) foo (); // expected-warning {{comparison of distinct pointer types ('id<MyProtocolAC>' and 'id<MyProtocolB>')}} 
 
-  if (obj_ab == obj_ac) foo (); // expected-warning {{invalid operands to binary expression ('id<MyProtocolAB>' and 'id<MyProtocolAC>')}} 
-  if (obj_ac == obj_ab) foo (); // expected-warning {{invalid operands to binary expression ('id<MyProtocolAC>' and 'id<MyProtocolAB>')}} 
+  if (obj_ab == obj_ac) foo (); // expected-warning {{comparison of distinct pointer types ('id<MyProtocolAB>' and 'id<MyProtocolAC>')}} 
+  if (obj_ac == obj_ab) foo (); // expected-warning {{comparison of distinct pointer types ('id<MyProtocolAC>' and 'id<MyProtocolAB>')}} 
 
   return 0;
 }
diff --git a/test/SemaObjC/comptypes-5.m b/test/SemaObjC/comptypes-5.m
index afd8a4949ed6..478e8c8114ac 100644
--- a/test/SemaObjC/comptypes-5.m
+++ b/test/SemaObjC/comptypes-5.m
@@ -26,8 +26,8 @@ int main()
   MyOtherClass<MyProtocol> *obj_c_super_p_q = nil;
   MyClass<MyProtocol> *obj_c_cat_p_q = nil;
 
-  obj_c_cat_p = obj_id_p;   // expected-warning {{incompatible type assigning 'id<MyProtocol>', expected 'MyClass *'}}
-  obj_c_super_p = obj_id_p;  // expected-warning {{incompatible type assigning 'id<MyProtocol>', expected 'MyOtherClass *'}}
+  obj_c_cat_p = obj_id_p;   
+  obj_c_super_p = obj_id_p;  
   obj_id_p = obj_c_cat_p;  /* Ok */
   obj_id_p = obj_c_super_p; /* Ok */
 
diff --git a/test/SemaObjC/comptypes-7.m b/test/SemaObjC/comptypes-7.m
index faca6937cb74..881fd2b5553b 100644
--- a/test/SemaObjC/comptypes-7.m
+++ b/test/SemaObjC/comptypes-7.m
@@ -28,7 +28,7 @@ int main()
   obj = j; // expected-warning {{incompatible pointer types assigning 'int *', expected 'id'}}
 
   obj_p = i; // expected-warning {{incompatible integer to pointer conversion assigning 'int', expected 'id<MyProtocol>'}}
-  obj_p = j; // expected-warning {{incompatible type assigning 'int *', expected 'id<MyProtocol>'}}
+  obj_p = j; // expected-warning {{incompatible pointer types assigning 'int *', expected 'id<MyProtocol>'}}
   
   obj_c = i; // expected-warning {{incompatible integer to pointer conversion assigning 'int', expected 'MyClass *'}}
   obj_c = j; // expected-warning {{incompatible pointer types assigning 'int *', expected 'MyClass *'}}
@@ -42,7 +42,7 @@ int main()
   i = obj_C; // expected-warning {{incompatible pointer to integer conversion assigning 'Class', expected 'int'}}
   
   j = obj;   // expected-warning {{incompatible pointer types assigning 'id', expected 'int *'}}
-  j = obj_p; // expected-warning {{incompatible type assigning 'id<MyProtocol>', expected 'int *'}}
+  j = obj_p; // expected-warning {{incompatible pointer types assigning 'id<MyProtocol>', expected 'int *'}}
   j = obj_c; // expected-warning {{incompatible pointer types assigning 'MyClass *', expected 'int *'}}
   j = obj_C; // expected-warning {{incompatible pointer types assigning 'Class', expected 'int *'}}
   
diff --git a/test/SemaObjC/comptypes-a.m b/test/SemaObjC/comptypes-a.m
index 936c6dfc5de9..5570d56b0b83 100644
--- a/test/SemaObjC/comptypes-a.m
+++ b/test/SemaObjC/comptypes-a.m
@@ -13,6 +13,7 @@ extern NSInteger codeAssistantCaseCompareItems(id a, id b, void *context);
 
 NSInteger codeAssistantCaseCompareItems(id<PBXCompletionItem> a, id<PBXCompletionItem> b, void *context)
 {
+  return 0;
 }
 
 @interface TedWantsToVerifyObjCDoesTheRightThing
diff --git a/test/SemaObjC/conditional-expr-3.m b/test/SemaObjC/conditional-expr-3.m
index 31d4834ff0af..9f1ee68c6f94 100644
--- a/test/SemaObjC/conditional-expr-3.m
+++ b/test/SemaObjC/conditional-expr-3.m
@@ -51,15 +51,15 @@ void f7(int cond, id x, A *a) {
 }
 
 void f8(int cond, id<P0,P1> x0, id<P0,P2> x1) {
-  barP0(cond ? x0 : x1);
+  barP0(cond ? x0 : x1); // expected-warning {{incompatible operand types ('id<P0,P1>' and 'id<P0,P2>')}}
 }
 
 void f9(int cond, id<P0,P1> x0, id<P0,P2> x1) {
-  barP1(cond ? x0 : x1);
+  barP1(cond ? x0 : x1); // expected-warning {{incompatible operand types ('id<P0,P1>' and 'id<P0,P2>')}}
 }
 
 void f10(int cond, id<P0,P1> x0, id<P0,P2> x1) {
-  barP2(cond ? x0 : x1);
+  barP2(cond ? x0 : x1); // expected-warning {{incompatible operand types ('id<P0,P1>' and 'id<P0,P2>')}}
 }
 
 int f11(int cond, A* a, B* b) {
diff --git a/test/SemaObjC/conditional-expr-4.m b/test/SemaObjC/conditional-expr-4.m
index 7d50ba60750c..87209581534c 100644
--- a/test/SemaObjC/conditional-expr-4.m
+++ b/test/SemaObjC/conditional-expr-4.m
@@ -1,5 +1,4 @@
-// RUN: clang-cc -fsyntax-only %s
-// XFAIL
+// RUN: clang-cc -fsyntax-only -verify %s
 // <rdar://problem/6212771>
 
 #define nil ((void*) 0)
@@ -26,6 +25,11 @@ A *f1_a(int cond, A *a) {
   return cond ? a : nil;
 }
 
+void *f1_const_a(int x, void *p, const A * q) {
+  void *r = x ? p : q; // expected-warning{{initializing 'void const *' discards qualifiers, expected 'void *'}}
+  return r;
+}
+
 // Check interaction with qualified id
 
 @protocol P0 @end
@@ -48,9 +52,7 @@ id f3(int cond, id<P0> a) {
 @end
 
 int f5(int cond, id<P1> a, id<P1> b) {
-  // This should result in something with id type, currently. This is
-  // almost certainly wrong and should be fixed.
-  return (cond ? a : b).x; // expected-error {{member reference base type ('id') is not a structure or union}}
+  return (cond ? a : b).x;
 }
 int f5_a(int cond, A *a, A *b) {
   return (cond ? a : b).x;
@@ -61,7 +63,7 @@ int f5_b(int cond, A *a, B *b) {
 
 int f6(int cond, id<P1> a, void *b) {
   // This should result in something with id type, currently.
-  return (cond ? a : b).x; // expected-error {{member reference base type ('id') is not a structure or union}}
+  return (cond ? a : b).x; // expected-error {{member reference base type 'void *' is not a structure or union}}
 }
 
 int f7(int cond, id<P1> a) {
@@ -69,10 +71,10 @@ int f7(int cond, id<P1> a) {
 }
 
 int f8(int cond, id<P1> a, A *b) {
-  // GCC regards this as a warning (comparison of distinct Objective-C types lacks a cast)
-  return a == b; // expected-error {{invalid operands to binary expression}}
+  return a == b; // expected-warning {{comparison of distinct pointer types ('id<P1>' and 'A *')}}
 }
 
 int f9(int cond, id<P1> a, A *b) {
-  return (cond ? a : b).x; // expected-error {{incompatible operand types}}
+  return (cond ? a : b).x; // expected-warning {{incompatible operand types ('id<P1>' and 'A *')}} \
+                              expected-error {{property 'x' not found on object of type 'id'}}
 }
diff --git a/test/SemaObjC/conditional-expr-5.m b/test/SemaObjC/conditional-expr-5.m
new file mode 100644
index 000000000000..d9c1a9474fe7
--- /dev/null
+++ b/test/SemaObjC/conditional-expr-5.m
@@ -0,0 +1,27 @@
+// RUN: clang-cc  -fsyntax-only -verify %s
+
+@interface PBXBuildSettingsDictionary
+{
+  int i;
+}
+@end
+
+@interface XCConditionalBuildSettingsDictionary : PBXBuildSettingsDictionary
+{
+}
+@end
+
+@implementation PBXBuildSettingsDictionary
+
+- (XCConditionalBuildSettingsDictionary *)conditionalDictionaryForConditionSet
+{
+  return i ? self : (id)0;
+}
+
+- (XCConditionalBuildSettingsDictionary *)conditionalDictionaryForConditionSet2
+{
+  return i ? (id)0 : self;
+}
+@end
+
+
diff --git a/test/SemaObjC/conditional-expr.m b/test/SemaObjC/conditional-expr.m
index ec3613b2aa9b..2043503ddf7b 100644
--- a/test/SemaObjC/conditional-expr.m
+++ b/test/SemaObjC/conditional-expr.m
@@ -27,9 +27,8 @@
 @implementation DTFilterOutputStream2 // expected-warning {{incomplete implementation}} expected-warning {{method definition for 'nextOutputStream' not found}}
 - (id)initWithNextOutputStream:(id <DTOutputStreams>) outputStream {
   id <DTOutputStreams> nextOutputStream = [self nextOutputStream];
-  // GCC warns about both of these.
   self = nextOutputStream; // expected-warning {{incompatible type assigning 'id<DTOutputStreams>', expected 'DTFilterOutputStream2 *'}}
-  return nextOutputStream ? nextOutputStream : self;
+  return nextOutputStream ? nextOutputStream : self; // expected-warning {{incompatible operand types ('id<DTOutputStreams>' and 'DTFilterOutputStream2 *')}}
 }
 @end
 
@@ -37,8 +36,84 @@
 @implementation DTFilterOutputStream3 // expected-warning {{cannot find interface declaration for 'DTFilterOutputStream3'}}
 - (id)initWithNextOutputStream:(id <DTOutputStreams>) outputStream {
   id <DTOutputStreams> nextOutputStream = [self nextOutputStream]; // expected-warning {{method '-nextOutputStream' not found (return type defaults to 'id')}}
-  // GCC warns about both of these as well (no errors).
   self = nextOutputStream; // expected-warning {{incompatible type assigning 'id<DTOutputStreams>', expected 'DTFilterOutputStream3 *'}}
-  return nextOutputStream ? nextOutputStream : self;
+  return nextOutputStream ? nextOutputStream : self; // expected-warning {{incompatible operand types ('id<DTOutputStreams>' and 'DTFilterOutputStream3 *')}}
 }
 @end
+
+//
+
+@protocol P0
+@property int intProp;
+@end
+@protocol P1
+@end
+@protocol P2
+@end
+
+@interface A <P0>
+@end
+
+@interface B : A
+@end
+
+@interface C
+@end
+
+@interface D
+@end
+
+void f0(id<P0> x) {
+  x.intProp = 1;
+}
+
+void f1(int cond, id<P0> x, id<P0> y) {
+  (cond ? x : y).intProp = 1;
+}
+
+void f2(int cond, id<P0> x, A *y) {
+  (cond ? x : y).intProp = 1;
+}
+
+void f3(int cond, id<P0> x, B *y) {
+  (cond ? x : y).intProp = 1;
+}
+
+void f4(int cond, id x, B *y) {
+  (cond ? x : y).intProp = 1; // expected-error {{property 'intProp' not found on object of type 'id'}}
+}
+
+void f5(int cond, id<P0> x, C *y) {
+  (cond ? x : y).intProp = 1; // expected-warning {{incompatible operand types ('id<P0>' and 'C *')}} expected-error {{property 'intProp' not found on object of type 'id'}}
+}
+
+void f6(int cond, C *x, D *y) {
+  (cond ? x : y).intProp = 1; // expected-warning {{incompatible operand types}}, expected-error {{property 'intProp' not found on object of type 'id'}}
+}
+
+id f7(int a, id<P0> x, A* p) {
+  return a ? x : p;
+}
+
+void f8(int a, A<P0> *x, A *y) {
+  [ (a ? x : y ) intProp ];
+}
+
+void f9(int a, A<P0> *x, A<P1> *y) {
+  id l0 = (a ? x : y ); // expected-warning {{incompatible operand types ('A<P0> *' and 'A<P1> *')'}}
+  A<P0> *l1 = (a ? x : y ); // expected-warning {{incompatible operand types ('A<P0> *' and 'A<P1> *')}}
+  A<P1> *l2 = (a ? x : y ); // expected-warning {{incompatible operand types ('A<P0> *' and 'A<P1> *')}}
+  [ (a ? x : y ) intProp ]; // expected-warning {{incompatible operand types ('A<P0> *' and 'A<P1> *')}}
+}
+
+void f10(int a, id<P0> x, id y) {
+  [ (a ? x : y ) intProp ];
+}
+
+void f11(int a, id<P0> x, id<P1> y) {
+  [ (a ? x : y ) intProp ]; // expected-warning {{incompatible operand types ('id<P0>' and 'id<P1>')}}
+}
+
+void f12(int a, A<P0> *x, A<P1> *y) {
+  A<P1>* l0 = (a ? x : y ); // expected-warning {{incompatible operand types ('A<P0> *' and 'A<P1> *')}}
+}
diff --git a/test/SemaObjC/crash-label.m b/test/SemaObjC/crash-label.m
new file mode 100644
index 000000000000..ff40cc67c5dc
--- /dev/null
+++ b/test/SemaObjC/crash-label.m
@@ -0,0 +1,9 @@
+// RUN: clang-cc  -fsyntax-only -verify %s
+
+  - (NSDictionary*) _executeScript:(NSString *)source { // expected-error 2 {{expected a type}} \
+							// expected-error {{missing context for method declaration}} 
+                          Exit:  [nilArgs release]; // expected-error {{use of undeclared identifier}}
+                          }
+                                     - (NSDictionary *) _setupKernelStandardMode:(NSString *)source { // expected-error 2 {{expected a type}} \
+expected-error {{missing context for method declaration}}
+                           Exit:   if(_ciKernel && !success ) { // expected-error {{use of undeclared identifier}} // expected-error 2 {{expected}}
diff --git a/test/SemaObjC/deref-interface.m b/test/SemaObjC/deref-interface.m
new file mode 100644
index 000000000000..1c85918ed57c
--- /dev/null
+++ b/test/SemaObjC/deref-interface.m
@@ -0,0 +1,12 @@
+// RUN: clang-cc -triple x86_64-apple-darwin9 -verify -fsyntax-only %s
+
+@interface NSView 
+  - (id)initWithView:(id)realView;
+@end
+
+@implementation NSView
+ - (id)initWithView:(id)realView {
+     *(NSView *)self = *(NSView *)realView;	// expected-error {{indirection cannot be to an interface in non-fragile ABI}}
+ }
+@end
+
diff --git a/test/SemaObjC/format-arg-attribute.m b/test/SemaObjC/format-arg-attribute.m
index 60cc7cb44f25..dc5aa8932cda 100644
--- a/test/SemaObjC/format-arg-attribute.m
+++ b/test/SemaObjC/format-arg-attribute.m
@@ -11,8 +11,7 @@ extern void fc3 (const NSString *) __attribute__((format_arg(1, 2))); // expecte
 
 struct s1 { int i; } __attribute__((format_arg(1)));  // expected-warning {{'format_arg' attribute only applies to function types}}
 union u1 { int i; } __attribute__((format_arg(1)));  // expected-warning {{'format_arg' attribute only applies to function types}}
-// FIXME: We don't flag this yet.
-enum e1 { E1V0 } __attribute__((format_arg(1))); /* { dg-error "does not apply|only applies" "format_arg on enum" } */
+enum e1 { E1V0 } __attribute__((format_arg(1))); // expected-warning {{'format_arg' attribute only applies to function types}}
 
 extern NSString *ff3 (const NSString *) __attribute__((format_arg(3-2)));
 extern NSString *ff4 (const NSString *) __attribute__((format_arg(foo))); // expected-error {{attribute requires 1 argument(s)}}
diff --git a/test/SemaObjC/id-isa-ref.m b/test/SemaObjC/id-isa-ref.m
new file mode 100644
index 000000000000..dc42f9a53965
--- /dev/null
+++ b/test/SemaObjC/id-isa-ref.m
@@ -0,0 +1,37 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// Failing currently due to Obj-C type representation changes. 2009-09-17
+// XFAIL
+
+typedef struct objc_object {
+  struct objc_class *isa;
+} *id;
+
+@interface NSObject {
+  struct objc_class *isa;
+}
+@end
+@interface Whatever : NSObject
++self;
+@end
+
+static void func() {
+ 
+  id x;
+
+  [(*x).isa self];
+  [x->isa self];
+  
+  Whatever *y;
+
+  // GCC allows this, with the following warning: 
+  //   instance variable ‘isa’ is @protected; this will be a hard error in the future
+  //
+  // FIXME: see if we can avoid the 2 warnings that follow the error.
+  [(*y).isa self]; // expected-error {{instance variable 'isa' is protected}} \
+                      expected-warning{{receiver type 'struct objc_class *' is not 'id' or interface pointer, consider casting it to 'id'}} \
+                      expected-warning{{method '-self' not found (return type defaults to 'id')}}
+  [y->isa self]; // expected-error {{instance variable 'isa' is protected}} \
+                    expected-warning{{receiver type 'struct objc_class *' is not 'id' or interface pointer, consider casting it to 'id'}} \
+                    expected-warning{{method '-self' not found (return type defaults to 'id')}}
+}
diff --git a/test/SemaObjC/id.m b/test/SemaObjC/id.m
index 1781ce71d9c3..70d981c42b17 100644
--- a/test/SemaObjC/id.m
+++ b/test/SemaObjC/id.m
@@ -15,6 +15,6 @@ void foo() {
 }
 
 // Test attempt to redefine 'id' in an incompatible fashion.
-typedef int id;   // expected-error {{typedef redefinition with different types}}
+typedef int id;  // FIXME: Decide how we want to deal with this (now that 'id' is more of a built-in type).
 id b;
 
diff --git a/test/SemaObjC/interface-scope-2.m b/test/SemaObjC/interface-scope-2.m
index d054e714f3b2..c9025903940c 100644
--- a/test/SemaObjC/interface-scope-2.m
+++ b/test/SemaObjC/interface-scope-2.m
@@ -83,6 +83,7 @@ typedef struct __LoreStuffNode {} LoreStuffNode;
 - init {
   LoreStuffNode *node;
   node = &(_historyStuff[1]);
+  return 0;
 }
 @end
 
@@ -108,6 +109,7 @@ _nfttFlags;
   if (self != ((void *)0)) {
     (void)memset(&_nfttFlags, 0, sizeof(struct _OingoBoingoContraptionPeonFlags));
   }
+  return 0;
 }
 @end
 
diff --git a/test/SemaObjC/invalid-objc-decls-1.m b/test/SemaObjC/invalid-objc-decls-1.m
index e3a94f62d5a6..4a3732eff188 100644
--- a/test/SemaObjC/invalid-objc-decls-1.m
+++ b/test/SemaObjC/invalid-objc-decls-1.m
@@ -32,3 +32,11 @@ Super foo( // expected-error{{interface interface type 'Super' cannot be returne
 	Super p1; // expected-error{{interface type cannot be statically allocated}}
 	return p1;
 }
+
+@interface NSMutableSet @end
+
+@interface DVTDummyAnnotationProvider  
+  @property(readonly) NSMutableSet annotations;	// expected-error{{interface type cannot be statically allocated}}
+
+@end
+
diff --git a/test/SemaObjC/message.m b/test/SemaObjC/message.m
index 7b6a4ee3f796..02901238f17f 100644
--- a/test/SemaObjC/message.m
+++ b/test/SemaObjC/message.m
@@ -95,6 +95,6 @@ int test5(int X) {
 void foo4() {
   struct objc_object X[10];
   
-  [X rect];
+  [X rect]; // expected-warning {{receiver type 'struct objc_object *' is not 'id' or interface pointer, consider casting it to 'id'}} expected-warning {{method '-rect' not found (return type defaults to 'id')}}
 }
 
diff --git a/test/SemaObjC/method-arg-decay.m b/test/SemaObjC/method-arg-decay.m
index 4b045914c095..7fd07d2ede33 100644
--- a/test/SemaObjC/method-arg-decay.m
+++ b/test/SemaObjC/method-arg-decay.m
@@ -87,6 +87,7 @@ extern NSMutableArray *XCFindPossibleKeyModules(PBXModule *module, BOOL useExpos
       PBXModule *obj = [XCFindPossibleKeyModules(pModule, (BOOL)0) objectOfType:type     matchingFunction:comparator usingData:data];
     }
   }
+  return 0;
 }
 - (BOOL)buffer:(char *)buf containsAnyPrompts:(char *[])prompts
 {
diff --git a/test/SemaObjC/method-conflict.m b/test/SemaObjC/method-conflict.m
index 7a9b9f0beee8..a4213f6c63c9 100644
--- a/test/SemaObjC/method-conflict.m
+++ b/test/SemaObjC/method-conflict.m
@@ -47,7 +47,9 @@ typedef NSUInteger XDSourceLanguage;
 
 + appendVisibility: (id <XDUMLNamedElement>) element withSpecification: (XDSCDisplaySpecification *) displaySpec to: (NSMutableAttributedString *) attributedString
 {
+  return 0;
 }
-+ (NSUInteger) compartmentsForClassifier: (id <XDSCClassifier>) classifier withSpecification: (XDSCDisplaySpecification *) displaySpec { 
++ (NSUInteger) compartmentsForClassifier: (id <XDSCClassifier>) classifier withSpecification: (XDSCDisplaySpecification *) displaySpec {
+  return 0;
 }
 @end 
diff --git a/test/SemaObjC/method-encoding-2.m b/test/SemaObjC/method-encoding-2.m
index 64a0bc4c323d..b3ffdcd0585c 100644
--- a/test/SemaObjC/method-encoding-2.m
+++ b/test/SemaObjC/method-encoding-2.m
@@ -7,6 +7,6 @@
 @end
 
 @implementation Intf
-- (in out bycopy id) address:(byref inout void *)location with:(out oneway unsigned **)arg2{}
-- (id) another:(void *)location with:(unsigned **)arg2 {}
+- (in out bycopy id) address:(byref inout void *)location with:(out oneway unsigned **)arg2{ return 0; }
+- (id) another:(void *)location with:(unsigned **)arg2 { return 0; }
 @end
diff --git a/test/SemaObjC/method-lookup-2.m b/test/SemaObjC/method-lookup-2.m
index dd0bca93644e..cca757509ad1 100644
--- a/test/SemaObjC/method-lookup-2.m
+++ b/test/SemaObjC/method-lookup-2.m
@@ -35,8 +35,8 @@ extern NSString *const NSWillBecomeMultiThreadedNotification;
 
 @implementation SenTestTool
 + (void) initialize {}
-+(SenTestTool *) sharedInstance {}
--(int) run {}
++(SenTestTool *) sharedInstance { return 0; }
+-(int) run { return 0; }
 +(int) run {
   return[[self sharedInstance] run];
 }
@@ -57,6 +57,7 @@ extern NSString *const NSWillBecomeMultiThreadedNotification;
 - whatever {
   id obj = [[XX alloc] init];
   [[obj class] classMethod];
+  return 0;
 }
 
 @end
diff --git a/test/SemaObjC/method-lookup.m b/test/SemaObjC/method-lookup.m
index 917ad6b3ee92..49dc789af783 100644
--- a/test/SemaObjC/method-lookup.m
+++ b/test/SemaObjC/method-lookup.m
@@ -29,6 +29,7 @@ static NSMutableArray * recentCompletions = ((void *)0);
             [(id)item setPriority:[item priority] / [PBXCodeAssistant factorForRecentCompletion:[item name]]];
         }
     }
+    return 0;
 }
 @end
 
diff --git a/test/SemaObjC/method-typecheck-1.m b/test/SemaObjC/method-typecheck-1.m
index d110c858a41a..a53c4d9f416a 100644
--- a/test/SemaObjC/method-typecheck-1.m
+++ b/test/SemaObjC/method-typecheck-1.m
@@ -8,8 +8,8 @@
 
 @implementation A 
 -(void) setMoo: (float) x {}	//  expected-warning {{conflicting parameter types in implementation of 'setMoo:': 'int' vs 'float'}}
-- (char) setMoo1: (int) x {}	//  expected-warning {{conflicting return type in implementation of 'setMoo1:': 'int' vs 'char'}}
-- (int) setOk : (int) x : (double) d {}
+- (char) setMoo1: (int) x { return 0; }	//  expected-warning {{conflicting return type in implementation of 'setMoo1:': 'int' vs 'char'}}
+- (int) setOk : (int) x : (double) d { return 0; }
 @end
 
 
@@ -20,7 +20,7 @@
 
 @implementation C 
 +(float) cMoo:   // expected-warning {{conflicting return type in implementation of 'cMoo:': 'void' vs 'float'}}
-   (float) x {}	//  expected-warning {{conflicting parameter types in implementation of 'cMoo:': 'int' vs 'float'}}
+   (float) x { return 0; }	//  expected-warning {{conflicting parameter types in implementation of 'cMoo:': 'int' vs 'float'}}
 @end
 
 
@@ -31,7 +31,6 @@
 
 @implementation A(CAT) 
 -(float) setCat:  // expected-warning {{conflicting return type in implementation of 'setCat:': 'void' vs 'float'}}
-(float) x {}	//  expected-warning {{conflicting parameter types in implementation of 'setCat:': 'int' vs 'float'}}
-+ (int) cCat: (int) x {}	//  expected-warning {{conflicting return type in implementation of 'cCat:': 'void' vs 'int'}}
+(float) x { return 0; }	//  expected-warning {{conflicting parameter types in implementation of 'setCat:': 'int' vs 'float'}}
++ (int) cCat: (int) x { return 0; }	//  expected-warning {{conflicting return type in implementation of 'cCat:': 'void' vs 'int'}}
 @end
-
diff --git a/test/SemaObjC/no-warn-unimpl-method.m b/test/SemaObjC/no-warn-unimpl-method.m
index 756c47b2fe80..2fcb06ff5e92 100644
--- a/test/SemaObjC/no-warn-unimpl-method.m
+++ b/test/SemaObjC/no-warn-unimpl-method.m
@@ -38,5 +38,5 @@
         - (void)forwardInvocation:(NSInvocation *)anInvocation
         {
         }
-	- (id) init {}        
+	- (id) init { return 0; }
 @end
diff --git a/test/SemaObjC/nonnull.m b/test/SemaObjC/nonnull.m
new file mode 100644
index 000000000000..869bbbd57e85
--- /dev/null
+++ b/test/SemaObjC/nonnull.m
@@ -0,0 +1,42 @@
+// RUN: clang-cc -fblocks -fsyntax-only -verify %s
+
+@class NSObject;
+
+int f1(int x) __attribute__((nonnull)); // expected-warning{{'nonnull' attribute applied to function with no pointer arguments}}
+int f2(int *x) __attribute__ ((nonnull (1)));
+int f3(int *x) __attribute__ ((nonnull (0))); // expected-error {{'nonnull' attribute parameter 1 is out of bounds}}
+int f4(int *x, int *y) __attribute__ ((nonnull (1,2)));
+int f5(int *x, int *y) __attribute__ ((nonnull (2,1)));
+int f6(NSObject *x) __attribute__ ((nonnull (1))); // no-warning
+int f7(NSObject *x) __attribute__ ((nonnull)); // no-warning
+
+
+extern void func1 (void (^block1)(), void (^block2)(), int) __attribute__((nonnull));
+
+extern void func3 (void (^block1)(), int, void (^block2)(), int)
+__attribute__((nonnull(1,3)));
+
+extern void func4 (void (^block1)(), void (^block2)()) __attribute__((nonnull(1)))
+__attribute__((nonnull(2)));
+
+void
+foo (int i1, int i2, int i3, void (^cp1)(), void (^cp2)(), void (^cp3)())
+{
+  func1(cp1, cp2, i1);
+  
+  func1(0, cp2, i1);  // expected-warning {{null passed to a callee which requires a non-null argument}}
+  func1(cp1, 0, i1);  // expected-warning {{null passed to a callee which requires a non-null argument}}
+  func1(cp1, cp2, 0);
+  
+  
+  func3(0, i2, cp3, i3); // expected-warning {{null passed to a callee which requires a non-null argument}}
+  func3(cp3, i2, 0, i3);  // expected-warning {{null passed to a callee which requires a non-null argument}}
+  
+  func4(0, cp1); // expected-warning {{null passed to a callee which requires a non-null argument}}
+  func4(cp1, 0); // expected-warning {{null passed to a callee which requires a non-null argument}}
+  
+  // Shouldn't these emit warnings?  Clang doesn't, and neither does GCC.  It
+  // seems that the checking should handle Objective-C pointers.
+  func6((NSObject*) 0); // no-warning
+  func7((NSObject*) 0); // no-warning
+}
diff --git a/test/SemaObjC/nsobject-attribute.m b/test/SemaObjC/nsobject-attribute.m
index 3544cb139aab..c47b909846c1 100644
--- a/test/SemaObjC/nsobject-attribute.m
+++ b/test/SemaObjC/nsobject-attribute.m
@@ -26,7 +26,7 @@ id getProperty(id self) {
 @synthesize x=x;
 @end
 
-int main(char *argc, char *argv[]) {
+int main(int argc, char *argv[]) {
     HandTested *to;
     to.x = tmp;  // setter
     if (tmp != to.x)
diff --git a/test/SemaObjC/objc2-merge-gc-attribue-decl.m b/test/SemaObjC/objc2-merge-gc-attribue-decl.m
index 9dae1efdcd2a..0da0ce876d3e 100644
--- a/test/SemaObjC/objc2-merge-gc-attribue-decl.m
+++ b/test/SemaObjC/objc2-merge-gc-attribue-decl.m
@@ -25,6 +25,5 @@ extern __strong id p5;
 extern char* __strong p6; // expected-note {{previous definition is here}}
 extern char* p6; // expected-error {{redefinition of 'p6' with a different type}}
 
-// FIXME. We do not issue error here because we don't put the attribute on the pointer type.
-extern __strong char* p7; 
-extern char* p7; 
+extern __strong char* p7; // expected-note {{previous definition is here}}
+extern char* p7; // expected-error {{redefinition of 'p7' with a different type}}
diff --git a/test/SemaObjC/property-11.m b/test/SemaObjC/property-11.m
index e8e60914716d..bb36c2766e75 100644
--- a/test/SemaObjC/property-11.m
+++ b/test/SemaObjC/property-11.m
@@ -29,6 +29,7 @@
   o = x.foo;
   [x setFoo:o];
   x.foo = o;
+  return 0;
 }
 
 @end
diff --git a/test/SemaObjC/property-9-impl-method.m b/test/SemaObjC/property-9-impl-method.m
index c97f38891190..06cb30482c82 100644
--- a/test/SemaObjC/property-9-impl-method.m
+++ b/test/SemaObjC/property-9-impl-method.m
@@ -55,10 +55,11 @@ NSSize minimumSize;
 
 @implementation OrganizerTabView
 @dynamic tabHeaderView, headerRect, minimumSize;
--(CGFloat) tabAreaThickness {}
+-(CGFloat) tabAreaThickness { return 0; }
 -(NSRectEdge) rectEdgeForTabs { 
   NSRect dummy, result = {};
   NSDivideRect(self.bounds, &result, &dummy, self.tabAreaThickness, self.rectEdgeForTabs);
+  return 0;
 }
 @end
 
diff --git a/test/SemaObjC/property-error-readonly-assign.m b/test/SemaObjC/property-error-readonly-assign.m
index edeff09dfadd..d5cef78f18f4 100644
--- a/test/SemaObjC/property-error-readonly-assign.m
+++ b/test/SemaObjC/property-error-readonly-assign.m
@@ -19,3 +19,26 @@ void f0(A *a, B* b) {
   b.ok = 20;
 }
 
+typedef struct {
+  int i1, i2;
+} NSRect;
+
+NSRect NSMakeRect();
+
+@interface NSWindow 
+{
+    NSRect _frame;
+}
+- (NSRect)frame;
+@end
+
+@interface NSWindow (Category)
+-(void)methodToMakeClangCrash;
+@end
+
+@implementation NSWindow (Category)
+-(void)methodToMakeClangCrash
+{
+ self.frame =  NSMakeRect(); // expected-error {{setter method is needed to assign to object using property assignment syntax}}
+}
+@end
diff --git a/test/SemaObjC/property-expression-error.m b/test/SemaObjC/property-expression-error.m
new file mode 100644
index 000000000000..b648ee939dbe
--- /dev/null
+++ b/test/SemaObjC/property-expression-error.m
@@ -0,0 +1,18 @@
+// RUN: clang-cc  -fsyntax-only -verify %s
+
+@interface AddressMyProperties 
+{
+  unsigned index;
+}
+@property unsigned index;
+@end
+
+@implementation AddressMyProperties
+@synthesize index;
+@end
+
+int main() {
+	AddressMyProperties *object;
+	&object.index; // expected-error {{address of property expression requested}}
+	return 0;
+}
diff --git a/test/SemaObjC/property-method-lookup-impl.m b/test/SemaObjC/property-method-lookup-impl.m
index ed7e9bcd4315..295bba524009 100644
--- a/test/SemaObjC/property-method-lookup-impl.m
+++ b/test/SemaObjC/property-method-lookup-impl.m
@@ -8,9 +8,7 @@
 
 @implementation SSyncCEList
 
-- (id) list
-{
-}
+- (id) list { return 0; }
 @end
 
 @interface SSyncConflictList : SSyncCEList
diff --git a/test/SemaObjC/property-missing.m b/test/SemaObjC/property-missing.m
index 1aa94ce71b25..301907ad1c7d 100644
--- a/test/SemaObjC/property-missing.m
+++ b/test/SemaObjC/property-missing.m
@@ -17,6 +17,6 @@ void f2(id<NSCopying> o)
 
 void f3(id o)
 {
-  o.foo; // expected-error{{member reference base type 'id' is not a structure or union}}
+  o.foo; // expected-error{{property 'foo' not found on object of type 'id'}}
 }
 
diff --git a/test/SemaObjC/protocol-archane.m b/test/SemaObjC/protocol-archane.m
index 3e70c0509652..05f5103178f2 100644
--- a/test/SemaObjC/protocol-archane.m
+++ b/test/SemaObjC/protocol-archane.m
@@ -28,8 +28,7 @@ typedef int NotAnObjCObjectType;
 // GCC doesn't diagnose this.
 NotAnObjCObjectType <SomeProtocol> *obj; // expected-error {{invalid protocol qualifiers on non-ObjC type}}
 
-// Decided not to support the following GCC extension. Found while researching rdar://6497631
 typedef struct objc_class *Class;
 
-Class <SomeProtocol> UnfortunateGCCExtension; // expected-error {{protocol qualified 'Class' is unsupported}}
+Class <SomeProtocol> UnfortunateGCCExtension;
 
diff --git a/test/SemaObjC/protocol-attribute.m b/test/SemaObjC/protocol-attribute.m
index ae8441132c77..6bd58dd9a03a 100644
--- a/test/SemaObjC/protocol-attribute.m
+++ b/test/SemaObjC/protocol-attribute.m
@@ -3,7 +3,7 @@
 __attribute ((unavailable))
 @protocol FwProto; // expected-note{{marked unavailable}}
 
-Class <FwProto> cFw = 0;  // expected-warning {{'FwProto' is unavailable}} expected-error{{protocol qualified 'Class' is unsupported}}
+Class <FwProto> cFw = 0;  // expected-warning {{'FwProto' is unavailable}}
 
 
 __attribute ((deprecated)) @protocol MyProto1
@@ -31,7 +31,7 @@ __attribute ((deprecated)) @protocol MyProto1
 
 
 
-Class <MyProto1> clsP1 = 0;  // expected-warning {{'MyProto1' is deprecated}} expected-error{{protocol qualified 'Class' is unsupported}}
+Class <MyProto1> clsP1 = 0;  // expected-warning {{'MyProto1' is deprecated}}
 
 @protocol FwProto @end // expected-note{{marked unavailable}}
 
diff --git a/test/SemaObjC/protocol-implementation-inherited.m b/test/SemaObjC/protocol-implementation-inherited.m
index 1aace211c844..55b92ae6684a 100644
--- a/test/SemaObjC/protocol-implementation-inherited.m
+++ b/test/SemaObjC/protocol-implementation-inherited.m
@@ -26,7 +26,7 @@
 @end
 
 @implementation B1
--foo {};
+-foo { return 0; };
 @end
 
 // Interface conforms to a protocol whose methods are provided by an
diff --git a/test/SemaObjC/protocol-lookup.m b/test/SemaObjC/protocol-lookup.m
index 0f1860d2c88e..87655bd9e7a0 100644
--- a/test/SemaObjC/protocol-lookup.m
+++ b/test/SemaObjC/protocol-lookup.m
@@ -44,6 +44,7 @@
 	[_foo release];
 	[_bar release];
 	[super dealloc];
+	return 0;
 }
 
 @end
diff --git a/test/SemaObjC/protocol-qualified-class-unsupported.m b/test/SemaObjC/protocol-qualified-class-unsupported.m
index ad1ed5dc9411..6e344c1f4414 100644
--- a/test/SemaObjC/protocol-qualified-class-unsupported.m
+++ b/test/SemaObjC/protocol-qualified-class-unsupported.m
@@ -23,7 +23,7 @@ id objc_getClass(const char *s);
 @interface Derived2: Object <Func>
 @end
 
-static void doSomething(Class <Func> unsupportedObjectType) { // expected-error {{protocol qualified 'Class' is unsupported}}
+static void doSomething(Class <Func> unsupportedObjectType) {
   [unsupportedObjectType class_func0];
 }
 
diff --git a/test/SemaObjC/rdr-6211479-array-property.m b/test/SemaObjC/rdr-6211479-array-property.m
index f8e4a07cba58..1781c5a40402 100644
--- a/test/SemaObjC/rdr-6211479-array-property.m
+++ b/test/SemaObjC/rdr-6211479-array-property.m
@@ -1,9 +1,8 @@
 // RUN: clang-cc -fsyntax-only -verify %s
-// XFAIL
 // <rdar://problem/6211479>
 
 typedef int T[2];
 
 @interface A
-@property(assign) T p2; // expected-error {{FIXME: property has invalid type}}
+@property(assign) T p2; // expected-error {{property cannot have array or function type 'T' (aka 'int [2]')}}
 @end
diff --git a/test/SemaObjC/return.m b/test/SemaObjC/return.m
new file mode 100644
index 000000000000..9acf47079958
--- /dev/null
+++ b/test/SemaObjC/return.m
@@ -0,0 +1,6 @@
+// RUN: clang-cc %s -fsyntax-only -verify
+
+int test1() {
+  id a;
+  @throw a;
+}
diff --git a/test/SemaObjC/selector-1.m b/test/SemaObjC/selector-1.m
index ee77015041db..a969b100cc68 100644
--- a/test/SemaObjC/selector-1.m
+++ b/test/SemaObjC/selector-1.m
@@ -8,6 +8,19 @@
 
 @end
 
+@interface I
+- (id) compare: (char) arg1;
+@end
+
+@interface J
+- (id) compare: (id) arg1;
+@end
+
+SEL foo()
+{
+	return @selector(compare:);	// Non warning on multiple selector found.
+}
+
 int main() {
  SEL s = @selector(retain);
  SEL s1 = @selector(meth1:);
diff --git a/test/SemaObjC/sizeof-interface.m b/test/SemaObjC/sizeof-interface.m
index 75d7daafbbcc..140a980311e4 100644
--- a/test/SemaObjC/sizeof-interface.m
+++ b/test/SemaObjC/sizeof-interface.m
@@ -77,3 +77,14 @@ int bar(I0 *P) {
 }
 @end
 
+
+@interface Foo @end
+
+int foo()
+{
+  Foo *f;
+  
+  // Both of these crash clang nicely
+  ++f; 	// expected-error {{arithmetic on pointer to interface 'Foo', which is not a constant size in non-fragile ABI}}
+  --f; 	// expected-error {{arithmetic on pointer to interface 'Foo', which is not a constant size in non-fragile ABI}}
+}
diff --git a/test/SemaObjC/static-ivar-ref-1.m b/test/SemaObjC/static-ivar-ref-1.m
index 3c37e9e83026..6b1a31226b20 100644
--- a/test/SemaObjC/static-ivar-ref-1.m
+++ b/test/SemaObjC/static-ivar-ref-1.m
@@ -1,4 +1,5 @@
-// RUN: clang-cc -ast-print %s
+// RUN: clang-cc -triple i386-unknown-unknown -ast-print %s &&
+// RUN: clang-cc -triple x86_64-apple-darwin10  -ast-print %s
 
 @interface current 
 {
diff --git a/test/SemaObjC/super-cat-prot.m b/test/SemaObjC/super-cat-prot.m
index 1ab0752faa38..6ddc31fbb9e6 100644
--- a/test/SemaObjC/super-cat-prot.m
+++ b/test/SemaObjC/super-cat-prot.m
@@ -35,14 +35,16 @@ typedef struct _IBInset {} IBInset;
 @interface NSView (NSView_IBViewProtocol) <IBViewProtocol>  - (NSRect)layoutRect; @end
 typedef enum { NSProTextFieldSquareBezel = 0, NSProTextFieldRoundedBezel = 1, NSProTextFieldDisplayBezel = 2 } MKModuleReusePolicy;
 @implementation NSProBox(IBAdditions)
--(NSString *)inspectorClassName {}
+-(NSString *)inspectorClassName { return 0; }
 -(IBInset)ibShadowInset {
   if ([self boxType] == NSBoxSeparator) {
     return [super ibShadowInset];
   }
+  while (1) {}
 }
 -(NSSize)minimumFrameSizeFromKnobPosition:(IBKnobPosition)knobPosition {
   if ([self boxType] != NSBoxSeparator)
     return [super minimumFrameSizeFromKnobPosition:knobPosition];
+  while (1) {}
 }
 @end
diff --git a/test/SemaObjC/super.m b/test/SemaObjC/super.m
index 9afd4eb983c5..83842afb9c3f 100644
--- a/test/SemaObjC/super.m
+++ b/test/SemaObjC/super.m
@@ -21,6 +21,7 @@
 
 + classMethod {
   [super cMethod]; // expected-warning{{method '+cMethod' not found (return type defaults to 'id')}}
+  return 0;
 }
 @end
 
diff --git a/test/SemaObjC/synchronized.m b/test/SemaObjC/synchronized.m
index 7131265b5bb7..01f82c168622 100644
--- a/test/SemaObjC/synchronized.m
+++ b/test/SemaObjC/synchronized.m
@@ -3,7 +3,7 @@
 @interface PBXTrackableTaskManager @end
 
 @implementation PBXTrackableTaskManager
-- (id) init {}
+- (id) init { return 0; }
 - (void) unregisterTask:(id) task {
   @synchronized (self) {
   id taskID = [task taskIdentifier];  // expected-warning {{method '-taskIdentifier' not found (return type defaults to 'id')}}
diff --git a/test/SemaObjC/undef-superclass-1.m b/test/SemaObjC/undef-superclass-1.m
index 0d670f8c0809..cb15dc39a3dc 100644
--- a/test/SemaObjC/undef-superclass-1.m
+++ b/test/SemaObjC/undef-superclass-1.m
@@ -24,3 +24,10 @@
     [super dealloc]; // expected-error {{no super class declared in @interface for 'SUPER'}}
 }
 @end
+
+@interface RecursiveClass : RecursiveClass // expected-error {{trying to recursively use 'RecursiveClass' as superclass of 'RecursiveClass'}}
+@end
+
+@implementation RecursiveClass
+@end
+
diff --git a/test/SemaObjC/unused.m b/test/SemaObjC/unused.m
index 88c6f1054c8d..bbe3109a2817 100644
--- a/test/SemaObjC/unused.m
+++ b/test/SemaObjC/unused.m
@@ -1,4 +1,4 @@
-// RUN: clang-cc %s -verify -fsyntax-only
+// RUN: clang-cc %s -verify -Wunused -fsyntax-only
 #include <stdio.h>
 
 @interface Greeter
@@ -11,8 +11,33 @@
 }
 @end
 
-int main (void) {
-    [Greeter hello];
-    return 0;
+
+int test1(void) {
+  [Greeter hello];
+  return 0;
+}
+
+
+
+@interface NSObject @end
+@interface NSString : NSObject 
+- (int)length;
+@end
+
+void test2() {
+  @"pointless example call for test purposes".length; // expected-warning {{property access result unused - getters should not have side effects}}
 }
 
+
+
+
+
+@interface foo
+- (int)meth: (int)x: (int)y: (int)z ;
+@end
+
+@implementation foo
+- (int) meth: (int)x: 
+(int)y: // expected-warning{{unused}} 
+(int) __attribute__((unused))z { return x; }
+@end
diff --git a/test/SemaObjC/warn-assign-property-nscopying.m b/test/SemaObjC/warn-assign-property-nscopying.m
new file mode 100644
index 000000000000..cf1acc466a27
--- /dev/null
+++ b/test/SemaObjC/warn-assign-property-nscopying.m
@@ -0,0 +1,15 @@
+// RUN: clang-cc  -fobjc-gc -fsyntax-only -verify %s
+
+@protocol NSCopying @end
+
+@interface NSObject <NSCopying>
+@end
+
+@interface NSDictionary : NSObject
+@end
+
+@interface INTF
+  @property NSDictionary* undoAction;  // expected-warning {{no 'assign', 'retain', or 'copy' attribute is specified - 'assign' is assumed}} // expected-warning {{default assign attribute on property 'undoAction' which implements NSCopying protocol is not appropriate with}}
+  @property id okAction;  // expected-warning {{no 'assign', 'retain', or 'copy' attribute is specified - 'assign' is assumed}}
+@end
+
diff --git a/test/SemaObjC/warn-superclass-method-mismatch.m b/test/SemaObjC/warn-superclass-method-mismatch.m
new file mode 100644
index 000000000000..f123a3f2ddac
--- /dev/null
+++ b/test/SemaObjC/warn-superclass-method-mismatch.m
@@ -0,0 +1,50 @@
+// RUN: clang-cc  -fsyntax-only -Wsuper-class-method-mismatch -verify %s
+
+@interface Root
+-(void) method_r: (char)ch : (float*)f1 : (int*) x; // expected-note {{previous declaration is here}}
+@end
+
+@class Sub;
+
+@interface Base : Root
+-(void) method: (int*) x; // expected-note {{previous declaration is here}}
+-(void) method1: (Base*) x; // expected-note {{previous declaration is here}}
+-(void) method2: (Sub*) x;
++ method3: (int)x1 : (Base *)x2 : (float)x3; // expected-note {{previous declaration is here}}
++ mathod4: (id)x1;
+- method5: (int) x : (double) d; // expected-note {{previous declaration is here}}
+- method6: (int) x : (float) d; // expected-note {{previous declaration is here}}
+@end
+
+struct A {
+  int x,y,z;
+};
+
+@interface Sub : Base
+-(void) method: (struct A*) a;	// expected-warning {{method parameter type 'struct A *' does not match super class method parameter type 'int *'}}
+-(void) method1: (Sub*) x;	// expected-warning {{method parameter type 'Sub *' does not match super class method parameter type 'Base *'}}
+-(void) method2: (Base*) x;	// no need to warn. At call point we warn if need be.
++ method3: (int)x1 : (Sub *)x2 : (float)x3;	// expected-warning {{method parameter type 'Sub *' does not match super class method parameter type 'Base *'}}
++ mathod4: (Base*)x1;
+-(void) method_r: (char)ch : (float*)f1 : (Sub*) x; // expected-warning {{method parameter type 'Sub *' does not match super class method parameter type 'int *'}}
+- method5: (int) x : (float) d; // expected-warning {{method parameter type 'float' does not match super class method parameter type 'double'}}
+- method6: (int) x : (double) d; // expected-warning {{method parameter type 'double' does not match super class method parameter type 'float'}}
+@end
+
+void f(Base *base, Sub *sub) {
+  int x;
+  [base method:&x];  // warn. if base is actually 'Sub' it will use -[Sub method] with wrong arguments
+  
+  Base *b;
+  [base method1:b]; // if base is actuall 'Sub'  it will use [Sub method1] with wrong argument.
+
+  [base method2:b];  // expected-warning {{}}
+
+  Sub *s;
+  [base method2:s]; // if base is actually 'Sub' OK. Either way OK.
+  
+}
+
+
+
+
diff --git a/test/SemaObjC/weak-attr-ivar.m b/test/SemaObjC/weak-attr-ivar.m
index 9e0e8cb4b3af..6af96ddb3c8b 100644
--- a/test/SemaObjC/weak-attr-ivar.m
+++ b/test/SemaObjC/weak-attr-ivar.m
@@ -45,8 +45,7 @@ typedef enum { Foo_HUH_NONE } FooHUHCode;
 }
 @property(copy) NSString *author;
 - (BOOL) isInteresting;
-@end  NSString *FooHUHCodeToString(FooHUHCode HUH) {
-}
+@end  NSString *FooHUHCodeToString(FooHUHCode HUH) { return 0; }
 @interface FooHUHCodeToStringTransformer: NSValueTransformer {
 }
 @end  @implementation FooPlaypenEntry  @synthesize author = _author;
@@ -62,12 +61,14 @@ typedef enum { Foo_HUH_NONE } FooHUHCode;
       }
     }
   }
+  return 0;
 }
 - (FooHUHCode) HUH {
   if (_HUH == Foo_HUH_NONE) {
     if (_mostInterestingChild)
       return [_mostInterestingChild HUH];
   }
+  return 0;
 }
 @end
 
diff --git a/test/SemaObjCXX/overload.mm b/test/SemaObjCXX/overload.mm
index 8ab22e1ca73e..47141002864c 100644
--- a/test/SemaObjCXX/overload.mm
+++ b/test/SemaObjCXX/overload.mm
@@ -1,4 +1,5 @@
 // RUN: clang-cc -fsyntax-only -verify %s
+// XFAIL
 @interface Foo
 @end
 
diff --git a/test/SemaObjCXX/protocol-lookup.mm b/test/SemaObjCXX/protocol-lookup.mm
index 0f1860d2c88e..87655bd9e7a0 100644
--- a/test/SemaObjCXX/protocol-lookup.mm
+++ b/test/SemaObjCXX/protocol-lookup.mm
@@ -44,6 +44,7 @@
 	[_foo release];
 	[_bar release];
 	[super dealloc];
+	return 0;
 }
 
 @end
diff --git a/test/SemaObjCXX/references.mm b/test/SemaObjCXX/references.mm
index 6a28ea902967..82797cef77c7 100644
--- a/test/SemaObjCXX/references.mm
+++ b/test/SemaObjCXX/references.mm
@@ -1,4 +1,6 @@
-// RUN: clang-cc -verify -emit-llvm -o %t %s
+// FIXME: This crashes, disable it until fixed.
+// RN: clang-cc -verify -emit-llvm -o - %s
+// RUN: false
 // XFAIL
 
 // Test reference binding.
diff --git a/test/SemaTemplate/ackermann.cpp b/test/SemaTemplate/ackermann.cpp
index 48fbbbb3cf1d..c936889f25f9 100644
--- a/test/SemaTemplate/ackermann.cpp
+++ b/test/SemaTemplate/ackermann.cpp
@@ -1,9 +1,9 @@
-// RUN: clang-cc -fsyntax-only -ftemplate-depth=1000 -verify %s
+// RUN: clang-cc -fsyntax-only -verify %s
 
 // template<unsigned M, unsigned N>
 // struct Ackermann {
 //   enum {
-//     value = M ? (N ? Ackermann<M-1, Ackermann<M-1, N-1> >::value
+//     value = M ? (N ? Ackermann<M-1, Ackermann<M, N-1> >::value
 //                    : Ackermann<M-1, 1>::value)
 //               : N + 1
 //   };
@@ -34,4 +34,5 @@ template<> struct Ackermann<0, 0> {
  };
 };
 
-int g0[Ackermann<3, 8>::value == 2045 ? 1 : -1];
+int g0[Ackermann<3, 4>::value == 125 ? 1 : -1];
+
diff --git a/test/SemaTemplate/ambiguous-ovl-print.cpp b/test/SemaTemplate/ambiguous-ovl-print.cpp
new file mode 100644
index 000000000000..ccdeb9bebc57
--- /dev/null
+++ b/test/SemaTemplate/ambiguous-ovl-print.cpp
@@ -0,0 +1,9 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+void f(void*, int); // expected-note{{candidate function}}
+template<typename T>
+  void f(T*, long); // expected-note{{candidate function template}}
+
+void test_f(int *ip, int i) {
+  f(ip, i); // expected-error{{ambiguous}}
+}
diff --git a/test/SemaTemplate/canonical-expr-type-0x.cpp b/test/SemaTemplate/canonical-expr-type-0x.cpp
new file mode 100644
index 000000000000..21552105b0ff
--- /dev/null
+++ b/test/SemaTemplate/canonical-expr-type-0x.cpp
@@ -0,0 +1,16 @@
+// RUN: clang-cc -fsyntax-only -verify -std=c++0x %s
+
+void f();
+
+// FIXME: would like to refer to the first function parameter in these test,
+// but that won't work (yet).
+
+// Test typeof(expr) canonicalization
+template<typename T, T N>
+void f0(T x, decltype(f(N)) y) { } // expected-note{{previous}}
+
+template<typename T, T N>
+void f0(T x, decltype((f)(N)) y) { }
+
+template<typename U, U M>
+void f0(U u, decltype(f(M))) { } // expected-error{{redefinition}}
diff --git a/test/SemaTemplate/canonical-expr-type.cpp b/test/SemaTemplate/canonical-expr-type.cpp
new file mode 100644
index 000000000000..0580c677e627
--- /dev/null
+++ b/test/SemaTemplate/canonical-expr-type.cpp
@@ -0,0 +1,53 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+void f();
+
+// Test typeof(expr) canonicalization
+template<typename T>
+void f0(T x, __typeof__(f(x)) y) { } // expected-note{{previous}}
+
+template<typename T>
+void f0(T x, __typeof__((f)(x)) y) { }
+
+template<typename U>
+void f0(U u, __typeof__(f(u))) { } // expected-error{{redefinition}}
+
+// Test insane typeof(expr) overload set canonicalization
+void f(int);
+void f(double);
+
+template<typename T, T N>
+void f0a(T x, __typeof__(f(N)) y) { } // expected-note{{previous}}
+
+void f(int);
+
+template<typename T, T N>
+void f0a(T x, __typeof__(f(N)) y) { } // expected-error{{redefinition}} \
+                                      // expected-note{{previous}}
+
+void f(float);
+
+template<typename T, T N>
+void f0a(T x, __typeof__(f(N)) y) { } // expected-error{{redefinition}}
+
+// Test dependently-sized array canonicalization
+template<typename T, int N, int M>
+void f1(T (&array)[N + M]) { } // expected-note{{previous}}
+
+template<typename T, int N, int M>
+void f1(T (&array)[M + N]) { }
+
+template<typename T, int M, int N>
+void f1(T (&array)[M + N]) { } // expected-error{{redefinition}}
+
+// Test dependently-sized extended vector type canonicalization
+template<typename T, int N, int M>
+struct X2 {
+  typedef T __attribute__((ext_vector_type(N))) type1;
+  typedef T __attribute__((ext_vector_type(M))) type2;
+  typedef T __attribute__((ext_vector_type(N))) type3;
+  
+  void f0(type1); // expected-note{{previous}}
+  void f0(type2);
+  void f0(type3); // expected-error{{redeclared}}
+};
diff --git a/test/SemaTemplate/class-template-spec.cpp b/test/SemaTemplate/class-template-spec.cpp
index 71d8ea14be6b..e44115c748c3 100644
--- a/test/SemaTemplate/class-template-spec.cpp
+++ b/test/SemaTemplate/class-template-spec.cpp
@@ -1,5 +1,6 @@
 // RUN: clang-cc -fsyntax-only -verify %s
-template<typename T, typename U = int> struct A; // expected-note 2{{template is declared here}}
+template<typename T, typename U = int> struct A; // expected-note {{template is declared here}} \
+                                                 // expected-note{{explicitly specialized}}
 
 template<> struct A<double, double>; // expected-note{{forward declaration}}
 
@@ -19,7 +20,8 @@ int test_incomplete_specs(A<double, double> *a1,
                           A<double> *a2)
 {
   (void)a1->x; // expected-error{{incomplete definition of type 'A<double, double>'}}
-  (void)a2->x; // expected-error{{implicit instantiation of undefined template 'struct A<double, int>'}}
+  (void)a2->x; // expected-error{{implicit instantiation of undefined template 'struct A<double, int>'}} \
+               // expected-note{{first required here}}
 }
 
 typedef float FLOAT;
@@ -49,13 +51,33 @@ struct A<char> {
 
 A<char>::A() { }
 
+// Make sure we can see specializations defined before the primary template.
+namespace N{ 
+  template<typename T> struct A0;
+}
+
+namespace N {
+  template<>
+  struct A0<void> {
+    typedef void* pointer;
+  };
+}
+
+namespace N {
+  template<typename T>
+  struct A0 {
+    void foo(A0<void>::pointer p = 0);
+  };
+}
+
 // Diagnose specialization errors
-struct A<double> { }; // expected-error{{template specialization requires 'template<>'}}
+struct A<double> { }; // expected-error{{template specialization requires 'template<>'}} \
+                      // expected-error{{after instantiation}}
 
 template<> struct ::A<double>;
 
 namespace N {
-  template<typename T> struct B; // expected-note 2{{template is declared here}}
+  template<typename T> struct B; // expected-note 2{{explicitly specialized}}
 
   template<> struct ::N::B<char>; // okay
   template<> struct ::N::B<short>; // okay
@@ -66,12 +88,12 @@ namespace N {
 
 template<> struct N::B<int> { }; // okay
 
-template<> struct N::B<float> { }; // expected-error{{class template specialization of 'B' not in namespace 'N'}}
+template<> struct N::B<float> { }; // expected-error{{originally}}
 
 namespace M {
   template<> struct ::N::B<short> { }; // expected-error{{class template specialization of 'B' not in a namespace enclosing 'N'}}
 
-  template<> struct ::A<long double>; // expected-error{{class template specialization of 'A' must occur in the global scope}}
+  template<> struct ::A<long double>; // expected-error{{originally}}
 }
 
 template<> struct N::B<char> { 
diff --git a/test/SemaTemplate/constructor-template.cpp b/test/SemaTemplate/constructor-template.cpp
new file mode 100644
index 000000000000..acd845bc2fd5
--- /dev/null
+++ b/test/SemaTemplate/constructor-template.cpp
@@ -0,0 +1,53 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+struct X0 { // expected-note{{candidate}}
+  X0(int); // expected-note{{candidate}}
+  template<typename T> X0(T);
+  template<typename T, typename U> X0(T*, U*);
+  
+  // PR4761
+  template<typename T> X0() : f0(T::foo) {}
+  int f0;
+};
+
+void accept_X0(X0);
+
+void test_X0(int i, float f) {
+  X0 x0a(i);
+  X0 x0b(f);
+  X0 x0c = i;
+  X0 x0d = f;
+  accept_X0(i);
+  accept_X0(&i);
+  accept_X0(f);
+  accept_X0(&f);
+  X0 x0e(&i, &f);
+  X0 x0f(&f, &i);
+  
+  X0 x0g(f, &i); // expected-error{{no matching constructor}}
+}
+
+template<typename T>
+struct X1 {
+  X1(const X1&);
+  template<typename U> X1(const X1<U>&);
+};
+
+template<typename T>
+struct Outer {
+  typedef X1<T> A;
+  
+  A alloc;
+  
+  explicit Outer(const A& a) : alloc(a) { }
+};
+
+void test_X1(X1<int> xi) {
+  Outer<int> oi(xi);
+  Outer<float> of(xi);
+}
+
+// PR4655
+template<class C> struct A {};
+template <> struct A<int>{A(const A<int>&);};
+struct B { A<int> x; B(B& a) : x(a.x) {} };
diff --git a/test/SemaTemplate/copy-ctor-assign.cpp b/test/SemaTemplate/copy-ctor-assign.cpp
new file mode 100644
index 000000000000..90fb0133a721
--- /dev/null
+++ b/test/SemaTemplate/copy-ctor-assign.cpp
@@ -0,0 +1,36 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// Make sure that copy constructors and assignment operators are properly 
+// generated when there is a matching 
+
+// PR5072
+template<typename T>
+struct X {
+  template<typename U> 
+  X(const X<U>& other) 
+    : value(other.value + 1) { } // expected-error{{binary expression}}
+
+  template<typename U> 
+  X& operator=(const X<U>& other)  {
+    value = other.value + 1; // expected-error{{binary expression}}
+    return *this;
+  }
+  
+  T value;
+};
+
+struct Y {};
+
+X<int Y::*> test0(X<int Y::*> x) { return x; }
+X<int> test1(X<long> x) { return x; }
+
+
+X<int> test2(X<int Y::*> x) { 
+  return x; // expected-note{{instantiation}}
+}
+
+void test3(X<int> &x, X<int> xi, X<long> xl, X<int Y::*> xmptr) {
+  x = xi;
+  x = xl;
+  x = xmptr; // expected-note{{instantiation}}
+}
\ No newline at end of file
diff --git a/test/SemaTemplate/current-instantiation.cpp b/test/SemaTemplate/current-instantiation.cpp
index 603c14016fbc..a1d9fcb5372b 100644
--- a/test/SemaTemplate/current-instantiation.cpp
+++ b/test/SemaTemplate/current-instantiation.cpp
@@ -69,3 +69,76 @@ struct X0 {
     void g8(typename ::X0<typename X0<T_type, U>::X1::my_T_type, U_type>::X1::my_T_type&); // expected-error{{redecl}}
   };
 };
+
+
+template<typename T, typename U>
+struct X0<T*, U*> {
+  typedef T T_type;
+  typedef U U_type;
+  typedef T* Tptr;
+  typedef U* Uptr;
+  
+  void f0(T&); // expected-note{{previous}}
+  void f0(typename X0::U_type&);
+  void f0(typename X0::T_type&); // expected-error{{redecl}}
+  
+  void f1(T&); // expected-note{{previous}}
+  void f1(typename X0::U_type&);
+  void f1(typename X0<T*, U*>::T_type&); // expected-error{{redecl}}
+  
+  void f2(T&); // expected-note{{previous}}
+  void f2(typename X0::U_type&);
+  void f2(typename X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
+  
+  void f3(T&); // expected-note{{previous}}
+  void f3(typename X0::U_type&);
+  void f3(typename ::X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
+
+  void f4(T&); // expected-note{{previous}}
+  void f4(typename X0::U_type&);
+  void f4(typename ::X0<Tptr, Uptr>::T_type&); // expected-error{{redecl}}
+  
+  void f5(X0*); // expected-note{{previous}}
+  void f5(::X0<T, U>*);
+  void f5(::X0<T*, U*>*); // expected-error{{redecl}}
+  
+  struct X2 {
+    typedef T my_T_type;
+    
+    void g0(T&); // expected-note{{previous}}
+    void g0(typename X0::U_type&);
+    void g0(typename X0::T_type&); // expected-error{{redecl}}
+    
+    void g1(T&); // expected-note{{previous}}
+    void g1(typename X0::U_type&);
+    void g1(typename X0<T*, U*>::T_type&); // expected-error{{redecl}}
+    
+    void g2(T&); // expected-note{{previous}}
+    void g2(typename X0::U_type&);
+    void g2(typename X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
+    
+    void g3(T&); // expected-note{{previous}}
+    void g3(typename X0::U_type&);
+    void g3(typename ::X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
+    
+    void g4(T&); // expected-note{{previous}}
+    void g4(typename X0::U_type&);
+    void g4(typename X2::my_T_type&); // expected-error{{redecl}}
+    
+    void g5(T&); // expected-note{{previous}}
+    void g5(typename X0::U_type&);
+    void g5(typename X0::X2::my_T_type&); // expected-error{{redecl}}
+    
+    void g6(T&); // expected-note{{previous}}
+    void g6(typename X0::U_type&);
+    void g6(typename X0<T*, U*>::X2::my_T_type&); // expected-error{{redecl}}
+    
+    void g7(T&); // expected-note{{previous}}
+    void g7(typename X0::U_type&);
+    void g7(typename ::X0<typename X2::my_T_type*, U_type*>::X2::my_T_type&); // expected-error{{redecl}}
+    
+    void g8(T&); // expected-note{{previous}}
+    void g8(typename X0<U, T_type>::T_type&);
+    void g8(typename ::X0<typename X0<T_type*, U*>::X2::my_T_type*, U_type*>::X2::my_T_type&); // expected-error{{redecl}}
+  };
+};
diff --git a/test/SemaTemplate/default-arguments.cpp b/test/SemaTemplate/default-arguments.cpp
index f9bb44ecb9c0..33677aab73ac 100644
--- a/test/SemaTemplate/default-arguments.cpp
+++ b/test/SemaTemplate/default-arguments.cpp
@@ -22,3 +22,23 @@ template<class T, bool = a<T>::v> struct p { }; // expected-error {{no member na
 
 template struct p<bool>; // expected-note {{in instantiation of default argument for 'p<bool>' required here}}
 template struct p<int>;
+
+// PR5187
+template<typename T, typename U>
+struct A;
+
+template<typename T, typename U = T>
+struct A;
+
+template<typename T, typename U>
+struct A {
+  void f(A<T>);
+};
+
+template<typename T>
+struct B { };
+
+template<>
+struct B<void> {
+  typedef B<void*> type;
+};
diff --git a/test/SemaTemplate/default-expr-arguments.cpp b/test/SemaTemplate/default-expr-arguments.cpp
new file mode 100644
index 000000000000..575283ed8b51
--- /dev/null
+++ b/test/SemaTemplate/default-expr-arguments.cpp
@@ -0,0 +1,86 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T>
+class C { C(int a0 = 0); };
+
+template<>
+C<char>::C(int a0);
+
+struct S { };
+
+template<typename T> void f1(T a, T b = 10) { } // expected-error{{cannot initialize 'b' with an rvalue of type 'int'}}
+
+template<typename T> void f2(T a, T b = T()) { }
+
+template<typename T> void f3(T a, T b = T() + T()); // expected-error{{invalid operands to binary expression ('struct S' and 'struct S')}}
+
+void g() {
+  f1(10);
+  f1(S()); // expected-note{{in instantiation of default function argument expression for 'f1<struct S>' required here}}
+  
+  f2(10);
+  f2(S());
+  
+  f3(10);
+  f3(S()); // expected-note{{in instantiation of default function argument expression for 'f3<struct S>' required here}}
+}
+
+template<typename T> struct F {
+  F(T t = 10); // expected-error{{cannot initialize 't' with an rvalue of type 'int'}}
+  void f(T t = 10); // expected-error{{cannot initialize 't' with an rvalue of type 'int'}}
+};
+
+struct FD : F<int> { };
+
+void g2() {
+  F<int> f;
+  FD fd;
+}
+
+void g3(F<int> f, F<struct S> s) {
+  f.f();
+  s.f(); // expected-note{{in instantiation of default function argument expression for 'f<struct S>' required here}}
+  
+  F<int> f2;
+  F<S> s2; // expected-note{{in instantiation of default function argument expression for 'F<struct S>' required here}}
+}
+
+template<typename T> struct G {
+  G(T) {}
+};
+
+void s(G<int> flags = 10) { }
+
+// Test default arguments
+template<typename T>
+struct X0 {
+  void f(T = T()); // expected-error{{no matching}}
+};
+
+template<typename U>
+void X0<U>::f(U) { }
+
+void test_x0(X0<int> xi) {
+  xi.f();
+  xi.f(17);
+}
+
+struct NotDefaultConstructible { // expected-note{{candidate}}
+  NotDefaultConstructible(int); // expected-note{{candidate}}
+};
+
+void test_x0_not_default_constructible(X0<NotDefaultConstructible> xn) {
+  xn.f(NotDefaultConstructible(17));
+  xn.f(42);
+  xn.f(); // expected-note{{in instantiation of default function argument}}
+}
+
+template<typename T>
+struct X1 {
+  typedef T value_type;
+  X1(const value_type& value = value_type());
+};
+
+void test_X1() {
+  X1<int> x1;
+}
diff --git a/test/SemaTemplate/dependent-base-member-init.cpp b/test/SemaTemplate/dependent-base-member-init.cpp
new file mode 100644
index 000000000000..b3d707b632b1
--- /dev/null
+++ b/test/SemaTemplate/dependent-base-member-init.cpp
@@ -0,0 +1,36 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// PR4381
+template<class T> struct X {};
+template<typename T> struct Y : public X<T>::X { };
+
+// PR4621
+class A1 {
+  A1(int x) {}
+};
+template<class C> class B1 : public A1 {
+  B1(C x) : A1(x.x) {}
+};
+class A2 { A2(int x, int y); };
+template <class C> class B2 {
+  A2 x;
+  B2(C x) : x(x.x, x.y) {}
+};
+template <class C> class B3 {
+  C x;
+  B3() : x(1,2) {}
+};
+
+// PR4627
+template<typename _Container> class insert_iterator {
+    _Container* container;
+    insert_iterator(_Container& __x) : container(&__x) {}
+};
+
+// PR4763
+template<typename T> struct s0 {};
+template<typename T> struct s0_traits {};
+template<typename T> struct s1 : s0<typename s0_traits<T>::t0> {
+  s1() {}
+};
+
diff --git a/test/SemaTemplate/dependent-type-identity.cpp b/test/SemaTemplate/dependent-type-identity.cpp
index 739cb7f39fa3..b7c9040e6cb5 100644
--- a/test/SemaTemplate/dependent-type-identity.cpp
+++ b/test/SemaTemplate/dependent-type-identity.cpp
@@ -59,7 +59,7 @@ struct X1 {
   void f6(typename N::X2<U>::template apply<U> *);
   void f6(typename N::X2<U>::template apply<T> *);
   void f6(typename ::N::X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
-
+  
   void f7(typename N::X2<T>::template apply<U> *); // expected-note{{previous}}
   void f7(typename N::X2<U>::template apply<U> *);
   void f7(typename N::X2<U>::template apply<T> *);
diff --git a/test/SemaTemplate/destructor-template.cpp b/test/SemaTemplate/destructor-template.cpp
new file mode 100644
index 000000000000..a7c8d247f021
--- /dev/null
+++ b/test/SemaTemplate/destructor-template.cpp
@@ -0,0 +1,12 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename A> class s0 {
+
+  template<typename B> class s1 : public s0<A> {
+    ~s1() {}
+    s0<A> ms0;
+  };
+
+};
+
+
diff --git a/test/SemaTemplate/example-dynarray.cpp b/test/SemaTemplate/example-dynarray.cpp
index 680ee04ba18e..0b8d605b623d 100644
--- a/test/SemaTemplate/example-dynarray.cpp
+++ b/test/SemaTemplate/example-dynarray.cpp
@@ -1,4 +1,4 @@
-// RUN: clang-cc -fsyntax-only -verify %s
+// RUN: clang %s -o %t
 #include <stddef.h>
 #include <stdlib.h>
 #include <assert.h>
@@ -24,6 +24,9 @@ public:
   }
   
   ~dynarray() {
+    for (unsigned I = 0, N = size(); I != N; ++I)
+      Start[I].~T();
+    
     free(Start);
   }
 
@@ -33,7 +36,9 @@ public:
     for (unsigned I = 0, N = other.size(); I != N; ++I)
       new (NewStart + I) T(other[I]);
 
-    // FIXME: destroy everything in Start
+    for (unsigned I = 0, N = size(); I != N; ++I)
+      Start[I].~T();
+    
     free(Start);
     Start = NewStart;
     Last = End = NewStart + other.size();
@@ -43,33 +48,11 @@ public:
   unsigned size() const { return Last - Start; }
   unsigned capacity() const { return End - Start; }
 
-  void push_back(const T& value) {
-    if (Last == End) {
-      unsigned NewCapacity = capacity() * 2;
-      if (NewCapacity == 0)
-        NewCapacity = 4;
-
-      T* NewStart = (T*)malloc(sizeof(T) * NewCapacity);
-
-      unsigned Size = size();
-      for (unsigned I = 0; I != Size; ++I)
-        new (NewStart + I) T(Start[I]);
-
-      // FIXME: destruct old values
-      free(Start);
-
-      Start = NewStart;
-      Last = Start + Size;
-      End = Start + NewCapacity;
-    }
-
-    new (Last) T(value);
-    ++Last;
-  }
-
+  void push_back(const T& value);
+  
   void pop_back() {
-    // FIXME: destruct old value
     --Last;
+    Last->~T();
   }
 
   T& operator[](unsigned Idx) {
@@ -108,6 +91,32 @@ public:
   T* Start, *Last, *End;
 };
 
+template<typename T>
+void dynarray<T>::push_back(const T& value) {
+  if (Last == End) {
+    unsigned NewCapacity = capacity() * 2;
+    if (NewCapacity == 0)
+      NewCapacity = 4;
+    
+    T* NewStart = (T*)malloc(sizeof(T) * NewCapacity);
+    
+    unsigned Size = size();
+    for (unsigned I = 0; I != Size; ++I)
+      new (NewStart + I) T(Start[I]);
+    
+    for (unsigned I = 0, N = size(); I != N; ++I)
+      Start[I].~T();
+    free(Start);
+    
+    Start = NewStart;
+    Last = Start + Size;
+    End = Start + NewCapacity;
+  }
+  
+  new (Last) T(value);
+  ++Last;
+}
+
 struct Point { 
   Point() { x = y = z = 0.0; }
   Point(const Point& other) : x(other.x), y(other.y), z(other.z) { }
diff --git a/test/SemaTemplate/explicit-instantiation.cpp b/test/SemaTemplate/explicit-instantiation.cpp
new file mode 100644
index 000000000000..b9a4ad282b9f
--- /dev/null
+++ b/test/SemaTemplate/explicit-instantiation.cpp
@@ -0,0 +1,75 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template void *; // expected-error{{expected unqualified-id}}
+
+template typedef void f0; // expected-error{{explicit instantiation of typedef}}
+
+int v0; // expected-note{{refers here}}
+template int v0; // expected-error{{does not refer}}
+
+template<typename T>
+struct X0 {
+  static T value;
+  
+  T f0(T x) {
+    return x + 1;  // expected-error{{invalid operands}}
+  } 
+  T* f0(T*, T*);
+  
+  template<typename U>
+  T f0(T, U);
+};
+
+template int X0<int>::value;
+
+struct NotDefaultConstructible {
+  NotDefaultConstructible(int);
+};
+
+template NotDefaultConstructible X0<NotDefaultConstructible>::value;
+
+template int X0<int>::f0(int);
+template int* X0<int>::f0(int*, int*);
+template int X0<int>::f0(int, float);
+
+template int X0<int>::f0(int) const; // expected-error{{does not refer}}
+template int* X0<int>::f0(int*, float*); // expected-error{{does not refer}}
+
+struct X1 { };
+typedef int X1::*MemPtr;
+
+template MemPtr X0<MemPtr>::f0(MemPtr); // expected-note{{requested here}}
+
+struct X2 {
+  int f0(int); // expected-note{{refers here}}
+  
+  template<typename T> T f1(T);
+  template<typename T> T* f1(T*);
+
+  template<typename T, typename U> void f2(T, U*); // expected-note{{candidate}}
+  template<typename T, typename U> void f2(T*, U); // expected-note{{candidate}}
+};
+
+template int X2::f0(int); // expected-error{{not an instantiation}}
+
+template int *X2::f1(int *); // okay
+
+template void X2::f2(int *, int *); // expected-error{{ambiguous}}
+
+
+template<typename T> void print_type();
+
+template void print_type<int>();
+template void print_type<float>();
+
+template<typename T> void print_type(T*);
+
+template void print_type(int*);
+template void print_type<int>(float*); // expected-error{{does not refer}}
+
+void print_type(double*);
+template void print_type<double>(double*);
+
+// PR5069
+template<int I> void foo0 (int (&)[I + 1]) { }
+template void foo0<2> (int (&)[3]);
diff --git a/test/SemaTemplate/explicit-specialization-member.cpp b/test/SemaTemplate/explicit-specialization-member.cpp
new file mode 100644
index 000000000000..197dae5a15af
--- /dev/null
+++ b/test/SemaTemplate/explicit-specialization-member.cpp
@@ -0,0 +1,11 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+template<typename T>
+struct X0 {
+  typedef T* type;
+  
+  void f0(T);
+  void f1(type);
+};
+
+template<> void X0<char>::f0(char);
+template<> void X0<char>::f1(type);
diff --git a/test/SemaTemplate/ext-vector-type.cpp b/test/SemaTemplate/ext-vector-type.cpp
index d6c02bb629ff..b6aebc102fb4 100644
--- a/test/SemaTemplate/ext-vector-type.cpp
+++ b/test/SemaTemplate/ext-vector-type.cpp
@@ -4,7 +4,7 @@ struct make1 {
   typedef T __attribute__((ext_vector_type(Length))) type; 
 };
 
-int test_make1() {
+void test_make1() {
   make1<int, 5>::type x;
   x.x = 4;
 }
diff --git a/test/SemaTemplate/extern-templates.cpp b/test/SemaTemplate/extern-templates.cpp
new file mode 100644
index 000000000000..28fda1a11e6b
--- /dev/null
+++ b/test/SemaTemplate/extern-templates.cpp
@@ -0,0 +1,66 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T>
+class X0 {
+public:
+  void f(T t);
+  
+  struct Inner {
+    void g(T t);
+  };
+};
+
+template<typename T>
+void X0<T>::f(T t) {
+  t = 17; // expected-error{{incompatible}}
+}
+
+extern template class X0<int>;
+
+extern template class X0<int*>;
+
+template<typename T>
+void X0<T>::Inner::g(T t) {
+  t = 17; // expected-error{{incompatible}}
+}
+
+void test_intptr(X0<int*> xi, X0<int*>::Inner xii) {
+  xi.f(0);
+  xii.g(0);
+}
+
+// FIXME: we would like the notes to point to the explicit instantiation at the
+// bottom.
+extern template class X0<long*>; // expected-note 2{{instantiation}}
+
+void test_longptr(X0<long*> xl, X0<long*>::Inner xli) {
+  xl.f(0);
+  xli.g(0);
+}
+
+template class X0<long*>;
+
+template<typename T>
+class X1 {
+public:
+  void f(T t) { t += 2; }
+  
+  void g(T t);
+};
+
+template<typename T>
+void X1<T>::g(T t) { 
+  t += 2; 
+}
+
+extern template class X1<void*>;
+
+void g_X1(X1<void*> x1, void *ptr) {
+  x1.g(ptr);
+}
+
+extern template void X1<const void*>::g(const void*);
+
+void g_X1_2(X1<const void *> x1, const void *ptr) {
+  x1.g(ptr);
+}
diff --git a/test/SemaTemplate/friend-template.cpp b/test/SemaTemplate/friend-template.cpp
new file mode 100644
index 000000000000..761c13076d2a
--- /dev/null
+++ b/test/SemaTemplate/friend-template.cpp
@@ -0,0 +1,64 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// PR5057
+namespace std {
+  class X {
+  public:
+    template<typename T>
+    friend struct Y;
+  };
+}
+
+namespace std {
+  template<typename T>
+  struct Y
+  {
+  };
+}
+
+
+namespace N {
+  template<typename T> void f1(T) { } // expected-note{{here}}
+
+  class X {
+    template<typename T> friend void f0(T);
+    template<typename T> friend void f1(T);
+  };
+
+  template<typename T> void f0(T) { }
+  template<typename T> void f1(T) { } // expected-error{{redefinition}}
+}
+
+// PR4768
+template<typename T>
+struct X0 {
+  template<typename U> friend struct X0;
+};
+
+template<typename T>
+struct X0<T*> {
+  template<typename U> friend struct X0;
+};
+
+template<>
+struct X0<int> {
+  template<typename U> friend struct X0;
+};
+
+template<typename T>
+struct X1 {
+  template<typename U> friend void f2(U);
+  template<typename U> friend void f3(U);
+};
+
+template<typename U> void f2(U);
+
+X1<int> x1i;
+
+template<> void f2(int);
+
+// FIXME: Should this declaration of f3 be required for the specialization of
+// f3<int> (further below) to work? GCC and EDG don't require it, we do...
+template<typename U> void f3(U);
+
+template<> void f3(int);
diff --git a/test/SemaTemplate/friend.cpp b/test/SemaTemplate/friend.cpp
new file mode 100644
index 000000000000..27299523862e
--- /dev/null
+++ b/test/SemaTemplate/friend.cpp
@@ -0,0 +1,14 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+template<typename T> struct A {
+  struct B { };
+  
+  friend struct B;
+};
+
+void f() {
+  A<int>::B b;
+}
+
+struct C0 {
+  friend struct A<int>;
+};
diff --git a/test/SemaTemplate/fun-template-def.cpp b/test/SemaTemplate/fun-template-def.cpp
index 8833ef4ddc1d..dee425007898 100644
--- a/test/SemaTemplate/fun-template-def.cpp
+++ b/test/SemaTemplate/fun-template-def.cpp
@@ -10,8 +10,13 @@ namespace std { class type_info {}; }
 
 struct dummy {};
 
+template<typename T>
+int f0(T x) {
+  return (sizeof(x) == sizeof(int))? 0 : (sizeof(x) == sizeof(double))? 1 : 2;
+}
+
 template <typename T, typename U>
-T f(T t1, U u1, int i1)
+T f1(T t1, U u1, int i1)
 {
   T t2 = i1;
   t2 = i1 + u1;
diff --git a/test/SemaTemplate/function-template-specialization.cpp b/test/SemaTemplate/function-template-specialization.cpp
new file mode 100644
index 000000000000..90e38cc882fe
--- /dev/null
+++ b/test/SemaTemplate/function-template-specialization.cpp
@@ -0,0 +1,35 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<int N> void f0(int (&array)[N]);
+
+// Simple function template specialization (using overloading)
+template<> void f0(int (&array)[1]);
+
+void test_f0() {
+  int iarr1[1];
+  f0(iarr1);
+}
+
+// Function template specialization where there are no matches
+template<> void f0(char (&array)[1]); // expected-error{{no function template matches}}
+template<> void f0<2>(int (&array)[2]) { }
+
+// Function template specialization that requires partial ordering
+template<typename T, int N> void f1(T (&array)[N]); // expected-note{{matches}}
+template<int N> void f1(int (&array)[N]); // expected-note{{matches}}
+
+template<> void f1(float (&array)[1]);
+template<> void f1(int (&array)[1]);
+
+// Function template specialization that results in an ambiguity
+template<typename T> void f1(T (&array)[17]); // expected-note{{matches}}
+template<> void f1(int (&array)[17]); // expected-error{{ambiguous}}
+
+// Resolving that ambiguity with explicitly-specified template arguments.
+template<int N> void f2(double (&array)[N]);
+template<typename T> void f2(T (&array)[42]);
+
+template<> void f2<double>(double (&array)[42]);
+template<> void f2<42>(double (&array)[42]);
+
+void f2<25>(double (&array)[25]); // expected-error{{specialization}} 
diff --git a/test/SemaTemplate/implicit-instantiation-1.cpp b/test/SemaTemplate/implicit-instantiation-1.cpp
index b8f9622001e1..d04bbd848407 100644
--- a/test/SemaTemplate/implicit-instantiation-1.cpp
+++ b/test/SemaTemplate/implicit-instantiation-1.cpp
@@ -22,4 +22,4 @@ void test_add(char *cp, int i, int *ip) {
   char* cp2 = add(cp, i);
   add(cp, cp); // expected-note{{instantiation of}}
   (void)sizeof(add(ip, ip));
-}
\ No newline at end of file
+}
diff --git a/test/SemaTemplate/injected-class-name.cpp b/test/SemaTemplate/injected-class-name.cpp
index c5f826d849ca..f9674c39a58b 100644
--- a/test/SemaTemplate/injected-class-name.cpp
+++ b/test/SemaTemplate/injected-class-name.cpp
@@ -19,7 +19,7 @@ X<float>::X<int> xi = x;
 
 // [temp.local]p1:
 
-// FIXME: test non-type and template template parameters
+// FIXME: test template template parameters
 template<typename T, typename U>
 struct X0 {
   typedef T type;
@@ -38,3 +38,11 @@ struct X0 {
   void f2(X0&);
   void f2(const ::X0<type, U_type2>&); // expected-error{{redecl}}
 };
+
+template<typename T, T N>
+struct X1 {
+  void f0(const X1&); // expected-note{{here}}
+  void f0(X1&);
+  void f0(const X1<T, N>&); // expected-error{{redecl}}
+};
+
diff --git a/test/SemaTemplate/instantiate-anonymous-union.cpp b/test/SemaTemplate/instantiate-anonymous-union.cpp
new file mode 100644
index 000000000000..375c1da3ca59
--- /dev/null
+++ b/test/SemaTemplate/instantiate-anonymous-union.cpp
@@ -0,0 +1,31 @@
+// RUN: clang-cc -fsyntax-only %s -Wall
+
+template <typename T> class A { struct { }; };
+
+A<int> a0;
+
+template <typename T> struct B {
+  union {
+    int a;
+    void* b;
+  };
+    
+  void f() {
+    a = 10;
+    b = 0;
+  }
+};
+
+B<int> b0;
+
+template <typename T> struct C {
+  union {
+    int a;
+    void* b;
+  };
+
+  C(int a) : a(a) { }
+  C(void* b) : b(b) { }
+};
+
+C<int> c0(0);
diff --git a/test/SemaTemplate/instantiate-cast.cpp b/test/SemaTemplate/instantiate-cast.cpp
index d99f3e556602..6b3fc6e12534 100644
--- a/test/SemaTemplate/instantiate-cast.cpp
+++ b/test/SemaTemplate/instantiate-cast.cpp
@@ -1,6 +1,6 @@
 // RUN: clang-cc -fsyntax-only -verify %s
 
-struct A { int x; };
+struct A { int x; }; 
 
 class Base { 
 public:
@@ -23,7 +23,7 @@ struct Constructible {
 template<typename T, typename U>
 struct CStyleCast0 {
   void f(T t) {
-    (void)((U)t); // FIXME:ugly expected-error{{operand}}
+    (void)((U)t); // expected-error{{C-style cast from 'struct A' to 'int'}}
   }
 };
 
@@ -36,7 +36,7 @@ template struct CStyleCast0<A, int>; // expected-note{{instantiation}}
 template<typename T, typename U>
 struct StaticCast0 {
   void f(T t) {
-    (void)static_cast<U>(t); // expected-error{{static_cast}}
+    (void)static_cast<U>(t); // expected-error{{static_cast from 'int' to 'struct A' is not allowed}}
   }
 };
 
@@ -89,7 +89,7 @@ template struct ConstCast0<int const *, float *>; // expected-note{{instantiatio
 template<typename T, typename U>
 struct FunctionalCast1 {
   void f(T t) {
-    (void)U(t); // FIXME:ugly expected-error{{operand}}
+    (void)U(t); // expected-error{{functional-style cast from 'struct A' to 'int'}}
   }
 };
 
diff --git a/test/SemaTemplate/instantiate-deeply.cpp b/test/SemaTemplate/instantiate-deeply.cpp
new file mode 100644
index 000000000000..27e430be5cbe
--- /dev/null
+++ b/test/SemaTemplate/instantiate-deeply.cpp
@@ -0,0 +1,22 @@
+// RUN: clang-cc -fsyntax-only -Wall -verify %s
+
+template<typename a> struct A {
+  template <typename b> struct B {
+    template <typename c> struct C {
+      template <typename d> struct D {
+        template <typename e> struct E {
+          e field;
+          E() : field(0) {
+            d v1 = 4;
+            c v2 = v1 * v1;
+            b v3 = 8;
+            a v4 = v3 * v3;
+            field += v2 + v4;
+          }
+        };
+      };
+    };
+  };
+};
+
+A<int>::B<int>::C<int>::D<int>::E<int> global;
diff --git a/test/SemaTemplate/instantiate-expr-2.cpp b/test/SemaTemplate/instantiate-expr-2.cpp
index 80f403ed56fe..146e63c5bb00 100644
--- a/test/SemaTemplate/instantiate-expr-2.cpp
+++ b/test/SemaTemplate/instantiate-expr-2.cpp
@@ -130,3 +130,51 @@ struct X0 {
 void test_X0(X0<int> x, IntegralConstant<int, sizeof(int)> ic) {
   x.f(5,ic);
 }
+
+namespace N8 {
+  struct X {
+    X operator+(const X&) const;
+  };
+  
+  template<typename T>
+  T test_plus(const T* xp, const T& x, const T& y) {
+    x.operator+(y);
+    return xp->operator+(y);
+  }
+  
+  void test_test_plus(X x) {
+    test_plus(&x, x, x);
+  }
+}
+
+namespace N9 {
+  struct A {
+    bool operator==(int value);
+  };
+  
+  template<typename T> struct B {
+    bool f(A a) {
+      return a == 1;
+    }
+  };
+  
+  template struct B<int>;  
+}
+
+namespace N10 {
+  template <typename T>
+  class A {
+    struct X { };
+    
+  public:
+    ~A() {
+      f(reinterpret_cast<X *>(0), reinterpret_cast<X *>(0));
+    }
+    
+  private:
+    void f(X *);
+    void f(X *, X *);
+  };
+  
+  template class A<int>;
+}
diff --git a/test/SemaTemplate/instantiate-expr-5.cpp b/test/SemaTemplate/instantiate-expr-5.cpp
new file mode 100644
index 000000000000..b42c0fb2aaf8
--- /dev/null
+++ b/test/SemaTemplate/instantiate-expr-5.cpp
@@ -0,0 +1,4 @@
+// RUN: clang-cc -fsyntax-only %s
+
+template <class A> int x(A x) { return x++; }
+int y() { return x<int>(1); }
diff --git a/test/SemaTemplate/instantiate-friend-class.cpp b/test/SemaTemplate/instantiate-friend-class.cpp
new file mode 100644
index 000000000000..9a4a73cc8a52
--- /dev/null
+++ b/test/SemaTemplate/instantiate-friend-class.cpp
@@ -0,0 +1,9 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+// PR4794
+
+template <class T> class X
+{
+  friend class Y;
+};
+X<int> y;
+
diff --git a/test/SemaTemplate/instantiate-function-1.cpp b/test/SemaTemplate/instantiate-function-1.cpp
index 023cc5437f69..2749ec24401b 100644
--- a/test/SemaTemplate/instantiate-function-1.cpp
+++ b/test/SemaTemplate/instantiate-function-1.cpp
@@ -140,7 +140,7 @@ template<typename T> struct Member0 {
     tp->f;
 
     this->f;
-    this.f; // expected-error{{member reference base type 'Member0<T> *const' is not a structure or union}}
+    this.f; // expected-error{{member reference base type 'Member0<T> *' is not a structure or union}}
   }
 };
 
diff --git a/test/SemaTemplate/instantiate-function-1.mm b/test/SemaTemplate/instantiate-function-1.mm
index aef2d9dbb7eb..be995e7ff615 100644
--- a/test/SemaTemplate/instantiate-function-1.mm
+++ b/test/SemaTemplate/instantiate-function-1.mm
@@ -1,3 +1,6 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+// XFAIL
+
 template<typename T> struct Member0 {
   void f(T t) {
     t;
diff --git a/test/SemaTemplate/instantiate-init.cpp b/test/SemaTemplate/instantiate-init.cpp
new file mode 100644
index 000000000000..870b27537fce
--- /dev/null
+++ b/test/SemaTemplate/instantiate-init.cpp
@@ -0,0 +1,28 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+struct X0 { // expected-note 4{{candidate}}
+  X0(int*, float*); // expected-note 4{{candidate}}
+};
+
+template<typename T, typename U>
+X0 f0(T t, U u) {
+  X0 x0(t, u); // expected-error{{no matching}}
+  return X0(t, u); // expected-error{{no matching}}
+}
+
+void test_f0(int *ip, float *fp, double *dp) {
+  f0(ip, fp);
+  f0(ip, dp); // expected-note{{instantiation}}
+}
+
+template<typename Ret, typename T, typename U>
+Ret f1(Ret *retty, T t, U u) {
+  Ret r0(t, u); // expected-error{{no matching}}
+  return Ret(t, u); // expected-error{{no matching}}
+}
+
+void test_f1(X0 *x0, int *ip, float *fp, double *dp) {
+  f1(x0, ip, fp);
+  f1(x0, ip, dp); // expected-note{{instantiation}}
+}
+
diff --git a/test/SemaTemplate/instantiate-member-initializers.cpp b/test/SemaTemplate/instantiate-member-initializers.cpp
new file mode 100644
index 000000000000..6fc70429a9d3
--- /dev/null
+++ b/test/SemaTemplate/instantiate-member-initializers.cpp
@@ -0,0 +1,26 @@
+// RUN: clang-cc -fsyntax-only -Wall -verify %s
+
+template<typename T> struct A {
+  A() : a(1) { } // expected-error{{incompatible type passing 'int', expected 'void *'}}
+
+  T a;
+};
+
+A<int> a0;
+A<void*> a1; // expected-note{{in instantiation of member function 'A<void *>::A' requested here}}
+
+template<typename T> struct B {
+  // FIXME: This should warn about initialization order
+  B() : b(1), a(2) { }
+  
+  int a;
+  int b;
+};
+
+B<int> b0;
+
+template <class T> struct AA { AA(int); };
+template <class T> class BB : public AA<T> {
+  BB() : AA<T>(1) {}
+};
+BB<int> x;
diff --git a/test/SemaTemplate/instantiate-member-template.cpp b/test/SemaTemplate/instantiate-member-template.cpp
new file mode 100644
index 000000000000..36f3b6fd490d
--- /dev/null
+++ b/test/SemaTemplate/instantiate-member-template.cpp
@@ -0,0 +1,105 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T>
+struct X0 {
+  template<typename U> T f0(U);
+  template<typename U> U& f1(T*, U); // expected-error{{pointer to a reference}} \
+                                     // expected-note{{candidate}}
+};
+
+X0<int> x0i;
+X0<void> x0v;
+X0<int&> x0ir; // expected-note{{instantiation}}
+
+void test_X0(int *ip, double *dp) {
+  X0<int> xi;
+  int i1 = xi.f0(ip);
+  double *&dpr = xi.f1(ip, dp);
+  xi.f1(dp, dp); // expected-error{{no matching}}
+
+  X0<void> xv;
+  double *&dpr2 = xv.f1(ip, dp);
+}
+
+template<typename T>
+struct X1 {
+  template<typename U>
+  struct Inner0 {
+    U x; 
+    T y; // expected-error{{void}}
+  };
+
+  template<typename U>
+  struct Inner1 {
+    U x; // expected-error{{void}}
+    T y;
+  };
+  
+  template<typename U>
+  struct Inner2 {
+    struct SuperInner {
+      U z; // expected-error{{void}}
+    };
+  };
+  
+  template<typename U>
+  struct Inner3 {
+    void f0(T t, U u) {
+      (void)(t + u); // expected-error{{invalid operands}}
+    }
+    
+    template<typename V>
+    V f1(T t, U u, V) {
+      return t + u; // expected-error{{incompatible type}}
+    }
+  };
+  
+  template<typename U>
+  struct Inner4;
+};
+
+template<typename T>
+template<typename U>
+struct X1<T>::Inner4 {
+  template<typename V>
+  V f2(T t, U u, V);
+  
+  static U value;
+};
+
+template<typename T>
+template<typename U>
+U X1<T>::Inner4<U>::value; // expected-error{{reference variable}}
+
+template<typename T>
+template<typename U>
+template<typename V>
+V X1<T>::Inner4<U>::f2(T t, U u, V) {
+  return t + u; // expected-error{{incompatible type}}
+}
+
+void test_X1(int *ip, int i, double *dp) {
+  X1<void>::Inner0<int> *xvip; // okay
+  X1<void>::Inner0<int> xvi; // expected-note{{instantiation}}
+  
+  X1<int>::Inner1<void> *xivp; // okay
+  X1<int>::Inner1<void> xiv; // expected-note{{instantiation}}
+  
+  X1<int>::Inner2<void>::SuperInner *xisivp; // okay
+  X1<int>::Inner2<void>::SuperInner xisiv; // expected-note{{instantiation}}
+  
+  X1<int*>::Inner3<int> id3;
+  id3.f0(ip, i);
+  id3.f0(dp, i); // expected-error{{incompatible type}}
+  id3.f1(ip, i, ip);
+  id3.f1(ip, i, dp); // expected-note{{instantiation}}
+  
+  X1<int*>::Inner3<double*> id3b;
+  id3b.f0(ip, dp); // expected-note{{instantiation}}
+  
+  X1<int*>::Inner4<int> id4;
+  id4.f2(ip, i, dp); // expected-note{{instantiation}}
+  
+  X1<int*>::Inner4<int>::value = 17;
+  i = X1<int*>::Inner4<int&>::value; // expected-note{{instantiation}}
+}
diff --git a/test/SemaTemplate/instantiate-method.cpp b/test/SemaTemplate/instantiate-method.cpp
index daea7465dc12..f7c09ef87900 100644
--- a/test/SemaTemplate/instantiate-method.cpp
+++ b/test/SemaTemplate/instantiate-method.cpp
@@ -72,3 +72,12 @@ void test_converts_to(ConvertsTo<int> ci, ConvertsTo<int *> cip) {
   int i = ci;
   int *ip = cip;
 }
+
+// PR4660
+template<class T> struct A0 { operator T*(); };
+template<class T> struct A1;
+
+int *a(A0<int> &x0, A1<int> &x1) {
+  int *y0 = x0;
+  int *y1 = x1; // expected-error{{initializing}}
+}
diff --git a/test/SemaTemplate/instantiate-static-var.cpp b/test/SemaTemplate/instantiate-static-var.cpp
index 99e6b9cc06c3..96fa34cc2aff 100644
--- a/test/SemaTemplate/instantiate-static-var.cpp
+++ b/test/SemaTemplate/instantiate-static-var.cpp
@@ -16,3 +16,25 @@ class Y {
 };
 
 Y<float> fy; // expected-note{{in instantiation of template class 'class Y<float>' requested here}}
+
+
+// out-of-line static member variables
+
+template<typename T>
+struct Z {
+  static T value;
+};
+
+template<typename T>
+T Z<T>::value; // expected-error{{no matching constructor}}
+
+struct DefCon {};
+
+struct NoDefCon { 
+  NoDefCon(const NoDefCon&);
+};
+
+void test() {
+  DefCon &DC = Z<DefCon>::value;
+  NoDefCon &NDC = Z<NoDefCon>::value; // expected-note{{instantiation}}
+}
diff --git a/test/SemaTemplate/instantiate-typedef.cpp b/test/SemaTemplate/instantiate-typedef.cpp
index d30309cc86ca..e092b531582b 100644
--- a/test/SemaTemplate/instantiate-typedef.cpp
+++ b/test/SemaTemplate/instantiate-typedef.cpp
@@ -12,5 +12,5 @@ add_pointer<float>::type test2(int * ptr) {
 }
 
 add_pointer<int&>::type // expected-note{{in instantiation of template class 'struct add_pointer<int &>' requested here}} \
-// expected-error {{unknown type name 'type'}}
+// expected-error {{no type named 'type' in 'struct add_pointer<int &>'}}
 test3(); 
diff --git a/test/SemaTemplate/instantiate-using-decl.cpp b/test/SemaTemplate/instantiate-using-decl.cpp
new file mode 100644
index 000000000000..fd9010fa4bbb
--- /dev/null
+++ b/test/SemaTemplate/instantiate-using-decl.cpp
@@ -0,0 +1,17 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T>
+struct A {
+  void f();
+};
+
+template<typename T>
+struct B : A<T> {
+  using A<T>::f;
+  
+  void g() {
+    f();
+  }
+};
+
+template struct B<int>;
diff --git a/test/SemaTemplate/member-access-expr.cpp b/test/SemaTemplate/member-access-expr.cpp
new file mode 100644
index 000000000000..f4922e8ff520
--- /dev/null
+++ b/test/SemaTemplate/member-access-expr.cpp
@@ -0,0 +1,77 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+template<typename T>
+void call_f0(T x) {
+  x.Base::f0();
+}
+
+struct Base {
+  void f0();
+};
+
+struct X0 : Base { 
+  typedef Base CrazyBase;
+};
+
+void test_f0(X0 x0) {
+  call_f0(x0);
+}
+
+template<typename TheBase, typename T>
+void call_f0_through_typedef(T x) {
+  typedef TheBase Base2;
+  x.Base2::f0();
+}
+
+void test_f0_through_typedef(X0 x0) {
+  call_f0_through_typedef<Base>(x0);
+}
+
+template<typename TheBase, typename T>
+void call_f0_through_typedef2(T x) {
+  typedef TheBase CrazyBase; // expected-note{{current scope}}
+  x.CrazyBase::f0(); // expected-error{{ambiguous}} \
+                     // expected-error 2{{no member named}}
+}
+
+struct OtherBase { };
+
+struct X1 : Base, OtherBase { 
+  typedef OtherBase CrazyBase; // expected-note{{object type}}
+};
+
+void test_f0_through_typedef2(X0 x0, X1 x1) {
+  call_f0_through_typedef2<Base>(x0);
+  call_f0_through_typedef2<OtherBase>(x1); // expected-note{{instantiation}}
+  call_f0_through_typedef2<Base>(x1); // expected-note{{instantiation}}
+}
+
+
+struct X2 {
+  operator int() const;
+};
+
+template<typename T, typename U>
+T convert(const U& value) {
+  return value.operator T(); // expected-error{{operator long}}
+}
+
+void test_convert(X2 x2) {
+  convert<int>(x2);
+  convert<long>(x2); // expected-note{{instantiation}}
+}
+
+template<typename T>
+void destruct(T* ptr) {
+  ptr->~T();
+}
+
+template<typename T>
+void destruct_intptr(int *ip) {
+  ip->~T();
+}
+
+void test_destruct(X2 *x2p, int *ip) {
+  destruct(x2p);
+  destruct(ip);
+  destruct_intptr<int>(ip);
+}
\ No newline at end of file
diff --git a/test/SemaTemplate/member-function-template.cpp b/test/SemaTemplate/member-function-template.cpp
new file mode 100644
index 000000000000..83bf16c69004
--- /dev/null
+++ b/test/SemaTemplate/member-function-template.cpp
@@ -0,0 +1,51 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+struct X {
+  template<typename T> T& f0(T);
+  
+  void g0(int i, double d) {
+    int &ir = f0(i);
+    double &dr = f0(d);
+  }
+  
+  template<typename T> T& f1(T);
+  template<typename T, typename U> U& f1(T, U);
+  
+  void g1(int i, double d) {
+    int &ir1 = f1(i);
+    int &ir2 = f1(d, i);
+    int &ir3 = f1(i, i);
+  }
+};
+
+void test_X_f0(X x, int i, float f) {
+  int &ir = x.f0(i);
+  float &fr = x.f0(f);
+}
+
+void test_X_f1(X x, int i, float f) {
+  int &ir1 = x.f1(i);
+  int &ir2 = x.f1(f, i);
+  int &ir3 = x.f1(i, i);
+}
+
+void test_X_f0_address() {
+  int& (X::*pm1)(int) = &X::f0;
+  float& (X::*pm2)(float) = &X::f0;
+}
+
+void test_X_f1_address() {
+  int& (X::*pm1)(int) = &X::f1;
+  float& (X::*pm2)(float) = &X::f1;
+  int& (X::*pm3)(float, int) = &X::f1;
+}
+
+void test_X_f0_explicit(X x, int i, long l) {
+  int &ir1 = x.f0<int>(i);
+  int &ir2 = x.f0<>(i);
+  long &il1 = x.f0<long>(i);
+}
+
+// PR4608
+class A { template <class x> x a(x z) { return z+y; } int y; };
+
diff --git a/test/SemaTemplate/member-initializers.cpp b/test/SemaTemplate/member-initializers.cpp
new file mode 100644
index 000000000000..62077fabc721
--- /dev/null
+++ b/test/SemaTemplate/member-initializers.cpp
@@ -0,0 +1,13 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T> struct A {
+  A() : j(10), i(10) { }
+  
+  int i;
+  int j;
+};
+
+template<typename T> struct B : A<T> {
+  B() : A<T>() { }
+};
+
diff --git a/test/SemaTemplate/member-template-access-expr.cpp b/test/SemaTemplate/member-template-access-expr.cpp
new file mode 100644
index 000000000000..20437aee39dc
--- /dev/null
+++ b/test/SemaTemplate/member-template-access-expr.cpp
@@ -0,0 +1,30 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename U, typename T>
+U f0(T t) {
+  return t.template get<U>();
+}
+
+template<typename U, typename T>
+int &f1(T t) {
+  // FIXME: When we pretty-print this, we lose the "template" keyword.
+  return t.U::template get<int&>();
+}
+
+struct X {
+  template<typename T> T get();
+};
+
+void test_f0(X x) {
+  int i = f0<int>(x);
+  int &ir = f0<int&>(x);
+}
+
+struct XDerived : public X {
+};
+
+void test_f1(XDerived xd) {
+  // FIXME: Not quite functional yet.
+//  int &ir = f1<X>(xd);
+}
+
diff --git a/test/SemaTemplate/metafun-apply.cpp b/test/SemaTemplate/metafun-apply.cpp
index 9261ed6a6c96..471b2ad3fae6 100644
--- a/test/SemaTemplate/metafun-apply.cpp
+++ b/test/SemaTemplate/metafun-apply.cpp
@@ -35,7 +35,8 @@ void test() {
   apply1<add_reference, void>::type t; // expected-note{{in instantiation of template class 'struct apply1<struct add_reference, void>' requested here}} \
   // FIXME: expected-error{{unexpected type name 'type': expected expression}}
 
-  apply1<bogus, int>::type t2; // expected-note{{in instantiation of template class 'struct apply1<struct bogus, int>' requested here}}
+  apply1<bogus, int>::type t2; // expected-note{{in instantiation of template class 'struct apply1<struct bogus, int>' requested here}} \
+  // FIXME: expected-error{{unexpected type name 'type': expected expression}}
 }
 
 
diff --git a/test/SemaTemplate/nested-linkage.cpp b/test/SemaTemplate/nested-linkage.cpp
new file mode 100644
index 000000000000..ffe9adc927d6
--- /dev/null
+++ b/test/SemaTemplate/nested-linkage.cpp
@@ -0,0 +1,3 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+extern "C" { extern "C++" { template<class C> C x(); } }
diff --git a/test/SemaTemplate/nested-template.cpp b/test/SemaTemplate/nested-template.cpp
index 84b1d35ba91d..5ee2c9954005 100644
--- a/test/SemaTemplate/nested-template.cpp
+++ b/test/SemaTemplate/nested-template.cpp
@@ -1,5 +1,4 @@
 // RUN: clang-cc -fsyntax-only -verify %s
-
 class A;
 
 class S {
@@ -14,3 +13,91 @@ public:
 int i;
 S::A<int>::Nested::type *ip = &i;
 
+template<typename T>
+struct Outer {
+  template<typename U>
+  class Inner0;
+  
+  template<typename U>
+  class Inner1 {
+    struct ReallyInner;
+    
+    T foo(U);
+    template<typename V> T bar(V);
+    template<typename V> T* bar(V);
+    
+    static T value1;
+    static U value2;
+  };
+};
+
+template<typename X>
+template<typename Y>
+class Outer<X>::Inner0 {
+public:
+  void f(X, Y);
+};
+
+template<typename X>
+template<typename Y>
+void Outer<X>::Inner0<Y>::f(X, Y) {
+}
+
+template<typename X>
+template<typename Y>
+struct Outer<X>::Inner1<Y>::ReallyInner {
+  static Y value3;
+  
+  void g(X, Y);
+};
+
+template<typename X>
+template<typename Y>
+void Outer<X>::Inner1<Y>::ReallyInner::g(X, Y) {
+}
+
+template<typename X>
+template<typename Y>
+X Outer<X>::Inner1<Y>::foo(Y) {
+  return X();
+}
+
+template<typename X>
+template<typename Y>
+template<typename Z>
+X Outer<X>::Inner1<Y>::bar(Z) {
+  return X();
+}
+
+template<typename X>
+template<typename Y>
+template<typename Z>
+X* Outer<X>::Inner1<Y>::bar(Z) {
+  return 0;
+}
+
+template<typename X>
+template<typename Y>
+X Outer<X>::Inner1<Y>::value1 = 0;
+
+template<typename X>
+template<typename Y>
+Y Outer<X>::Inner1<Y>::value2 = Y();
+
+template<typename X>
+template<typename Y>
+Y Outer<X>::Inner1<Y>::ReallyInner::value3 = Y();
+
+template<typename X>
+template<typename Y>
+Y Outer<X>::Inner1<Y*>::ReallyInner::value4; // expected-error{{Outer<X>::Inner1<Y *>::ReallyInner::}}
+
+
+template<typename T>
+struct X0 { };
+
+template<typename T>
+struct X0<T*> {
+  template<typename U>
+  void f(U u = T()) { }
+};
diff --git a/test/SemaTemplate/partial-spec-instantiate.cpp b/test/SemaTemplate/partial-spec-instantiate.cpp
new file mode 100644
index 000000000000..8d1ae238977c
--- /dev/null
+++ b/test/SemaTemplate/partial-spec-instantiate.cpp
@@ -0,0 +1,20 @@
+// RUN: clang-cc -fsyntax-only %s
+
+// PR4607
+template <class T> struct X {};
+
+template <> struct X<char>
+{
+  static char* g();
+};
+
+template <class T> struct X2 {};
+
+template <class U>
+struct X2<U*> {
+  static void f() {
+    X<U>::g();
+  }
+};
+
+void a(char *a, char *b) {X2<char*>::f();}
diff --git a/test/SemaTemplate/qualified-id.cpp b/test/SemaTemplate/qualified-id.cpp
new file mode 100644
index 000000000000..85efab2b5cc9
--- /dev/null
+++ b/test/SemaTemplate/qualified-id.cpp
@@ -0,0 +1,9 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+// PR5061
+namespace a {
+  template <typename T> class C {};
+}
+namespace b {
+  template<typename T> void f0(a::C<T> &a0) { }
+}
diff --git a/test/SemaTemplate/qualified-names-diag.cpp b/test/SemaTemplate/qualified-names-diag.cpp
index c875332905fb..1d53e5cb98ba 100644
--- a/test/SemaTemplate/qualified-names-diag.cpp
+++ b/test/SemaTemplate/qualified-names-diag.cpp
@@ -1,7 +1,7 @@
 // RUN: clang-cc -fsyntax-only -verify %s
 
 namespace std {
-  template<typename T> class vector { };
+  template<typename T> class vector { }; // expected-note{{candidate}}
 }
 
 typedef int INT;
diff --git a/test/SemaTemplate/temp_class_order.cpp b/test/SemaTemplate/temp_class_order.cpp
new file mode 100644
index 000000000000..4687ddf7d9e9
--- /dev/null
+++ b/test/SemaTemplate/temp_class_order.cpp
@@ -0,0 +1,42 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+
+template<typename T, typename U>
+struct X1 {
+  static const int value = 0;
+};
+
+template<typename T, typename U>
+struct X1<T*, U*> {
+  static const int value = 1;
+};
+
+template<typename T>
+struct X1<T*, T*> {
+  static const int value = 2;
+};
+
+template<typename T>
+struct X1<const T*, const T*> {
+  static const int value = 3;
+};
+
+int array0[X1<int, int>::value == 0? 1 : -1];
+int array1[X1<int*, float*>::value == 1? 1 : -1];
+int array2[X1<int*, int*>::value == 2? 1 : -1];
+typedef const int* CIP;
+int array3[X1<const int*, CIP>::value == 3? 1 : -1];
+
+template<typename T, typename U>
+struct X2 { };
+
+template<typename T, typename U>
+struct X2<T*, U> { }; // expected-note{{matches}}
+
+template<typename T, typename U>
+struct X2<T, U*> { }; // expected-note{{matches}}
+
+template<typename T, typename U>
+struct X2<const T*, const U*> { };
+
+X2<int*, int*> x2a; // expected-error{{ambiguous}}
+X2<const int*, const int*> x2b;
diff --git a/test/SemaTemplate/temp_class_spec.cpp b/test/SemaTemplate/temp_class_spec.cpp
index 1a534236c8eb..dad857e8e66d 100644
--- a/test/SemaTemplate/temp_class_spec.cpp
+++ b/test/SemaTemplate/temp_class_spec.cpp
@@ -16,8 +16,7 @@ struct is_pointer<const T*> {
 
 int array0[is_pointer<int>::value? -1 : 1];
 int array1[is_pointer<int*>::value? 1 : -1];
-int array2[is_pointer<const int*>::value? 1 : -1]; // expected-error{{partial ordering}} \
-// expected-error{{negative}}
+int array2[is_pointer<const int*>::value? 1 : -1];
 
 template<typename T>
 struct is_lvalue_reference {
@@ -32,6 +31,38 @@ struct is_lvalue_reference<T&> {
 int lvalue_ref0[is_lvalue_reference<int>::value? -1 : 1];
 int lvalue_ref1[is_lvalue_reference<const int&>::value? 1 : -1];
 
+template<typename T>
+struct is_const {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_const<const T> {
+  static const bool value = true;
+};
+
+int is_const0[is_const<int>::value? -1 : 1];
+int is_const1[is_const<const int>::value? 1 : -1];
+int is_const2[is_const<const volatile int>::value? 1 : -1];
+int is_const3[is_const<const int [3]>::value? 1 : -1];
+int is_const4[is_const<const volatile int[3]>::value? 1 : -1];
+int is_const5[is_const<volatile int[3]>::value? -1 : 1];
+
+template<typename T>
+struct is_volatile {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_volatile<volatile T> {
+  static const bool value = true;
+};
+
+int is_volatile0[is_volatile<int>::value? -1 : 1];
+int is_volatile1[is_volatile<volatile int>::value? 1 : -1];
+int is_volatile2[is_volatile<const volatile int>::value? 1 : -1];
+int is_volatile3[is_volatile<volatile char[3]>::value? 1 : -1];
+                 
 template<typename T, typename U>
 struct is_same {
   static const bool value = false;
@@ -62,7 +93,20 @@ struct remove_reference<T&> {
 
 int remove_ref0[is_same<remove_reference<int>::type, int>::value? 1 : -1];
 int remove_ref1[is_same<remove_reference<int&>::type, int>::value? 1 : -1];
-                
+
+template<typename T>
+struct remove_const {
+  typedef T type;
+};
+
+template<typename T>
+struct remove_const<const T> {
+  typedef T type;
+};
+
+int remove_const0[is_same<remove_const<const int>::type, int>::value? 1 : -1];
+int remove_const1[is_same<remove_const<const int[3]>::type, int[3]>::value? 1 : -1];
+
 template<typename T>
 struct is_incomplete_array {
   static const bool value = false;
@@ -104,6 +148,24 @@ struct get_array_size<T[N]> {
 int array_size0[get_array_size<int[12]>::value == 12? 1 : -1];
 
 template<typename T>
+struct remove_extent {
+  typedef T type;
+};
+
+template<typename T>
+struct remove_extent<T[]> { 
+  typedef T type;
+};
+
+template<typename T, unsigned N>
+struct remove_extent<T[N]> { 
+  typedef T type;
+};
+
+int remove_extent0[is_same<remove_extent<int[][5]>::type, int[5]>::value? 1 : -1];
+int remove_extent1[is_same<remove_extent<const int[][5]>::type, const int[5]>::value? 1 : -1];
+
+template<typename T>
 struct is_unary_function {
   static const bool value = false;
 };
@@ -261,3 +323,10 @@ template<class T, int I> class A<T, T*, I> { }; //#2
 template<class T1, class T2, int I> class A<T1*, T2, I> { }; //#3 
 template<class T> class A<int, T*, 5> { }; //#4 
 template<class T1, class T2, int I> class A<T1, T2*, I> { }; //#5 
+
+// Redefinition of class template partial specializations
+template<typename T, T N, typename U> class A0;
+
+template<typename T, T N> class A0<T, N, int> { }; // expected-note{{here}}
+template<typename T, T N> class A0<T, N, int>;
+template<typename T, T N> class A0<T, N, int> { }; // expected-error{{redef}}
diff --git a/test/SemaTemplate/temp_class_spec_neg.cpp b/test/SemaTemplate/temp_class_spec_neg.cpp
index b50bd8f634aa..a029f474fc58 100644
--- a/test/SemaTemplate/temp_class_spec_neg.cpp
+++ b/test/SemaTemplate/temp_class_spec_neg.cpp
@@ -9,7 +9,7 @@ namespace N {
 }
 
 template<typename T>
-struct N::M::A<T*> { }; // expected-error{{not in namespace}}
+struct N::M::A<T*> { }; // expected-error{{originally}}
 
 // C++ [temp.class.spec]p9
 //   bullet 1
@@ -25,7 +25,7 @@ template <class T, T* t> struct C<T*, t>; // okay
 
 template< int X, int (*array_ptr)[X] > class A2 {}; // expected-note{{here}}
 int array[5]; 
-template< int X > class A2<X,&array> { }; // expected-error{{specializes}}
+template< int X > class A2<X, &array> { }; // expected-error{{specializes}}
 
 template<typename T, int N, template<typename X> class TT>
 struct Test0;
diff --git a/test/SemaTemplate/temp_func_order.cpp b/test/SemaTemplate/temp_func_order.cpp
new file mode 100644
index 000000000000..5fd7c8d74571
--- /dev/null
+++ b/test/SemaTemplate/temp_func_order.cpp
@@ -0,0 +1,95 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+template<typename T>
+int &f0(T);
+
+template<typename T>
+float &f0(T*);
+
+void test_f0(int i, int *ip) {
+  int &ir = f0(i);
+  float &fr = f0(ip);
+}
+
+template<typename T, typename U>
+int &f1(T, U);
+
+template<typename T>
+float &f1(T, T);
+
+void test_f1(int i, float f) {
+  int &ir = f1(i, f);
+  float &fr1 = f1(i, i);
+  float &fr2 = f1(f, f);
+}
+
+template<typename T, typename U>
+struct A { };
+
+template<typename T>
+int &f2(T);
+
+template<typename T, typename U>
+float &f2(A<T, U>);
+
+template<typename T>
+double &f2(A<T, T>);
+
+void test_f2(int i, A<int, float> aif, A<int, int> aii) {
+  int &ir = f2(i);
+  float &fr = f2(aif);
+  double &dr = f2(aii);
+}
+
+template<typename T, typename U>
+int &f3(T*, U); // expected-note{{candidate}}
+
+template<typename T, typename U>
+float &f3(T, U*); // expected-note{{candidate}}
+
+void test_f3(int i, int *ip, float *fp) {
+  int &ir = f3(ip, i);
+  float &fr = f3(i, fp);
+  f3(ip, ip); // expected-error{{ambiguous}}
+}
+
+template<typename T>
+int &f4(T&);
+
+template<typename T>
+float &f4(const T&);
+
+void test_f4(int i, const int ic) {
+  int &ir1 = f4(i);
+  float &fr1 = f4(ic);
+}
+
+template<typename T, typename U>
+int &f5(T&, const U&); // expected-note{{candidate}}
+
+template<typename T, typename U>
+float &f5(const T&, U&); // expected-note{{candidate}}
+
+void test_f5(int i, const int ic) {
+  f5(i, i); // expected-error{{ambiguous}}
+}
+
+template<typename T, typename U>
+int &f6(T&, U&);
+
+template<typename T, typename U>
+float &f6(const T&, U&);
+
+void test_f6(int i, const int ic) {
+  int &ir = f6(i, i);
+  float &fr = f6(ic, ic);
+}
+
+struct CrazyFun {
+  template<typename T, typename U> operator A<T, U>();
+  template<typename T> operator A<T, T>();
+};
+
+void fun(CrazyFun cf) {
+  A<int, float> aif = cf;
+  A<int, int> aii = cf;  
+}
diff --git a/test/SemaTemplate/typename-specifier-4.cpp b/test/SemaTemplate/typename-specifier-4.cpp
new file mode 100644
index 000000000000..c7484c19fca7
--- /dev/null
+++ b/test/SemaTemplate/typename-specifier-4.cpp
@@ -0,0 +1,70 @@
+// RUN: clang-cc -fsyntax-only -verify %s
+template<typename T, typename U> 
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+template<typename MetaFun, typename T1, typename T2>
+struct metafun_apply2 {
+  typedef typename MetaFun::template apply<T1, T2> inner;
+  typedef typename inner::type type;
+};
+
+template<typename T, typename U> struct pair;
+
+struct make_pair {
+  template<typename T1, typename T2>
+  struct apply {
+    typedef pair<T1, T2> type;
+  };
+};
+
+int a0[is_same<metafun_apply2<make_pair, int, float>::type, 
+               pair<int, float> >::value? 1 : -1];
+int a1[is_same<
+         typename make_pair::template apply<int, float>,
+         make_pair::apply<int, float>
+       >::value? 1 : -1];
+
+template<typename MetaFun>
+struct swap_and_apply2 {
+  template<typename T1, typename T2>
+  struct apply {
+    typedef typename MetaFun::template apply<T2, T1> new_metafun;
+    typedef typename new_metafun::type type;
+  };
+};
+
+int a2[is_same<swap_and_apply2<make_pair>::apply<int, float>::type, 
+               pair<float, int> >::value? 1 : -1];
+
+template<typename MetaFun>
+struct swap_and_apply2b {
+  template<typename T1, typename T2>
+  struct apply {
+    typedef typename MetaFun::template apply<T2, T1>::type type;
+  };
+};
+
+int a3[is_same<swap_and_apply2b<make_pair>::apply<int, float>::type, 
+               pair<float, int> >::value? 1 : -1];
+
+template<typename T>
+struct X0 {
+  template<typename U, typename V>
+  struct Inner;
+  
+  void f0(X0<T>::Inner<T*, T&>); // expected-note{{here}}
+  void f0(typename X0<T>::Inner<T*, T&>); // expected-error{{redecl}}
+
+  void f1(X0<T>::Inner<T*, T&>); // expected-note{{here}}
+  void f1(typename X0<T>::template Inner<T*, T&>); // expected-error{{redecl}}
+
+  void f2(typename X0<T>::Inner<T*, T&>::type); // expected-note{{here}}
+  void f2(typename X0<T>::template Inner<T*, T&>::type); // expected-error{{redecl}}
+};
diff --git a/test/SemaTemplate/typename-specifier.cpp b/test/SemaTemplate/typename-specifier.cpp
index d3fca3eacad5..2501b8d048ff 100644
--- a/test/SemaTemplate/typename-specifier.cpp
+++ b/test/SemaTemplate/typename-specifier.cpp
@@ -16,7 +16,7 @@ namespace N {
 int i;
 
 typename N::A::type *ip1 = &i;
-typename N::B::type *ip2 = &i; // expected-error{{ no type named 'type' in 'B'}}
+typename N::B::type *ip2 = &i; // expected-error{{no type named 'type' in 'struct N::B'}}
 typename N::C::type *ip3 = &i; // expected-error{{typename specifier refers to non-type member 'type'}}
 
 void test(double d) {
@@ -33,7 +33,8 @@ void test(double d) {
 namespace N {
   template<typename T>
   struct X {
-    typedef typename T::type type; // expected-error 2{{no type named 'type' in 'B'}} \
+    typedef typename T::type type; // expected-error {{no type named 'type' in 'struct N::B'}} \
+    // expected-error {{no type named 'type' in 'struct B'}} \
     // FIXME: location info for error above isn't very good \
     // expected-error 2{{typename specifier refers to non-type member 'type'}} \
     // expected-error{{type 'int' cannot be used prior to '::' because it has no members}}
@@ -42,12 +43,12 @@ namespace N {
 
 N::X<N::A>::type *ip4 = &i;
 N::X<N::B>::type *ip5 = &i; // expected-note{{in instantiation of template class 'struct N::X<struct N::B>' requested here}} \
-// expected-error{{unknown type name 'type'}}
+// expected-error{{no type named 'type' in}}
 N::X<N::C>::type *ip6 = &i; // expected-note{{in instantiation of template class 'struct N::X<struct N::C>' requested here}} \
-// expected-error{{unknown type name 'type'}}
+// expected-error{{no type named 'type' in}}
 
 N::X<int>::type fail1; // expected-note{{in instantiation of template class 'struct N::X<int>' requested here}} \
-// expected-error{{unknown type name 'type'}}
+// expected-error{{no type named 'type' in}}
 
 template<typename T>
 struct Y {
@@ -69,6 +70,6 @@ struct C {
 
 ::Y<A>::type ip7 = &i;
 ::Y<B>::type ip8 = &i; // expected-note{{in instantiation of template class 'struct Y<struct B>' requested here}} \
-// expected-error{{unknown type name 'type'}}
+// expected-error{{no type named 'type' in}}
 ::Y<C>::type ip9 = &i; // expected-note{{in instantiation of template class 'struct Y<struct C>' requested here}} \
-// expected-error{{unknown type name 'type'}}
+// expected-error{{no type named 'type' in}}
diff --git a/test/SemaTemplate/value-dependent-null-pointer-constant.cpp b/test/SemaTemplate/value-dependent-null-pointer-constant.cpp
new file mode 100644
index 000000000000..8bde1277edd5
--- /dev/null
+++ b/test/SemaTemplate/value-dependent-null-pointer-constant.cpp
@@ -0,0 +1,29 @@
+// RUN: clang-cc -fsyntax-only %s
+
+template<typename T, int N>
+struct X0 {
+  const char *f0(bool Cond) {
+    return Cond? "honk" : N;
+  }
+
+  const char *f1(bool Cond) {
+    return Cond? N : "honk";
+  }
+  
+  bool f2(const char *str) {
+    return str == N;
+  }
+};
+
+// PR4996
+template<unsigned I> int f0() { 
+  return __builtin_choose_expr(I, 0, 1); 
+}
+
+// PR5041
+struct A { };
+
+template <typename T> void f(T *t)
+{
+  (void)static_cast<void*>(static_cast<A*>(t));
+}
\ No newline at end of file
diff --git a/test/TestRunner.sh b/test/TestRunner.sh
index bb20728578c1..f96d3d552d2e 100755
--- a/test/TestRunner.sh
+++ b/test/TestRunner.sh
@@ -1,134 +1,13 @@
 #!/bin/sh
 #
-#  TestRunner.sh - This script is used to run arbitrary unit tests.  Unit
-#  tests must contain the command used to run them in the input file, starting
-#  immediately after a "RUN:" string.
-#
-#  This runner recognizes and replaces the following strings in the command:
-#
-#     %s - Replaced with the input name of the program, or the program to
-#          execute, as appropriate.
-#     %S - Replaced with the directory where the input file resides
-#     %prcontext - prcontext.tcl script
-#     %t - temporary file name (derived from testcase name)
-#
-
-FILENAME=$1
-TESTNAME=$1
-SUBST=$1
-FILEDIR=`dirname $TESTNAME`
-
-OUTPUT=Output/$1.out
-
-# create the output directory if it does not already exist
-mkdir -p `dirname $OUTPUT` > /dev/null 2>&1
-
-if test $# != 1; then
-  # If more than one parameter is passed in, there must be three parameters:
-  # The filename to read from (already processed), the command used to execute,
-  # and the file to output to.
-  SUBST=$2
-  OUTPUT=$3
-  TESTNAME=$3
-fi
-
-ulimit -t 40
-
-# Verify the script contains a run line.
-grep -q 'RUN:' $FILENAME || ( 
-   echo "******************** TEST '$TESTNAME' HAS NO RUN LINE! ********************"
-   exit 1
-)
-
-# Run under valgrind if the VG environment variable has been set.
-CLANG=$CLANG
-if [ ! -n "$CLANG" ]; then
-    CLANG="clang"
-fi
-
-# Resolve the path, and Make sure $CLANG actually exists; otherwise
-# ensuing failures are non-obvious.
-CLANG=$(which "$CLANG")
-if [ -z $CLANG ]; then
-  echo "Couldn't find 'clang' program, try setting CLANG in your environment"
-  exit 1
-fi
-
-if [ -n "$VG" ]; then
-  rm -f $OUTPUT.vg
-  CLANG="valgrind --leak-check=full --quiet --log-file=$OUTPUT.vg $CLANG"
-fi
-
-# Assuming $CLANG is correct, use it to derive clang-cc. We expect to
-# be looking in a build directory, so just add '-cc'.
-CLANGCC=$CLANGCC
-if [ ! -n "$CLANGCC" ]; then
-    CLANGCC="$CLANG-cc"
-fi
-
-# Try to sanity check $CLANGCC too
-CLANGCC=$(which "$CLANGCC")
-# If that failed, ask clang.
-if [ -z "$CLANGCC" ]; then
-    CLANGCC=$($CLANG -print-prog-name=clang-cc)
-fi
-if [ -z "$CLANGCC" ]; then
-  echo "Couldn't find 'clang-cc' program, make sure clang is found in your build directory"
-  exit 1
-fi
-
-SCRIPT=$OUTPUT.script
-TEMPOUTPUT=$OUTPUT.tmp
-grep 'RUN:' $FILENAME | \
-  sed -e "s|^.*RUN:\(.*\)$|\1|g" \
-      -e "s| clang | $CLANG |g" \
-      -e "s| clang-cc | $CLANGCC |g" \
-      -e "s|%s|$SUBST|g" \
-      -e "s|%S|$FILEDIR|g" \
-      -e "s|%prcontext|prcontext.tcl|g" \
-      -e "s|%t|$TEMPOUTPUT|g" > $SCRIPT
-
-IS_XFAIL=0
-if (grep -q XFAIL $FILENAME); then
-    IS_XFAIL=1
-    printf "XFAILED '$TESTNAME': "
-    grep XFAIL $FILENAME
-fi
-
-/bin/sh $SCRIPT > $OUTPUT 2>&1
-SCRIPT_STATUS=$?
+# TestRunner.sh - Backward compatible utility for testing an individual file.
 
-if [ -n "$VG" ]; then
-  [ ! -s $OUTPUT.vg ]
-  VG_STATUS=$?
-else
-  VG_STATUS=0
-fi
+# Find where this script is.
+Dir=$(dirname $(which $0))
+AbsDir=$(cd $Dir; pwd)
 
-if [ $IS_XFAIL -ne 0 ]; then
-    if [ $SCRIPT_STATUS -ne 0 ]; then
-        SCRIPT_STATUS=0
-    else
-        SCRIPT_STATUS=1
-    fi
-fi
+# Find 'lit', assuming standard layout.
+lit=$AbsDir/../../../utils/lit/lit.py
 
-if [ $SCRIPT_STATUS -ne 0 -o $VG_STATUS -ne 0 ]; then
-  echo "******************** TEST '$TESTNAME' FAILED! ********************"
-  echo "Command: "
-  cat $SCRIPT
-  if [ $SCRIPT_STATUS -eq 0 ]; then
-    echo "Output:"
-  elif [ $IS_XFAIL -ne 0 ]; then
-    echo "Incorrect Output (Expected Failure):"
-  else
-    echo "Incorrect Output:"
-  fi
-  cat $OUTPUT
-  if [ $VG_STATUS -ne 0 ]; then
-    echo "Valgrind Output:"
-    cat $OUTPUT.vg
-  fi
-  echo "******************** TEST '$TESTNAME' FAILED! ********************"
-  exit 1
-fi
+# Dispatch to lit.
+$lit "$@"
diff --git a/test/lit.cfg b/test/lit.cfg
new file mode 100644
index 000000000000..60d8df057730
--- /dev/null
+++ b/test/lit.cfg
@@ -0,0 +1,152 @@
+# -*- Python -*-
+
+import os
+import platform
+
+# Configuration file for the 'lit' test runner.
+
+# name: The name of this test suite.
+config.name = 'Clang'
+
+# testFormat: The test format to use to interpret tests.
+#
+# For now we require '&&' between commands, until they get globally killed and
+# the test runner updated.
+execute_external = platform.system() != 'Windows'
+config.test_format = lit.formats.ShTest(execute_external,
+                                        require_and_and = True)
+
+# suffixes: A list of file extensions to treat as test files.
+config.suffixes = ['.c', '.cpp', '.m', '.mm']
+
+# test_source_root: The root path where tests are located.
+config.test_source_root = os.path.dirname(__file__)
+
+# test_exec_root: The root path where tests should be run.
+clang_obj_root = getattr(config, 'clang_obj_root', None)
+if clang_obj_root is not None:
+    config.test_exec_root = os.path.join(clang_obj_root, 'test')
+
+# Set llvm_{src,obj}_root for use by others.
+config.llvm_src_root = getattr(config, 'llvm_src_root', None)
+config.llvm_obj_root = getattr(config, 'llvm_obj_root', None)
+
+# Tweak the PATH to include the tools dir and the scripts dir.
+if clang_obj_root is not None:
+    llvm_tools_dir = getattr(config, 'llvm_tools_dir', None)
+    if not llvm_tools_dir:
+        lit.fatal('No LLVM tools dir set!')
+    path = os.path.pathsep.join((llvm_tools_dir, config.environment['PATH']))
+    config.environment['PATH'] = path
+
+    llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
+    if not llvm_libs_dir:
+        lit.fatal('No LLVM libs dir set!')
+    path = os.path.pathsep.join((llvm_libs_dir,
+                                 config.environment.get('LD_LIBRARY_PATH','')))
+    config.environment['LD_LIBRARY_PATH'] = path
+
+###
+
+# Check that the object root is known.
+if config.test_exec_root is None:
+    # Otherwise, we haven't loaded the site specific configuration (the user is
+    # probably trying to run on a test file directly, and either the site
+    # configuration hasn't been created by the build system, or we are in an
+    # out-of-tree build situation).
+
+    # Try to detect the situation where we are using an out-of-tree build by
+    # looking for 'llvm-config'.
+    #
+    # FIXME: I debated (i.e., wrote and threw away) adding logic to
+    # automagically generate the lit.site.cfg if we are in some kind of fresh
+    # build situation. This means knowing how to invoke the build system
+    # though, and I decided it was too much magic.
+
+    llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
+    if not llvm_config:
+        lit.fatal('No site specific configuration available!')
+
+    # Get the source and object roots.
+    llvm_src_root = lit.util.capture(['llvm-config', '--src-root']).strip()
+    llvm_obj_root = lit.util.capture(['llvm-config', '--obj-root']).strip()
+    clang_src_root = os.path.join(llvm_src_root, "tools", "clang")
+    clang_obj_root = os.path.join(llvm_obj_root, "tools", "clang")
+
+    # Validate that we got a tree which points to here, using the standard
+    # tools/clang layout.
+    this_src_root = os.path.dirname(config.test_source_root)
+    if os.path.realpath(clang_src_root) != os.path.realpath(this_src_root):
+        lit.fatal('No site specific configuration available!')
+
+    # Check that the site specific configuration exists.
+    site_cfg = os.path.join(clang_obj_root, 'test', 'lit.site.cfg')
+    if not os.path.exists(site_cfg):
+        lit.fatal('No site specific configuration available!')
+
+    # Okay, that worked. Notify the user of the automagic, and reconfigure.
+    lit.note('using out-of-tree build at %r' % clang_obj_root)
+    lit.load_config(config, site_cfg)
+    raise SystemExit
+
+###
+
+# Discover the 'clang' and 'clangcc' to use.
+
+import os
+
+def inferClang(PATH):
+    # Determine which clang to use.
+    clang = os.getenv('CLANG')
+
+    # If the user set clang in the environment, definitely use that and don't
+    # try to validate.
+    if clang:
+        return clang
+
+    # Otherwise look in the path.
+    clang = lit.util.which('clang', PATH)
+
+    if not clang:
+        lit.fatal("couldn't find 'clang' program, try setting "
+                  "CLANG in your environment")
+
+    return clang
+
+def inferClangCC(clang, PATH):
+    clangcc = os.getenv('CLANGCC')
+
+    # If the user set clang in the environment, definitely use that and don't
+    # try to validate.
+    if clangcc:
+        return clangcc
+
+    # Otherwise try adding -cc since we expect to be looking in a build
+    # directory.
+    if clang.endswith('.exe'):
+        clangccName = clang[:-4] + '-cc.exe'
+    else:
+        clangccName = clang + '-cc'
+    clangcc = lit.util.which(clangccName, PATH)
+    if not clangcc:
+        # Otherwise ask clang.
+        res = lit.util.capture([clang, '-print-prog-name=clang-cc'])
+        res = res.strip()
+        if res and os.path.exists(res):
+            clangcc = res
+
+    if not clangcc:
+        lit.fatal("couldn't find 'clang-cc' program, try setting "
+                  "CLANGCC in your environment")
+
+    return clangcc
+
+config.clang = inferClang(config.environment['PATH'])
+if not lit.quiet:
+    lit.note('using clang: %r' % config.clang)
+config.substitutions.append( (' clang ', ' ' + config.clang + ' ') )
+
+config.clang_cc = inferClangCC(config.clang, config.environment['PATH'])
+if not lit.quiet:
+    lit.note('using clang-cc: %r' % config.clang_cc)
+config.substitutions.append( (' clang-cc ', ' ' + config.clang_cc + ' ') )
diff --git a/test/lit.site.cfg.in b/test/lit.site.cfg.in
new file mode 100644
index 000000000000..9dabafcde1f4
--- /dev/null
+++ b/test/lit.site.cfg.in
@@ -0,0 +1,10 @@
+## Autogenerated by LLVM/Clang configuration.
+# Do not edit!
+config.llvm_src_root = "@LLVM_SOURCE_DIR@"
+config.llvm_obj_root = "@LLVM_BINARY_DIR@"
+config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
+config.llvm_libs_dir = "@LLVM_LIBS_DIR@"
+config.clang_obj_root = "@CLANG_BINARY_DIR@"
+
+# Let the main config do the real work.
+lit.load_config(config, "@CLANG_SOURCE_DIR@/test/lit.cfg")