Import Clang, at r72732.

190 files changed, 5206 insertions, 0 deletions

diff --git a/test/CodeGen/2007-11-29-ArraySizeFromInitializer.c b/test/CodeGen/2007-11-29-ArraySizeFromInitializer.c
new file mode 100644
index 0000000..3b15824
--- /dev/null
+++ b/test/CodeGen/2007-11-29-ArraySizeFromInitializer.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+int array[] = {1, 2, 3, 4, 5};
+
diff --git a/test/CodeGen/2008-02-07-bitfield-bug.c b/test/CodeGen/2008-02-07-bitfield-bug.c
new file mode 100644
index 0000000..dc2ebb7
--- /dev/null
+++ b/test/CodeGen/2008-02-07-bitfield-bug.c
@@ -0,0 +1,11 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+// PR1990
+
+struct test {
+  char a[3];
+  unsigned char b:1;
+};
+
+void f(struct test *t) {
+  t->b = 1;
+}
diff --git a/test/CodeGen/2008-02-08-bitfield-bug.c b/test/CodeGen/2008-02-08-bitfield-bug.c
new file mode 100644
index 0000000..fc69e58
--- /dev/null
+++ b/test/CodeGen/2008-02-08-bitfield-bug.c
@@ -0,0 +1,9 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+
+struct test {
+  unsigned a:1;
+  unsigned b:1;
+};
+
+struct test *t;
+
diff --git a/test/CodeGen/2008-02-26-inline-asm-bug.c b/test/CodeGen/2008-02-26-inline-asm-bug.c
new file mode 100644
index 0000000..a6816f5
--- /dev/null
+++ b/test/CodeGen/2008-02-26-inline-asm-bug.c
@@ -0,0 +1,6 @@
+// RUN: clang-cc -emit-llvm < %s | grep "\$0,\$1"
+
+void f() {
+  int d1, d2;
+  asm("%0,%1": "=r" (d1) : "r" (d2));
+}
diff --git a/test/CodeGen/2008-07-17-no-emit-on-error.c b/test/CodeGen/2008-07-17-no-emit-on-error.c
new file mode 100644
index 0000000..89aeb18
--- /dev/null
+++ b/test/CodeGen/2008-07-17-no-emit-on-error.c
@@ -0,0 +1,10 @@
+// RUN: rm -f %t1.bc 
+// RUN: not clang-cc %s -emit-llvm-bc -o %t1.bc
+// RUN: not test -f %t1.bc
+
+void f() {
+}
+
+void g() {
+  *10;
+}
diff --git a/test/CodeGen/2008-07-21-mixed-var-fn-decl.c b/test/CodeGen/2008-07-21-mixed-var-fn-decl.c
new file mode 100644
index 0000000..c55c86b
--- /dev/null
+++ b/test/CodeGen/2008-07-21-mixed-var-fn-decl.c
@@ -0,0 +1,5 @@
+// RUN: clang-cc -emit-llvm -o - %s | grep -e "@g[0-9] " | count 2
+
+int g0, f0();
+int f1(), g1;
+
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
new file mode 100644
index 0000000..19bf9a2
--- /dev/null
+++ b/test/CodeGen/2008-07-22-bitfield-init-after-zero-len-array.c
@@ -0,0 +1,11 @@
+// RUN: clang-cc --emit-llvm -o %t %s &&
+// RUN: grep "i8 52" %t | count 1
+
+struct et7 {
+  float lv7[0];
+  char mv7:6;
+} yv7 = {
+  {}, 
+  52, 
+};
+
diff --git a/test/CodeGen/2008-07-22-packed-bitfield-access.c b/test/CodeGen/2008-07-22-packed-bitfield-access.c
new file mode 100644
index 0000000..437a4be
--- /dev/null
+++ b/test/CodeGen/2008-07-22-packed-bitfield-access.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc %s -emit-llvm -o -
+
+int main () {
+  struct foo {
+    unsigned a:16;
+    unsigned b:32 __attribute__ ((packed));
+  } x;
+  x.b = 0x56789abcL;
+  return 0;
+}
diff --git a/test/CodeGen/2008-07-29-override-alias-decl.c b/test/CodeGen/2008-07-29-override-alias-decl.c
new file mode 100644
index 0000000..43f4e3e
--- /dev/null
+++ b/test/CodeGen/2008-07-29-override-alias-decl.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc -emit-llvm -o - %s | grep -e "^@f" | count 1
+
+int x() {}
+
+int f() __attribute__((weak, alias("x")));
+
+/* Test that we link to the alias correctly instead of making a new
+   forward definition. */
+int f();
+int h() {
+  return f();
+}
diff --git a/test/CodeGen/2008-07-30-implicit-initialization.c b/test/CodeGen/2008-07-30-implicit-initialization.c
new file mode 100644
index 0000000..2f4c14e
--- /dev/null
+++ b/test/CodeGen/2008-07-30-implicit-initialization.c
@@ -0,0 +1,28 @@
+// RUN: clang-cc -triple i386-unknown-unknown --emit-llvm-bc -o - %s | opt --std-compile-opts | llvm-dis > %t &&
+// RUN: grep "ret i32" %t | count 2 &&
+// RUN: grep "ret i32 0" %t | count 2
+// <rdar://problem/6113085>
+
+struct s0 {
+  int x, y;
+};
+
+int f0() {
+  struct s0 x = {0};
+  return x.y;
+}
+
+#if 0
+/* Optimizer isn't smart enough to reduce this since we use
+   memset. Hrm. */
+int f1() {
+  struct s0 x[2] = { {0} };
+  return x[1].x;
+}
+#endif
+
+int f2() {
+  int x[2] = { 0 };
+  return x[1];
+}
+
diff --git a/test/CodeGen/2008-07-30-redef-of-bitcasted-decl.c b/test/CodeGen/2008-07-30-redef-of-bitcasted-decl.c
new file mode 100644
index 0000000..c374f8d
--- /dev/null
+++ b/test/CodeGen/2008-07-30-redef-of-bitcasted-decl.c
@@ -0,0 +1,28 @@
+// RUN: clang-cc --emit-llvm -o - %s
+// <rdar://problem/6108358>
+
+/* For posterity, the issue here begins initial "char []" decl for
+ * s. This is a tentative definition and so a global was being
+ * emitted, however the mapping in GlobalDeclMap referred to a bitcast
+ * of this global.
+ *
+ * The problem was that later when the correct definition for s is
+ * emitted we were doing a RAUW on the old global which was destroying
+ * the bitcast in the GlobalDeclMap (since it cannot be replaced
+ * properly), leaving a dangling pointer.
+ *
+ * The purpose of bar is just to trigger a use of the old decl
+ * sometime after the dangling pointer has been introduced.
+ */
+
+char s[];
+
+static void bar(void *db) {
+  eek(s);
+}
+
+char s[5] = "hi";
+
+int foo() {
+  bar(0);
+}
diff --git a/test/CodeGen/2008-07-31-asm-labels.c b/test/CodeGen/2008-07-31-asm-labels.c
new file mode 100644
index 0000000..f114f65
--- /dev/null
+++ b/test/CodeGen/2008-07-31-asm-labels.c
@@ -0,0 +1,33 @@
+// RUN: clang-cc -emit-llvm -o %t %s &&
+// RUN: grep "@pipe()" %t | count 0 &&
+// RUN: grep '_thisIsNotAPipe' %t | count 3 &&
+// RUN: grep 'g0' %t | count 0 &&
+// RUN: grep '_renamed' %t | count 2 &&
+// RUN: clang-cc -DUSE_DEF -emit-llvm -o %t %s &&
+// RUN: grep "@pipe()" %t | count 0 &&
+// RUN: grep '_thisIsNotAPipe' %t | count 3
+// <rdr://6116729>
+
+void pipe() asm("_thisIsNotAPipe");
+
+void f0() {
+  pipe();
+}
+
+void pipe(int);
+
+void f1() {
+  pipe(1);
+}
+
+#ifdef USE_DEF
+void pipe(int arg) {
+  int x = 10;
+}
+#endif
+
+// PR3698
+extern int g0 asm("_renamed");
+int f2() {
+  return g0;
+}
diff --git a/test/CodeGen/2008-07-31-promotion-of-compound-pointer-arithmetic.c b/test/CodeGen/2008-07-31-promotion-of-compound-pointer-arithmetic.c
new file mode 100644
index 0000000..0ce4ba6
--- /dev/null
+++ b/test/CodeGen/2008-07-31-promotion-of-compound-pointer-arithmetic.c
@@ -0,0 +1,25 @@
+// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm-bc -o - %s | opt -std-compile-opts | llvm-dis | grep "ret i32 1" | count 3
+// <rdr://6115726>
+
+int f0() {
+  int x;
+  unsigned short n = 1;
+  int *a = &x;
+  int *b = &x;
+  a = a - n;
+  b -= n;
+  return a == b;
+}
+
+int f1(int *a) {
+  long b = a - (int*) 1;
+  a -= (int*) 1;
+  return b == (long) a;
+}
+
+int f2(long n) {
+  int *b = n + (int*) 1;
+  n += (int*) 1;
+  return b == (int*) n;
+}
+
diff --git a/test/CodeGen/2008-08-04-void-pointer-arithmetic.c b/test/CodeGen/2008-08-04-void-pointer-arithmetic.c
new file mode 100644
index 0000000..22815f3
--- /dev/null
+++ b/test/CodeGen/2008-08-04-void-pointer-arithmetic.c
@@ -0,0 +1,6 @@
+// RUN: clang-cc --emit-llvm -o - %s
+// <rdar://problem/6122967>
+
+int f0(void *a, void *b) {
+  return a - b;
+}
diff --git a/test/CodeGen/2008-08-19-cast-of-typedef.c b/test/CodeGen/2008-08-19-cast-of-typedef.c
new file mode 100644
index 0000000..3db5e90
--- /dev/null
+++ b/test/CodeGen/2008-08-19-cast-of-typedef.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc --emit-llvm -o %t %s
+
+typedef short T[4];
+struct s {
+  T f0;
+};
+
+void foo(struct s *x) {
+  bar((long) x->f0);
+}
diff --git a/test/CodeGen/2008-08-25-incompatible-cond-expr.m b/test/CodeGen/2008-08-25-incompatible-cond-expr.m
new file mode 100644
index 0000000..3cc42d8
--- /dev/null
+++ b/test/CodeGen/2008-08-25-incompatible-cond-expr.m
@@ -0,0 +1,10 @@
+// RUN: clang-cc -emit-llvm -o %t %s
+
+@protocol P0
+@end
+@interface A <P0>
+@end
+
+id f0(int a, id<P0> x, A* p) {
+  return a ? x : p;
+}
diff --git a/test/CodeGen/2008-09-22-bad-switch-type.c b/test/CodeGen/2008-09-22-bad-switch-type.c
new file mode 100644
index 0000000..2526dd9
--- /dev/null
+++ b/test/CodeGen/2008-09-22-bad-switch-type.c
@@ -0,0 +1,34 @@
+// RUN: clang-cc -emit-llvm -o %t %s
+// PR2817
+
+void f0(void) {
+  switch (0) {
+  case (unsigned long long) 0 < 0: 
+    break;
+  }
+
+  switch (0) {
+  case (unsigned long long) 0 > 0: 
+    break;
+  }
+
+  switch (0) {
+  case (unsigned long long) 0 <= 0: 
+    break;
+  }
+
+  switch (0) {
+  case (unsigned long long) 0 >= 0: 
+    break;
+  }
+
+  switch (0) {
+  case (unsigned long long) 0 == 0: 
+    break;
+  }
+
+  switch (0) {
+  case (unsigned long long) 0 != 0: 
+    break;
+  }
+}
diff --git a/test/CodeGen/2008-12-02-logical-or-fold.c b/test/CodeGen/2008-12-02-logical-or-fold.c
new file mode 100644
index 0000000..d54bf28
--- /dev/null
+++ b/test/CodeGen/2008-12-02-logical-or-fold.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc -emit-llvm -o - %s | grep "store i32 1"
+// PR3150
+
+int a() {return 1||1;}
diff --git a/test/CodeGen/2009-01-21-invalid-debug-info.m b/test/CodeGen/2009-01-21-invalid-debug-info.m
new file mode 100644
index 0000000..9a955a1
--- /dev/null
+++ b/test/CodeGen/2009-01-21-invalid-debug-info.m
@@ -0,0 +1,16 @@
+// RUN: clang-cc -S -g -o %t.s %s
+
+// FIXME: This test case can be removed at some point (since it will
+// no longer effectively test anything). The reason it was causing
+// trouble was the synthesized self decl in im1 was causing the debug
+// info for I1* to be generated, but referring to an invalid compile
+// unit. This was later referred to by f1 and created ill formed debug
+// information.
+
+@interface I1 @end
+
+@implementation I1
+-im0 {}
+@end
+
+I1 *f1(void) { return 0; }
diff --git a/test/CodeGen/2009-03-22-increment-bitfield.c b/test/CodeGen/2009-03-22-increment-bitfield.c
new file mode 100644
index 0000000..f0aaafd
--- /dev/null
+++ b/test/CodeGen/2009-03-22-increment-bitfield.c
@@ -0,0 +1,7 @@
+// RUN: clang-cc -emit-llvm -O1 < %s | grep "ret i32 0"
+
+int a(void) {
+  return ++(struct x {unsigned x : 2;}){3}.x;
+}
+
+
diff --git a/test/CodeGen/2009-04-23-dbg.c b/test/CodeGen/2009-04-23-dbg.c
new file mode 100644
index 0000000..4be6dab
--- /dev/null
+++ b/test/CodeGen/2009-04-23-dbg.c
@@ -0,0 +1,20 @@
+// RUN: clang-cc -g -o %t  %s -emit-llvm-bc && llc %t -f -o %t.s
+# 1 "a.c"
+# 1 "a.c" 1
+# 1 "<built-in>" 1
+# 103 "<built-in>"
+# 103 "<command line>" 1
+
+# 1 "/private/tmp/a.h" 1
+int bar;
+# 105 "<command line>" 2
+# 105 "<built-in>" 2
+# 1 "a.c" 2
+# 1 "/private/tmp/a.h" 1
+int bar;
+# 2 "a.c" 2
+
+int main() {
+ bar = 0;
+ return 0;
+}
diff --git a/test/CodeGen/2009-05-22-callingconv.c b/test/CodeGen/2009-05-22-callingconv.c
new file mode 100644
index 0000000..2b70d84
--- /dev/null
+++ b/test/CodeGen/2009-05-22-callingconv.c
@@ -0,0 +1,25 @@
+// RUN: clang-cc %s -emit-llvm -o - | grep call | grep x86_stdcallcc
+void abort(void) __attribute__((__noreturn__));
+typedef void re_string_t;
+typedef void re_dfa_t;
+typedef int reg_errcode_t;
+static reg_errcode_t re_string_construct (re_string_t *pstr, const char *str,
+       int len, char * trans,
+       int icase, const re_dfa_t *dfa)
+     __attribute__ ((regparm (3), stdcall));
+static reg_errcode_t
+re_string_construct (pstr, str, len, trans, icase, dfa)
+     re_string_t *pstr;
+     const char *str;
+     int len, icase;
+     char * trans;
+     const re_dfa_t *dfa;
+{
+        if (dfa != (void*)0x282020c0)
+                abort();
+return 0;
+}
+int main()
+{
+  return re_string_construct(0, 0, 0, 0, 0, (void*)0x282020c0);
+}
diff --git a/test/CodeGen/2009-05-28-const-typedef.c b/test/CodeGen/2009-05-28-const-typedef.c
new file mode 100644
index 0000000..e46e83b
--- /dev/null
+++ b/test/CodeGen/2009-05-28-const-typedef.c
@@ -0,0 +1,17 @@
+// RUN: clang-cc -emit-llvm %s -o -
+// PR4281
+
+typedef struct {
+        int i;
+} something;
+
+typedef const something const_something;
+
+something fail(void);
+
+int
+main(int argc, char *argv[])
+{
+        const_something R = fail();
+}
+
diff --git a/test/CodeGen/2009-06-01-addrofknr.c b/test/CodeGen/2009-06-01-addrofknr.c
new file mode 100644
index 0000000..16a5bbf
--- /dev/null
+++ b/test/CodeGen/2009-06-01-addrofknr.c
@@ -0,0 +1,21 @@
+// RUN: clang-cc %s -o %t -emit-llvm -verify
+// PR4289
+
+struct funcptr {
+    int (*func)();
+};
+
+static int func(f)
+        void *f;
+{
+}
+
+int
+main(int argc, char *argv[])
+{
+        struct funcptr fp;
+
+        fp.func = &func;
+        fp.func = func;
+}
+
diff --git a/test/CodeGen/OpaqueStruct.c b/test/CodeGen/OpaqueStruct.c
new file mode 100644
index 0000000..b994c30
--- /dev/null
+++ b/test/CodeGen/OpaqueStruct.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+typedef struct a b;
+
+b* x;
+
+struct a {
+  b* p;
+};
+
+void f() {
+  b* z = x->p;
+}
diff --git a/test/CodeGen/PR2001-bitfield-reload.c b/test/CodeGen/PR2001-bitfield-reload.c
new file mode 100644
index 0000000..797b494
--- /dev/null
+++ b/test/CodeGen/PR2001-bitfield-reload.c
@@ -0,0 +1,17 @@
+// RUN: clang-cc -triple i386-unknown-unknown --emit-llvm-bc -o - %s | opt --std-compile-opts | llvm-dis > %t &&
+// RUN: grep "ret i32" %t | count 1 &&
+// RUN: grep "ret i32 1" %t | count 1
+// PR2001
+
+/* Test that the result of the assignment properly uses the value *in
+   the bitfield* as opposed to the RHS. */
+static int foo(int i) {
+  struct {
+    int f0 : 2;
+  } x;
+  return (x.f0 = i);
+}
+
+int bar() {
+  return foo(-5) == -1;
+}
diff --git a/test/CodeGen/PR2413-void-address-cast-error.c b/test/CodeGen/PR2413-void-address-cast-error.c
new file mode 100644
index 0000000..95a4c6d
--- /dev/null
+++ b/test/CodeGen/PR2413-void-address-cast-error.c
@@ -0,0 +1,6 @@
+// RUN: clang-cc -emit-llvm %s -o -
+void f()
+{
+        void *addr;
+        addr = (void *)( ((long int)addr + 7L) );
+}
diff --git a/test/CodeGen/PR2643-null-store-to-bitfield.c b/test/CodeGen/PR2643-null-store-to-bitfield.c
new file mode 100644
index 0000000..6a5b0e9
--- /dev/null
+++ b/test/CodeGen/PR2643-null-store-to-bitfield.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc -emit-llvm -o - %s
+// PR2643
+
+void foo() {
+  struct {
+    int a : 1;
+    int b : 1;
+  } entry = {0};
+}
+
diff --git a/test/CodeGen/PR2743-reference-missing-static.c b/test/CodeGen/PR2743-reference-missing-static.c
new file mode 100644
index 0000000..e152c52
--- /dev/null
+++ b/test/CodeGen/PR2743-reference-missing-static.c
@@ -0,0 +1,16 @@
+// RUN: clang-cc -emit-llvm -o %t %s
+// PR2743
+// <rdr://6094512>
+
+/* CodeGen should handle this even if it makes it past
+   sema. Unfortunately this test will become useless once sema starts
+   rejecting this. */
+
+static void e0();
+void f0() { e0(); }
+
+inline void e1();
+void f1() { e1(); }
+
+void e2() __attribute__((weak));
+void f2() { e2(); }
diff --git a/test/CodeGen/PR3130-cond-constant.c b/test/CodeGen/PR3130-cond-constant.c
new file mode 100644
index 0000000..e488eeb
--- /dev/null
+++ b/test/CodeGen/PR3130-cond-constant.c
@@ -0,0 +1,3 @@
+// RUN: clang-cc -emit-llvm %s -o -
+
+int a = 2.0 ? 1 : 2;
diff --git a/test/CodeGen/PR3589-freestanding-libcalls.c b/test/CodeGen/PR3589-freestanding-libcalls.c
new file mode 100644
index 0000000..90b5fff
--- /dev/null
+++ b/test/CodeGen/PR3589-freestanding-libcalls.c
@@ -0,0 +1,9 @@
+// RUN: clang-cc -emit-llvm %s -o - | grep 'declare i32 @printf' | count 1 &&
+// RUN: clang-cc -O2 -emit-llvm %s -o - | grep 'declare i32 @puts' | count 1 &&
+// RUN: clang-cc -ffreestanding -O2 -emit-llvm %s -o - | grep 'declare i32 @puts' | count 0
+
+#include <stdio.h>
+
+void f0() {
+  printf("hello\n");
+}
diff --git a/test/CodeGen/PR3613-static-decl.c b/test/CodeGen/PR3613-static-decl.c
new file mode 100644
index 0000000..365b9b2
--- /dev/null
+++ b/test/CodeGen/PR3613-static-decl.c
@@ -0,0 +1,16 @@
+// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm -o %t %s &&
+// RUN: grep '@g0 = internal global .struct.s0 <{ i32 3 }>' %t | count 1
+
+struct s0 {
+  int a;
+};
+
+static struct s0 g0;
+
+static int f0(void) {
+  return g0.a;
+}
+
+static struct s0 g0 = {3};
+
+void *g1 = f0;
diff --git a/test/CodeGen/PR3709-int-to-pointer-sign.c b/test/CodeGen/PR3709-int-to-pointer-sign.c
new file mode 100644
index 0000000..24c42f6
--- /dev/null
+++ b/test/CodeGen/PR3709-int-to-pointer-sign.c
@@ -0,0 +1,5 @@
+// RUN: clang-cc -emit-llvm %s -o - -O1 -triple=x86_64-gnu-linux | grep "i64 -1"
+
+// PR3709
+long long a() { return (long long)(int*)-1;}
+
diff --git a/test/CodeGen/PR3869-indirect-goto-long.c b/test/CodeGen/PR3869-indirect-goto-long.c
new file mode 100644
index 0000000..140e4ec
--- /dev/null
+++ b/test/CodeGen/PR3869-indirect-goto-long.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc -emit-llvm-bc -o - %s
+// PR3869
+int a(long long b) { goto *b; }
+
diff --git a/test/CodeGen/address-space-cast.c b/test/CodeGen/address-space-cast.c
new file mode 100644
index 0000000..2fba5ec
--- /dev/null
+++ b/test/CodeGen/address-space-cast.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc -emit-llvm < %s
+
+volatile unsigned char* const __attribute__((address_space(1))) serial_ctrl = 0x02;
+
diff --git a/test/CodeGen/address-space.c b/test/CodeGen/address-space.c
new file mode 100644
index 0000000..3b6a8e6
--- /dev/null
+++ b/test/CodeGen/address-space.c
@@ -0,0 +1,20 @@
+// RUN: clang-cc -emit-llvm < %s | grep '@foo.*global.*addrspace(1)' &&
+// RUN: clang-cc -emit-llvm < %s | grep '@ban.*global.*addrspace(1)' &&
+// RUN: clang-cc -emit-llvm < %s | grep 'load.*addrspace(1)' | count 2 &&
+// RUN: clang-cc -emit-llvm < %s | grep 'load.*addrspace(2).. @A' &&
+// RUN: clang-cc -emit-llvm < %s | grep 'load.*addrspace(2).. @B'
+
+int foo __attribute__((address_space(1)));
+int ban[10] __attribute__((address_space(1)));
+
+int bar() { return foo; }
+
+int baz(int i) { return ban[i]; }
+
+// Both A and B point into addrspace(2).
+__attribute__((address_space(2))) int *A, *B;
+
+void test3() {
+  *A = *B;
+}
+
diff --git a/test/CodeGen/alias.c b/test/CodeGen/alias.c
new file mode 100644
index 0000000..b0c71fb
--- /dev/null
+++ b/test/CodeGen/alias.c
@@ -0,0 +1,32 @@
+// RUN: clang-cc -triple i386-pc-linux-gnu -emit-llvm -o %t %s &&
+// RUN: grep '@g0 = common global i32 0' %t &&
+// RUN: grep '@f1 = alias void ()\* @f0' %t &&
+// RUN: grep '@g1 = alias i32\* @g0' %t &&
+// RUN: grep 'define void @f0() nounwind {' %t &&
+
+void f0(void) { }
+extern void f1(void);
+extern void f1(void) __attribute((alias("f0")));
+
+int g0;
+extern int g1;
+extern int g1 __attribute((alias("g0")));
+
+// Make sure that aliases cause referenced values to be emitted.
+// PR3200
+// RUN: grep 'define internal i32 @foo1()' %t &&
+static inline int foo1() { return 0; }
+int foo() __attribute__((alias("foo1")));
+
+
+// RUN: grep '@bar1 = internal global i32 42' %t
+static int bar1 = 42;
+int bar() __attribute__((alias("bar1")));
+
+
+extern int test6();
+void test7() { test6(); }  // test6 is emitted as extern.
+
+// test6 changes to alias.
+int test6() __attribute__((alias("test7")));
+
diff --git a/test/CodeGen/align-local.c b/test/CodeGen/align-local.c
new file mode 100644
index 0000000..afbe1d5
--- /dev/null
+++ b/test/CodeGen/align-local.c
@@ -0,0 +1,8 @@
+// RUN: clang-cc -emit-llvm < %s | grep "align 16" | count 2
+
+typedef struct __attribute((aligned(16))) {int x[4];} ff;
+
+int a() {
+  ff a;
+  struct {int x[4];} b __attribute((aligned(16)));
+}
diff --git a/test/CodeGen/alignof.c b/test/CodeGen/alignof.c
new file mode 100644
index 0000000..d39f4e4
--- /dev/null
+++ b/test/CodeGen/alignof.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc -triple i386-unknown-unknown -O1 -emit-llvm -o %t %s &&
+// RUN: grep 'ret i32 4' %t
+
+enum e0 { E0 };
+struct s0 {
+  enum e0         a:31;
+};
+
+struct s0 t1_tmp;
+int f0() {
+  return __alignof__(t1_tmp);
+}
diff --git a/test/CodeGen/array.c b/test/CodeGen/array.c
new file mode 100644
index 0000000..5bcc26e
--- /dev/null
+++ b/test/CodeGen/array.c
@@ -0,0 +1,14 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+int f() {
+ int a[2];
+ a[0] = 0;
+}
+
+int f2() {
+  int x = 0;
+  int y = 1;
+  int a[10] = { y, x, 2, 3};
+  int b[10] = { 2,4,x,6,y,8};
+  int c[5] = { 0,1,2,3};
+}
diff --git a/test/CodeGen/asm-2.c b/test/CodeGen/asm-2.c
new file mode 100644
index 0000000..f5b378e
--- /dev/null
+++ b/test/CodeGen/asm-2.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc -emit-llvm %s -o %t -triple i386-pc-linux-gnu -O2 &&
+// RUN: not grep "load" %t
+
+// <rdar://problem/6841383>
+int cpuid(unsigned data) {
+  int a, b;
+  
+  asm("xyz" :"=a"(a), "=d"(b) : "a"(data));
+  return a + b;
+}
diff --git a/test/CodeGen/asm.c b/test/CodeGen/asm.c
new file mode 100644
index 0000000..58373fc
--- /dev/null
+++ b/test/CodeGen/asm.c
@@ -0,0 +1,103 @@
+// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm %s -o %t &&
+void t1(int len) {
+  __asm__ volatile("" : "=&r"(len), "+&r"(len));
+}
+
+void t2(unsigned long long t)  {
+  __asm__ volatile("" : "+m"(t));
+}
+
+void t3(unsigned char *src, unsigned long long temp) {
+  __asm__ volatile("" : "+m"(temp), "+r"(src));
+}
+
+void t4() {
+  unsigned long long a;
+  struct reg { unsigned long long a, b; } b;
+
+	__asm__ volatile ("":: "m"(a), "m"(b));
+}
+
+// PR3417
+void t5(int i) {
+  asm("nop" : "=r"(i) : "0"(t5));
+}
+
+// PR3641
+void t6(void) {
+  __asm__ volatile("" : : "i" (t6));
+}
+
+// RUN: grep "T7 NAMED: \$1" %t &&
+void t7(int a) {
+  __asm__ volatile("T7 NAMED: %[input]" : "+r"(a): [input] "i" (4));
+}
+
+// RUN: grep "T8 NAMED MODIFIER: \${0:c}" %t
+void t8() {
+  __asm__ volatile("T8 NAMED MODIFIER: %c[input]" :: [input] "i" (4));
+}
+
+// PR3682
+unsigned t9(unsigned int a) {
+  asm("bswap %0 %1" : "+r" (a));
+  return a;
+}
+
+// PR3908
+// RUN: grep "PR3908 \$1 \$3 \$2 \$0" %t
+void t10(int r) {
+  __asm__("PR3908 %[lf] %[xx] %[li] %[r]" : [r] "+r" (r) : [lf] "mx" (0), [li] "mr" (0), [xx] "x" ((double)(0)));
+}         
+
+
+// PR3373
+unsigned t11(signed char input) {
+  unsigned  output;
+  __asm__("xyz"
+          : "=a" (output)
+          : "0" (input));
+  return output;
+}
+
+// PR3373
+unsigned char t12(unsigned input) {
+  unsigned char output;
+  __asm__("xyz"
+          : "=a" (output)
+          : "0" (input));
+  return output;
+}
+
+unsigned char t13(unsigned input) {
+  unsigned char output;
+  __asm__("xyz %1"
+          : "=a" (output)
+          : "0" (input));
+  return output;
+}
+
+struct large {
+  int x[1000];
+};
+
+unsigned long t15(int x, struct large *P) {
+  __asm__("xyz "
+          : "=r" (x)
+          : "m" (*P), "0" (x));
+  return x;
+}
+
+
+
+
+// bitfield destination of an asm.
+struct S {
+  int a : 4;
+};
+
+void t14(struct S *P) {
+  __asm__("abc %0" : "=r"(P->a) );
+}
+
+
diff --git a/test/CodeGen/atomic.c b/test/CodeGen/atomic.c
new file mode 100644
index 0000000..66dc702
--- /dev/null
+++ b/test/CodeGen/atomic.c
@@ -0,0 +1,53 @@
+// RUN: clang-cc %s -emit-llvm -o - -triple=i686-apple-darwin9 > %t1 &&
+// RUN: grep @llvm.atomic.load.add.i32 %t1 | count 3 &&
+// RUN: grep @llvm.atomic.load.sub.i8 %t1 | count 2 &&
+// RUN: grep @llvm.atomic.load.min.i32 %t1 &&
+// RUN: grep @llvm.atomic.load.max.i32 %t1 &&
+// RUN: grep @llvm.atomic.load.umin.i32 %t1 &&
+// RUN: grep @llvm.atomic.load.umax.i32 %t1 &&
+// RUN: grep @llvm.atomic.swap.i32 %t1 &&
+// RUN: grep @llvm.atomic.cmp.swap.i32 %t1 | count 4 &&
+// RUN: grep @llvm.atomic.load.and.i32 %t1 | count 2 &&
+// RUN: grep @llvm.atomic.load.or.i8 %t1  &&
+// RUN: grep @llvm.atomic.load.xor.i8 %t1
+
+
+int atomic(void)
+{
+  // non-sensical test for sync functions
+  int old;
+  int val = 1;
+  char valc = 1;
+  unsigned int uval = 1;
+  int cmp = 0;
+
+  old = __sync_fetch_and_add(&val, 1);
+  old = __sync_fetch_and_sub(&valc, 2);
+  old = __sync_fetch_and_min(&val, 3);
+  old = __sync_fetch_and_max(&val, 4);
+  old = __sync_fetch_and_umin(&uval, 5u);
+  old = __sync_fetch_and_umax(&uval, 6u);
+  old = __sync_lock_test_and_set(&val, 7);
+  old = __sync_val_compare_and_swap(&val, 4, 1976);
+  old = __sync_bool_compare_and_swap(&val, 4, 1976);
+  old = __sync_fetch_and_and(&val, 0x9);
+  old = __sync_fetch_and_or(&val, 0xa);
+  old = __sync_fetch_and_xor(&val, 0xb);
+  old = __sync_fetch_and_nand(&val, 0xb);
+
+  old = __sync_add_and_fetch(&val, 1);
+  old = __sync_sub_and_fetch(&val, 2);
+  old = __sync_and_and_fetch(&valc, 3);
+  old = __sync_or_and_fetch(&valc, 4);
+  old = __sync_xor_and_fetch(&valc, 5);
+  old = __sync_nand_and_fetch(&valc, 5);
+
+  
+  __sync_val_compare_and_swap((void **)0, (void *)0, (void *)0);
+
+  
+  __sync_lock_release(&val);
+  __sync_synchronize ();
+
+  return old;
+}
diff --git a/test/CodeGen/attr-cleanup.c b/test/CodeGen/attr-cleanup.c
new file mode 100644
index 0000000..03dde33
--- /dev/null
+++ b/test/CodeGen/attr-cleanup.c
@@ -0,0 +1,8 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+// <rdar://problem/6827047>
+void f(void* arg);
+void g() {
+	__attribute__((cleanup(f))) void *g;
+}
+
diff --git a/test/CodeGen/attr-nodebug.c b/test/CodeGen/attr-nodebug.c
new file mode 100644
index 0000000..b96ad26
--- /dev/null
+++ b/test/CodeGen/attr-nodebug.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc -g -emit-llvm -o %t %s &&
+// RUN: not grep 'call void @llvm.dbg.func.start' %t
+
+void t1() __attribute__((nodebug));
+
+void t1()
+{
+  int a = 10;
+  
+  a++;
+}
+
diff --git a/test/CodeGen/attr-noinline.c b/test/CodeGen/attr-noinline.c
new file mode 100644
index 0000000..199c291
--- /dev/null
+++ b/test/CodeGen/attr-noinline.c
@@ -0,0 +1,9 @@
+// RUN: clang-cc -g -emit-llvm -o %t %s &&
+// RUN: grep 'noinline' %t
+
+void t1() __attribute__((noinline));
+
+void t1()
+{
+}
+
diff --git a/test/CodeGen/attr-used.c b/test/CodeGen/attr-used.c
new file mode 100644
index 0000000..8521ffd
--- /dev/null
+++ b/test/CodeGen/attr-used.c
@@ -0,0 +1,14 @@
+// RUN: clang-cc -emit-llvm -o %t %s &&
+// RUN: grep '@llvm.used = .*@g0' %t &&
+// RUN: grep '@llvm.used = .*@f0' %t &&
+// RUN: grep '@llvm.used = .*@f1.l0' %t
+
+
+int g0 __attribute__((used));
+
+static void __attribute__((used)) f0(void) {
+}
+
+void f1() { 
+  static int l0 __attribute__((used)) = 5225; 
+}
diff --git a/test/CodeGen/attributes.c b/test/CodeGen/attributes.c
new file mode 100644
index 0000000..d45d512
--- /dev/null
+++ b/test/CodeGen/attributes.c
@@ -0,0 +1,59 @@
+// 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
+
+void t1() __attribute__((noreturn));
+void t1() {}
+
+void t2() __attribute__((nothrow));
+void t2() {}
+
+void t3() __attribute__((weak));
+void t3() {}
+
+void t4() __attribute__((visibility("hidden")));
+void t4() {}
+
+int t5 __attribute__((weak)) = 2;
+
+int t6 __attribute__((visibility("protected")));
+
+void t7() __attribute__((noreturn, nothrow));
+void t7() {}
+
+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;
+}
+
+int __attribute__((weak_import)) t15(void);
+extern int t16 __attribute__((weak_import));
+int t17() {
+  return t15() + t16;
+}
+
+
diff --git a/test/CodeGen/bitfield-assign.c b/test/CodeGen/bitfield-assign.c
new file mode 100644
index 0000000..05d4dda
--- /dev/null
+++ b/test/CodeGen/bitfield-assign.c
@@ -0,0 +1,44 @@
+/* Check that the result of a bitfield assignment is properly
+   truncated and does not generate a redundant load. */
+
+/* Check that we get one load for each simple assign and two for the
+   compound assign (load the old value before the add then load again
+   to store back). Also check that our g0 pattern is good. */
+// RUN: clang-cc -triple i386-unknown-unknown -O0 -emit-llvm -o %t %s &&
+// RUN: grep 'load ' %t | count 5 &&
+// RUN: grep "@g0" %t | count 4 &&
+
+// Check that we got the right value.
+// RUN: clang-cc -triple i386-unknown-unknown -O3 -emit-llvm -o %t %s &&
+// RUN: grep 'load ' %t | count 0 &&
+// RUN: grep "@g0" %t | count 0
+
+struct s0 {
+  int f0 : 2;
+  _Bool f1 : 1;
+  unsigned f2 : 2;
+};
+
+int g0();
+
+void f0(void) {
+  struct s0 s;  
+  if ((s.f0 = 3) != -1) g0();
+}
+
+void f1(void) {
+  struct s0 s;  
+  if ((s.f1 = 3) != 1) g0();
+}
+
+void f2(void) {
+  struct s0 s;  
+  if ((s.f2 = 3) != 3) g0();
+}
+
+void f3(void) {
+  struct s0 s;
+  // Just check this one for load counts.
+  s.f0 += 3;
+}
+
diff --git a/test/CodeGen/bitfield-init.c b/test/CodeGen/bitfield-init.c
new file mode 100644
index 0000000..7459614
--- /dev/null
+++ b/test/CodeGen/bitfield-init.c
@@ -0,0 +1,14 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+typedef struct { unsigned int i: 1; } c;
+const c d = { 1 };
+
+// PR2310
+struct Token {
+  unsigned n : 31;
+};
+void sqlite3CodeSubselect(){
+  struct Token one = { 1 };
+}
+
+typedef union T0 { char field0 : 2; } T0;
+T0 T0_values = { 0 };
diff --git a/test/CodeGen/bitfield-promote.c b/test/CodeGen/bitfield-promote.c
new file mode 100644
index 0000000..5894e51
--- /dev/null
+++ b/test/CodeGen/bitfield-promote.c
@@ -0,0 +1,19 @@
+// RUN: clang -O3 -emit-llvm -S -o %t %s &&
+// RUN: grep 'ret i64 4294967292' %t | count 2 &&
+// RUN: grep 'ret i64 -4' %t | count 1 &&
+// RUN: true
+
+long long f0(void) {
+ struct { unsigned f0 : 32; } x = { 18 };
+ return (long long) (x.f0 - (int) 22);
+}
+
+long long f1(void) {
+ struct { unsigned f0 : 31; } x = { 18 };
+ return (long long) (x.f0 - (int) 22);
+}
+
+long long f2(void) {
+ struct { unsigned f0     ; } x = { 18 };
+ return (long long) (x.f0 - (int) 22);
+}
diff --git a/test/CodeGen/bitfield.c b/test/CodeGen/bitfield.c
new file mode 100644
index 0000000..02f2de7
--- /dev/null
+++ b/test/CodeGen/bitfield.c
@@ -0,0 +1,74 @@
+// RUN: clang-cc -triple i386-unknown-unknown %s -emit-llvm -o %t -O3 &&
+// RUN: grep "ret i32" %t | count 4 &&
+// RUN: grep "ret i32 1" %t | count 4
+
+static int f0(int n) {
+  struct s0 {
+    int a : 30;
+    int b : 2;
+    long long c : 31;
+  } x = { 0xdeadbeef, 0xdeadbeef, 0xdeadbeef };
+  
+  x.a += n;
+  x.b += n;
+  x.c += n;
+
+  return x.a + x.b + x.c;
+}
+
+int g0(void) {
+  return f0(-1) + 44335655;
+}
+
+static int f1(void) {
+  struct s1 { 
+    int a:13; 
+    char b; 
+    unsigned short c:7;
+  } x;
+  
+  x.a = -40;
+  x.b = 10;
+  x.c = 15;
+
+  return x.a + x.b + x.c;
+}
+
+int g1(void) {
+  return f1() + 16;
+}
+
+static int f2(void) {
+  struct s2 {
+    short a[3];
+    int b : 15;
+  } x;
+  
+  x.a[0] = x.a[1] = x.a[2] = -40;
+  x.b = 10;
+
+  return x.b;
+}
+
+int g2(void) {
+  return f2() - 9;
+}
+
+static int f3(int n) {
+  struct s3 {
+    unsigned a:16;
+    unsigned b:28 __attribute__ ((packed));
+  } x = { 0xdeadbeef, 0xdeadbeef };
+  struct s4 {
+    signed a:16;
+    signed b:28 __attribute__ ((packed));
+  } y;
+  y.a = -0x56789abcL;
+  y.b = -0x56789abcL;
+  return ((y.a += x.a += n) + 
+          (y.b += x.b += n));
+}
+
+int g3(void) {
+  return f3(20) + 130725747;
+}
diff --git a/test/CodeGen/blocks-1.c b/test/CodeGen/blocks-1.c
new file mode 100644
index 0000000..10498cb
--- /dev/null
+++ b/test/CodeGen/blocks-1.c
@@ -0,0 +1,78 @@
+// RUN: clang-cc %s -emit-llvm -o %t -fblocks &&
+// RUN: grep "_Block_object_dispose" %t | count 17 &&
+// RUN: grep "__copy_helper_block_" %t | count 16 &&
+// RUN: grep "__destroy_helper_block_" %t | count 16 &&
+// RUN: grep "__Block_byref_id_object_copy_" %t | count 2 &&
+// RUN: grep "__Block_byref_id_object_dispose_" %t | count 2 &&
+// RUN: grep "i32 135)" %t | count 2 &&
+// RUN: grep "_Block_object_assign" %t | count 10
+
+#include <stdio.h>
+
+void test1() {
+  __block int a;
+  int b=2;
+  a=1;
+  printf("a is %d, b is %d\n", a, b);
+  ^{ a = 10; printf("a is %d, b is %d\n", a, b); }();
+  printf("a is %d, b is %d\n", a, b);
+  a = 1;
+  printf("a is %d, b is %d\n", a, b);
+}
+
+void test2() {
+  __block int a;
+  a=1;
+  printf("a is %d\n", a);
+  ^{
+    ^{
+      a = 10;
+    }();
+  }();
+  printf("a is %d\n", a);
+  a = 1;
+  printf("a is %d\n", a);
+}
+
+void test3() {
+  __block int k;
+  __block int (^j)(int);
+  ^{j=0; k=0;}();
+}
+
+int test4() {
+  extern int g;
+  static int i = 1;
+  ^(int j){ i = j; g = 0; }(0);
+  return i + g;
+}
+
+int g;
+
+void test5() {
+  __block struct { int i; } i;
+  ^{ (void)i; }();
+}
+
+void test6() {
+  __block int i;
+  ^{ i=1; }();
+  ^{}();
+}
+
+void test7() {
+  ^{
+    __block int i;
+    ^{ i = 1; }();
+  }();
+}
+
+int main() {
+  int rv = 0;
+  test1();
+  test2();
+  test3();
+  rv += test4();
+  test5();
+  return rv;
+}
diff --git a/test/CodeGen/blocks-2.c b/test/CodeGen/blocks-2.c
new file mode 100644
index 0000000..5ee2a73
--- /dev/null
+++ b/test/CodeGen/blocks-2.c
@@ -0,0 +1,13 @@
+// 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.
+
+static __inline__ __attribute__((always_inline)) int bar(int va, int vb) { return (va == vb); }
+
+int test_block_dbg() {
+  extern int g;
+  static int i = 1;
+  ^(int j){ i = bar(3,4); }(0);
+  return i + g;
+}
+
diff --git a/test/CodeGen/blocks-seq.c b/test/CodeGen/blocks-seq.c
new file mode 100644
index 0000000..f637fbc
--- /dev/null
+++ b/test/CodeGen/blocks-seq.c
@@ -0,0 +1,18 @@
+// 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
+
+int rhs();
+
+void foo() {
+  __block int i;
+  i = rhs();
+  i += rhs();
+}
diff --git a/test/CodeGen/blocks.c b/test/CodeGen/blocks.c
new file mode 100644
index 0000000..39c5b06
--- /dev/null
+++ b/test/CodeGen/blocks.c
@@ -0,0 +1,30 @@
+// RUN: clang-cc -triple i386-unknown-unknown %s -emit-llvm -o %t -fblocks &&
+void (^f)(void) = ^{};
+
+// rdar://6768379
+int f0(int (^a0)()) {
+  return a0(1, 2, 3);
+}
+
+// Verify that attributes on blocks are set correctly.
+typedef struct s0 T;
+struct s0 {
+  int a[64];
+};
+
+// RUN: grep 'internal void @__f2_block_invoke_(.struct.s0\* noalias sret .*, .*, .* byval .*)' %t &&
+struct s0 f2(struct s0 a0) {
+  return ^(struct s0 a1){ return a1; }(a0);
+}
+
+// This should not crash: rdar://6808051
+void *P = ^{
+  void *Q = __func__;
+};
+
+void (^test1)(void) = ^(void) {
+  __block int i;
+  ^ { i = 1; }();
+};
+
+// RUN: true
diff --git a/test/CodeGen/bool-bitfield.c b/test/CodeGen/bool-bitfield.c
new file mode 100644
index 0000000..50990a4
--- /dev/null
+++ b/test/CodeGen/bool-bitfield.c
@@ -0,0 +1,54 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+// From GCC PR19331
+struct SysParams
+{
+ unsigned short tag;
+ unsigned short version;
+ unsigned int seqnum;
+ int contrast;
+ int igain_1, igain_2;
+ int oattn_1, oattn_2;
+ int max_out_vltg_1, max_out_vltg_2;
+ int max_mains_current;
+ int meters_mode;
+ int input_select;
+ _Bool input_parallelch2:1;
+ _Bool cliplmt_ch1:1;
+ _Bool cliplmt_ch2:1;
+ _Bool gate_ch1:1;
+ _Bool gate_ch2:1;
+ _Bool mute_ch1:1;
+ _Bool mute_ch2:1;
+ _Bool brownout:1;
+ _Bool power_on:1;
+ _Bool pwrup_mute:1;
+ _Bool keylock:1;
+ _Bool dsp_ch1:1;
+ _Bool dsp_ch2:1;
+ int dsp_preset;
+ long unlock_code;
+};
+extern struct SysParams params;
+
+void foo(void *);
+void kcmd_setParams(void)
+{
+ struct {
+  unsigned char igain_1;
+  unsigned char igain_2;
+  unsigned char max_out_vltg_1;
+  unsigned char max_out_vltg_2;
+  unsigned char max_imains;
+  unsigned char cliplmt_ch1:1;
+  unsigned char cliplmt_ch2:1;
+  unsigned char gate_ch1:1;
+  unsigned char gate_ch2:1;
+ } msg;
+ foo(&msg);
+ params.cliplmt_ch1 = msg.cliplmt_ch1;
+ params.cliplmt_ch2 = msg.cliplmt_ch2;
+ params.gate_ch1 = msg.gate_ch1;
+ params.gate_ch2 = msg.gate_ch2;
+}
+
diff --git a/test/CodeGen/bool-convert.c b/test/CodeGen/bool-convert.c
new file mode 100644
index 0000000..4df81bb
--- /dev/null
+++ b/test/CodeGen/bool-convert.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc -emit-llvm < %s | grep i1 | count 1
+// All of these should uses the memory representation of _Bool
+struct teststruct1 {_Bool a, b;} test1;
+_Bool* test2;
+_Bool test3[10];
+_Bool (*test4)[];
+void f(int x) {
+  _Bool test5;
+  _Bool test6[x];
+}
diff --git a/test/CodeGen/bool-init.c b/test/CodeGen/bool-init.c
new file mode 100644
index 0000000..7d331ed
--- /dev/null
+++ b/test/CodeGen/bool-init.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc -emit-llvm < %s | grep i1 | count 1
+
+// Check that the type of this global isn't i1
+_Bool test = &test;
diff --git a/test/CodeGen/boolassign.c b/test/CodeGen/boolassign.c
new file mode 100644
index 0000000..2d14f8c
--- /dev/null
+++ b/test/CodeGen/boolassign.c
@@ -0,0 +1,6 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+
+int testBoolAssign(void) {
+int ss;
+if ((ss = ss && ss)) {}
+}
diff --git a/test/CodeGen/builtin-count-zeros.c b/test/CodeGen/builtin-count-zeros.c
new file mode 100644
index 0000000..374acc4
--- /dev/null
+++ b/test/CodeGen/builtin-count-zeros.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc -emit-llvm %s -o - | grep 'cttz' | count 2 &&
+// RUN: clang-cc -emit-llvm %s -o - | grep 'ctlz' | count 2
+
+int a(int a) {return __builtin_ctz(a) + __builtin_clz(a);}
diff --git a/test/CodeGen/builtin-memfns.c b/test/CodeGen/builtin-memfns.c
new file mode 100644
index 0000000..9ae380c
--- /dev/null
+++ b/test/CodeGen/builtin-memfns.c
@@ -0,0 +1,15 @@
+// RUN: clang-cc -triple i386-pc-linux-gnu -emit-llvm -o %t %s &&
+// RUN: grep '@llvm.memset.i32' %t &&
+// RUN: grep '@llvm.memcpy.i32' %t &&
+// RUN: grep '@llvm.memmove.i32' %t &&
+// RUN: grep __builtin %t | count 0
+
+int main(int argc, char **argv) {
+  unsigned char a = 0x11223344;
+  unsigned char b = 0x11223344;
+  __builtin_bzero(&a, sizeof(a));
+  __builtin_memset(&a, 0, sizeof(a));
+  __builtin_memcpy(&a, &b, sizeof(a));
+  __builtin_memmove(&a, &b, sizeof(a));
+  return 0;
+}
diff --git a/test/CodeGen/builtin-nanf.c b/test/CodeGen/builtin-nanf.c
new file mode 100644
index 0000000..e048c7a
--- /dev/null
+++ b/test/CodeGen/builtin-nanf.c
@@ -0,0 +1,15 @@
+// RUN: clang-cc -triple x86_64-apple-darwin9 -emit-llvm -o %t %s &&
+// RUN: grep 'float 0x7FF8000000000000, float 0x7FF8000000000000, float 0x7FF8000020000000, float 0x7FF8000000000000, float 0x7FF80001E0000000, float 0x7FF8001E00000000, float 0x7FF801E000000000, float 0x7FF81E0000000000, float 0x7FF9E00000000000, float 0x7FFFFFFFE0000000' %t
+
+float n[] = {
+  __builtin_nanf("0"),
+  __builtin_nanf(""),
+  __builtin_nanf("1"),
+  __builtin_nanf("0x7fc00000"),
+  __builtin_nanf("0x7fc0000f"),
+  __builtin_nanf("0x7fc000f0"),
+  __builtin_nanf("0x7fc00f00"),
+  __builtin_nanf("0x7fc0f000"),
+  __builtin_nanf("0x7fcf0000"),
+  __builtin_nanf("0xffffffff"),
+};
diff --git a/test/CodeGen/builtin-rename.c b/test/CodeGen/builtin-rename.c
new file mode 100644
index 0000000..d0b5c24
--- /dev/null
+++ b/test/CodeGen/builtin-rename.c
@@ -0,0 +1,8 @@
+// RUN: clang-cc %s -emit-llvm -o - | grep 'declare.*printf' | count 1
+// PR3612
+
+int printf(const char *, ...);
+
+int foo(void) {
+  return printf(printf);
+}
diff --git a/test/CodeGen/builtin-stackaddress.c b/test/CodeGen/builtin-stackaddress.c
new file mode 100644
index 0000000..5c6d540
--- /dev/null
+++ b/test/CodeGen/builtin-stackaddress.c
@@ -0,0 +1,9 @@
+// RUN: clang-cc -emit-llvm < %s | grep "llvm.returnaddress" &&
+// RUN: clang-cc -emit-llvm < %s | grep "llvm.frameaddress"
+void* a(unsigned x) {
+return __builtin_return_address(0);
+}
+
+void* c(unsigned x) {
+return __builtin_frame_address(0);
+}
diff --git a/test/CodeGen/builtin-unwind-init.c b/test/CodeGen/builtin-unwind-init.c
new file mode 100644
index 0000000..49a016a
--- /dev/null
+++ b/test/CodeGen/builtin-unwind-init.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc -emit-llvm < %s -o - | grep -F "llvm.eh.unwind.init"
+
+int a() { __builtin_unwind_init(); }
+
diff --git a/test/CodeGen/builtinmemcpy.c b/test/CodeGen/builtinmemcpy.c
new file mode 100644
index 0000000..d1fdebb
--- /dev/null
+++ b/test/CodeGen/builtinmemcpy.c
@@ -0,0 +1,3 @@
+// RUN: clang-cc -emit-llvm < %s -o - | grep "llvm.memcpy"
+
+char* x(char* a, char* b) {return __builtin_memcpy(a, b, 4);}
diff --git a/test/CodeGen/builtins-ffs_parity_popcount.c b/test/CodeGen/builtins-ffs_parity_popcount.c
new file mode 100644
index 0000000..4746998
--- /dev/null
+++ b/test/CodeGen/builtins-ffs_parity_popcount.c
@@ -0,0 +1,15 @@
+// RUN: clang-cc -emit-llvm -o - %s > %t
+// RUN: ! grep "__builtin" %t
+
+#include <stdio.h>
+
+void test(int M, long long N) {
+  printf("%d %lld: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n",
+         M, N,
+         __builtin_ffs(M), __builtin_ffsl(M), __builtin_ffsll(M),
+         __builtin_parity(M), __builtin_parityl(M), __builtin_parityll(M),
+         __builtin_popcount(M), __builtin_popcountl(M), __builtin_popcountll(M),
+         __builtin_ffs(N), __builtin_ffsl(N), __builtin_ffsll(N),
+         __builtin_parity(N), __builtin_parityl(N), __builtin_parityll(N),
+         __builtin_popcount(N), __builtin_popcountl(N), __builtin_popcountll(N));
+}
diff --git a/test/CodeGen/builtins-powi.c b/test/CodeGen/builtins-powi.c
new file mode 100644
index 0000000..73f752f
--- /dev/null
+++ b/test/CodeGen/builtins-powi.c
@@ -0,0 +1,29 @@
+// RUN: clang-cc -emit-llvm -o - %s > %t
+// RUN: ! grep "__builtin" %t
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+void test(long double a, int b) {
+  printf("%Lf**%d: %08x %08x %016Lx\n", 
+         a, b,
+         __builtin_powi(a, b),
+         __builtin_powif(a, b),
+         __builtin_powil(a, b)
+         );
+}
+
+int main() {
+  int i;
+
+  test(-1,-1LL);
+  test(0,0);
+  test(1,1);
+
+  for (i=0; i<3; i++) {
+    test(random(), i);
+  }
+
+  return 0;
+}
diff --git a/test/CodeGen/builtins-x86.c b/test/CodeGen/builtins-x86.c
new file mode 100644
index 0000000..33ab360
--- /dev/null
+++ b/test/CodeGen/builtins-x86.c
@@ -0,0 +1,522 @@
+// RUN: clang-cc -DUSE_64 -triple x86_64-unknown-unknown -emit-llvm -o %t %s &&
+// RUN: clang-cc -DUSE_ALL -triple x86_64-unknown-unknown -fsyntax-only -o %t %s
+
+#ifdef USE_ALL
+#define USE_3DNOW
+#define USE_64
+#define USE_SSE4
+#endif
+
+// 64-bit
+typedef char V8c __attribute__((vector_size(8 * sizeof(char))));
+typedef signed short V4s __attribute__((vector_size(8)));
+typedef signed int V2i __attribute__((vector_size(8)));
+typedef signed long long V1LLi __attribute__((vector_size(8)));
+
+typedef float V2f __attribute__((vector_size(8)));
+
+// 128-bit
+typedef char V16c __attribute__((vector_size(16)));
+typedef signed short V8s __attribute__((vector_size(16)));
+typedef signed int V4i __attribute__((vector_size(16)));
+typedef signed long long V2LLi __attribute__((vector_size(16)));
+
+typedef float V4f __attribute__((vector_size(16)));
+typedef double V2d __attribute__((vector_size(16)));
+
+void f0() {
+  signed char         tmp_c;
+//  unsigned char       tmp_Uc;
+  signed short        tmp_s;
+#ifdef USE_ALL
+  unsigned short      tmp_Us;
+#endif
+  signed int          tmp_i;
+  unsigned int        tmp_Ui;
+  signed long long    tmp_LLi;
+//  unsigned long long  tmp_ULLi;
+  float               tmp_f;
+  double              tmp_d;
+
+  void*          tmp_vp;
+  const void*    tmp_vCp;
+  char*          tmp_cp; 
+  const char*    tmp_cCp; 
+  int*           tmp_ip;
+  float*         tmp_fp;
+  const float*   tmp_fCp;
+  double*        tmp_dp;
+  const double*  tmp_dCp;
+
+#define imm_i 32
+#define imm_i_0_2 0
+#define imm_i_0_4 3
+#define imm_i_0_8 7
+#define imm_i_0_16 15
+  // Check this.
+#define imm_i_0_256 0
+
+  V2i*   tmp_V2ip;
+  V1LLi* tmp_V1LLip;
+  V2LLi* tmp_V2LLip;
+
+  // 64-bit
+  V8c    tmp_V8c;
+  V4s    tmp_V4s;
+  V2i    tmp_V2i;
+  V1LLi  tmp_V1LLi;
+#ifdef USE_3DNOW
+  V2f    tmp_V2f;
+#endif
+
+  // 128-bit
+  V16c   tmp_V16c;
+  V8s    tmp_V8s;
+  V4i    tmp_V4i;
+  V2LLi  tmp_V2LLi;
+  V4f    tmp_V4f;
+  V2d    tmp_V2d;
+
+  tmp_i = __builtin_ia32_comieq(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_comilt(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_comile(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_comigt(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_comige(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_comineq(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_ucomieq(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_ucomilt(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_ucomile(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_ucomigt(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_ucomige(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_ucomineq(tmp_V4f, tmp_V4f);
+  tmp_i = __builtin_ia32_comisdeq(tmp_V2d, tmp_V2d);
+  tmp_i = __builtin_ia32_comisdlt(tmp_V2d, tmp_V2d);
+  tmp_i = __builtin_ia32_comisdle(tmp_V2d, tmp_V2d);
+  tmp_i = __builtin_ia32_comisdgt(tmp_V2d, tmp_V2d);
+  tmp_i = __builtin_ia32_comisdge(tmp_V2d, tmp_V2d);
+  tmp_i = __builtin_ia32_comisdneq(tmp_V2d, tmp_V2d);
+  tmp_i = __builtin_ia32_ucomisdeq(tmp_V2d, tmp_V2d);
+  tmp_i = __builtin_ia32_ucomisdlt(tmp_V2d, tmp_V2d);
+  tmp_i = __builtin_ia32_ucomisdle(tmp_V2d, tmp_V2d);
+  tmp_i = __builtin_ia32_ucomisdgt(tmp_V2d, tmp_V2d);
+  tmp_i = __builtin_ia32_ucomisdge(tmp_V2d, tmp_V2d);
+  tmp_i = __builtin_ia32_ucomisdneq(tmp_V2d, tmp_V2d);
+  tmp_V4f = __builtin_ia32_addps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_subps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_mulps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_divps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_addss(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_subss(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_mulss(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_divss(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_cmpps(tmp_V4f, tmp_V4f, 0);
+  tmp_V4f = __builtin_ia32_cmpps(tmp_V4f, tmp_V4f, 1);
+  tmp_V4f = __builtin_ia32_cmpps(tmp_V4f, tmp_V4f, 2);
+  tmp_V4f = __builtin_ia32_cmpps(tmp_V4f, tmp_V4f, 3);
+  tmp_V4f = __builtin_ia32_cmpps(tmp_V4f, tmp_V4f, 4);
+  tmp_V4f = __builtin_ia32_cmpps(tmp_V4f, tmp_V4f, 5);
+  tmp_V4f = __builtin_ia32_cmpps(tmp_V4f, tmp_V4f, 6);
+  tmp_V4f = __builtin_ia32_cmpps(tmp_V4f, tmp_V4f, 7);
+  tmp_V4f = __builtin_ia32_cmpss(tmp_V4f, tmp_V4f, 0);
+  tmp_V4f = __builtin_ia32_cmpss(tmp_V4f, tmp_V4f, 1);
+  tmp_V4f = __builtin_ia32_cmpss(tmp_V4f, tmp_V4f, 2);
+  tmp_V4f = __builtin_ia32_cmpss(tmp_V4f, tmp_V4f, 3);
+  tmp_V4f = __builtin_ia32_cmpss(tmp_V4f, tmp_V4f, 4);
+  tmp_V4f = __builtin_ia32_cmpss(tmp_V4f, tmp_V4f, 5);
+  tmp_V4f = __builtin_ia32_cmpss(tmp_V4f, tmp_V4f, 6);
+  tmp_V4f = __builtin_ia32_cmpss(tmp_V4f, tmp_V4f, 7);
+  tmp_V4f = __builtin_ia32_minps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_maxps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_minss(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_maxss(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_andps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_andnps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_orps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_xorps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_movss(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_movhlps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_movlhps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_unpckhps(tmp_V4f, tmp_V4f);
+  tmp_V4f = __builtin_ia32_unpcklps(tmp_V4f, tmp_V4f);
+  tmp_V8c = __builtin_ia32_paddb(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_paddw(tmp_V4s, tmp_V4s);
+  tmp_V2i = __builtin_ia32_paddd(tmp_V2i, tmp_V2i);
+
+  tmp_V1LLi = __builtin_ia32_paddq(tmp_V1LLi, tmp_V1LLi);
+  tmp_V8c = __builtin_ia32_psubb(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_psubw(tmp_V4s, tmp_V4s);
+  tmp_V2i = __builtin_ia32_psubd(tmp_V2i, tmp_V2i);
+  tmp_V1LLi = __builtin_ia32_psubq(tmp_V1LLi, tmp_V1LLi);
+  tmp_V8c = __builtin_ia32_paddsb(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_paddsw(tmp_V4s, tmp_V4s);
+  tmp_V8c = __builtin_ia32_psubsb(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_psubsw(tmp_V4s, tmp_V4s);
+  tmp_V8c = __builtin_ia32_paddusb(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_paddusw(tmp_V4s, tmp_V4s);
+  tmp_V8c = __builtin_ia32_psubusb(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_psubusw(tmp_V4s, tmp_V4s);
+  tmp_V4s = __builtin_ia32_pmullw(tmp_V4s, tmp_V4s);
+  tmp_V4s = __builtin_ia32_pmulhw(tmp_V4s, tmp_V4s);
+  tmp_V4s = __builtin_ia32_pmulhuw(tmp_V4s, tmp_V4s);
+  tmp_V1LLi = __builtin_ia32_pand(tmp_V1LLi, tmp_V1LLi);
+  tmp_V1LLi = __builtin_ia32_pandn(tmp_V1LLi, tmp_V1LLi);
+  tmp_V1LLi = __builtin_ia32_por(tmp_V1LLi, tmp_V1LLi);
+  tmp_V1LLi = __builtin_ia32_pxor(tmp_V1LLi, tmp_V1LLi);
+  tmp_V8c = __builtin_ia32_pavgb(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_pavgw(tmp_V4s, tmp_V4s);
+  tmp_V8c = __builtin_ia32_pcmpeqb(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_pcmpeqw(tmp_V4s, tmp_V4s);
+  tmp_V2i = __builtin_ia32_pcmpeqd(tmp_V2i, tmp_V2i);
+  tmp_V8c = __builtin_ia32_pcmpgtb(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_pcmpgtw(tmp_V4s, tmp_V4s);
+  tmp_V2i = __builtin_ia32_pcmpgtd(tmp_V2i, tmp_V2i);
+  tmp_V8c = __builtin_ia32_pmaxub(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_pmaxsw(tmp_V4s, tmp_V4s);
+  tmp_V8c = __builtin_ia32_pminub(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_pminsw(tmp_V4s, tmp_V4s);
+  tmp_V8c = __builtin_ia32_punpckhbw(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_punpckhwd(tmp_V4s, tmp_V4s);
+  tmp_V2i = __builtin_ia32_punpckhdq(tmp_V2i, tmp_V2i);
+  tmp_V8c = __builtin_ia32_punpcklbw(tmp_V8c, tmp_V8c);
+  tmp_V4s = __builtin_ia32_punpcklwd(tmp_V4s, tmp_V4s);
+  tmp_V2i = __builtin_ia32_punpckldq(tmp_V2i, tmp_V2i);
+  tmp_V2d = __builtin_ia32_addpd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_subpd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_mulpd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_divpd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_addsd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_subsd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_mulsd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_divsd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_cmppd(tmp_V2d, tmp_V2d, 0);
+  tmp_V2d = __builtin_ia32_cmppd(tmp_V2d, tmp_V2d, 1);
+  tmp_V2d = __builtin_ia32_cmppd(tmp_V2d, tmp_V2d, 2);
+  tmp_V2d = __builtin_ia32_cmppd(tmp_V2d, tmp_V2d, 3);
+  tmp_V2d = __builtin_ia32_cmppd(tmp_V2d, tmp_V2d, 4);
+  tmp_V2d = __builtin_ia32_cmppd(tmp_V2d, tmp_V2d, 5);
+  tmp_V2d = __builtin_ia32_cmppd(tmp_V2d, tmp_V2d, 6);
+  tmp_V2d = __builtin_ia32_cmppd(tmp_V2d, tmp_V2d, 7);
+  tmp_V2d = __builtin_ia32_cmpsd(tmp_V2d, tmp_V2d, 0);
+  tmp_V2d = __builtin_ia32_cmpsd(tmp_V2d, tmp_V2d, 1);
+  tmp_V2d = __builtin_ia32_cmpsd(tmp_V2d, tmp_V2d, 2);
+  tmp_V2d = __builtin_ia32_cmpsd(tmp_V2d, tmp_V2d, 3);
+  tmp_V2d = __builtin_ia32_cmpsd(tmp_V2d, tmp_V2d, 4);
+  tmp_V2d = __builtin_ia32_cmpsd(tmp_V2d, tmp_V2d, 5);
+  tmp_V2d = __builtin_ia32_cmpsd(tmp_V2d, tmp_V2d, 6);
+  tmp_V2d = __builtin_ia32_cmpsd(tmp_V2d, tmp_V2d, 7);
+  tmp_V2d = __builtin_ia32_minpd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_maxpd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_minsd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_maxsd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_andpd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_andnpd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_orpd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_xorpd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_movsd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_unpckhpd(tmp_V2d, tmp_V2d);
+  tmp_V2d = __builtin_ia32_unpcklpd(tmp_V2d, tmp_V2d);
+  tmp_V16c = __builtin_ia32_paddb128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_paddw128(tmp_V8s, tmp_V8s);
+  tmp_V4i = __builtin_ia32_paddd128(tmp_V4i, tmp_V4i);
+  tmp_V2LLi = __builtin_ia32_paddq128(tmp_V2LLi, tmp_V2LLi);
+  tmp_V16c = __builtin_ia32_psubb128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_psubw128(tmp_V8s, tmp_V8s);
+  tmp_V4i = __builtin_ia32_psubd128(tmp_V4i, tmp_V4i);
+  tmp_V2LLi = __builtin_ia32_psubq128(tmp_V2LLi, tmp_V2LLi);
+  tmp_V16c = __builtin_ia32_paddsb128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_paddsw128(tmp_V8s, tmp_V8s);
+  tmp_V16c = __builtin_ia32_psubsb128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_psubsw128(tmp_V8s, tmp_V8s);
+  tmp_V16c = __builtin_ia32_paddusb128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_paddusw128(tmp_V8s, tmp_V8s);
+  tmp_V16c = __builtin_ia32_psubusb128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_psubusw128(tmp_V8s, tmp_V8s);
+  tmp_V8s = __builtin_ia32_pmullw128(tmp_V8s, tmp_V8s);
+  tmp_V8s = __builtin_ia32_pmulhw128(tmp_V8s, tmp_V8s);
+  tmp_V2LLi = __builtin_ia32_pand128(tmp_V2LLi, tmp_V2LLi);
+  tmp_V2LLi = __builtin_ia32_pandn128(tmp_V2LLi, tmp_V2LLi);
+  tmp_V2LLi = __builtin_ia32_por128(tmp_V2LLi, tmp_V2LLi);
+  tmp_V2LLi = __builtin_ia32_pxor128(tmp_V2LLi, tmp_V2LLi);
+  tmp_V16c = __builtin_ia32_pavgb128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_pavgw128(tmp_V8s, tmp_V8s);
+  tmp_V16c = __builtin_ia32_pcmpeqb128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_pcmpeqw128(tmp_V8s, tmp_V8s);
+  tmp_V4i = __builtin_ia32_pcmpeqd128(tmp_V4i, tmp_V4i);
+  tmp_V16c = __builtin_ia32_pcmpgtb128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_pcmpgtw128(tmp_V8s, tmp_V8s);
+  tmp_V4i = __builtin_ia32_pcmpgtd128(tmp_V4i, tmp_V4i);
+  tmp_V16c = __builtin_ia32_pmaxub128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_pmaxsw128(tmp_V8s, tmp_V8s);
+  tmp_V16c = __builtin_ia32_pminub128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_pminsw128(tmp_V8s, tmp_V8s);
+  tmp_V16c = __builtin_ia32_punpckhbw128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_punpckhwd128(tmp_V8s, tmp_V8s);
+  tmp_V4i = __builtin_ia32_punpckhdq128(tmp_V4i, tmp_V4i);
+  tmp_V2LLi = __builtin_ia32_punpckhqdq128(tmp_V2LLi, tmp_V2LLi);
+  tmp_V16c = __builtin_ia32_punpcklbw128(tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_punpcklwd128(tmp_V8s, tmp_V8s);
+  tmp_V4i = __builtin_ia32_punpckldq128(tmp_V4i, tmp_V4i);
+  tmp_V2LLi = __builtin_ia32_punpcklqdq128(tmp_V2LLi, tmp_V2LLi);
+  tmp_V8s = __builtin_ia32_packsswb128(tmp_V8s, tmp_V8s);
+  tmp_V4i = __builtin_ia32_packssdw128(tmp_V4i, tmp_V4i);
+  tmp_V8s = __builtin_ia32_packuswb128(tmp_V8s, tmp_V8s);
+  tmp_V8s = __builtin_ia32_pmulhuw128(tmp_V8s, tmp_V8s);
+  tmp_V4f = __builtin_ia32_addsubps(tmp_V4f, tmp_V4f);
+  tmp_V2d = __builtin_ia32_addsubpd(tmp_V2d, tmp_V2d);
+  tmp_V4f = __builtin_ia32_haddps(tmp_V4f, tmp_V4f);
+  tmp_V2d = __builtin_ia32_haddpd(tmp_V2d, tmp_V2d);
+  tmp_V4f = __builtin_ia32_hsubps(tmp_V4f, tmp_V4f);
+  tmp_V2d = __builtin_ia32_hsubpd(tmp_V2d, tmp_V2d);
+  tmp_V8s = __builtin_ia32_phaddw128(tmp_V8s, tmp_V8s);
+  tmp_V4s = __builtin_ia32_phaddw(tmp_V4s, tmp_V4s);
+  tmp_V4i = __builtin_ia32_phaddd128(tmp_V4i, tmp_V4i);
+  tmp_V2i = __builtin_ia32_phaddd(tmp_V2i, tmp_V2i);
+  tmp_V8s = __builtin_ia32_phaddsw128(tmp_V8s, tmp_V8s);
+  tmp_V4s = __builtin_ia32_phaddsw(tmp_V4s, tmp_V4s);
+  tmp_V8s = __builtin_ia32_phsubw128(tmp_V8s, tmp_V8s);
+  tmp_V4s = __builtin_ia32_phsubw(tmp_V4s, tmp_V4s);
+  tmp_V4i = __builtin_ia32_phsubd128(tmp_V4i, tmp_V4i);
+  tmp_V2i = __builtin_ia32_phsubd(tmp_V2i, tmp_V2i);
+  tmp_V8s = __builtin_ia32_phsubsw128(tmp_V8s, tmp_V8s);
+  tmp_V4s = __builtin_ia32_phsubsw(tmp_V4s, tmp_V4s);
+  tmp_V16c = __builtin_ia32_pmaddubsw128(tmp_V16c, tmp_V16c);
+  tmp_V8c = __builtin_ia32_pmaddubsw(tmp_V8c, tmp_V8c);
+  tmp_V8s = __builtin_ia32_pmulhrsw128(tmp_V8s, tmp_V8s);
+  tmp_V4s = __builtin_ia32_pmulhrsw(tmp_V4s, tmp_V4s);
+  tmp_V16c = __builtin_ia32_pshufb128(tmp_V16c, tmp_V16c);
+  tmp_V8c = __builtin_ia32_pshufb(tmp_V8c, tmp_V8c);
+  tmp_V16c = __builtin_ia32_psignb128(tmp_V16c, tmp_V16c);
+  tmp_V8c = __builtin_ia32_psignb(tmp_V8c, tmp_V8c);
+  tmp_V8s = __builtin_ia32_psignw128(tmp_V8s, tmp_V8s);
+  tmp_V4s = __builtin_ia32_psignw(tmp_V4s, tmp_V4s);
+  tmp_V4i = __builtin_ia32_psignd128(tmp_V4i, tmp_V4i);
+  tmp_V2i = __builtin_ia32_psignd(tmp_V2i, tmp_V2i);
+  tmp_V16c = __builtin_ia32_pabsb128(tmp_V16c);
+  tmp_V8c = __builtin_ia32_pabsb(tmp_V8c);
+  tmp_V8s = __builtin_ia32_pabsw128(tmp_V8s);
+  tmp_V4s = __builtin_ia32_pabsw(tmp_V4s);
+  tmp_V4i = __builtin_ia32_pabsd128(tmp_V4i);
+  tmp_V2i = __builtin_ia32_pabsd(tmp_V2i);
+  tmp_V4s = __builtin_ia32_psllw(tmp_V4s, tmp_V1LLi);
+  tmp_V2i = __builtin_ia32_pslld(tmp_V2i, tmp_V1LLi);
+  tmp_V1LLi = __builtin_ia32_psllq(tmp_V1LLi, tmp_V1LLi);
+  tmp_V4s = __builtin_ia32_psrlw(tmp_V4s, tmp_V1LLi);
+  tmp_V2i = __builtin_ia32_psrld(tmp_V2i, tmp_V1LLi);
+  tmp_V1LLi = __builtin_ia32_psrlq(tmp_V1LLi, tmp_V1LLi);
+  tmp_V4s = __builtin_ia32_psraw(tmp_V4s, tmp_V1LLi);
+  tmp_V2i = __builtin_ia32_psrad(tmp_V2i, tmp_V1LLi);
+#ifdef USE_ALL
+  tmp_V4s = __builtin_ia32_pshufw(tmp_V4s, imm_i);
+#endif
+  tmp_V2i = __builtin_ia32_pmaddwd(tmp_V4s, tmp_V4s);
+  tmp_V8c = __builtin_ia32_packsswb(tmp_V4s, tmp_V4s);
+  tmp_V4s = __builtin_ia32_packssdw(tmp_V2i, tmp_V2i);
+  tmp_V8c = __builtin_ia32_packuswb(tmp_V4s, tmp_V4s);
+
+  (void) __builtin_ia32_ldmxcsr(tmp_Ui);
+  tmp_Ui = __builtin_ia32_stmxcsr();
+  tmp_V4f = __builtin_ia32_cvtpi2ps(tmp_V4f, tmp_V2i);
+  tmp_V2i = __builtin_ia32_cvtps2pi(tmp_V4f);
+  tmp_V4f = __builtin_ia32_cvtsi2ss(tmp_V4f, tmp_i);
+#ifdef USE_64
+  tmp_V4f = __builtin_ia32_cvtsi642ss(tmp_V4f, tmp_LLi);
+#endif
+  tmp_i = __builtin_ia32_cvtss2si(tmp_V4f);
+#ifdef USE_64
+  tmp_LLi = __builtin_ia32_cvtss2si64(tmp_V4f);
+#endif
+  tmp_V2i = __builtin_ia32_cvttps2pi(tmp_V4f);
+  tmp_i = __builtin_ia32_cvttss2si(tmp_V4f);
+#ifdef USE_64
+  tmp_LLi = __builtin_ia32_cvttss2si64(tmp_V4f);
+#endif
+  (void) __builtin_ia32_maskmovq(tmp_V8c, tmp_V8c, tmp_cp);
+  tmp_V4f = __builtin_ia32_loadups(tmp_fCp);
+  (void) __builtin_ia32_storeups(tmp_fp, tmp_V4f);
+  tmp_V4f = __builtin_ia32_loadhps(tmp_V4f, tmp_V2ip);
+  tmp_V4f = __builtin_ia32_loadlps(tmp_V4f, tmp_V2ip);
+  (void) __builtin_ia32_storehps(tmp_V2ip, tmp_V4f);
+  (void) __builtin_ia32_storelps(tmp_V2ip, tmp_V4f);
+  tmp_i = __builtin_ia32_movmskps(tmp_V4f);
+  tmp_i = __builtin_ia32_pmovmskb(tmp_V8c);
+  (void) __builtin_ia32_movntps(tmp_fp, tmp_V4f);
+  (void) __builtin_ia32_movntq(tmp_V1LLip, tmp_V1LLi);
+  (void) __builtin_ia32_sfence();
+
+  tmp_V4s = __builtin_ia32_psadbw(tmp_V8c, tmp_V8c);
+  tmp_V4f = __builtin_ia32_rcpps(tmp_V4f);
+  tmp_V4f = __builtin_ia32_rcpss(tmp_V4f);
+  tmp_V4f = __builtin_ia32_rsqrtps(tmp_V4f);
+  tmp_V4f = __builtin_ia32_rsqrtss(tmp_V4f);
+  tmp_V4f = __builtin_ia32_sqrtps(tmp_V4f);
+  tmp_V4f = __builtin_ia32_sqrtss(tmp_V4f);
+  tmp_V4f = __builtin_ia32_shufps(tmp_V4f, tmp_V4f, imm_i);
+#ifdef USE_3DNOW
+  (void) __builtin_ia32_femms();
+  tmp_V8c = __builtin_ia32_pavgusb(tmp_V8c, tmp_V8c);
+  tmp_V2i = __builtin_ia32_pf2id(tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfacc(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfadd(tmp_V2f, tmp_V2f);
+  tmp_V2i = __builtin_ia32_pfcmpeq(tmp_V2f, tmp_V2f);
+  tmp_V2i = __builtin_ia32_pfcmpge(tmp_V2f, tmp_V2f);
+  tmp_V2i = __builtin_ia32_pfcmpgt(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfmax(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfmin(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfmul(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfrcp(tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfrcpit1(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfrcpit2(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfrsqrt(tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfrsqit1(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfsub(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfsubr(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pi2fd(tmp_V2i);
+  tmp_V4s = __builtin_ia32_pmulhrw(tmp_V4s, tmp_V4s);
+#endif
+#ifdef USE_3DNOWA
+  tmp_V2i = __builtin_ia32_pf2iw(tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfnacc(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pfpnacc(tmp_V2f, tmp_V2f);
+  tmp_V2f = __builtin_ia32_pi2fw(tmp_V2i);
+  tmp_V2f = __builtin_ia32_pswapdsf(tmp_V2f);
+  tmp_V2i = __builtin_ia32_pswapdsi(tmp_V2i);
+#endif
+  (void) __builtin_ia32_maskmovdqu(tmp_V16c, tmp_V16c, tmp_cp);
+  tmp_V2d = __builtin_ia32_loadupd(tmp_dCp);
+  (void) __builtin_ia32_storeupd(tmp_dp, tmp_V2d);
+  tmp_V2d = __builtin_ia32_loadhpd(tmp_V2d, tmp_dCp);
+  tmp_V2d = __builtin_ia32_loadlpd(tmp_V2d, tmp_dCp);
+  tmp_i = __builtin_ia32_movmskpd(tmp_V2d);
+  tmp_i = __builtin_ia32_pmovmskb128(tmp_V16c);
+  (void) __builtin_ia32_movnti(tmp_ip, tmp_i);
+  (void) __builtin_ia32_movntpd(tmp_dp, tmp_V2d);
+  (void) __builtin_ia32_movntdq(tmp_V2LLip, tmp_V2LLi);
+  tmp_V4i = __builtin_ia32_pshufd(tmp_V4i, imm_i);
+  tmp_V8s = __builtin_ia32_pshuflw(tmp_V8s, imm_i);
+  tmp_V8s = __builtin_ia32_pshufhw(tmp_V8s, imm_i);
+  tmp_V2LLi = __builtin_ia32_psadbw128(tmp_V16c, tmp_V16c);
+  tmp_V2d = __builtin_ia32_sqrtpd(tmp_V2d);
+  tmp_V2d = __builtin_ia32_sqrtsd(tmp_V2d);
+  tmp_V2d = __builtin_ia32_shufpd(tmp_V2d, tmp_V2d, imm_i);
+  tmp_V2d = __builtin_ia32_cvtdq2pd(tmp_V4i);
+  tmp_V4f = __builtin_ia32_cvtdq2ps(tmp_V4i);
+  tmp_V2LLi = __builtin_ia32_cvtpd2dq(tmp_V2d);
+  tmp_V2i = __builtin_ia32_cvtpd2pi(tmp_V2d);
+  tmp_V4f = __builtin_ia32_cvtpd2ps(tmp_V2d);
+  tmp_V4i = __builtin_ia32_cvttpd2dq(tmp_V2d);
+  tmp_V2i = __builtin_ia32_cvttpd2pi(tmp_V2d);
+  tmp_V2d = __builtin_ia32_cvtpi2pd(tmp_V2i);
+  tmp_i = __builtin_ia32_cvtsd2si(tmp_V2d);
+  tmp_i = __builtin_ia32_cvttsd2si(tmp_V2d);
+#ifdef USE_64
+  tmp_LLi = __builtin_ia32_cvtsd2si64(tmp_V2d);
+  tmp_LLi = __builtin_ia32_cvttsd2si64(tmp_V2d);
+#endif
+  tmp_V4i = __builtin_ia32_cvtps2dq(tmp_V4f);
+  tmp_V2d = __builtin_ia32_cvtps2pd(tmp_V4f);
+  tmp_V4i = __builtin_ia32_cvttps2dq(tmp_V4f);
+  tmp_V2d = __builtin_ia32_cvtsi2sd(tmp_V2d, tmp_i);
+#ifdef USE_64
+  tmp_V2d = __builtin_ia32_cvtsi642sd(tmp_V2d, tmp_LLi);
+#endif
+  tmp_V4f = __builtin_ia32_cvtsd2ss(tmp_V4f, tmp_V2d);
+  tmp_V2d = __builtin_ia32_cvtss2sd(tmp_V2d, tmp_V4f);
+  (void) __builtin_ia32_clflush(tmp_vCp);
+  (void) __builtin_ia32_lfence();
+  (void) __builtin_ia32_mfence();
+  tmp_V16c = __builtin_ia32_loaddqu(tmp_cCp);
+  (void) __builtin_ia32_storedqu(tmp_cp, tmp_V16c);
+  tmp_V4s = __builtin_ia32_psllwi(tmp_V4s, tmp_i);
+  tmp_V2i = __builtin_ia32_pslldi(tmp_V2i, tmp_i);
+  tmp_V1LLi = __builtin_ia32_psllqi(tmp_V1LLi, tmp_i);
+  tmp_V4s = __builtin_ia32_psrawi(tmp_V4s, tmp_i);
+  tmp_V2i = __builtin_ia32_psradi(tmp_V2i, tmp_i);
+  tmp_V4s = __builtin_ia32_psrlwi(tmp_V4s, tmp_i);
+  tmp_V2i = __builtin_ia32_psrldi(tmp_V2i, tmp_i);
+  tmp_V1LLi = __builtin_ia32_psrlqi(tmp_V1LLi, tmp_i);
+  tmp_V1LLi = __builtin_ia32_pmuludq(tmp_V2i, tmp_V2i);
+  tmp_V2LLi = __builtin_ia32_pmuludq128(tmp_V4i, tmp_V4i);
+  tmp_V8s = __builtin_ia32_psraw128(tmp_V8s, tmp_V8s);
+  tmp_V4i = __builtin_ia32_psrad128(tmp_V4i, tmp_V4i);
+  tmp_V8s = __builtin_ia32_psrlw128(tmp_V8s, tmp_V8s);
+  tmp_V4i = __builtin_ia32_psrld128(tmp_V4i, tmp_V4i);
+  tmp_V2LLi = __builtin_ia32_psrlq128(tmp_V2LLi, tmp_V2LLi);
+  tmp_V8s = __builtin_ia32_psllw128(tmp_V8s, tmp_V8s);
+  tmp_V4i = __builtin_ia32_pslld128(tmp_V4i, tmp_V4i);
+  tmp_V2LLi = __builtin_ia32_psllq128(tmp_V2LLi, tmp_V2LLi);
+  tmp_V8s = __builtin_ia32_psllwi128(tmp_V8s, tmp_i);
+  tmp_V4i = __builtin_ia32_pslldi128(tmp_V4i, tmp_i);
+  tmp_V2LLi = __builtin_ia32_psllqi128(tmp_V2LLi, tmp_i);
+  tmp_V8s = __builtin_ia32_psrlwi128(tmp_V8s, tmp_i);
+  tmp_V4i = __builtin_ia32_psrldi128(tmp_V4i, tmp_i);
+  tmp_V2LLi = __builtin_ia32_psrlqi128(tmp_V2LLi, tmp_i);
+  tmp_V8s = __builtin_ia32_psrawi128(tmp_V8s, tmp_i);
+  tmp_V4i = __builtin_ia32_psradi128(tmp_V4i, tmp_i);
+  tmp_V8s = __builtin_ia32_pmaddwd128(tmp_V8s, tmp_V8s);
+  (void) __builtin_ia32_monitor(tmp_vp, tmp_Ui, tmp_Ui);
+  (void) __builtin_ia32_mwait(tmp_Ui, tmp_Ui);
+#ifdef USE_ALL
+  tmp_V4f = __builtin_ia32_movshdup(tmp_V4f);
+  tmp_V4f = __builtin_ia32_movsldup(tmp_V4f);
+#endif
+  tmp_V16c = __builtin_ia32_lddqu(tmp_cCp);
+  tmp_V2LLi = __builtin_ia32_palignr128(tmp_V2LLi, tmp_V2LLi, imm_i);
+  tmp_V1LLi = __builtin_ia32_palignr(tmp_V1LLi, tmp_V1LLi, imm_i);
+  tmp_V2i = __builtin_ia32_vec_init_v2si(tmp_i, tmp_i);
+  tmp_V4s = __builtin_ia32_vec_init_v4hi(tmp_s, tmp_s, tmp_s, tmp_s);
+  tmp_V8c = __builtin_ia32_vec_init_v8qi(tmp_c, tmp_c, tmp_c, tmp_c, tmp_c, tmp_c, tmp_c, tmp_c);
+  tmp_d = __builtin_ia32_vec_ext_v2df(tmp_V2d, imm_i_0_2);
+  tmp_LLi = __builtin_ia32_vec_ext_v2di(tmp_V2LLi, imm_i_0_2);
+  tmp_f = __builtin_ia32_vec_ext_v4sf(tmp_V4f, imm_i_0_4);
+  tmp_i = __builtin_ia32_vec_ext_v4si(tmp_V4i, imm_i_0_4);
+#ifdef USE_ALL
+  tmp_Us = __builtin_ia32_vec_ext_v8hi(tmp_V8s, imm_i_0_8);
+  tmp_s = __builtin_ia32_vec_ext_v4hi(tmp_V4s, imm_i_0_4);
+#endif
+  tmp_i = __builtin_ia32_vec_ext_v2si(tmp_V2i, imm_i_0_2);
+  tmp_V8s = __builtin_ia32_vec_set_v8hi(tmp_V8s, tmp_s, imm_i_0_8);
+  tmp_V4s = __builtin_ia32_vec_set_v4hi(tmp_V4s, tmp_s, imm_i_0_4);
+  tmp_V4i = __builtin_ia32_loadlv4si(tmp_V2ip);
+  (void) __builtin_ia32_storelv4si(tmp_V2ip, tmp_V2LLi);
+#ifdef USE_SSE4
+  tmp_V16c = __builtin_ia32_pblendvb128(tmp_V16c, tmp_V16c, tmp_V16c);
+  tmp_V8s = __builtin_ia32_pblendw128(tmp_V8s, tmp_V8s, imm_i_0_256);
+  tmp_V2d = __builtin_ia32_blendpd(tmp_V2d, tmp_V2d, imm_i_0_256);
+  tmp_V4f = __builtin_ia32_blendps(tmp_V4f, tmp_V4f, imm_i_0_256);
+  tmp_V2d = __builtin_ia32_blendvpd(tmp_V2d, tmp_V2d, tmp_V2d);
+  tmp_V4f = __builtin_ia32_blendvps(tmp_V4f, tmp_V4f, tmp_V4f);
+  tmp_V8s = __builtin_ia32_packusdw128(tmp_V4i, tmp_V4i);
+  tmp_V16c = __builtin_ia32_pmaxsb128(tmp_V16c, tmp_V16c);
+  tmp_V4i = __builtin_ia32_pmaxsd128(tmp_V4i, tmp_V4i);
+  tmp_V4i = __builtin_ia32_pmaxud128(tmp_V4i, tmp_V4i);
+  tmp_V8s = __builtin_ia32_pmaxuw128(tmp_V8s, tmp_V8s);
+  tmp_V16c = __builtin_ia32_pminsb128(tmp_V16c, tmp_V16c);
+  tmp_V4i = __builtin_ia32_pminsd128(tmp_V4i, tmp_V4i);
+  tmp_V4i = __builtin_ia32_pminud128(tmp_V4i, tmp_V4i);
+  tmp_V8s = __builtin_ia32_pminuw128(tmp_V8s, tmp_V8s);
+  tmp_V4i = __builtin_ia32_pmovsxbd128(tmp_V16c);
+  tmp_V2LLi = __builtin_ia32_pmovsxbq128(tmp_V16c);
+  tmp_V8s = __builtin_ia32_pmovsxbw128(tmp_V16c);
+  tmp_V2LLi = __builtin_ia32_pmovsxdq128(tmp_V4i);
+  tmp_V4i = __builtin_ia32_pmovsxwd128(tmp_V8s);
+  tmp_V2LLi = __builtin_ia32_pmovsxwq128(tmp_V8s);
+  tmp_V4i = __builtin_ia32_pmovzxbd128(tmp_V16c);
+  tmp_V2LLi = __builtin_ia32_pmovzxbq128(tmp_V16c);
+  tmp_V8s = __builtin_ia32_pmovzxbw128(tmp_V16c);
+  tmp_V2LLi = __builtin_ia32_pmovzxdq128(tmp_V4i);
+  tmp_V4i = __builtin_ia32_pmovzxwd128(tmp_V8s);
+  tmp_V2LLi = __builtin_ia32_pmovzxwq128(tmp_V8s);
+  tmp_V2LLi = __builtin_ia32_pmuldq128(tmp_V4i, tmp_V4i);
+  tmp_V4i = __builtin_ia32_pmulld128(tmp_V4i, tmp_V4i);
+  tmp_V4f = __builtin_ia32_roundps(tmp_V4f, imm_i_0_16);
+  //  tmp_V4f = __builtin_ia32_roundss(tmp_V4f, tmp_V4f, imm_i_0_16);
+  //  tmp_V2d = __builtin_ia32_roundsd(tmp_V2d, tmp_V2d, imm_i_0_16);
+  tmp_V2d = __builtin_ia32_roundpd(tmp_V2d, imm_i_0_16);
+  tmp_V16c = __builtin_ia32_vec_set_v16qi(tmp_V16c, tmp_i, tmp_i);
+  tmp_V4i  = __builtin_ia32_vec_set_v4si(tmp_V4i, tmp_i, tmp_i);
+  tmp_V4f = __builtin_ia32_insertps128(tmp_V4f, tmp_V4f, tmp_i);
+  tmp_V2LLi = __builtin_ia32_vec_set_v2di(tmp_V2LLi, tmp_LLi, tmp_i);
+#endif
+}
+
+
diff --git a/test/CodeGen/builtins.c b/test/CodeGen/builtins.c
new file mode 100644
index 0000000..ce5cd74
--- /dev/null
+++ b/test/CodeGen/builtins.c
@@ -0,0 +1,124 @@
+// RUN: clang-cc -emit-llvm -o %t %s &&
+// RUN: not grep __builtin %t
+
+#include <stdio.h>
+#include <math.h>
+
+void p(char *str, int x) {
+  printf("%s: %d\n", str, x);
+}
+void q(char *str, double x) {
+  printf("%s: %f\n", str, x);
+}
+
+int main() {
+  int N = random();
+#define P(n,args) p(#n #args, __builtin_##n args)
+#define Q(n,args) q(#n #args, __builtin_##n args)
+#define V(n,args) p(#n #args, (__builtin_##n args, 0))
+  P(types_compatible_p, (int, float));
+  P(choose_expr, (0, 10, 20));
+  P(constant_p, (sizeof(10)));
+  P(expect, (N == 12, 0)); 
+  V(prefetch, (&N));
+  V(prefetch, (&N, 1));
+  V(prefetch, (&N, 1, 0));
+  
+  // Numeric Constants
+
+  Q(huge_val, ());
+  Q(huge_valf, ());
+  Q(huge_vall, ());
+  Q(inf, ());
+  Q(inff, ());
+  Q(infl, ());
+
+  // FIXME:
+  // XXX note funny semantics for the (last) argument
+  //  P(fpclassify, (FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, 1.0));
+  //  P(isinf_sign, (1.0));
+
+  Q(nan, (""));
+  Q(nanf, (""));
+  Q(nanl, (""));
+  Q(nans, (""));
+  Q(nan, ("10"));
+  Q(nanf, ("10"));
+  Q(nanl, ("10"));
+  Q(nans, ("10"));
+
+  P(isgreater, (1., 2.));
+  P(isgreaterequal, (1., 2.));
+  P(isless, (1., 2.));
+  P(islessequal, (1., 2.));
+  P(islessgreater, (1., 2.));
+  P(isunordered, (1., 2.));
+
+  // Bitwise & Numeric Functions
+
+  P(abs, (N));
+
+  P(clz, (N));
+  P(clzl, (N));
+  P(clzll, (N));
+  P(ctz, (N));
+  P(ctzl, (N));
+  P(ctzll, (N));
+  P(ffs, (N));
+  P(ffsl, (N));
+  P(ffsll, (N));
+  P(parity, (N));
+  P(parityl, (N));
+  P(parityll, (N));
+  P(popcount, (N));
+  P(popcountl, (N));
+  P(popcountll, (N));
+  Q(powi, (1.2f, N));
+  Q(powif, (1.2f, N));
+  Q(powil, (1.2f, N));
+
+  // Lib functions
+  int a, b, n = random(); // Avoid optimizing out.
+  char s0[10], s1[] = "Hello";
+  V(strcat, (s0, s1));
+  V(strcmp, (s0, s1));
+  V(strncat, (s0, s1, n));
+  V(strchr, (s0, s1[0]));
+  V(strrchr, (s0, s1[0]));
+  V(strcpy, (s0, s1));
+  V(strncpy, (s0, s1, n));
+  
+  // Object size checking
+  V(__memset_chk, (s0, 0, sizeof s0, n));
+  V(__memcpy_chk, (s0, s1, sizeof s0, n));
+  V(__memmove_chk, (s0, s1, sizeof s0, n));
+  V(__mempcpy_chk, (s0, s1, sizeof s0, n));
+  V(__strncpy_chk, (s0, s1, sizeof s0, n));
+  V(__strcpy_chk, (s0, s1, n));
+  s0[0] = 0;
+  V(__strcat_chk, (s0, s1, n));
+  P(object_size, (s0, 0));
+  P(object_size, (s0, 1));
+  P(object_size, (s0, 2));
+  P(object_size, (s0, 3));
+
+  // Whatever
+
+  P(bswap32, (N));
+  P(bswap64, (N));
+  // FIXME
+  // V(clear_cache, (&N, &N+1));
+  V(trap, ());
+  P(extract_return_addr, (&N));
+
+  return 0;
+}
+
+
+
+void strcat() {}
+
+void foo() {
+ __builtin_strcat(0, 0);
+}
+
diff --git a/test/CodeGen/builtinshufflevector.c b/test/CodeGen/builtinshufflevector.c
new file mode 100644
index 0000000..9a3ae61
--- /dev/null
+++ b/test/CodeGen/builtinshufflevector.c
@@ -0,0 +1,5 @@
+// RUN: clang-cc -emit-llvm < %s | grep 'shufflevector' | count 1
+typedef int v4si __attribute__ ((vector_size (16)));
+
+v4si a(v4si x, v4si y) {return __builtin_shufflevector(x, y, 3, 2, 5, 7);}
+
diff --git a/test/CodeGen/c-strings.c b/test/CodeGen/c-strings.c
new file mode 100644
index 0000000..ee85f60
--- /dev/null
+++ b/test/CodeGen/c-strings.c
@@ -0,0 +1,36 @@
+// RUN: clang-cc -emit-llvm -o %t %s &&
+// RUN: grep "hello" %t | count 3 &&
+// RUN: grep 'c"hello\\00"' %t | count 2 &&
+// RUN: grep 'c"hello\\00\\00\\00"' %t | count 1 &&
+// RUN: grep 'c"ola"' %t | count 1
+
+/* Should be 3 hello string, two global (of different sizes), the rest
+   are shared. */
+
+void f0() {
+  bar("hello");
+}
+
+void f1() {
+  static char *x = "hello";
+  bar(x);
+}
+
+void f2() {
+  static char x[] = "hello";
+  bar(x);
+}
+
+void f3() {
+  static char x[8] = "hello";
+  bar(x);
+}
+
+void f4() {
+  static struct s {
+    char *name;
+  } x = { "hello" };
+  gaz(&x);
+}
+
+char x[3] = "ola";
diff --git a/test/CodeGen/cast-to-union.c b/test/CodeGen/cast-to-union.c
new file mode 100644
index 0000000..03aee3e
--- /dev/null
+++ b/test/CodeGen/cast-to-union.c
@@ -0,0 +1,13 @@
+// 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
+
+union u { int i; double d; };
+
+void foo() {
+  union u ola = (union u) 351;
+}
+
+union u w = (union u)2;
+union u y = (union u)73.0;
diff --git a/test/CodeGen/cast.c b/test/CodeGen/cast.c
new file mode 100644
index 0000000..6fb2b11
--- /dev/null
+++ b/test/CodeGen/cast.c
@@ -0,0 +1,6 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+
+extern void go(const void *p);
+float v[2] = { 0.0, 1.0 };
+void foo(void) { go(v); }
+
diff --git a/test/CodeGen/cfstring.c b/test/CodeGen/cfstring.c
new file mode 100644
index 0000000..a78dfda
--- /dev/null
+++ b/test/CodeGen/cfstring.c
@@ -0,0 +1,13 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+#define CFSTR __builtin___CFStringMakeConstantString
+
+void f() {
+  CFSTR("Hello, World!");
+}
+
+// rdar://6248329
+void *G = CFSTR("yo joe");
+
+void h() {
+  static void* h = CFSTR("Goodbye, World!");
+}
diff --git a/test/CodeGen/cfstring2.c b/test/CodeGen/cfstring2.c
new file mode 100644
index 0000000..ceefeb9
--- /dev/null
+++ b/test/CodeGen/cfstring2.c
@@ -0,0 +1,13 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+typedef const struct __CFString * CFStringRef;
+
+#define CFSTR(x) (CFStringRef) __builtin___CFStringMakeConstantString (x)
+
+void f() {
+  CFSTR("Hello, World!");
+}
+
+// rdar://6151192
+void *G = CFSTR("yo joe");
+
diff --git a/test/CodeGen/cleanup-stack.c b/test/CodeGen/cleanup-stack.c
new file mode 100644
index 0000000..b0c5e88
--- /dev/null
+++ b/test/CodeGen/cleanup-stack.c
@@ -0,0 +1,25 @@
+// RUN: clang-cc -triple i386-unknown-unknown -O3 -emit-llvm %s -o %t &&
+// RUN: grep "ret i32 9" %t
+
+struct s0 {
+  int *var;
+  int addend;
+};
+
+static void f0(struct s0 *p) {
+  *p->var += p->addend;
+}
+
+int f1(void) {
+  int var = 0;
+  
+  {
+    struct s0 x __attribute__((cleanup(f0))) = { &var, 2 };  
+    struct s0 y __attribute__((cleanup(f0))) = { &var, 3 };
+    {
+      struct s0 y __attribute__((cleanup(f0))) = { &var, 4 };
+    }
+  }
+
+  return var;
+}
diff --git a/test/CodeGen/complex.c b/test/CodeGen/complex.c
new file mode 100644
index 0000000..6a0d3d6
--- /dev/null
+++ b/test/CodeGen/complex.c
@@ -0,0 +1,61 @@
+// RUN: clang-cc -emit-llvm < %s
+
+int main(void)
+{
+  double _Complex a = 5;
+  double _Complex b = 42;
+
+  return a * b != b * a;
+}
+
+_Complex double bar(int);
+void test(_Complex double*);
+void takecomplex(_Complex double);
+
+void test2(int c) {
+  _Complex double X;
+  X = bar(1);
+  test(&X);
+  takecomplex(X);
+}
+
+_Complex double g1, g2;
+_Complex float cf;
+double D;
+
+void test3() {
+  g1 = g1 + g2;
+  g1 = g1 - g2;
+  g1 = g1 * g2;
+  g1 = +-~g1;
+
+  double Gr = __real g1;
+
+  cf += D;
+  // FIXME: Currently unsupported!
+  //D += cf;
+  cf /= g1;
+  g1 = g1 + D;
+  g1 = D + g1;
+}
+
+void t1() {
+  (__real__ cf) = 4.0;
+}
+
+void t2() {
+  (__imag__ cf) = 4.0;
+}
+
+// PR1960
+void t3() {
+  __complex__ long long v = 2;
+}
+
+// PR3131
+float _Complex t4();
+
+void t5() {
+  float _Complex x = t4();
+}
+
diff --git a/test/CodeGen/compound-literal.c b/test/CodeGen/compound-literal.c
new file mode 100644
index 0000000..ef04367
--- /dev/null
+++ b/test/CodeGen/compound-literal.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc < %s -emit-llvm
+
+int* a = &(int){1};
+struct s {int a, b, c;} * b = &(struct s) {1, 2, 3};
+// Not working; complex constants are broken
+// _Complex double * x = &(_Complex double){1.0f};
+
+int xxx() {
+int* a = &(int){1};
+struct s {int a, b, c;} * b = &(struct s) {1, 2, 3};
+_Complex double * x = &(_Complex double){1.0f};
+}
diff --git a/test/CodeGen/compound-type.c b/test/CodeGen/compound-type.c
new file mode 100644
index 0000000..352f6cc
--- /dev/null
+++ b/test/CodeGen/compound-type.c
@@ -0,0 +1,7 @@
+// RUN: clang-cc < %s -emit-llvm -triple i686-pc-linux-gnu > %t &&
+// RUN: grep "div i32" %t &&
+// RUN: grep "shl i32" %t
+
+unsigned char a,b;
+void c(void) {a <<= b;}
+void d(void) {a /= b;}
diff --git a/test/CodeGen/compound.c b/test/CodeGen/compound.c
new file mode 100644
index 0000000..c546007
--- /dev/null
+++ b/test/CodeGen/compound.c
@@ -0,0 +1,25 @@
+// RUN: clang-cc < %s -emit-llvm
+int A;
+long long B;
+int C;
+int *P;
+void test1() {
+  C = (A /= B);
+
+  P -= 4;
+
+  C = P - (P+10);
+}
+
+short x; 
+void test2(char c) { x += c; }
+
+void foo(char *strbuf) {
+  int stufflen = 4;
+  strbuf += stufflen;
+}
+
+
+// Aggregate cast to void
+union uu { int a;}; void f(union uu p) { (void) p;}
+
diff --git a/test/CodeGen/conditional-gnu-ext.c b/test/CodeGen/conditional-gnu-ext.c
new file mode 100644
index 0000000..1483d8a
--- /dev/null
+++ b/test/CodeGen/conditional-gnu-ext.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+// PR1824
+
+int foo(int x, short y) {
+  return x ?: y;
+}
+
+// rdar://6586493
+float test(float x, int Y) {
+  return Y != 0 ? : x;
+}
+
diff --git a/test/CodeGen/conditional.c b/test/CodeGen/conditional.c
new file mode 100644
index 0000000..2228670
--- /dev/null
+++ b/test/CodeGen/conditional.c
@@ -0,0 +1,44 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+float test1(int cond, float a, float b)
+{
+  return cond ? a : b;
+}
+double test2(int cond, float a, double b)
+{
+  return cond ? a : b;
+}
+
+void f();
+
+void test3(){
+   1 ? f() : (void)0;
+}
+
+void test4() {
+int i; short j;
+float* k = 1 ? &i : &j;
+}
+
+void test5() {
+  const int* cip;
+  void* vp;
+  cip = 0 ? vp : cip;
+}
+
+void test6();
+void test7(int);
+void* test8() {return 1 ? test6 : test7;}
+
+
+void _efree(void *ptr);
+
+void _php_stream_free3()
+{
+	(1 ? free(0) : _efree(0));
+}
+
+void _php_stream_free4()
+{
+	1 ? _efree(0) : free(0);
+}
diff --git a/test/CodeGen/const-init.c b/test/CodeGen/const-init.c
new file mode 100644
index 0000000..0364cc1
--- /dev/null
+++ b/test/CodeGen/const-init.c
@@ -0,0 +1,104 @@
+// RUN: clang-cc -triple i386-pc-linux-gnu -verify -emit-llvm -o %t %s &&
+
+#include <stdint.h>
+
+// Brace-enclosed string array initializers
+char a[] = { "asdf" };
+
+// Double-implicit-conversions of array/functions (not legal C, but
+// clang accepts it for gcc compat).
+intptr_t b = a; // expected-warning {{incompatible pointer to integer conversion}}
+int c();
+void *d = c;
+intptr_t e = c; // expected-warning {{incompatible pointer to integer conversion}}
+
+int f, *g = __extension__ &f, *h = (1 != 1) ? &f : &f;
+
+union s2 {
+  struct {
+    struct { } *f0;
+  } f0;
+};
+
+int g0 = (int)(&(((union s2 *) 0)->f0.f0) - 0);
+
+// RUN: grep '@g1x = global %. { double 1.000000e+00, double 0.000000e+00 }' %t &&
+_Complex double g1x = 1.0f;
+// RUN: grep '@g1y = global %. { double 0.000000e+00, double 1.000000e+00 }' %t &&
+_Complex double g1y = 1.0fi;
+// RUN: grep '@g1 = global %. { i8 1, i8 10 }' %t &&
+_Complex char g1 = (char) 1 + (char) 10 * 1i;
+// RUN: grep '@g2 = global %2 { i32 1, i32 10 }' %t &&
+_Complex int g2 = 1 + 10i;
+// RUN: grep '@g3 = global %. { float 1.000000e+00, float 1.000000e+01 }' %t &&
+_Complex float g3 = 1.0 + 10.0i;
+// RUN: grep '@g4 = global %. { double 1.000000e+00, double 1.000000e+01 }' %t &&
+_Complex double g4 = 1.0 + 10.0i;
+// RUN: grep '@g5 = global %2 zeroinitializer' %t &&
+_Complex int g5 = (2 + 3i) == (5 + 7i);
+// RUN: grep '@g6 = global %. { double -1.100000e+01, double 2.900000e+01 }' %t &&
+_Complex double g6 = (2.0 + 3.0i) * (5.0 + 7.0i);
+// RUN: grep '@g7 = global i32 1' %t &&
+int g7 = (2 + 3i) * (5 + 7i) == (-11 + 29i);
+// RUN: grep '@g8 = global i32 1' %t &&
+int g8 = (2.0 + 3.0i) * (5.0 + 7.0i) == (-11.0 + 29.0i);
+// RUN: grep '@g9 = global i32 0' %t &&
+int g9 = (2 + 3i) * (5 + 7i) != (-11 + 29i);
+// RUN: grep '@g10 = global i32 0' %t &&
+int g10 = (2.0 + 3.0i) * (5.0 + 7.0i) != (-11.0 + 29.0i);
+
+
+// Global references
+// RUN: grep '@g11.l0 = internal global i32 ptrtoint (i32 ()\* @g11 to i32)' %t &&
+long g11() { 
+  static long l0 = (long) g11;
+  return l0; 
+}
+
+// RUN: grep '@g12 = global i32 ptrtoint (i8\* @g12_tmp to i32)' %t &&
+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 &&
+struct g13_s0 {
+   long a;
+};
+struct g13_s0 g13[] = {
+   { (long) &g12_tmp }
+};
+
+// RUN: grep '@g14 = global i8\* inttoptr (i64 100 to i8\*)' %t &&
+void *g14 = (void*) 100;
+
+// RUN: grep '@g15 = global i32 -1' %t &&
+int g15 = (int) (char) ((void*) 0 + 255);
+
+// RUN: grep '@g16 = global i64 4294967295' %t &&
+long long g16 = (long long) ((void*) 0xFFFFFFFF);
+
+// RUN: grep '@g17 = global i32\* @g15' %t &&
+int *g17 = (int *) ((long) &g15);
+
+// RUN: grep '@g18.p = internal global \[1 x i32\*\] \[i32\* @g19\]' %t &&
+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 &&
+
+struct g20_s0;
+struct g20_s1 {
+  struct g20_s0 *f0, **f1;
+};
+void *g20(void) {
+  static struct g20_s1 l0 = { ((void*) 0), &l0.f0 };
+  return l0.f1;
+}
+
+// PR4108
+struct g21 {int g21;};
+const struct g21 g21 = (struct g21){1};
+
+// RUN: true
+
diff --git a/test/CodeGen/const-label-addr.c b/test/CodeGen/const-label-addr.c
new file mode 100644
index 0000000..f8c35c6
--- /dev/null
+++ b/test/CodeGen/const-label-addr.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+int a() {
+A:;static void* a = &&A;
+}
diff --git a/test/CodeGen/constant-comparison.c b/test/CodeGen/constant-comparison.c
new file mode 100644
index 0000000..ea3e896
--- /dev/null
+++ b/test/CodeGen/constant-comparison.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc -emit-llvm %s -o - 2>&1 | not grep warning &&
+// RUN: clang-cc -emit-llvm %s -o - | grep @b | count 1
+
+int a, b;
+int *c1 = 1 < 2 ? &a : &b;
+int *c2 = 3 != 3LL ? &b : &a;
+int *c3 = !(3 <= 4.0) ? &b : &a;
+int *c4 = &a - (6 * 5 > 30);
+int *c5 = &a + (6 * 5 >= 30);
+int c6 = 44 < 33;
+
+
diff --git a/test/CodeGen/constructor-attribute.c b/test/CodeGen/constructor-attribute.c
new file mode 100644
index 0000000..9a1fa76
--- /dev/null
+++ b/test/CodeGen/constructor-attribute.c
@@ -0,0 +1,38 @@
+// RUN: clang-cc -emit-llvm -o %t %s &&
+// RUN: grep -e "global_ctors.*@A" %t &&
+// RUN: grep -e "global_dtors.*@B" %t &&
+// RUN: grep -e "global_ctors.*@C" %t &&
+// RUN: grep -e "global_dtors.*@D" %t
+
+#include <stdio.h>
+
+void A() __attribute__((constructor));
+void B() __attribute__((destructor));
+
+void A() {
+  printf("A\n");
+}
+
+void B() {
+  printf("B\n");
+}
+
+static void C() __attribute__((constructor));
+
+static void D() __attribute__((destructor));
+
+static int foo() {
+  return 10;
+}
+
+static void C() {
+  printf("A: %d\n", foo());
+}
+
+static void D() {
+  printf("B\n");
+}
+
+int main() {
+  return 0;
+}
diff --git a/test/CodeGen/cxx-condition.cpp b/test/CodeGen/cxx-condition.cpp
new file mode 100644
index 0000000..330a17a
--- /dev/null
+++ b/test/CodeGen/cxx-condition.cpp
@@ -0,0 +1,9 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+void f() {
+  int a;
+  if (int x=a) ++a; else a=x;
+  while (int x=a) ++a;
+  for (; int x=a; --a) ;
+  switch (int x=0) { }
+}
diff --git a/test/CodeGen/cxx-default-arg.cpp b/test/CodeGen/cxx-default-arg.cpp
new file mode 100644
index 0000000..8391b9c
--- /dev/null
+++ b/test/CodeGen/cxx-default-arg.cpp
@@ -0,0 +1,25 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+// Note: define CLANG_GENERATE_KNOWN_GOOD and compile to generate code
+// that makes all of the defaulted arguments explicit. The resulting
+// byte code should be identical to the compilation without
+// CLANG_GENERATE_KNOWN_GOOD.
+#ifdef CLANG_GENERATE_KNOWN_GOOD
+#  define DEFARG(...) __VA_ARGS__
+#else
+#  define DEFARG(...)
+#endif
+
+extern int x;
+struct S { float x; float y; } s;
+double _Complex c;
+
+void f(int i = 0, int j = 1, int k = x, struct S t = s, double _Complex d = c);
+
+void g() {
+  f(0, 1, x, s DEFARG(, c));
+  f(0, 1, x DEFARG(, s, c));
+  f(0, 1 DEFARG(, x, s, c));
+  f(0 DEFARG(, 1, x, s, c));
+  f(DEFARG(0, 1, x, s, c));
+}
diff --git a/test/CodeGen/cxx-value-init.cpp b/test/CodeGen/cxx-value-init.cpp
new file mode 100644
index 0000000..e238698
--- /dev/null
+++ b/test/CodeGen/cxx-value-init.cpp
@@ -0,0 +1,11 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+enum E {};
+int v1 = E();
+float v2 = float();
+
+void f() {
+  int v3 = int();
+  _Complex int v4 = typeof(_Complex int)();
+  _Complex float v5 = typeof(_Complex float)();
+}
diff --git a/test/CodeGen/darwin-string-literals.c b/test/CodeGen/darwin-string-literals.c
new file mode 100644
index 0000000..ff245fc
--- /dev/null
+++ b/test/CodeGen/darwin-string-literals.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc -triple i386-apple-darwin9 -emit-llvm %s -o %t &&
+
+// 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
+
+const char *g0 = "string0";
+const void *g1 = __builtin___CFStringMakeConstantString("string1");
+const void *g2 = __builtin___CFStringMakeConstantString("hello \u2192 \u2603 \u2190 world");
diff --git a/test/CodeGen/debug-info.c b/test/CodeGen/debug-info.c
new file mode 100644
index 0000000..e0ec2c9
--- /dev/null
+++ b/test/CodeGen/debug-info.c
@@ -0,0 +1,37 @@
+// RUN: clang-cc -o %t --emit-llvm -g %s
+
+// PR3023
+void convert(void) {
+  struct { typeof(0) f0; } v0;
+}
+
+// PR2784
+struct OPAQUE;
+typedef struct OPAQUE *PTR;
+PTR p;
+
+
+// PR2950
+struct s0;
+struct s0 { struct s0 *p; } g0;
+
+struct s0 *f0(struct s0 *a0) {
+  return a0->p;
+}
+
+// PR3134
+char xpto[];
+
+// PR3427
+struct foo {
+	int a;
+	void *ptrs[];
+};
+struct foo bar;
+
+// PR4143
+struct foo2 {
+        enum bar *bar;
+};
+
+struct foo2 foo2;
diff --git a/test/CodeGen/designated-initializers.c b/test/CodeGen/designated-initializers.c
new file mode 100644
index 0000000..4669339
--- /dev/null
+++ b/test/CodeGen/designated-initializers.c
@@ -0,0 +1,21 @@
+// 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"
+
+struct foo {
+    void *a;
+    int b;
+};
+
+union { int i; float f; } u = { };
+
+int main(int argc, char **argv)
+{
+  union { int i; float f; } u2 = { };
+    static struct foo foo = {
+        .b = 1024,
+    };
+}
+
+int b[2] = {
+    [1] 22
+};
diff --git a/test/CodeGen/dllimport-dllexport.c b/test/CodeGen/dllimport-dllexport.c
new file mode 100644
index 0000000..fe49ae7
--- /dev/null
+++ b/test/CodeGen/dllimport-dllexport.c
@@ -0,0 +1,7 @@
+// RUN: clang-cc -emit-llvm < %s -o %t &&
+// RUN: grep 'dllexport' %t | count 1 &&
+// RUN: not grep 'dllimport' %t
+
+void __attribute__((dllimport)) foo1();
+void __attribute__((dllexport)) foo1(){}
+void __attribute__((dllexport)) foo2();
diff --git a/test/CodeGen/dostmt.c b/test/CodeGen/dostmt.c
new file mode 100644
index 0000000..4fb3dcd
--- /dev/null
+++ b/test/CodeGen/dostmt.c
@@ -0,0 +1,70 @@
+// RUN: clang-cc %s -emit-llvm -o -
+
+int bar();
+int test0() {
+  int i;
+  i = 1 + 2;
+  do {
+    i = bar();
+    i = bar();
+  } while(0);
+  return i;
+}
+
+
+int test1() {
+  int i;
+  i = 1 + 2;
+  do {
+    i = bar();
+    if (i == 42)
+      break;
+    i = bar();
+  } while(1);
+  return i;
+}
+
+
+int test2() {
+  int i;
+  i = 1 + 2;
+  do {
+    i = bar();
+    if (i == 42)
+      continue;
+    i = bar();
+  } while(1);
+  return i;
+}
+
+
+int test3() {
+  int i;
+  i = 1 + 2;
+  do {
+    i = bar();
+    if (i == 42)
+      break;
+  } while(0);
+  return i;
+}
+
+
+int test4() {
+  int i;
+  i = 1 + 2;
+  do {
+    i = bar();
+    if (i == 42)
+      continue;
+  } while(0);
+  return i;
+}
+
+// rdar://6103124
+void test5() {
+  do { break; } while(0);
+}
+
+ 
+
diff --git a/test/CodeGen/emit-all-decls.c b/test/CodeGen/emit-all-decls.c
new file mode 100644
index 0000000..775cb6f
--- /dev/null
+++ b/test/CodeGen/emit-all-decls.c
@@ -0,0 +1,8 @@
+// RUN: clang-cc -emit-llvm -o %t %s &&
+// RUN: not grep "@foo" %t &&
+// RUN: clang-cc -femit-all-decls -emit-llvm -o %t %s &&
+// RUN: grep "@foo" %t
+
+static void foo() {
+  
+}
diff --git a/test/CodeGen/empty-union-init.c b/test/CodeGen/empty-union-init.c
new file mode 100644
index 0000000..8448b3d
--- /dev/null
+++ b/test/CodeGen/empty-union-init.c
@@ -0,0 +1,13 @@
+// RUN: clang-cc -emit-llvm < %s -o -
+// PR2419
+
+struct Mem {
+        union {
+        } u;
+};
+
+struct Mem *columnMem(){
+        static const struct Mem nullMem = { {} };
+}
+
+
diff --git a/test/CodeGen/enum.c b/test/CodeGen/enum.c
new file mode 100644
index 0000000..172d308
--- /dev/null
+++ b/test/CodeGen/enum.c
@@ -0,0 +1,18 @@
+// RUN: clang-cc -triple i386-unknown-unknown %s -emit-llvm-bc -o - | opt -std-compile-opts | llvm-dis | grep 'ret i32 6'
+
+static enum { foo, bar = 1U } z;
+
+int main (void)
+{
+  int r = 0;
+
+  if (bar - 2 < 0)
+    r += 4;
+  if (foo - 1 < 0)
+    r += 2;
+  if (z - 1 < 0)
+    r++;
+
+  return r;
+}
+
diff --git a/test/CodeGen/exprs.c b/test/CodeGen/exprs.c
new file mode 100644
index 0000000..36cfff9
--- /dev/null
+++ b/test/CodeGen/exprs.c
@@ -0,0 +1,118 @@
+// RUN: clang-cc %s -emit-llvm -o -
+
+// PR1895
+// sizeof function
+int zxcv(void);
+int x=sizeof(zxcv);
+int y=__alignof__(zxcv);
+
+
+void *test(int *i) {
+ short a = 1;
+ i += a;
+ i + a;
+ a + i;
+}
+
+_Bool test2b; 
+int test2() {if (test2b);}
+
+// PR1921
+int test3() {
+  const unsigned char *bp;
+  bp -= (short)1;
+}
+
+// PR2080 - sizeof void
+int t1 = sizeof(void);
+int t2 = __alignof__(void);
+void test4() {
+  t1 = sizeof(void);
+  t2 = __alignof__(void);
+  
+  t1 = sizeof(test4());
+  t2 = __alignof__(test4());
+}
+
+// 'const float' promotes to double in varargs.
+int test5(const float x, float float_number) {
+  return __builtin_isless(x, float_number);
+}
+
+// this one shouldn't fold
+int ola() {
+  int a=2;
+  if ((0, (int)a) & 2) { return 1; }
+  return 2;
+}
+
+// this one shouldn't fold as well
+void eMaisUma() {
+	double t[1];
+	if (*t)
+		return;
+}
+
+// rdar://6520707
+void f0(void (*fp)(void), void (*fp2)(void)) {
+  int x = fp - fp2;
+}
+
+// noop casts as lvalues.
+struct X {
+  int Y;
+};
+struct X foo();
+int bar() {
+  return ((struct X)foo()).Y + 1;
+}
+
+// PR3809: INC/DEC of function pointers.
+void f2(void);
+unsigned f1(void) {
+  void (*fp)(void) = f2;
+  
+  ++fp;
+  fp++;
+  --fp;
+  fp--;
+  return (unsigned) fp;
+}  
+
+union f3_x {int x; float y;};
+int f3() {return ((union f3_x)2).x;}
+
+union f4_y {int x; _Complex float y;};
+_Complex float f4() {return ((union f4_y)(_Complex float)2.0).y;}
+
+struct f5_a { int a; } f5_a;
+union f5_z {int x; struct f5_a y;};
+struct f5_a f5() {return ((union f5_z)f5_a).y;}
+
+// ?: in "lvalue"
+struct s6 { int f0; };
+int f6(int a0, struct s6 a1, struct s6 a2) {
+  return (a0 ? a1 : a2).f0;
+}
+
+// PR4026
+void f7() {
+  __func__;
+}
+
+// PR4067
+int f8() {
+  return ({ foo(); }).Y;
+}
+
+// rdar://6880558
+struct S;
+struct C {
+  int i;
+  struct S *tab[];
+};
+struct S { struct C c; };
+void f9(struct S *x) {
+  foo(((void)1, x->c).tab[0]);
+}
+
diff --git a/test/CodeGen/ext-vector-shuffle.c b/test/CodeGen/ext-vector-shuffle.c
new file mode 100644
index 0000000..37d3ed4
--- /dev/null
+++ b/test/CodeGen/ext-vector-shuffle.c
@@ -0,0 +1,15 @@
+// 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;
+typedef __attribute__(( ext_vector_type(4) )) float float4;
+
+float2 test1(float4 V) {
+  return V.xy + V.wz;
+}
+
+float4 test2(float4 V) {
+  float2 W = V.ww;
+  return W.xyxy + W.yxyx;
+}
diff --git a/test/CodeGen/ext-vector.c b/test/CodeGen/ext-vector.c
new file mode 100644
index 0000000..e3b6211
--- /dev/null
+++ b/test/CodeGen/ext-vector.c
@@ -0,0 +1,129 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+typedef __attribute__(( ext_vector_type(4) )) float float4;
+typedef __attribute__(( ext_vector_type(2) )) float float2;
+typedef __attribute__(( ext_vector_type(4) )) int int4;
+
+float4 foo = (float4){ 1.0, 2.0, 3.0, 4.0 };
+
+const float4 bar = (float4){ 1.0, 2.0, 3.0, __builtin_inff() };
+
+float4 test1(float4 V) {
+  return V.wzyx+V;
+}
+
+float2 vec2, vec2_2;
+float4 vec4, vec4_2;
+float f;
+
+void test2() {
+    vec2 = vec4.xy;  // shorten
+    f = vec2.x;      // extract elt
+    vec4 = vec4.yyyy;  // splat
+    
+    vec2.x = f;      // insert one.
+    vec2.yx = vec2; // reverse
+}
+
+void test3(float4 *out) {
+  *out = ((float4) {1.0f, 2.0f, 3.0f, 4.0f });
+}
+
+void test4(float4 *out) {
+  float a = 1.0f;
+  float b = 2.0f;
+  float c = 3.0f;
+  float d = 4.0f;
+  *out = ((float4) {a,b,c,d});
+}
+
+void test5(float4 *out) {
+  float a;
+  float4 b;
+  
+  a = 1.0f;
+  b = a;
+  b = b * 5.0f;
+  b = 5.0f * b;
+  b *= a;
+  
+  *out = b;
+}
+
+void test6(float4 *ap, float4 *bp, float c) {
+  float4 a = *ap;
+  float4 b = *bp;
+  
+  a = a + b;
+  a = a - b;
+  a = a * b;
+  a = a / b;
+  
+  a = a + c;
+  a = a - c;
+  a = a * c;
+  a = a / c;
+
+  a += b;
+  a -= b;
+  a *= b;
+  a /= b;
+  
+  a += c;
+  a -= c;
+  a *= c;
+  a /= c;
+
+  // Vector comparisons can sometimes crash the x86 backend: rdar://6326239,
+  // reject them until the implementation is stable.
+#if 0
+  int4 cmp;
+  cmp = a < b;
+  cmp = a <= b;
+  cmp = a < b;
+  cmp = a >= b;
+  cmp = a == b;
+  cmp = a != b;
+#endif
+}
+
+void test7(int4 *ap, int4 *bp, int c) {
+  int4 a = *ap;
+  int4 b = *bp;
+  
+  a = a + b;
+  a = a - b;
+  a = a * b;
+  a = a / b;
+  a = a % b;
+  
+  a = a + c;
+  a = a - c;
+  a = a * c;
+  a = a / c;
+  a = a % c;
+
+  a += b;
+  a -= b;
+  a *= b;
+  a /= b;
+  a %= b;
+  
+  a += c;
+  a -= c;
+  a *= c;
+  a /= c;
+  a %= c;
+
+  // Vector comparisons can sometimes crash the x86 backend: rdar://6326239,
+  // reject them until the implementation is stable.
+#if 0
+  int4 cmp;
+  cmp = a < b;
+  cmp = a <= b;
+  cmp = a < b;
+  cmp = a >= b;
+  cmp = a == b;
+  cmp = a != b;
+#endif
+}
diff --git a/test/CodeGen/extern-block-var.c b/test/CodeGen/extern-block-var.c
new file mode 100644
index 0000000..e8de3e7
--- /dev/null
+++ b/test/CodeGen/extern-block-var.c
@@ -0,0 +1,6 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+
+int f() {
+  extern int a;
+  return a;
+}
diff --git a/test/CodeGen/flexible-array-init.c b/test/CodeGen/flexible-array-init.c
new file mode 100644
index 0000000..fb98a8e
--- /dev/null
+++ b/test/CodeGen/flexible-array-init.c
@@ -0,0 +1,8 @@
+// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm -o - %s | grep 7 | count 1 &&
+// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm -o - %s | grep 11 | count 1 &&
+// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm -o - %s | grep 13 | count 1 &&
+// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm -o - %s | grep 15 | count 1
+
+struct { int x; int y[]; } a = { 1, 7, 11 };
+
+struct { int x; int y[]; } b = { 1, { 13, 15 } };
diff --git a/test/CodeGen/func-decl-cleanup.c b/test/CodeGen/func-decl-cleanup.c
new file mode 100644
index 0000000..4808e12
--- /dev/null
+++ b/test/CodeGen/func-decl-cleanup.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc %s -emit-llvm -o -
+
+
+// PR2360
+typedef void fn_t();
+
+fn_t a,b;
+
+void b()
+{
+}
+
diff --git a/test/CodeGen/func-return-member.c b/test/CodeGen/func-return-member.c
new file mode 100644
index 0000000..e6fc562
--- /dev/null
+++ b/test/CodeGen/func-return-member.c
@@ -0,0 +1,23 @@
+// RUN: clang-cc -emit-llvm < %s 2>&1 | not grep 'cannot codegen this l-value expression yet'
+
+struct frk { float _Complex c; int x; };
+struct faz { struct frk f; };
+struct fuz { struct faz f; };
+
+extern struct fuz foo(void);
+
+int X;
+struct frk F;
+float _Complex C;
+
+void bar(void) {
+  X = foo().f.f.x;
+}
+
+void bun(void) {
+  F = foo().f.f;
+}
+
+void ban(void) {
+  C = foo().f.f.c;
+}
diff --git a/test/CodeGen/function-attributes.c b/test/CodeGen/function-attributes.c
new file mode 100644
index 0000000..ba2e4e4
--- /dev/null
+++ b/test/CodeGen/function-attributes.c
@@ -0,0 +1,69 @@
+// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm -o %t %s &&
+// RUN: grep 'define signext i8 @f0(i32 %x) nounwind' %t &&
+// RUN: grep 'define zeroext i8 @f1(i32 %x) nounwind' %t &&
+// RUN: grep 'define void @f2(i8 signext %x) nounwind' %t &&
+// RUN: grep 'define void @f3(i8 zeroext %x) nounwind' %t &&
+// RUN: grep 'define signext i16 @f4(i32 %x) nounwind' %t &&
+// RUN: grep 'define zeroext i16 @f5(i32 %x) nounwind' %t &&
+// RUN: grep 'define void @f6(i16 signext %x) nounwind' %t &&
+// RUN: grep 'define void @f7(i16 zeroext %x) nounwind' %t &&
+
+signed char f0(int x) { return x; }
+
+unsigned char f1(int x) { return x; }
+
+void f2(signed char x) { }
+
+void f3(unsigned char x) { }
+
+signed short f4(int x) { return x; }
+
+unsigned short f5(int x) { return x; }
+
+void f6(signed short x) { }
+
+void f7(unsigned short x) { }
+
+// RUN: grep 'define void @f8() nounwind alwaysinline' %t &&
+void __attribute__((always_inline)) f8(void) { }
+
+// RUN: grep 'call void @f9_t() noreturn' %t &&
+void __attribute__((noreturn)) f9_t(void);
+void f9(void) { f9_t(); }
+
+// FIXME: We should be setting nounwind on calls.
+// RUN: grep 'call i32 @f10_t() readnone' %t &&
+int __attribute__((const)) f10_t(void);
+int f10(void) { return f10_t(); }
+int f11(void) {
+ exit:
+  return f10_t();
+}
+int f12(int arg) {
+  return arg ? 0 : f10_t();
+}
+
+// RUN: grep 'define void @f13() nounwind readnone' %t &&
+void f13(void) __attribute__((pure)) __attribute__((const));
+void f13(void){}
+
+
+// Ensure that these get inlined: rdar://6853279
+// RUN: not grep '@ai_' %t &&
+static __inline__ __attribute__((always_inline))
+int ai_1() {  return 4; }
+
+static __inline__ __attribute__((always_inline))
+struct {
+  int a, b, c, d, e;
+} ai_2() { }
+
+
+int foo() {
+  ai_2();
+  return ai_1();
+}
+
+
+
+// RUN: true
diff --git a/test/CodeGen/function-decay.m b/test/CodeGen/function-decay.m
new file mode 100644
index 0000000..5652fdb
--- /dev/null
+++ b/test/CodeGen/function-decay.m
@@ -0,0 +1,10 @@
+// RUN: clang-cc %s -emit-llvm -o -
+
+@interface I0 @end
+@implementation I0
+- (void) im0: (int (void)) a0 {
+}
+@end
+
+void func(int pf(void)) {
+}
diff --git a/test/CodeGen/functions.c b/test/CodeGen/functions.c
new file mode 100644
index 0000000..9855992
--- /dev/null
+++ b/test/CodeGen/functions.c
@@ -0,0 +1,35 @@
+// RUN: clang-cc %s -emit-llvm -o %t &&
+
+int g();
+
+int foo(int i) {
+	return g(i);
+}
+
+int g(int i) {
+	return g(i);
+}
+
+// rdar://6110827
+typedef void T(void);
+void test3(T f) {
+  f();
+}
+
+int a(int);
+int a() {return 1;}
+
+// RUN: grep 'define void @f0()' %t &&
+void f0() {}
+
+void f1();
+// RUN: grep 'call void @f1()' %t &&
+void f2(void) {
+  f1(1, 2, 3);
+}
+// RUN: grep 'define void @f1()' %t &&
+void f1() {}
+
+// RUN: grep 'define .* @f3' %t | not grep -F '...'
+struct foo { int X, Y, Z; } f3() {
+}
diff --git a/test/CodeGen/global-decls.c b/test/CodeGen/global-decls.c
new file mode 100644
index 0000000..80222ea
--- /dev/null
+++ b/test/CodeGen/global-decls.c
@@ -0,0 +1,22 @@
+// RUN: clang-cc -triple i386-pc-linux-gnu -emit-llvm -o %t %s &&
+
+// RUN: grep '@g0_ext = extern_weak global i32' %t &&
+extern int g0_ext __attribute__((weak));
+// RUN: grep 'declare extern_weak i32 @g1_ext()' %t &&
+extern int __attribute__((weak)) g1_ext (void);
+
+// RUN: grep '@g0_common = weak global i32' %t &&
+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) {}
+
+// Force _ext references
+void f0() {
+  int a = g0_ext;
+  int b = g1_ext();
+}
+
+// RUN: true
diff --git a/test/CodeGen/global-init.c b/test/CodeGen/global-init.c
new file mode 100644
index 0000000..4b769f8
--- /dev/null
+++ b/test/CodeGen/global-init.c
@@ -0,0 +1,7 @@
+// RUN: clang-cc -emit-llvm -o - %s | not grep "common"
+
+// This checks that the global won't be marked as common. 
+// (It shouldn't because it's being initialized).
+
+int a;
+int a = 242;
diff --git a/test/CodeGen/global-with-initialiser.c b/test/CodeGen/global-with-initialiser.c
new file mode 100644
index 0000000..29b4e21
--- /dev/null
+++ b/test/CodeGen/global-with-initialiser.c
@@ -0,0 +1,25 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+const int globalInt = 1;
+int globalIntWithFloat = 1.5f;
+int globalIntArray[5] = { 1, 2 };
+int globalIntFromSizeOf = sizeof(globalIntArray);
+char globalChar = 'a';
+char globalCharArray[5] = { 'a', 'b' };
+float globalFloat = 1.0f;
+float globalFloatWithInt = 1;
+float globalFloatArray[5] = { 1.0f, 2.0f };
+double globalDouble = 1.0;
+double globalDoubleArray[5] = { 1.0, 2.0 };
+char *globalString = "abc";
+char *globalStringArray[5] = { "123", "abc" };
+long double globalLongDouble = 1;
+long double globalLongDoubleArray[5] = { 1.0, 2.0 };
+
+struct Struct {
+	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
new file mode 100644
index 0000000..2798cae
--- /dev/null
+++ b/test/CodeGen/globalinit.c
@@ -0,0 +1,51 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+int A[10] = { 1,2,3,4,5 };
+
+
+extern int x[];
+void foo() { x[0] = 1; }
+int x[10];
+void bar() { x[0] = 1; }
+
+
+extern int y[];
+void *g = y;
+
+int latin_ptr2len (char *p);
+int (*mb_ptr2len) (char *p) = latin_ptr2len;
+
+
+char string[8] = "string";   // extend init
+char string2[4] = "string";  // truncate init
+
+char *test(int c) {
+ static char buf[10];
+ static char *bufptr = buf;
+
+ return c ? buf : bufptr;
+}
+
+
+_Bool booltest = 0;
+void booltest2() {
+  static _Bool booltest3 = 4;
+}
+
+// Scalars in braces.
+static int a = { 1 };
+
+// References to enums.
+enum {
+	EnumA, EnumB
+};
+
+int c[] = { EnumA, EnumB };
+
+// Binary operators
+int d[] = { EnumA | EnumB };
+
+// PR1968
+static int array[];
+static int array[4];
+
diff --git a/test/CodeGen/illegal-UTF8.m b/test/CodeGen/illegal-UTF8.m
new file mode 100644
index 0000000..a9d5a37
--- /dev/null
+++ b/test/CodeGen/illegal-UTF8.m
@@ -0,0 +1,8 @@
+// RUN: clang %s -S -m64 -o -
+
+@class NSString;
+
+// FIXME: GCC emits the following warning:
+// CodeGen/illegal-UTF8.m:4: warning: input conversion stopped due to an input byte that does not belong to the input codeset UTF-8
+
+NSString *S = @"\xff\xff___WAIT___";
diff --git a/test/CodeGen/incomplete-function-type.c b/test/CodeGen/incomplete-function-type.c
new file mode 100644
index 0000000..a641268
--- /dev/null
+++ b/test/CodeGen/incomplete-function-type.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc -emit-llvm %s -o - | not grep opaque
+
+enum teste1 test1f(void), (*test1)(void) = test1f;
+struct tests2 test2f(), (*test2)() = test2f;
+struct tests3;
+void test3f(struct tests3), (*test3)(struct tests3) = test3f;
+enum teste1 { TEST1 };
+struct tests2 { int x,y,z,a,b,c,d,e,f,g; };
+struct tests3 { float x; };
+
diff --git a/test/CodeGen/indirect-goto.c b/test/CodeGen/indirect-goto.c
new file mode 100644
index 0000000..b9a6019
--- /dev/null
+++ b/test/CodeGen/indirect-goto.c
@@ -0,0 +1,20 @@
+// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm-bc -o - %s | opt -std-compile-opts | llvm-dis > %t &&
+// RUN: grep "ret i32" %t | count 1 &&
+// RUN: grep "ret i32 210" %t | count 1
+
+static int foo(unsigned i) {
+  const void *addrs[] = { &&L1, &&L2, &&L3, &&L4, &&L5 };
+  int res = 1;
+
+  goto *addrs[i];
+ L5: res *= 11;
+ L4: res *= 7;
+ L3: res *= 5;
+ L2: res *= 3;
+ L1: res *= 2; 
+  return res;
+}
+
+int bar() {
+  return foo(3);
+}
diff --git a/test/CodeGen/init-with-member-expr.c b/test/CodeGen/init-with-member-expr.c
new file mode 100644
index 0000000..7750dbf
--- /dev/null
+++ b/test/CodeGen/init-with-member-expr.c
@@ -0,0 +1,21 @@
+// RUN: clang-cc < %s -emit-llvm
+struct test {
+  int a;
+};
+
+extern struct test t;
+
+int *b=&t.a;
+
+
+// PR2049
+typedef struct mark_header_tag {
+ unsigned char mark[7];
+} 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);
+
+        return 0;
+}
+
diff --git a/test/CodeGen/init.c b/test/CodeGen/init.c
new file mode 100644
index 0000000..2e239cf
--- /dev/null
+++ b/test/CodeGen/init.c
@@ -0,0 +1,31 @@
+// RUN: clang-cc -triple i386-unknown-unknown -emit-llvm %s -o %t &&
+
+void f1() {
+  // Scalars in braces.
+  int a = { 1 };
+}
+
+void f2() {
+  int a[2][2] = { { 1, 2 }, { 3, 4 } };
+  int b[3][3] = { { 1, 2 }, { 3, 4 } };
+  int *c[2] = { &a[1][1], &b[2][2] };
+  int *d[2][2] = { {&a[1][1], &b[2][2]}, {&a[0][0], &b[1][1]} };
+  int *e[3][3] = { {&a[1][1], &b[2][2]}, {&a[0][0], &b[1][1]} };
+  char ext[3][3] = {".Y",".U",".V"};
+}
+
+typedef void (* F)(void);
+extern void foo(void);
+struct S { F f; };
+void f3() {
+  struct S a[1] = { { foo } };
+}
+
+// Constants
+// RUN: grep '@g3 = constant i32 10' %t &&
+// RUN: grep '@f4.g4 = internal constant i32 12' %t
+const int g3 = 10;
+int f4() {
+  static const int g4 = 12;
+  return g4;
+}
diff --git a/test/CodeGen/inline.c b/test/CodeGen/inline.c
new file mode 100644
index 0000000..234f1f8
--- /dev/null
+++ b/test/CodeGen/inline.c
@@ -0,0 +1,86 @@
+// RUN: echo "C89 tests:" &&
+// RUN: clang %s -emit-llvm -S -o %t -std=c89 &&
+// RUN: grep "define available_externally i32 @ei()" %t &&
+// RUN: grep "define i32 @foo()" %t &&
+// RUN: grep "define i32 @bar()" %t &&
+// RUN: grep "define void @unreferenced1()" %t &&
+// RUN: not grep unreferenced2 %t &&
+// RUN: grep "define void @gnu_inline()" %t &&
+// 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 void @test3()" %t &&
+// RUN: grep "define available_externally i32 @test4" %t &&
+// RUN: grep "define available_externally i32 @test5" %t &&
+
+// RUN: echo "\nC99 tests:" &&
+// RUN: clang %s -emit-llvm -S -o %t -std=c99 &&
+// RUN: grep "define i32 @ei()" %t &&
+// RUN: grep "define available_externally i32 @foo()" %t &&
+// RUN: grep "define i32 @bar()" %t &&
+// RUN: not grep unreferenced1 %t &&
+// RUN: grep "define void @unreferenced2()" %t &&
+// RUN: grep "define void @gnu_inline()" %t &&
+// 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 available_externally i32 @test4" %t &&
+// RUN: grep "define i32 @test5" %t &&
+
+// RUN: echo "\nC++ tests:" &&
+// RUN: clang %s -emit-llvm -S -o %t -std=c++98 &&
+// RUN: grep "define linkonce_odr i32 @_Z2eiv()" %t &&
+// RUN: grep "define linkonce_odr i32 @_Z3foov()" %t &&
+// RUN: grep "define i32 @_Z3barv()" %t &&
+// RUN: not grep unreferenced %t &&
+// RUN: grep "define void @_Z10gnu_inlinev()" %t &&
+// RUN: grep "define available_externally void @_Z13gnu_ei_inlinev()" %t
+
+extern __inline int ei() { return 123; }
+
+__inline int foo() {
+  return ei();
+}
+
+int bar() { return foo(); }
+
+
+__inline void unreferenced1() {}
+extern __inline void unreferenced2() {}
+
+__inline __attribute((__gnu_inline__)) void gnu_inline() {}
+
+// PR3988
+extern __inline __attribute__((gnu_inline)) void gnu_ei_inline() {}
+void (*P)() = gnu_ei_inline;
+
+// <rdar://problem/6818429>
+int test1();
+__inline int test1() { return 4; }
+__inline int test2() { return 5; }
+__inline int test2();
+int test2();
+
+void test_test1() { test1(); }
+void test_test2() { test2(); }
+
+// PR3989
+extern __inline void test3() __attribute__((gnu_inline));
+__inline void test3() {}
+
+void test_test3() { test3(); }
+
+extern int test4(void);
+extern __inline __attribute__ ((__gnu_inline__)) int test4(void)
+{
+}
+
+void test_test4() { test4(); }
+
+extern __inline int test5(void);
+extern __inline int __attribute__ ((__gnu_inline__)) test5(void)
+{
+}
+
+void test_test5() { test5(); }
diff --git a/test/CodeGen/int-to-pointer.c b/test/CodeGen/int-to-pointer.c
new file mode 100644
index 0000000..7cefc39
--- /dev/null
+++ b/test/CodeGen/int-to-pointer.c
@@ -0,0 +1,6 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+void *test(int i)
+{
+  return (void *)i;
+}
diff --git a/test/CodeGen/kr-func-promote.c b/test/CodeGen/kr-func-promote.c
new file mode 100644
index 0000000..d4c3851
--- /dev/null
+++ b/test/CodeGen/kr-func-promote.c
@@ -0,0 +1,5 @@
+// RUN: clang-cc -triple i386-unknown-unknown %s -emit-llvm -o - | grep "i32 @a(i32)"
+
+int a();
+int a(x) short x; {return x;}
+
diff --git a/test/CodeGen/kr-style-block.c b/test/CodeGen/kr-style-block.c
new file mode 100644
index 0000000..ac788dc
--- /dev/null
+++ b/test/CodeGen/kr-style-block.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc -emit-llvm %s -o %t -fblocks
+
+void foo (void(^)());
+
+int main()
+{
+foo(
+  ^() { }
+);
+}
diff --git a/test/CodeGen/libcalls.c b/test/CodeGen/libcalls.c
new file mode 100644
index 0000000..6953216
--- /dev/null
+++ b/test/CodeGen/libcalls.c
@@ -0,0 +1,22 @@
+// RUN: clang-cc -fmath-errno=1 -emit-llvm -o %t %s &&
+// RUN: grep "declare " %t | count 6 &&
+// RUN: grep "declare " %t | grep "@llvm." | count 1 &&
+// RUN: clang-cc -fmath-errno=0 -emit-llvm -o %t %s &&
+// RUN: grep "declare " %t | count 6 &&
+// RUN: grep "declare " %t | grep -v "@llvm." | count 0
+
+// IRgen only pays attention to const; it should always call llvm for
+// this.
+float sqrtf(float) __attribute__((const));
+
+void test_sqrt(float a0, double a1, long double a2) {
+  float l0 = sqrtf(a0);
+  double l1 = sqrt(a1);
+  long double l2 = sqrtl(a2);
+}
+
+void test_pow(float a0, double a1, long double a2) {
+  float l0 = powf(a0, a0);
+  double l1 = pow(a1, a1);
+  long double l2 = powl(a2, a2);
+}
diff --git a/test/CodeGen/lineno-dbginfo.c b/test/CodeGen/lineno-dbginfo.c
new file mode 100644
index 0000000..fe9e59a
--- /dev/null
+++ b/test/CodeGen/lineno-dbginfo.c
@@ -0,0 +1,5 @@
+// RUN: echo "#include <stdio.h>" > %t.h
+// RUN: clang -S -save-temps -g -include %t.h %s -emit-llvm -o %t.ll
+// RUN: grep "i32 5" %t.ll
+// outer is at line number 5.
+int outer = 42;
diff --git a/test/CodeGen/linkage-redecl.c b/test/CodeGen/linkage-redecl.c
new file mode 100644
index 0000000..b015ca8
--- /dev/null
+++ b/test/CodeGen/linkage-redecl.c
@@ -0,0 +1,11 @@
+// RUN: clang-cc -emit-llvm %s -o - |grep internal
+
+// C99 6.2.2p3
+// PR3425
+static void f(int x);
+
+void g0() {
+  f(5);
+}
+
+extern void f(int x) { } // still has internal linkage
diff --git a/test/CodeGen/long-double-x86.c b/test/CodeGen/long-double-x86.c
new file mode 100644
index 0000000..b01ce0b
--- /dev/null
+++ b/test/CodeGen/long-double-x86.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc %s -emit-llvm -o - -triple=i686-apple-darwin9 | grep x86_fp80
+
+long double x = 0;
+int checksize[sizeof(x) == 16 ? 1 : -1];
diff --git a/test/CodeGen/mandel.c b/test/CodeGen/mandel.c
new file mode 100644
index 0000000..6f46ee4
--- /dev/null
+++ b/test/CodeGen/mandel.c
@@ -0,0 +1,67 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+/* Sparc is not C99-compliant */
+#if defined(sparc) || defined(__sparc__) || defined(__sparcv9)
+
+int main() { return 0; }
+
+#else /* sparc */
+
+#define ESCAPE 2
+#define IMAGE_WIDTH 150
+#define IMAGE_HEIGHT 50
+#if 1
+#define IMAGE_SIZE 60
+#else
+#define IMAGE_SIZE 5000
+#endif
+#define START_X -2.1
+#define END_X 1.0
+#define START_Y -1.25
+#define MAX_ITER 100
+
+#define step_X ((END_X - START_X)/IMAGE_WIDTH)
+#define step_Y ((-START_Y - START_Y)/IMAGE_HEIGHT)
+
+#define I 1.0iF
+
+#include <math.h>
+
+#include <stdio.h>
+
+volatile double __complex__ accum;
+
+void mandel() {
+  int x, y, n;
+  for (y = 0; y < IMAGE_HEIGHT; ++y) {
+    for (x = 0; x < IMAGE_WIDTH; ++x) {
+      double __complex__ c = (START_X+x*step_X) + (START_Y+y*step_Y) * I;
+      double __complex__ z = 0.0;
+
+      for (n = 0; n < MAX_ITER; ++n) {
+        z = z * z + c;
+        if (hypot(__real__ z, __imag__ z) >= ESCAPE)
+          break;
+      }
+
+      if (n == MAX_ITER)
+        putchar(' ');
+      else if (n > 6)
+        putchar('.');
+      else if (n > 3)
+        putchar('+');
+      else if (n > 2)
+        putchar('x');
+      else
+        putchar('*');
+    }
+    putchar('\n');
+  }
+}
+
+int main() {
+  mandel();
+  return 0;
+}
+
+#endif /* sparc */
diff --git a/test/CodeGen/mangle.c b/test/CodeGen/mangle.c
new file mode 100644
index 0000000..17d74ba
--- /dev/null
+++ b/test/CodeGen/mangle.c
@@ -0,0 +1,54 @@
+// RUN: clang-cc -triple i386-pc-linux-gnu -emit-llvm -o %t %s &&
+// RUN: grep '@_Z2f0i' %t &&
+// RUN: grep '@_Z2f0l' %t &&
+
+// Make sure we mangle overloadable, even in C system headers.
+
+# 1 "somesystemheader.h" 1 3 4
+void __attribute__((__overloadable__)) f0(int a) {}
+void __attribute__((__overloadable__)) f0(long b) {}
+
+
+
+// These should get merged.
+void foo() __asm__("bar");
+void foo2() __asm__("bar");
+
+// RUN: grep '@"\\01foo"' %t &&
+// RUN: grep '@"\\01bar"' %t
+
+int nux __asm__("foo");
+extern float nux2 __asm__("foo");
+
+int test() { 
+  foo();
+  foo2();
+  
+  return nux + nux2;
+}
+
+
+// Function becomes a variable.
+void foo3() __asm__("var");
+
+void test2() {
+  foo3();
+}
+int foo4 __asm__("var") = 4;
+
+
+// Variable becomes a function
+extern int foo5 __asm__("var2");
+
+void test3() {
+  foo5 = 1;
+}
+
+void foo6() __asm__("var2");
+void foo6() {
+}
+
+
+
+int foo7 __asm__("foo7") __attribute__((used));
+float foo8 __asm__("foo7") = 42;
diff --git a/test/CodeGen/merge-attrs.c b/test/CodeGen/merge-attrs.c
new file mode 100644
index 0000000..1aab47a
--- /dev/null
+++ b/test/CodeGen/merge-attrs.c
@@ -0,0 +1,13 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+
+void *malloc(__SIZE_TYPE__ size) __attribute__ ((__nothrow__));
+
+inline static void __zend_malloc() {
+    malloc(1);
+}
+
+void *malloc(__SIZE_TYPE__ size) __attribute__ ((__nothrow__));
+
+void fontFetch() {
+    __zend_malloc(1);
+}
diff --git a/test/CodeGen/merge-statics.c b/test/CodeGen/merge-statics.c
new file mode 100644
index 0000000..c442669
--- /dev/null
+++ b/test/CodeGen/merge-statics.c
@@ -0,0 +1,13 @@
+// RUN: clang-cc < %s -emit-llvm | grep internal | count 1
+
+// The two decls for 'a' should merge into one llvm GlobalVariable.
+
+struct s { int x; };
+static struct s a;
+
+struct s *ap1 = &a;
+
+static struct s a =  {
+    10
+};
+
diff --git a/test/CodeGen/mmintrin-test.c b/test/CodeGen/mmintrin-test.c
new file mode 100644
index 0000000..2a9ab56
--- /dev/null
+++ b/test/CodeGen/mmintrin-test.c
@@ -0,0 +1,26 @@
+// RUN: clang-cc -triple i386-apple-darwin9 -mcpu=pentium4 -emit-llvm -o %t %s && 
+// RUN: grep define %t | count 1 &&
+// RUN: clang-cc -triple i386-apple-darwin9 -mcpu=pentium4 -g -emit-llvm -o %t %s && 
+// RUN: grep define %t | count 1
+
+#include <mmintrin.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  int array[16] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 };
+  __m64 *p = (__m64 *)array;
+  
+  __m64 accum = _mm_setzero_si64();
+  
+  for (int i=0; i<8; ++i)
+    accum = _mm_add_pi32(p[i], accum);
+  
+  __m64 accum2 = _mm_unpackhi_pi32(accum, accum);
+  accum = _mm_add_pi32(accum, accum2);
+  
+  int result = _mm_cvtsi64_si32(accum);
+  _mm_empty();
+  printf("%d\n", result );
+  
+  return 0;
+}
diff --git a/test/CodeGen/no-common.c b/test/CodeGen/no-common.c
new file mode 100644
index 0000000..190873c
--- /dev/null
+++ b/test/CodeGen/no-common.c
@@ -0,0 +1,6 @@
+// RUN: clang -emit-llvm -S -o %t %s &&
+// RUN: grep '@x = common global' %t &&
+// RUN: clang -fno-common -emit-llvm -S -o %t %s &&
+// RUN: grep '@x = global' %t
+
+int x;
diff --git a/test/CodeGen/offsetof.c b/test/CodeGen/offsetof.c
new file mode 100644
index 0000000..b0f5727
--- /dev/null
+++ b/test/CodeGen/offsetof.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+
+// PR2910
+struct sockaddr_un {
+ unsigned char sun_len;
+ char sun_path[104];
+};
+
+int test(int len) {
+  return __builtin_offsetof(struct sockaddr_un, sun_path[len+1]);
+}
+
diff --git a/test/CodeGen/opaque-pointer.c b/test/CodeGen/opaque-pointer.c
new file mode 100644
index 0000000..7f78b91
--- /dev/null
+++ b/test/CodeGen/opaque-pointer.c
@@ -0,0 +1,13 @@
+// RUN: clang-cc %s -emit-llvm -o -
+struct test;
+
+typedef void (*my_func) (struct test *);
+my_func handler;
+
+struct test {
+  char a;
+};
+
+char f(struct test *t) {
+  return t->a;
+}
diff --git a/test/CodeGen/overloadable.c b/test/CodeGen/overloadable.c
new file mode 100644
index 0000000..4b58c82
--- /dev/null
+++ b/test/CodeGen/overloadable.c
@@ -0,0 +1,26 @@
+// RUN: clang-cc -emit-llvm %s -o - | grep _Z1fPA10_1X
+int __attribute__((overloadable)) f(int x) { return x; }
+float __attribute__((overloadable)) f(float x) { return x; }
+double __attribute__((overloadable)) f(double x) { return x; }
+double _Complex __attribute__((overloadable)) f(double _Complex x) { return x; }
+typedef short v4hi __attribute__ ((__vector_size__ (8)));
+v4hi __attribute__((overloadable)) f(v4hi x) { return x; }
+
+struct X { };
+void  __attribute__((overloadable)) f(struct X (*ptr)[10]) { }
+
+void __attribute__((overloadable)) f(int x, int y, ...) { }
+
+int main() {
+  int iv = 17;
+  float fv = 3.0f;
+  double dv = 4.0;
+  double _Complex cdv;
+  v4hi vv;
+
+  iv = f(iv);
+  fv = f(fv);
+  dv = f(dv);
+  cdv = f(cdv);
+  vv = f(vv);
+}
diff --git a/test/CodeGen/parameter-passing.c b/test/CodeGen/parameter-passing.c
new file mode 100644
index 0000000..2ace299
--- /dev/null
+++ b/test/CodeGen/parameter-passing.c
@@ -0,0 +1,57 @@
+// Check the various ways in which the three classes of values
+// (scalar, complex, aggregate) interact with parameter passing
+// (function entry, function return, call argument, call result).
+//
+// We also check _Bool and empty structures, as these can have annoying
+// corner cases.
+
+// RUN: clang-cc %s -triple i386-unknown-unknown -O3 -emit-llvm -o %t &&
+// RUN: not grep '@g0' %t &&
+
+// 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: not grep '@g0' %t &&
+// RUN: true
+
+typedef _Bool BoolTy;
+typedef int ScalarTy;
+typedef _Complex int ComplexTy;
+typedef struct { int a, b, c; } AggrTy;
+typedef struct { int a[0]; } EmptyTy;
+
+static int result;
+
+static BoolTy bool_id(BoolTy a) { return a; }
+static AggrTy aggr_id(AggrTy a) { return a; }
+static EmptyTy empty_id(EmptyTy a) { return a; }
+static ScalarTy scalar_id(ScalarTy a) { return a; }
+static ComplexTy complex_id(ComplexTy a) { return a; }
+
+static void bool_mul(BoolTy a) { result *= a; }
+
+static void aggr_mul(AggrTy a) { result *= a.a * a.b * a.c; }
+
+static void empty_mul(EmptyTy a) { result *= 53; }
+
+static void scalar_mul(ScalarTy a) { result *= a; }
+
+static void complex_mul(ComplexTy a) { result *= __real a * __imag a; }
+
+extern void g0(void);
+
+void f0(void) {
+  result = 1;
+  
+  bool_mul(bool_id(1));
+  aggr_mul(aggr_id((AggrTy) { 2, 3, 5}));
+  empty_mul(empty_id((EmptyTy) {}));
+  scalar_mul(scalar_id(7));
+  complex_mul(complex_id(11 + 13i));
+  
+  // This call should be eliminated.
+  if (result != 2 * 3 * 5 * 7 * 11 * 13 * 53)
+    g0();
+}
+
diff --git a/test/CodeGen/pascal-string.c b/test/CodeGen/pascal-string.c
new file mode 100644
index 0000000..fcd807c
--- /dev/null
+++ b/test/CodeGen/pascal-string.c
@@ -0,0 +1,8 @@
+// RUN: clang-cc -emit-llvm -o - %s -fpascal-strings | grep "05Hello"
+
+unsigned char * Foo( void )
+{
+  static unsigned char s[256] = "\pHello";
+  return s;
+}
+
diff --git a/test/CodeGen/pointer-arithmetic.c b/test/CodeGen/pointer-arithmetic.c
new file mode 100644
index 0000000..5049875
--- /dev/null
+++ b/test/CodeGen/pointer-arithmetic.c
@@ -0,0 +1,22 @@
+// RUN: clang-cc -S %s -o -
+
+typedef int Int;
+
+int f0(int *a, Int *b) { return a - b; }
+
+int f1(const char *a, char *b) { return b - a; }
+
+// GNU extensions
+typedef void (*FP)(void);
+void *f2(void *a, int b) { return a + b; }
+void *f2_1(void *a, int b) { return (a += b); }
+void *f3(int a, void *b) { return a + b; }
+void *f3_1(int a, void *b) { return (a += b); }
+void *f4(void *a, int b) { return a - b; }
+void *f4_1(void *a, int b) { return (a -= b); }
+FP f5(FP a, int b) { return a + b; }
+FP f5_1(FP a, int b) { return (a += b); }
+FP f6(int a, FP b) { return a + b; }
+FP f6_1(int a, FP b) { return (a += b); }
+FP f7(FP a, int b) { return a - b; }
+FP f7_1(FP a, int b) { return (a -= b); }
diff --git a/test/CodeGen/pointer-cmp-type.c b/test/CodeGen/pointer-cmp-type.c
new file mode 100644
index 0000000..d88c091
--- /dev/null
+++ b/test/CodeGen/pointer-cmp-type.c
@@ -0,0 +1,3 @@
+// RUN: clang-cc -emit-llvm %s -o - | grep "icmp ult"
+
+int a(char* a, char* b) {return a<b;}
diff --git a/test/CodeGen/pointer-to-int.c b/test/CodeGen/pointer-to-int.c
new file mode 100644
index 0000000..e40bd91
--- /dev/null
+++ b/test/CodeGen/pointer-to-int.c
@@ -0,0 +1,13 @@
+// RUN: clang-cc -emit-llvm %s -o -
+
+int test(void* i)
+{
+  return (int)i;
+}
+
+// rdar://6093986
+int test2(void) {
+  float x[2];
+  return x;
+}
+
diff --git a/test/CodeGen/private-extern.c b/test/CodeGen/private-extern.c
new file mode 100644
index 0000000..f3ffe54
--- /dev/null
+++ b/test/CodeGen/private-extern.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc -emit-llvm -o %t %s &&
+// RUN: grep '@g0 = external hidden constant i32' %t &&
+// RUN: grep '@g1 = hidden constant i32 1' %t
+
+__private_extern__ const int g0;
+__private_extern__ const int g1 = 1;
+
+int f0(void) {
+  return g0;
+}
diff --git a/test/CodeGen/rdr-6098585-default-after-caserange.c b/test/CodeGen/rdr-6098585-default-after-caserange.c
new file mode 100644
index 0000000..3a11ad6
--- /dev/null
+++ b/test/CodeGen/rdr-6098585-default-after-caserange.c
@@ -0,0 +1,18 @@
+// RUN: clang-cc -triple i386-unknown-unknown --emit-llvm-bc -o - %s | opt -std-compile-opts | llvm-dis > %t &&
+// RUN: grep "ret i32" %t | count 1 && 
+// RUN: grep "ret i32 10" %t | count 1
+
+// Ensure that default after a case range is not ignored.
+
+static int f1(unsigned x) {
+  switch(x) {
+  case 10 ... 0xFFFFFFFF:
+    return 0;
+  default:
+    return 10;
+  }
+}
+
+int g() {
+  return f1(2);
+}
diff --git a/test/CodeGen/rdr-6098585-default-fallthrough-to-caserange.c b/test/CodeGen/rdr-6098585-default-fallthrough-to-caserange.c
new file mode 100644
index 0000000..f1d15dc
--- /dev/null
+++ b/test/CodeGen/rdr-6098585-default-fallthrough-to-caserange.c
@@ -0,0 +1,20 @@
+// RUN: clang-cc -triple i386-unknown-unknown --emit-llvm-bc -o - %s | opt -std-compile-opts | llvm-dis > %t &&
+// RUN: grep "ret i32 10" %t
+
+// Ensure that this doesn't compile to infinite loop in g() due to
+// miscompilation of fallthrough from default to a (tested) case
+// range.
+
+static int f0(unsigned x) {
+  switch(x) {
+  default:
+    x += 1;
+  case 10 ... 0xFFFFFFFF:
+    return 0;
+  }
+}
+
+int g() {
+  f0(1);
+  return 10;
+}
diff --git a/test/CodeGen/rdr-6098585-empty-case-range.c b/test/CodeGen/rdr-6098585-empty-case-range.c
new file mode 100644
index 0000000..ca5ff1b
--- /dev/null
+++ b/test/CodeGen/rdr-6098585-empty-case-range.c
@@ -0,0 +1,23 @@
+// RUN: clang-cc -triple i386-unknown-unknown --emit-llvm-bc -o - %s | opt -std-compile-opts | llvm-dis > %t &&
+// RUN: grep "ret i32" %t | count 2 &&
+// RUN: grep "ret i32 3" %t | count 2
+
+// This generated incorrect code because of poor switch chaining.
+int f1(int x) {
+  switch(x) {
+  default:
+    return 3;
+  case 10 ... 0xFFFFFFFF:
+    return 0;
+  }
+}
+
+// This just asserted because of the way case ranges were calculated.
+int f2(int x) {
+  switch (x) {
+  default:
+    return 3;
+  case 10 ... -1: 
+    return 0;
+  }
+}
diff --git a/test/CodeGen/rdr-6098585-fallthrough-to-empty-range.c b/test/CodeGen/rdr-6098585-fallthrough-to-empty-range.c
new file mode 100644
index 0000000..b347449
--- /dev/null
+++ b/test/CodeGen/rdr-6098585-fallthrough-to-empty-range.c
@@ -0,0 +1,15 @@
+// RUN: clang-cc -triple i386-unknown-unknown --emit-llvm-bc -o - %s | opt -std-compile-opts | llvm-dis > %t &&
+// RUN: grep "ret i32 %" %t
+
+// Make sure return is not constant (if empty range is skipped or miscompiled)
+
+int f0(unsigned x) {
+  switch(x) {
+  case 2:
+    // fallthrough empty range
+  case 10 ... 9:
+    return 10;
+  default:
+    return 0;
+  }
+}
diff --git a/test/CodeGen/rdr-6098585-unsigned-caserange.c b/test/CodeGen/rdr-6098585-unsigned-caserange.c
new file mode 100644
index 0000000..8003598
--- /dev/null
+++ b/test/CodeGen/rdr-6098585-unsigned-caserange.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc -triple i386-unknown-unknown --emit-llvm-bc -o - %s | opt -std-compile-opts | llvm-dis > %t &&
+// RUN: grep "ret i32" %t | count 1 &&
+// RUN: grep "ret i32 3" %t | count 1
+
+int f2(unsigned x) {
+  switch(x) {
+  default:
+    return 3;
+  case 0xFFFFFFFF ... 1: // This range should be empty because x is unsigned.
+    return 0;
+  }
+}
diff --git a/test/CodeGen/rdr-6732143-dangling-block-reference.m b/test/CodeGen/rdr-6732143-dangling-block-reference.m
new file mode 100644
index 0000000..2d1baa6
--- /dev/null
+++ b/test/CodeGen/rdr-6732143-dangling-block-reference.m
@@ -0,0 +1,10 @@
+// RUN: clang-cc -triple x86_64-apple-darwin9 -emit-llvm %s -o -
+
+void f0(id x) {
+  @synchronized (x) {      
+    do { ; } while(0);
+    @try {
+    } @finally {
+    }
+  }
+}
diff --git a/test/CodeGen/regparm.c b/test/CodeGen/regparm.c
new file mode 100644
index 0000000..fdf07ea
--- /dev/null
+++ b/test/CodeGen/regparm.c
@@ -0,0 +1,19 @@
+// RUN: clang-cc -triple i386-unknown-unknown %s -emit-llvm -o - | grep inreg | count 2
+
+#define FASTCALL __attribute__((regparm(2)))
+
+typedef struct {
+  int aaa;
+  double bbbb;
+  int ccc[200];
+} foo;
+
+static void FASTCALL
+reduced(char b, double c, foo* d, double e, int f)
+{
+}
+
+int
+main(void) {
+	reduced(0, 0.0, 0, 0.0, 0);
+}
diff --git a/test/CodeGen/shared-string-literals.c b/test/CodeGen/shared-string-literals.c
new file mode 100644
index 0000000..a05975b
--- /dev/null
+++ b/test/CodeGen/shared-string-literals.c
@@ -0,0 +1,9 @@
+// RUN: clang-cc -emit-llvm %s -o %t
+
+char *globalString = "abc";
+char *globalStringArray[5] = { "123", "abc" };
+char *anotherGlobalString = "123";
+
+int main() {
+    printf("123");
+}
diff --git a/test/CodeGen/sizeof-vla.c b/test/CodeGen/sizeof-vla.c
new file mode 100644
index 0000000..af50885
--- /dev/null
+++ b/test/CodeGen/sizeof-vla.c
@@ -0,0 +1,13 @@
+// RUN: clang-cc -triple x86_64-unknown-unknown -emit-llvm -o %t %s
+
+// PR3442
+
+static void *g(unsigned long len);
+
+void
+f(int n)
+{
+ unsigned begin_set[n];
+ 
+ g(sizeof(begin_set));
+}
diff --git a/test/CodeGen/statements.c b/test/CodeGen/statements.c
new file mode 100644
index 0000000..1ff7601
--- /dev/null
+++ b/test/CodeGen/statements.c
@@ -0,0 +1,13 @@
+// RUN: clang-cc < %s -emit-llvm
+
+void test1(int x) {
+switch (x) {
+case 111111111111111111111111111111111111111:
+bar();
+}
+}
+
+// Mismatched type between return and function result.
+int test2() { return; }
+void test3() { return 4; }
+
diff --git a/test/CodeGen/static-forward-decl-fun.c b/test/CodeGen/static-forward-decl-fun.c
new file mode 100644
index 0000000..a945df3
--- /dev/null
+++ b/test/CodeGen/static-forward-decl-fun.c
@@ -0,0 +1,6 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+
+static int staticfun(void);
+int (*staticuse1)(void) = staticfun;
+static int staticfun() {return 1;}
+int (*staticuse2)(void) = staticfun;
diff --git a/test/CodeGen/static-forward-decl.c b/test/CodeGen/static-forward-decl.c
new file mode 100644
index 0000000..f12c22f
--- /dev/null
+++ b/test/CodeGen/static-forward-decl.c
@@ -0,0 +1,5 @@
+// RUN: clang-cc %s -emit-llvm -o - -triple=i686-apple-darwin9 | grep "global i32 10"
+
+static int i;
+int*j=&i;
+static int i = 10;
diff --git a/test/CodeGen/static-local-union.c b/test/CodeGen/static-local-union.c
new file mode 100644
index 0000000..f276b20
--- /dev/null
+++ b/test/CodeGen/static-local-union.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc -emit-llvm < %s
+
+int a() {static union{int a;} r[2] = {1,2};return r[1].a;}
+
diff --git a/test/CodeGen/static-order.c b/test/CodeGen/static-order.c
new file mode 100644
index 0000000..243e96b
--- /dev/null
+++ b/test/CodeGen/static-order.c
@@ -0,0 +1,19 @@
+// RUN: clang-cc -emit-llvm -o - %s | not grep "zeroinitializer"
+
+struct s {
+    int a;
+};
+
+static void *v;
+
+static struct s a;
+
+static struct s a = {
+    10
+};
+
+void *f()
+{
+  if (a.a)
+    return v;
+}
diff --git a/test/CodeGen/staticinit.c b/test/CodeGen/staticinit.c
new file mode 100644
index 0000000..91fcdcf
--- /dev/null
+++ b/test/CodeGen/staticinit.c
@@ -0,0 +1,31 @@
+// RUN: clang-cc -triple i386-pc-linux-gnu -emit-llvm -o %t %s &&
+// RUN: grep "g.b = internal global i8. getelementptr" %t &&
+
+struct AStruct { 
+	int i;
+	char *s;
+	double d;
+};
+
+void f() {
+  static int i = 42;
+  static int is[] = { 1, 2, 3, 4 };
+  static char* str = "forty-two";
+  static char* strs[] = { "one", "two", "three", "four" };
+  static struct AStruct myStruct = { 1, "two", 3.0 };
+}
+
+void g() {
+  static char a[10];
+  static char *b = a;
+}
+
+struct s { void *p; };
+
+void foo(void) {
+  static struct s var = {((void*)&((char*)0)[0])};
+}
+
+// RUN: grep "f1.l0 = internal global i32 ptrtoint (i32 ()\* @f1 to i32)" %t
+int f1(void) { static int l0 = (unsigned) f1; }
+
diff --git a/test/CodeGen/stdcall-fastcall.c b/test/CodeGen/stdcall-fastcall.c
new file mode 100644
index 0000000..11b6521
--- /dev/null
+++ b/test/CodeGen/stdcall-fastcall.c
@@ -0,0 +1,17 @@
+// 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);
+void __attribute__((stdcall)) f2(void);
+void __attribute__((fastcall)) f3(void) {
+  f1();
+}
+void __attribute__((stdcall)) f4(void) {
+  f2();
+}
+
+int main(void) {
+    f3(); f4();
+    return 0;
+}
+
diff --git a/test/CodeGen/string-init.c b/test/CodeGen/string-init.c
new file mode 100644
index 0000000..38c7ec0
--- /dev/null
+++ b/test/CodeGen/string-init.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc -emit-llvm %s -o %t &&
+// RUN: grep 'internal constant \[10 x i8\]' %t &&
+// RUN: not grep -F "[5 x i8]" %t &&
+// RUN: not grep "store " %t
+
+void test(void) {
+  char a[10] = "asdf";
+  char b[10] = { "asdf" };
+}
+
diff --git a/test/CodeGen/string-literal.c b/test/CodeGen/string-literal.c
new file mode 100644
index 0000000..a401193
--- /dev/null
+++ b/test/CodeGen/string-literal.c
@@ -0,0 +1,7 @@
+// RUN: clang-cc -emit-llvm %s -o -
+
+int main() {
+  char a[10] = "abc";
+
+  void *foo = L"AB";
+}
diff --git a/test/CodeGen/struct-comma.c b/test/CodeGen/struct-comma.c
new file mode 100644
index 0000000..d7f50da
--- /dev/null
+++ b/test/CodeGen/struct-comma.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc %s -emit-llvm -o -
+
+struct S {int a, b;} x;
+void a(struct S* b) {*b = (r(), x);}
diff --git a/test/CodeGen/struct-copy.c b/test/CodeGen/struct-copy.c
new file mode 100644
index 0000000..62c29ab
--- /dev/null
+++ b/test/CodeGen/struct-copy.c
@@ -0,0 +1,7 @@
+// RUN: clang-cc -emit-llvm %s -o - | grep 'call.*llvm.memcpy'
+struct x { int a[100]; };
+
+
+void foo(struct x *P, struct x *Q) {
+  *P = *Q;
+}
diff --git a/test/CodeGen/struct-init.c b/test/CodeGen/struct-init.c
new file mode 100644
index 0000000..a38442b
--- /dev/null
+++ b/test/CodeGen/struct-init.c
@@ -0,0 +1,12 @@
+// RUN: clang-cc %s -emit-llvm -o -
+
+typedef struct _zend_ini_entry zend_ini_entry;
+struct _zend_ini_entry {
+	void *mh_arg1;
+};
+
+char a;
+
+const zend_ini_entry ini_entries[] = {
+	{  ((char*)&((zend_ini_entry*)0)->mh_arg1 - (char*)(void*)0)},
+};
diff --git a/test/CodeGen/struct-passing.c b/test/CodeGen/struct-passing.c
new file mode 100644
index 0000000..9a4f476
--- /dev/null
+++ b/test/CodeGen/struct-passing.c
@@ -0,0 +1,21 @@
+// RUN: clang-cc -triple i386-pc-linux-gnu -emit-llvm -o %t %s &&
+// RUN: grep 'declare i32 @f0() readnone$' %t &&
+// RUN: grep 'declare i32 @f1() readonly$' %t &&
+// RUN: grep 'declare void @f2(.* noalias sret)$' %t &&
+// RUN: grep 'declare void @f3(.* noalias sret)$' %t &&
+// RUN: grep 'declare void @f4(.* byval)$' %t &&
+// RUN: grep 'declare void @f5(.* byval)$' %t &&
+// RUN: true
+// PR3835
+
+typedef int T0;
+typedef struct { int a[16]; } T1;
+
+T0 __attribute__((const)) f0(void);
+T0 __attribute__((pure)) f1(void);
+T1 __attribute__((const)) f2(void);
+T1 __attribute__((pure)) f3(void);
+void __attribute__((const)) f4(T1 a);
+void __attribute__((pure)) f5(T1 a);
+
+void *ps[] = { f0, f1, f2, f3, f4, f5 };
diff --git a/test/CodeGen/struct-x86-darwin.c b/test/CodeGen/struct-x86-darwin.c
new file mode 100644
index 0000000..050e26d
--- /dev/null
+++ b/test/CodeGen/struct-x86-darwin.c
@@ -0,0 +1,25 @@
+// 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
+// Test struct layout for x86-darwin target
+
+struct STest1 {int x; short y[4]; double z; } st1;
+struct STest2 {short a,b; int c,d; } st2;
+struct STest3 {char a; short b; int c; } st3;
+
+// Bitfields 
+struct STestB1 {char a; char b:2; } stb1;
+struct STestB2 {char a; char b:5; char c:4; } stb2;
+struct STestB3 {char a; char b:2; } stb3;
+struct STestB4 {char a; short b:2; char c; } stb4;
+struct STestB5 {char a; short b:10; char c; } stb5;
+struct STestB6 {int a:1; char b; int c:13 } stb6;
+
+// Packed struct STestP1 {char a; short b; int c; } __attribute__((__packed__)) stp1;
diff --git a/test/CodeGen/struct.c b/test/CodeGen/struct.c
new file mode 100644
index 0000000..ed36842
--- /dev/null
+++ b/test/CodeGen/struct.c
@@ -0,0 +1,192 @@
+// RUN: clang-cc -triple i386-unknown-unknown %s -emit-llvm -o -
+
+struct  {
+  int x;
+  int y;
+} point;
+
+void fn1() {
+  point.x = 42;
+}
+
+/* Nested member */
+struct  {
+  struct {
+    int a;
+    int b;
+  } p1;
+} point2;
+
+void fn2() {
+  point2.p1.a = 42;
+}
+
+/* Indirect reference */
+typedef struct __sf {
+ unsigned char *c;
+ short flags;
+} F;
+
+typedef struct __sf2 {
+  F *ff;
+} F2;
+
+int fn3(F2 *c) {
+  if (c->ff->c >= 0)
+    return 1;
+  else
+    return 0;
+}
+
+/* Nested structs */
+typedef struct NA {
+  int data;
+  struct NA *next;
+} NA;
+void f1() {  NA a; }
+
+typedef struct NB {
+  int d1;
+  struct _B2 {
+    int d2;
+    struct NB *n2;
+  } B2;
+} NB;
+
+void f2() { NB b; }
+
+extern NB *f3();
+void f4() {
+  f3()->d1 = 42;
+}
+
+void f5() {
+  (f3())->d1 = 42;
+}
+
+/* Function calls */
+typedef struct {
+  int location;
+  int length;
+} range;
+extern range f6();
+void f7()
+{
+  range r = f6();
+}
+
+/* Member expressions */
+typedef struct {
+  range range1;
+  range range2;
+} rangepair;
+
+void f8()
+{
+  rangepair p;
+
+  range r = p.range1;
+}
+
+void f9(range *p)
+{
+  range r = *p;
+}
+
+void f10(range *p)
+{
+  range r = p[0];
+}
+
+/* _Bool types */
+
+struct _w
+{
+  short a,b;
+  short c,d;
+  short e,f;
+  short g;
+
+  unsigned int h,i;
+
+  _Bool j,k;
+} ws;
+
+/* Implicit casts (due to typedefs) */
+typedef struct _a
+{
+  int a;
+} a;
+
+void f11()
+{
+    struct _a a1;
+    a a2;
+    
+    a1 = a2;
+    a2 = a1;
+}
+
+/* Implicit casts (due to const) */
+void f12()
+{
+	struct _a a1;
+	const struct _a a2;
+	
+	a1 = a2;
+}
+
+/* struct initialization */
+struct a13 {int b; int c;};
+struct a13 c13 = {5};
+typedef struct a13 a13;
+struct a14 { short a; int b; } x = {1, 1};
+
+/* flexible array members */
+struct a15 {char a; int b[];} c15;
+int a16(void) {c15.a = 1;}
+
+/* compound literals */
+void f13()
+{
+  a13 x; x = (a13){1,2};
+}
+
+/* va_arg */
+int f14(int i, ...) {
+  __builtin_va_list l;
+  __builtin_va_start(l,i);
+  a13 b = __builtin_va_arg(l, a13);
+  int c = __builtin_va_arg(l, a13).c;
+  return b.b;
+}
+
+/* Attribute packed */
+struct __attribute__((packed)) S2839 { double a[19];  signed char b; } s2839[5];
+
+struct __attribute__((packed)) SS { long double a; char b; } SS;
+
+
+/* As lvalue */
+
+int f15() {
+  extern range f15_ext();
+  return f15_ext().location;
+}
+
+range f16() {
+  extern rangepair f16_ext();
+  return f16_ext().range1;
+}
+
+int f17() {
+  extern range f17_ext();
+  range r;
+  return (r = f17_ext()).location;
+}
+
+range f18() {
+  extern rangepair f18_ext();
+  rangepair rp;
+  return (rp = f18_ext()).range1;
+}
diff --git a/test/CodeGen/switch.c b/test/CodeGen/switch.c
new file mode 100644
index 0000000..3254fbf
--- /dev/null
+++ b/test/CodeGen/switch.c
@@ -0,0 +1,87 @@
+// RUN: clang-cc %s -emit-llvm-bc -o - | opt -std-compile-opts -disable-output
+
+int foo(int i) {
+  int j = 0;
+  switch (i) {
+  case -1:
+    j = 1; break;
+  case 1 : 
+    j = 2; break;
+  case 2:
+    j = 3; break;
+  default:
+    j = 42; break;
+  }
+  j = j + 1;
+  return j;
+}
+
+    
+int foo2(int i) {
+  int j = 0;
+  switch (i) {
+  case 1 : 
+    j = 2; break;
+  case 2 ... 10:
+    j = 3; break;
+  default:
+    j = 42; break;
+  }
+  j = j + 1;
+  return j;
+}
+
+    
+int foo3(int i) {
+  int j = 0;
+  switch (i) {
+  default:
+    j = 42; break;
+  case 111:
+    j = 111; break;
+  case 0 ... 100:
+    j = 1; break;
+  case 222:
+    j = 222; break;
+  }
+  return j;
+}
+
+
+int foo4(int i) {
+  int j = 0;
+  switch (i) {
+  case 111:
+    j = 111; break;
+  case 0 ... 100:
+    j = 1; break;
+  case 222:
+    j = 222; break;
+  default:
+    j = 42; break;
+  case 501 ... 600:
+    j = 5; break;
+  }
+  return j;
+}
+
+void foo5(){
+    switch(0){
+    default:
+        if (0) {
+
+        }
+    }
+}
+
+void foo6(){
+    switch(0){
+    }
+}
+
+void foo7(){
+    switch(0){
+      foo7();
+    }
+}
+
diff --git a/test/CodeGen/tentative-decls.c b/test/CodeGen/tentative-decls.c
new file mode 100644
index 0000000..3301c23
--- /dev/null
+++ b/test/CodeGen/tentative-decls.c
@@ -0,0 +1,39 @@
+// RUN: clang-cc -emit-llvm -o %t %s &&
+
+// RUN: grep '@r = common global \[1 x .*\] zeroinitializer' %t &&
+
+int r[];
+int (*a)[] = &r;
+
+struct s0;
+struct s0 x;
+// RUN: grep '@x = common global .struct.s0 zeroinitializer' %t &&
+
+struct s0 y;
+// RUN: grep '@y = common global .struct.s0 zeroinitializer' %t &&
+struct s0 *f0() {
+  return &y;
+}
+
+struct s0 {
+  int x;
+};
+
+// RUN: grep '@b = common global \[1 x .*\] zeroinitializer' %t &&
+int b[];
+int *f1() {
+  return b;
+}
+
+// Check that the most recent tentative definition wins.
+// RUN: grep '@c = common global \[4 x .*\] zeroinitializer' %t &&
+int c[];
+int c[4];
+
+// Check that we emit static tentative definitions
+// RUN: grep '@c5 = internal global \[1 x .*\] zeroinitializer' %t &&
+static int c5[];
+static int func() { return c5[0]; }
+int callfunc() { return func(); }
+
+// RUN: true
diff --git a/test/CodeGen/thread-specifier.c b/test/CodeGen/thread-specifier.c
new file mode 100644
index 0000000..456f7a6
--- /dev/null
+++ b/test/CodeGen/thread-specifier.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc -triple i686-pc-linux-gnu -emit-llvm -o - %s | grep thread_local | count 4
+
+__thread int a;
+extern __thread int b;
+int c() { return &b; }
+int d() {
+  __thread static int e;
+  __thread static union {float a; int b;} f = {.b = 1};
+}
+
diff --git a/test/CodeGen/trapv.c b/test/CodeGen/trapv.c
new file mode 100644
index 0000000..c96488b
--- /dev/null
+++ b/test/CodeGen/trapv.c
@@ -0,0 +1,10 @@
+// RUN: clang-cc -ftrapv %s -emit-llvm -o %t &&
+// RUN: grep "__overflow_handler" %t | count 2
+
+unsigned int ui, uj, uk;
+int i, j, k;
+
+void foo() {
+  ui = uj + uk;
+  i = j + k;
+}
diff --git a/test/CodeGen/typedef-func.c b/test/CodeGen/typedef-func.c
new file mode 100644
index 0000000..a64426d
--- /dev/null
+++ b/test/CodeGen/typedef-func.c
@@ -0,0 +1,16 @@
+// RUN: clang-cc -emit-llvm < %s
+
+// PR2414
+struct mad_frame{};
+enum mad_flow {};
+
+typedef enum mad_flow filter_func_t(void *, struct mad_frame *);
+
+filter_func_t mono_filter;
+
+void addfilter2(filter_func_t *func){}
+
+void setup_filters()
+{
+  addfilter2( mono_filter);
+}
diff --git a/test/CodeGen/typedef.c b/test/CodeGen/typedef.c
new file mode 100644
index 0000000..3bdd52f
--- /dev/null
+++ b/test/CodeGen/typedef.c
@@ -0,0 +1,8 @@
+// RUN: clang-cc -emit-llvm %s -o -
+
+typedef struct { int i; } Value;
+typedef Value *PValue;
+
+int get_value(PValue v) {
+  return v->i;
+}
diff --git a/test/CodeGen/types.c b/test/CodeGen/types.c
new file mode 100644
index 0000000..75cb851
--- /dev/null
+++ b/test/CodeGen/types.c
@@ -0,0 +1,34 @@
+// RUN: clang-cc -emit-llvm <%s
+
+struct FileName {
+    struct FileName *next;
+} *fnhead;
+
+
+struct ieeeExternal {
+    struct ieeeExternal *next;
+} *exthead;
+
+
+void test1()
+{
+    struct ieeeExternal *exttmp = exthead;
+}
+
+struct MpegEncContext;
+typedef struct MpegEncContext {int pb;} MpegEncContext;
+static void test2(void) {MpegEncContext s; s.pb;}
+
+
+struct Village;
+
+struct List {
+  struct Village *v;
+};
+
+struct Village {
+  struct List returned;
+};
+
+void test3(struct List a) {
+}
diff --git a/test/CodeGen/uint128_t.c b/test/CodeGen/uint128_t.c
new file mode 100644
index 0000000..b3bf727
--- /dev/null
+++ b/test/CodeGen/uint128_t.c
@@ -0,0 +1,18 @@
+// RUN: clang-cc %s -emit-llvm -o - -triple=x86_64-apple-darwin9
+
+typedef unsigned long long uint64_t;
+extern uint64_t numer;
+extern uint64_t denom;
+
+uint64_t
+f(uint64_t val)
+{
+    __uint128_t tmp;
+
+    tmp = val;
+    tmp *= numer;
+    tmp /= denom;
+
+    return tmp;
+}
+
diff --git a/test/CodeGen/union-init.c b/test/CodeGen/union-init.c
new file mode 100644
index 0000000..c882d31
--- /dev/null
+++ b/test/CodeGen/union-init.c
@@ -0,0 +1,31 @@
+// RUN: clang-cc -emit-llvm < %s -o -
+
+// A nice and complicated initialization example with unions from Python
+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 */
+} PyGC_Head;
+
+struct gc_generation {
+	PyGC_Head head;
+	int threshold; /* collection threshold */
+	int count; /* count of allocations or collections of younger
+		      generations */
+};
+
+#define NUM_GENERATIONS 3
+#define GEN_HEAD(n) (&generations[n].head)
+
+/* 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},
+};
diff --git a/test/CodeGen/union.c b/test/CodeGen/union.c
new file mode 100644
index 0000000..4884690
--- /dev/null
+++ b/test/CodeGen/union.c
@@ -0,0 +1,41 @@
+// RUN: clang-cc %s -emit-llvm -o -
+
+union u_tag {
+  int a;
+  float b;
+} u;
+
+void f() {
+  u.b = 11;
+}
+
+float get_b(union u_tag *my_u) {
+  return my_u->b;
+}
+
+int f2( float __x ) { 
+  union{ 
+    float __f; 
+    unsigned int __u; 
+  }__u;
+  return (int)(__u.__u >> 31); 
+}
+
+typedef union { int i; int *j; } value;
+
+int f3(value v) {
+  return *v.j;
+}
+
+enum E9 { one, two };
+union S65 { enum E9 a; } ; union S65 s65;
+void fS65() { enum E9 e = s65.a; } 
+
+typedef union{
+  unsigned char x[65536];
+} q;
+int qfunc() {q buf; unsigned char* x = buf.x;}
+
+union RR {_Bool a : 1;} RRU;
+int RRF(void) {return RRU.a;}
+
diff --git a/test/CodeGen/unwind-attr.c b/test/CodeGen/unwind-attr.c
new file mode 100644
index 0000000..b2890c4
--- /dev/null
+++ b/test/CodeGen/unwind-attr.c
@@ -0,0 +1,5 @@
+// RUN: clang-cc -fexceptions -emit-llvm -o - %s | grep "@foo() {" | count 1 &&
+// RUN: clang-cc -emit-llvm -o - %s | grep "@foo() nounwind {" | count 1
+
+int foo(void) {
+}
diff --git a/test/CodeGen/var-align.c b/test/CodeGen/var-align.c
new file mode 100644
index 0000000..b0b62ae
--- /dev/null
+++ b/test/CodeGen/var-align.c
@@ -0,0 +1,4 @@
+// RUN: clang-cc -emit-llvm %s -o - | grep "align 16" | count 2
+
+__attribute((aligned(16))) float a[128];
+union {int a[4]; __attribute((aligned(16))) float b[4];} u;
diff --git a/test/CodeGen/variable-array.c b/test/CodeGen/variable-array.c
new file mode 100644
index 0000000..f5621c2
--- /dev/null
+++ b/test/CodeGen/variable-array.c
@@ -0,0 +1,19 @@
+// RUN: clang-cc -emit-llvm < %s | grep puts | count 4
+
+// PR3248
+int a(int x)
+{
+  int (*y)[x];
+  return sizeof(*(puts("asdf"),y));
+}
+
+// PR3247
+int b() {
+  return sizeof(*(char(*)[puts("asdf")])0);
+}
+
+// PR3247
+int c() {
+  static int (*y)[puts("asdf")];
+  return sizeof(*y);
+}
diff --git a/test/CodeGen/vector.c b/test/CodeGen/vector.c
new file mode 100644
index 0000000..2e753b4
--- /dev/null
+++ b/test/CodeGen/vector.c
@@ -0,0 +1,13 @@
+// RUN: clang-cc -emit-llvm %s -o -
+typedef short __v4hi __attribute__ ((__vector_size__ (8)));
+
+void f()
+{
+    __v4hi A = (__v4hi)0LL;
+}
+
+__v4hi x = {1,2,3};
+__v4hi y = {1,2,3,4};
+
+typedef int vty __attribute((vector_size(16)));
+int a() { vty b; return b[2LL]; }
diff --git a/test/CodeGen/visibility.c b/test/CodeGen/visibility.c
new file mode 100644
index 0000000..bb9b6e0
--- /dev/null
+++ b/test/CodeGen/visibility.c
@@ -0,0 +1,41 @@
+// RUN: clang-cc -triple i386-unknown-unknown -fvisibility=default -emit-llvm -o %t %s &&
+// RUN: grep '@g_com = common global i32 0' %t &&
+// RUN: grep '@g_def = global i32 0' %t &&
+// RUN: grep '@g_ext = external global i32' %t &&
+// RUN: grep '@g_deferred = internal global' %t &&
+// RUN: grep 'declare void @f_ext()' %t &&
+// RUN: grep 'define internal void @f_deferred()' %t &&
+// RUN: grep 'define i32 @f_def()' %t &&
+// RUN: clang-cc -triple i386-unknown-unknown -fvisibility=protected -emit-llvm -o %t %s &&
+// RUN: grep '@g_com = common protected global i32 0' %t &&
+// RUN: grep '@g_def = protected global i32 0' %t &&
+// RUN: grep '@g_ext = external global i32' %t &&
+// RUN: grep '@g_deferred = internal global' %t &&
+// RUN: grep 'declare void @f_ext()' %t &&
+// 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_def = hidden global i32 0' %t &&
+// RUN: grep '@g_ext = external global i32' %t &&
+// RUN: grep '@g_deferred = internal global' %t &&
+// RUN: grep 'declare void @f_ext()' %t &&
+// RUN: grep 'define internal void @f_deferred()' %t &&
+// RUN: grep 'define hidden i32 @f_def()' %t &&
+// RUN: true
+
+int g_com;
+int g_def = 0;
+extern int g_ext;
+static char g_deferred[] = "hello";
+
+extern void f_ext(void);
+
+static void f_deferred(void) {
+}
+
+int f_def(void) {
+  f_ext();
+  f_deferred();
+  return g_com + g_def + g_ext + g_deferred[0];
+}
diff --git a/test/CodeGen/vla.c b/test/CodeGen/vla.c
new file mode 100644
index 0000000..844e49e
--- /dev/null
+++ b/test/CodeGen/vla.c
@@ -0,0 +1,37 @@
+// RUN: clang-cc %s -emit-llvm -o %t
+
+int b(char* x);
+
+// Extremely basic VLA test
+void a(int x) {
+  char arry[x];
+  arry[0] = 10;
+  b(arry);
+}
+
+int c(int n)
+{
+  return sizeof(int[n]);
+}
+
+int f0(int x) {
+  int vla[x];
+  return vla[x-1];
+}
+
+void
+f(int count)
+{
+ int a[count];
+
+  do {  } while (0);
+
+  if (a[0] != 3) {
+  }
+}
+
+void g(int count) {
+  // Make sure we emit sizes correctly in some obscure cases
+  int (*a[5])[count];
+  int (*b)[][count];
+}
diff --git a/test/CodeGen/volatile-1.c b/test/CodeGen/volatile-1.c
new file mode 100644
index 0000000..ac3b4c2
--- /dev/null
+++ b/test/CodeGen/volatile-1.c
@@ -0,0 +1,143 @@
+// RUN: clang-cc -Wno-unused-value -emit-llvm < %s -o %t &&
+// RUN: grep volatile %t | count 145 &&
+// RUN: grep memcpy %t | count 4
+
+volatile int i, j, k;
+volatile int ar[5];
+volatile char c;
+volatile _Complex int ci;
+volatile struct S {
+#ifdef __cplusplus
+  void operator =(volatile struct S&o) volatile;
+#endif
+  int i;
+} a, b;
+
+//void operator =(volatile struct S&o1, volatile struct S&o2) volatile;
+#include <stdio.h>
+
+int main() {
+  // A use.
+  i;
+  // A use of the real part
+  (float)(ci);
+  // A use.
+  (void)ci;
+  // A use.
+  (void)a;
+  // Not a use.
+  (void)(ci=ci);
+  // Not a use.
+  (void)(i=j);
+  ci+=ci;
+  (ci += ci) + ci;
+  asm("nop");
+  (i += j) + k;
+  asm("nop");
+  // A use
+  (i += j) + 1;
+  asm("nop");
+  ci+ci;
+  // A use.
+  __real i;
+  // A use.
+  +ci;
+  asm("nop");
+  // Not a use.
+  (void)(i=i);
+  (float)(i=i);
+  // A use.
+  (void)i;
+  i=i;
+  i=i=i;
+#ifndef __cplusplus
+  // Not a use.
+  (void)__builtin_choose_expr(0, i=i, j=j);
+#endif
+  // A use.
+  k ? (i=i) : (j=j);
+  (void)(i,(i=i));
+  i=i,i;
+  (i=j,k=j);
+  (i=j,k);
+  (i,j);
+  i=c=k;
+  i+=k;
+  // A use of both.
+  ci;
+#ifndef __cplusplus
+  // A use of _real.
+  (int)ci;
+  // A use of both.
+  (_Bool)ci;
+#endif
+  ci=ci;
+  ci=ci=ci;
+  __imag ci = __imag ci = __imag ci;
+  // Not a use.
+  __real (i = j);
+  // Not a use.
+  __imag i;
+  
+  // ============================================================
+  // FIXME: Test cases we get wrong.
+
+  // A use.  We load all of a into a copy of a, then load i.  gcc forgets to do
+  // the assignment.
+  // (a = a).i;
+
+  // ============================================================
+  // Test cases where we intentionally differ from gcc, due to suspected bugs in
+  // gcc.
+
+  // Not a use.  gcc forgets to do the assignment.
+  ((a=a),a);
+
+  // Not a use.  gcc gets this wrong, it doesn't emit the copy!  
+  // (void)(a=a);
+
+  // Not a use.  gcc got this wrong in 4.2 and omitted the side effects
+  // entirely, but it is fixed in 4.4.0.
+  __imag (i = j);
+
+#ifndef __cplusplus
+  // A use of the real part
+  (float)(ci=ci);
+  // Not a use, bug?  gcc treats this as not a use, that's probably a bug due to
+  // tree folding ignoring volatile.
+  (int)(ci=ci);
+#endif
+
+  // A use.
+  (float)(i=i);
+  // A use.  gcc treats this as not a use, that's probably a bug due to tree
+  // folding ignoring volatile.
+  (int)(i=i);
+
+  // A use.
+  -(i=j);
+  // A use.  gcc treats this a not a use, that's probably a bug due to tree
+  // folding ignoring volatile.
+  +(i=k);
+
+  // A use. gcc treats this a not a use, that's probably a bug due to tree
+  // folding ignoring volatile.
+  __real (ci=ci);
+
+  // A use.
+  i + 0;
+  // A use.
+  (i=j) + i;
+  // A use.  gcc treats this as not a use, that's probably a bug due to tree
+  // folding ignoring volatile.
+  (i=j) + 0;
+
+#ifdef __cplusplus
+  (i,j)=k;
+  (j=k,i)=i;
+  struct { int x; } s, s1;
+  printf("s is at %p\n", &s);
+  printf("s is at %p\n", &(s = s1));
+  printf("s.x is at %p\n", &((s = s1).x));
+#endif
+}
diff --git a/test/CodeGen/volatile.c b/test/CodeGen/volatile.c
new file mode 100644
index 0000000..212a0ae
--- /dev/null
+++ b/test/CodeGen/volatile.c
@@ -0,0 +1,94 @@
+// RUN: clang-cc -emit-llvm < %s -o %t &&
+// RUN: grep volatile %t | count 25 &&
+// RUN: grep memcpy %t | count 7
+
+// The number 25 comes from the current codegen for volatile loads;
+// if this number changes, it's not necessarily something wrong, but
+// something has changed to affect volatile load/store codegen
+
+int S;
+volatile int vS;
+
+int* pS;
+volatile int* pvS;
+
+int A[10];
+volatile int vA[10];
+
+struct { int x; } F;
+struct { volatile int x; } vF;
+
+struct { int x; } F2;
+volatile struct { int x; } vF2;
+volatile struct { int x; } *vpF2;
+
+struct { struct { int y; } x; } F3;
+volatile struct { struct { int y; } x; } vF3;
+
+struct { int x:3; } BF;
+struct { volatile int x:3; } vBF;
+
+typedef int v4si __attribute__ ((vector_size (16)));
+v4si V;
+volatile v4si vV;
+
+typedef __attribute__(( ext_vector_type(4) )) int extv4;
+extv4 VE;
+volatile extv4 vVE;
+
+volatile struct {int x;} aggFct(void);
+
+void main() {
+  int i;
+
+  // load
+  i=S;
+  i=vS;
+  i=*pS;
+  i=*pvS;
+  i=A[2];
+  i=vA[2];
+  i=F.x;
+  i=vF.x;
+  i=F2.x;
+  i=vF2.x;
+  i=vpF2->x;
+  i=F3.x.y;
+  i=vF3.x.y;
+  i=BF.x;
+  i=vBF.x;
+  i=V[3];
+  i=vV[3];
+  i=VE.yx[1];
+  i=vVE.zy[1];
+  i = aggFct().x;
+
+
+  // store
+  S=i;
+  vS=i;
+  *pS=i;
+  *pvS=i;
+  A[2]=i;
+  vA[2]=i;
+  F.x=i;
+  vF.x=i;
+  F2.x=i;
+  vF2.x=i;
+  vpF2->x=i;
+  vF3.x.y=i;
+  BF.x=i;
+  vBF.x=i;
+  V[3]=i;
+  vV[3]=i;
+
+  // other ops:
+  ++S;
+  ++vS;
+  i+=S;
+  i+=vS;
+  (void)vF2;
+  vF2 = vF2;
+  vF2 = vF2 = vF2;
+  vF2 = (vF2, vF2);
+}
diff --git a/test/CodeGen/weak-global.c b/test/CodeGen/weak-global.c
new file mode 100644
index 0000000..d4ee52f
--- /dev/null
+++ b/test/CodeGen/weak-global.c
@@ -0,0 +1,3 @@
+// RUN: clang-cc -emit-llvm < %s | grep common
+
+int i;
diff --git a/test/CodeGen/weak-incomplete.c b/test/CodeGen/weak-incomplete.c
new file mode 100644
index 0000000..a15dbac
--- /dev/null
+++ b/test/CodeGen/weak-incomplete.c
@@ -0,0 +1,5 @@
+// RUN: clang-cc -emit-llvm < %s | grep 'extern_weak' | count 1
+
+struct S;
+void __attribute__((weak)) foo1(struct S);
+void (*foo2)(struct S) = foo1;
diff --git a/test/CodeGen/whilestmt.c b/test/CodeGen/whilestmt.c
new file mode 100644
index 0000000..95e18f4
--- /dev/null
+++ b/test/CodeGen/whilestmt.c
@@ -0,0 +1,62 @@
+// RUN: clang-cc %s -emit-llvm -o -
+
+int bar();
+int foo() {
+  int i;
+  i = 1 + 2;
+  while(1) {
+    i = bar();
+    i = bar();
+  };
+  return i;
+}
+
+
+int foo1() {
+  int i;
+  i = 1 + 2;
+  while(1) {
+    i = bar();
+    if (i == 42)
+      break;
+    i = bar();
+  };
+  return i;
+}
+
+
+int foo2() {
+  int i;
+  i = 1 + 2;
+  while(1) {
+    i = bar();
+    if (i == 42)
+      continue;
+    i = bar();
+  };
+  return i;
+}
+
+
+int foo3() {
+  int i;
+  i = 1 + 2;
+  while(1) {
+    i = bar();
+    if (i == 42)
+      break;
+  };
+  return i;
+}
+
+
+int foo4() {
+  int i;
+  i = 1 + 2;
+  while(1) {
+    i = bar();
+    if (i == 42)
+      continue;
+  };
+  return i;
+}
diff --git a/test/CodeGen/writable-strings.c b/test/CodeGen/writable-strings.c
new file mode 100644
index 0000000..c8b70d5
--- /dev/null
+++ b/test/CodeGen/writable-strings.c
@@ -0,0 +1,8 @@
+// RUN: clang-cc -emit-llvm -o - -fwritable-strings %s
+
+int main() {
+    char *str = "abc";
+    str[0] = '1';
+    printf("%s", str);
+}
+
diff --git a/test/CodeGen/x86.c b/test/CodeGen/x86.c
new file mode 100644
index 0000000..10808dc
--- /dev/null
+++ b/test/CodeGen/x86.c
@@ -0,0 +1,23 @@
+// 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 &&
+// RUN: grep "dx" %t1 &&
+// RUN: grep "di" %t1 &&
+// RUN: grep "si" %t1 &&
+// RUN: grep "st" %t1 &&
+// RUN: grep "st(1)" %t1
+
+void test1() {
+  int d1, d2;
+  asm ("" : "=a" (d1), "=b" (d2) :
+       "c" (0), "d" (0), "S" (0), "D" (0), "t" (0), "u" (0));
+}
+
+
+// rdar://6803924
+typedef double T __attribute__ ((__vector_size__ (16)));
+T test2(T va) {
+  return __builtin_ia32_shufpd(va, va, 3);
+}
+
diff --git a/test/CodeGen/x86_32-arguments.c b/test/CodeGen/x86_32-arguments.c
new file mode 100644
index 0000000..8980c66
--- /dev/null
+++ b/test/CodeGen/x86_32-arguments.c
@@ -0,0 +1,157 @@
+// RUN: clang-cc -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 &&
+// RUN: grep 'define float @f3()' %t &&
+// RUN: grep 'define double @f4()' %t &&
+// 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 'define i64 @f8_1()' %t && 
+// RUN: grep 'define void @f8_2(i32 %a0.0, i32 %a0.1)' %t &&
+
+char f0(void) {
+}
+
+short f1(void) {
+}
+
+int f2(void) {
+}
+
+float f3(void) {
+}
+
+double f4(void) {
+}
+
+long double f5(void) {
+}
+
+void f6(char a0, short a1, int a2, long long a3, void *a4) {
+}
+
+typedef enum { A, B, C } E;
+
+void f7(E a0) {
+}
+
+struct s8 {
+  int a;
+  int b;
+};
+struct s8 f8_1(void) {
+}
+void f8_2(struct s8 a0) {
+}
+
+// This should be passed just as s8.
+
+// RUN: grep 'define i64 @f9_1()' %t &&
+
+// FIXME: llvm-gcc expands this, this may have some value for the
+// backend in terms of optimization but doesn't change the ABI.
+// RUN: grep 'define void @f9_2(%.truct.s9\* byval %a0)' %t &&
+struct s9 {
+  int a : 17;
+  int b;
+};
+struct s9 f9_1(void) {
+}
+void f9_2(struct s9 a0) {
+}
+
+// Return of small structures and unions
+
+// RUN: grep 'float @f10()' %t &&
+struct s10 {
+  union { };
+  float f;
+} f10(void) {}
+
+// Small vectors and 1 x {i64,double} are returned in registers
+
+// RUN: grep 'i32 @f11()' %t &&
+// RUN: grep -F 'void @f12(<2 x i32>* noalias sret %agg.result)' %t &&
+// RUN: grep 'i64 @f13()' %t &&
+// RUN: grep 'i64 @f14()' %t &&
+// RUN: grep '<2 x i64> @f15()' %t &&
+// RUN: grep '<2 x i64> @f16()' %t &&
+typedef short T11 __attribute__ ((vector_size (4)));
+T11 f11(void) {}
+typedef int T12 __attribute__ ((vector_size (8)));
+T12 f12(void) {}
+typedef long long T13 __attribute__ ((vector_size (8)));
+T13 f13(void) {}
+typedef double T14 __attribute__ ((vector_size (8)));
+T14 f14(void) {}
+typedef long long T15 __attribute__ ((vector_size (16)));
+T15 f15(void) {}
+typedef double T16 __attribute__ ((vector_size (16)));
+T16 f16(void) {}
+
+// And when the single element in a struct (but not for 64 and
+// 128-bits).
+
+// RUN: grep 'i32 @f17()' %t &&
+// RUN: grep -F 'void @f18(%2* noalias sret %agg.result)' %t &&
+// RUN: grep -F 'void @f19(%3* noalias sret %agg.result)' %t &&
+// 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) {}
+
+// 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) {}
+
+// 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) {}
+
+// RUN: grep 'void @f28(%.truct.s28\* noalias sret %agg.result)' %t &&
+struct s28 { int a; int b[]; } f28(void) {}
+
+// RUN: grep 'define i16 @f29()' %t &&
+struct s29 { struct { } a[1]; char b; char c; } f29(void) {}
+
+// RUN: grep 'define i16 @f30()' %t &&
+struct s30 { char a; char b : 4; } f30(void) {}
+
+// RUN: grep 'define float @f31()' %t &&
+struct s31 { char : 0; float b; char : 0; } f31(void) {}
+
+// RUN: grep 'define i32 @f32()' %t &&
+struct s32 { char a; unsigned : 0; } f32(void) {}
+
+// RUN: grep 'define float @f33()' %t &&
+struct s33 { float a; long long : 0; } f33(void) {}
+
+// RUN: grep 'define float @f34()' %t &&
+struct s34 { struct { int : 0; } a; float b; } f34(void) {}
+
+// RUN: grep 'define i16 @f35()' %t &&
+struct s35 { struct { int : 0; } a; char b; char c; } f35(void) {}
+
+// RUN: grep 'define i16 @f36()' %t &&
+struct s36 { struct { int : 0; } a[2][10]; char b; char c; } f36(void) {}
+
+// RUN: grep 'define float @f37()' %t &&
+struct s37 { float c[1][1]; } f37(void) {}
+
+// RUN: grep 'define void @f38(.struct.s38. noalias sret .agg.result)' %t &&
+struct s38 { char a[3]; short b; } f38(void) {}
+
+// RUN: true
diff --git a/test/CodeGen/x86_64-arguments.c b/test/CodeGen/x86_64-arguments.c
new file mode 100644
index 0000000..6f7ec82
--- /dev/null
+++ b/test/CodeGen/x86_64-arguments.c
@@ -0,0 +1,85 @@
+// RUN: clang-cc -triple x86_64-unknown-unknown -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 &&
+// RUN: grep 'define float @f3()' %t &&
+// RUN: grep 'define double @f4()' %t &&
+// 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 'define .0 @f8_1()' %t &&
+// RUN: grep 'define void @f8_2(.0)' %t &&
+
+char f0(void) {
+}
+
+short f1(void) {
+}
+
+int f2(void) {
+}
+
+float f3(void) {
+}
+
+double f4(void) {
+}
+
+long double f5(void) {
+}
+
+void f6(char a0, short a1, int a2, long long a3, void *a4) {
+}
+
+typedef enum { A, B, C } E;
+
+void f7(E a0) {
+}
+
+// Test merging/passing of upper eightbyte with X87 class.
+union u8 {
+  long double a;
+  int b;
+};
+union u8 f8_1() {}
+void f8_2(union u8 a0) {}
+
+// RUN: grep 'define i64 @f9()' %t &&
+struct s9 { int a; int b; int : 0; } f9(void) {}
+
+// 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() {}
+
+// 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) {}
+void f12_1(struct s12 a0) {}
+
+// Check that sret parameter is accounted for when checking available integer
+// registers.
+// 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_0 f13(int a, int b, int c, int d, 
+                 struct s13_1 { long long f0[2]; } e, int f) {}
+
+// RUN: grep 'define void @f14(.*, i8 signext .X)' %t &&
+void f14(int a, int b, int c, int d, int e, int f, 
+         char X) {}
+// RUN: grep 'define void @f15(.*, i8\* .X)' %t &&
+void f15(int a, int b, int c, int d, int e, int f, 
+         void *X) {}
+// RUN: grep 'define void @f16(.*, float .X)' %t &&
+void f16(float a, float b, float c, float d, float e, float f, float g, float h,
+         float X) {}
+// RUN: grep 'define void @f17(.*, x86_fp80 .X)' %t &&
+void f17(float a, float b, float c, float d, float e, float f, float g, float h,
+         long double X) {}
+
+// RUN: true