diff --git a/test/CodeGen/2002-01-23-LoadQISIReloadFailure.c b/test/CodeGen/2002-01-23-LoadQISIReloadFailure.c
new file mode 100644
index 0000000..ec454c8
--- /dev/null
+++ b/test/CodeGen/2002-01-23-LoadQISIReloadFailure.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* Regression test.  Just compile .c -> .ll to test */
+int foo(void) {
+  unsigned char *pp;
+  unsigned w_cnt;
+
+  w_cnt += *pp;
+
+  return w_cnt;
+}
diff --git a/test/CodeGen/2002-01-24-ComplexSpaceInType.c b/test/CodeGen/2002-01-24-ComplexSpaceInType.c
new file mode 100644
index 0000000..9af533d
--- /dev/null
+++ b/test/CodeGen/2002-01-24-ComplexSpaceInType.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+// This caused generation of the following type name:
+//   %Array = uninitialized global [10 x %complex int]
+//
+// which caused problems because of the space int the complex int type
+//
+
+struct { int X, Y; } Array[10];
+
+void foo() {}
diff --git a/test/CodeGen/2002-01-24-HandleCallInsnSEGV.c b/test/CodeGen/2002-01-24-HandleCallInsnSEGV.c
new file mode 100644
index 0000000..739a841
--- /dev/null
+++ b/test/CodeGen/2002-01-24-HandleCallInsnSEGV.c
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+void *dlclose(void*);
+
+void ap_os_dso_unload(void *handle)
+{
+    dlclose(handle);
+    return;     /* This return triggers the bug: Weird */
+}
diff --git a/test/CodeGen/2002-02-13-ConditionalInCall.c b/test/CodeGen/2002-02-13-ConditionalInCall.c
new file mode 100644
index 0000000..d389371
--- /dev/null
+++ b/test/CodeGen/2002-02-13-ConditionalInCall.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* Test problem where bad code was generated with a ?: statement was 
+   in a function call argument */
+
+void foo(int, double, float);
+
+void bar(int x) {
+  foo(x, x ? 1.0 : 12.5, 1.0f);
+}
+
diff --git a/test/CodeGen/2002-02-13-ReloadProblem.c b/test/CodeGen/2002-02-13-ReloadProblem.c
new file mode 100644
index 0000000..da7f5e4
--- /dev/null
+++ b/test/CodeGen/2002-02-13-ReloadProblem.c
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* This triggered a problem in reload, fixed by disabling most of the 
+ * steps of compilation in GCC.  Before this change, the code went through
+ * the entire backend of GCC, even though it was unnecessary for LLVM output
+ * now it is skipped entirely, and since reload doesn't run, it can't cause
+ * a problem.
+ */
+
+extern int tolower(int);
+
+const char *rangematch(const char *pattern, int test, int c) {
+
+  if ((c <= test) | (tolower(c) <= tolower((unsigned char)test)))
+    return 0;
+
+  return pattern;
+}
diff --git a/test/CodeGen/2002-02-13-TypeVarNameCollision.c b/test/CodeGen/2002-02-13-TypeVarNameCollision.c
new file mode 100644
index 0000000..c76aef0
--- /dev/null
+++ b/test/CodeGen/2002-02-13-TypeVarNameCollision.c
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* This testcase causes a symbol table collision.  Type names and variable
+ * names should be in distinct namespaces
+ */
+
+typedef struct foo {
+  int X, Y;
+} FOO;
+
+static FOO foo[100];
+
+int test() {
+  return foo[4].Y;
+}
+
diff --git a/test/CodeGen/2002-02-13-UnnamedLocal.c b/test/CodeGen/2002-02-13-UnnamedLocal.c
new file mode 100644
index 0000000..58a9f5a
--- /dev/null
+++ b/test/CodeGen/2002-02-13-UnnamedLocal.c
@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* Testcase for a problem where GCC allocated xqic to a register,
+ * and did not have a VAR_DECL that explained the stack slot to LLVM.
+ * Now the LLVM code synthesizes a stack slot if one is presented that
+ * has not been previously recognized.  This is where alloca's named 
+ * 'local' come from now. 
+ */
+
+typedef struct {
+  short x;
+} foostruct;
+
+int foo(foostruct ic);
+
+void test() {
+  foostruct xqic;
+  foo(xqic);
+}
+
+
diff --git a/test/CodeGen/2002-02-14-EntryNodePreds.c b/test/CodeGen/2002-02-14-EntryNodePreds.c
new file mode 100644
index 0000000..60d1104
--- /dev/null
+++ b/test/CodeGen/2002-02-14-EntryNodePreds.c
@@ -0,0 +1,37 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* GCC Used to generate code that contained a branch to the entry node of 
+ * the do_merge function.  This is illegal LLVM code.  To fix this, GCC now
+ * inserts an entry node regardless of whether or not it has to insert allocas.
+ */
+
+struct edge_rec
+{
+  struct VERTEX *v;
+  struct edge_rec *next;
+  int wasseen;
+  int more_data;
+};
+
+typedef struct edge_rec *QUAD_EDGE;
+
+typedef struct {
+  QUAD_EDGE left, right;
+} EDGE_PAIR;
+
+struct EDGE_STACK {
+    int ptr;
+    QUAD_EDGE *elts;
+    int stack_size;
+};
+
+int do_merge(QUAD_EDGE ldo, QUAD_EDGE rdo) {
+  int lvalid;
+  QUAD_EDGE basel,rcand;
+  while (1) {
+    if (!lvalid) {
+      return (int)basel->next;
+    }
+  }
+}
+
diff --git a/test/CodeGen/2002-02-16-RenamingTest.c b/test/CodeGen/2002-02-16-RenamingTest.c
new file mode 100644
index 0000000..bb23e68
--- /dev/null
+++ b/test/CodeGen/2002-02-16-RenamingTest.c
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* test that locals are renamed with . notation */
+
+void abc(void *);
+
+void Test5(double X) {
+  abc(&X);
+  {
+    int X;
+    abc(&X);
+    {
+      float X;
+      abc(&X);
+    }
+  }
+}
+
diff --git a/test/CodeGen/2002-02-17-ArgumentAddress.c b/test/CodeGen/2002-02-17-ArgumentAddress.c
new file mode 100644
index 0000000..d1ad6a8
--- /dev/null
+++ b/test/CodeGen/2002-02-17-ArgumentAddress.c
@@ -0,0 +1,39 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+int test(int X) {
+  return X;
+}
+
+void abc(int *X);
+int def(int Y, int Z) {
+  abc(&Z);
+  return Y;
+}
+
+struct Test { short X, x; int Y, Z; };
+
+int Testing(struct Test *A) {
+  return A->X+A->Y;
+}
+
+int Test2(int X, struct Test A, int Y) {
+  return X+Y+A.X+A.Y;
+}
+int Test3(struct Test A, struct Test B) {
+  return A.X+A.Y+B.Y+B.Z;
+}
+
+struct Test Test4(struct Test A) {
+  return A;
+}
+
+int Test6() {
+  int B[200];
+  return B[4];
+}
+
+struct STest2 { int X; short Y[4]; double Z; };
+
+struct STest2 Test7(struct STest2 X) {
+  return X;
+}
diff --git a/test/CodeGen/2002-02-18-StaticData.c b/test/CodeGen/2002-02-18-StaticData.c
new file mode 100644
index 0000000..d0cf524
--- /dev/null
+++ b/test/CodeGen/2002-02-18-StaticData.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+double FOO = 17;
+double BAR = 12.0;
+float XX = 12.0f;
+
+static char *procnames[] = {
+  "EXIT"
+};
+
+void *Data[] = { &FOO, &BAR, &XX };
+
diff --git a/test/CodeGen/2002-03-12-ArrayInitialization.c b/test/CodeGen/2002-03-12-ArrayInitialization.c
new file mode 100644
index 0000000..f05b838
--- /dev/null
+++ b/test/CodeGen/2002-03-12-ArrayInitialization.c
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* GCC would generate bad code if not enough initializers are 
+   specified for an array.
+ */
+
+int a[10] = { 0, 2};
+
+char str[10] = "x";
+
+void *Arr[5] = { 0, 0 };
+
+float F[12] = { 1.23f, 34.7f };
+
+struct Test { int X; double Y; };
+
+struct Test Array[10] = { { 2, 12.0 }, { 3, 24.0 } };
+
+int B[4][4] = { { 1, 2, 3, 4}, { 5, 6, 7 }, { 8, 9 } };
diff --git a/test/CodeGen/2002-03-12-StructInitialize.c b/test/CodeGen/2002-03-12-StructInitialize.c
new file mode 100644
index 0000000..1316fbb
--- /dev/null
+++ b/test/CodeGen/2002-03-12-StructInitialize.c
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+typedef struct Connection_Type {
+   long    to;
+   char    type[10];
+   long    length;
+} Connection;
+
+Connection link[3]
+= { {1, "link1", 10},
+    {2, "link2", 20},
+    {3, "link3", 30} };
+
diff --git a/test/CodeGen/2002-03-12-StructInitializer.c b/test/CodeGen/2002-03-12-StructInitializer.c
new file mode 100644
index 0000000..a65675b
--- /dev/null
+++ b/test/CodeGen/2002-03-12-StructInitializer.c
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* GCC was not emitting string constants of the correct length when
+ * embedded into a structure field like this.  It thought the strlength
+ * was -1.
+ */
+
+typedef struct Connection_Type {
+   long    to;
+   char    type[10];
+   long    length;
+} Connection;
+
+Connection link[3]
+= { {1, "link1", 10},
+    {2, "link2", 20},
+    {3, "link3", 30} };
+
diff --git a/test/CodeGen/2002-03-14-BrokenPHINode.c b/test/CodeGen/2002-03-14-BrokenPHINode.c
new file mode 100644
index 0000000..eb05859
--- /dev/null
+++ b/test/CodeGen/2002-03-14-BrokenPHINode.c
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* GCC was generating PHI nodes with an arity < #pred of the basic block the
+ * PHI node lived in.  This was breaking LLVM because the number of entries
+ * in a PHI node must equal the number of predecessors for a basic block.
+ */
+
+int trys(char *s, int x)
+{
+  int asa;
+  double Val;
+  int LLS;
+  if (x) {
+    asa = LLS + asa;
+  } else {
+  }
+  return asa+(int)Val;
+}
+
diff --git a/test/CodeGen/2002-03-14-BrokenSSA.c b/test/CodeGen/2002-03-14-BrokenSSA.c
new file mode 100644
index 0000000..65e5cfa
--- /dev/null
+++ b/test/CodeGen/2002-03-14-BrokenSSA.c
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* This code used to break GCC's SSA computation code.  It would create
+   uses of B & C that are not dominated by their definitions.  See:
+   http://gcc.gnu.org/ml/gcc/2002-03/msg00697.html
+ */
+int bar();
+int foo()
+{
+  int a,b,c;
+
+  a = b + c;
+  b = bar();
+  c = bar();
+  return a + b + c;
+}
+
diff --git a/test/CodeGen/2002-03-14-QuotesInStrConst.c b/test/CodeGen/2002-03-14-QuotesInStrConst.c
new file mode 100644
index 0000000..de4bdd6
--- /dev/null
+++ b/test/CodeGen/2002-03-14-QuotesInStrConst.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* GCC was not escaping quotes in string constants correctly, so this would
+ * get emitted:
+ *  %.LC1 = internal global [32 x sbyte] c"*** Word "%s" on line %d is not\00"
+ */
+
+const char *Foo() {
+  return "*** Word \"%s\" on line %d is not";
+}
diff --git a/test/CodeGen/2002-04-07-SwitchStmt.c b/test/CodeGen/2002-04-07-SwitchStmt.c
new file mode 100644
index 0000000..cf1ec79
--- /dev/null
+++ b/test/CodeGen/2002-04-07-SwitchStmt.c
@@ -0,0 +1,22 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+int printf(const char *, ...);
+int foo();
+
+int main() {
+  while (foo()) {
+     switch (foo()) {
+     case 0:
+     case 1:
+     case 2:
+     case 3:
+       printf("3");
+     case 4: printf("4");
+     case 5:
+     case 6:
+     default:
+       break;
+     }
+   }
+   return 0;
+}
diff --git a/test/CodeGen/2002-04-08-LocalArray.c b/test/CodeGen/2002-04-08-LocalArray.c
new file mode 100644
index 0000000..9b5ef79
--- /dev/null
+++ b/test/CodeGen/2002-04-08-LocalArray.c
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* GCC is not outputting the static array to the LLVM backend, so bad things
+ * happen.  Note that if this is defined static, everything seems fine.
+ */
+double test(unsigned X) {
+  double student_t[30]={0.0 , 12.706 , 4.303 , 3.182 , 2.776 , 2.571 ,
+                               2.447 , 2.365 , 2.306 , 2.262 , 2.228 ,
+                               2.201 , 2.179 , 2.160 , 2.145 , 2.131 ,
+                               2.120 , 2.110 , 2.101 , 2.093 , 2.086 ,
+                               2.080 , 2.074 , 2.069 , 2.064 , 2.060 ,
+                               2.056 , 2.052 , 2.048 , 2.045 };
+  return student_t[X];
+}
diff --git a/test/CodeGen/2002-04-09-StructRetVal.c b/test/CodeGen/2002-04-09-StructRetVal.c
new file mode 100644
index 0000000..f043ab7
--- /dev/null
+++ b/test/CodeGen/2002-04-09-StructRetVal.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+struct S {
+  int i;
+  short s1, s2;
+};
+
+struct S func_returning_struct(void);
+
+void loop(void) {
+  func_returning_struct();
+}
diff --git a/test/CodeGen/2002-04-10-StructParameters.c b/test/CodeGen/2002-04-10-StructParameters.c
new file mode 100644
index 0000000..72cebc6
--- /dev/null
+++ b/test/CodeGen/2002-04-10-StructParameters.c
@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+typedef struct {
+  char p;
+  short q;
+  char r;
+  int X;
+  short Y, Z;
+  int Q;
+} foo;
+
+int test(foo X, float);
+int testE(char,short,char,int,int,float);
+void test3(foo *X) {
+  X->q = 1;
+}
+
+void test2(foo Y) {
+  testE(Y.p, Y.q, Y.r, Y.X, Y.Y, 0.1f);
+  test(Y, 0.1f);
+  test2(Y);
+  test3(&Y);
+}
+
diff --git a/test/CodeGen/2002-05-23-StaticValues.c b/test/CodeGen/2002-05-23-StaticValues.c
new file mode 100644
index 0000000..b8c25b7
--- /dev/null
+++ b/test/CodeGen/2002-05-23-StaticValues.c
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* Make sure the frontend is correctly marking static stuff as internal! */
+
+int X;
+static int Y = 12;
+
+static void foo(int Z) {
+  Y = Z;
+}
+
+void *test() {
+  foo(12);
+  return &Y;
+}
diff --git a/test/CodeGen/2002-05-23-TypeNameCollision.c b/test/CodeGen/2002-05-23-TypeNameCollision.c
new file mode 100644
index 0000000..c15c952
--- /dev/null
+++ b/test/CodeGen/2002-05-23-TypeNameCollision.c
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* Testcase for when struct tag conflicts with typedef name... grr */
+
+typedef struct foo {
+  struct foo *X;
+  int Y;
+} * foo;
+
+foo F1;
+struct foo *F2;
+
+enum bar { test1, test2 };
+
+typedef float bar;
+
+enum bar B1;
+bar B2;
+
diff --git a/test/CodeGen/2002-07-14-MiscListTests.c b/test/CodeGen/2002-07-14-MiscListTests.c
new file mode 100644
index 0000000..901701a
--- /dev/null
+++ b/test/CodeGen/2002-07-14-MiscListTests.c
@@ -0,0 +1,71 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+// Test list stuff
+
+void *malloc(unsigned);
+
+// Test opaque structure support.  the list type is defined later
+struct list;
+
+struct list *PassThroughList(struct list *L) {
+  return L;
+}
+
+
+// Recursive data structure tests...
+
+typedef struct list {
+  int Data;
+  struct list *Next;
+} list;
+
+list *Data;
+
+void foo() {
+  static int Foo = 0;            // Test static local variable
+  Foo += 1;                      // Increment static variable
+
+  Data = (list*)malloc(12);      // This is not a proper list allocation
+}
+
+extern list ListNode1;
+list ListNode3 = { 4, 0          };
+list ListNode2 = { 3, &ListNode3 };
+list ListNode0 = { 1, &ListNode1 };
+list ListNode1 = { 2, &ListNode2 };
+
+
+list ListArray[10];
+
+// Iterative insert fn
+void InsertIntoListTail(list **L, int Data) {
+  while (*L)
+    L = &(*L)->Next;
+  *L = (list*)malloc(sizeof(list));
+  (*L)->Data = Data;
+  (*L)->Next = 0;
+}
+
+// Recursive list search fn
+list *FindData(list *L, int Data) {
+  if (L == 0) return 0;
+  if (L->Data == Data) return L;
+  return FindData(L->Next, Data);
+}
+
+void foundIt(void);
+
+// Driver fn...
+void DoListStuff() {
+  list *MyList = 0;
+  InsertIntoListTail(&MyList, 100);
+  InsertIntoListTail(&MyList, 12);
+  InsertIntoListTail(&MyList, 42);
+  InsertIntoListTail(&MyList, 1123);
+  InsertIntoListTail(&MyList, 1213);
+
+  if (FindData(MyList, 75)) foundIt();
+  if (FindData(MyList, 42)) foundIt();
+  if (FindData(MyList, 700)) foundIt();
+}
+
diff --git a/test/CodeGen/2002-07-14-MiscTests.c b/test/CodeGen/2002-07-14-MiscTests.c
new file mode 100644
index 0000000..2a65124
--- /dev/null
+++ b/test/CodeGen/2002-07-14-MiscTests.c
@@ -0,0 +1,57 @@
+// RUN: %clang_cc1 -w -emit-llvm %s  -o /dev/null
+
+/* These are random tests that I used when working on the GCC frontend 
+   originally. */
+
+// test floating point comparison!
+int floatcomptest(double *X, double *Y, float *x, float *y) {
+  return *X < *Y || *x < *y;
+}
+
+extern void *malloc(unsigned);
+
+// Exposed a bug
+void *memset_impl(void *dstpp, int c, unsigned len) {
+  long long int dstp = (long long int) dstpp;
+
+  while (dstp % 4 != 0)
+    {
+      ((unsigned char *) dstp)[0] = c;
+      dstp += 1;
+      len -= 1;
+    }
+  return dstpp;
+}
+
+// TEST problem with signed/unsigned versions of the same constants being shared
+// incorrectly!
+//
+static char *temp;
+static int remaining;
+static char *localmalloc(int size) {
+  char *blah;
+  
+  if (size>remaining) 
+    {
+      temp = (char *) malloc(32768);
+      remaining = 32768;
+      return temp;
+    }
+  return 0;
+}
+
+typedef struct { double X; double Y; int Z; } PBVTest;
+
+PBVTest testRetStruct(float X, double Y, int Z) {
+  PBVTest T = { X, Y, Z };
+  return T;
+}
+PBVTest testRetStruct2(void);  // external func no inlining
+
+
+double CallRetStruct(float X, double Y, int Z) {
+  PBVTest T = testRetStruct2();
+  return T.X+X+Y+Z;
+}
+
+
diff --git a/test/CodeGen/2002-07-14-MiscTests2.c b/test/CodeGen/2002-07-14-MiscTests2.c
new file mode 100644
index 0000000..ad13017
--- /dev/null
+++ b/test/CodeGen/2002-07-14-MiscTests2.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+// Test ?: in function calls
+extern fp(int, char*);
+char *Ext;
+void
+__bb_exit_func (void)
+{
+  fp (12, Ext ? Ext : "<none>");
+}
+
+
diff --git a/test/CodeGen/2002-07-16-HardStringInit.c b/test/CodeGen/2002-07-16-HardStringInit.c
new file mode 100644
index 0000000..b307359
--- /dev/null
+++ b/test/CodeGen/2002-07-16-HardStringInit.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+  char      auto_kibitz_list[100][20] = {
+                                      {"diepx"},
+                                      {"ferret"},
+                                      {"knightc"},
+                                      {"knightcap"}};
+
diff --git a/test/CodeGen/2002-07-17-StringConstant.c b/test/CodeGen/2002-07-17-StringConstant.c
new file mode 100644
index 0000000..5b86a5b
--- /dev/null
+++ b/test/CodeGen/2002-07-17-StringConstant.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+char * foo() { return "\\begin{"; }
diff --git a/test/CodeGen/2002-07-30-SubregSetAssertion.c b/test/CodeGen/2002-07-30-SubregSetAssertion.c
new file mode 100644
index 0000000..39e97b3
--- /dev/null
+++ b/test/CodeGen/2002-07-30-SubregSetAssertion.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+union X {
+  void *B;
+};
+
+union X foo() {
+  union X A;
+  A.B = (void*)123;
+  return A;
+}
diff --git a/test/CodeGen/2002-07-30-UnionTest.c b/test/CodeGen/2002-07-30-UnionTest.c
new file mode 100644
index 0000000..d5b92e7
--- /dev/null
+++ b/test/CodeGen/2002-07-30-UnionTest.c
@@ -0,0 +1,22 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+union X;
+struct Empty {};
+union F {};
+union Q { union Q *X; };
+union X {
+  char C;
+  int A, Z;
+  long long B;
+  void *b1;
+  struct { int A; long long Z; } Q;
+};
+
+union X foo(union X A) {
+  A.C = 123;
+  A.A = 39249;
+  //A.B = (void*)123040123321;
+  A.B = 12301230123123LL;
+  A.Z = 1;
+  return A;
+}
diff --git a/test/CodeGen/2002-07-30-VarArgsCallFailure.c b/test/CodeGen/2002-07-30-VarArgsCallFailure.c
new file mode 100644
index 0000000..784305d
--- /dev/null
+++ b/test/CodeGen/2002-07-30-VarArgsCallFailure.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+int tcount;
+void test(char *, const char*, int);
+void foo() {
+  char Buf[10];
+  test(Buf, "n%%%d", tcount++);
+}
diff --git a/test/CodeGen/2002-07-31-BadAssert.c b/test/CodeGen/2002-07-31-BadAssert.c
new file mode 100644
index 0000000..512a63a
--- /dev/null
+++ b/test/CodeGen/2002-07-31-BadAssert.c
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+typedef struct
+{
+        unsigned char type;        /* Indicates, NORMAL, SUBNORMAL, etc. */
+} InternalFPF;
+
+
+static void SetInternalFPFZero(InternalFPF *dest) {
+  dest->type=0;
+}
+
+void denormalize(InternalFPF *ptr) {
+   SetInternalFPFZero(ptr);
+}
+
diff --git a/test/CodeGen/2002-07-31-SubregFailure.c b/test/CodeGen/2002-07-31-SubregFailure.c
new file mode 100644
index 0000000..5c7f38f
--- /dev/null
+++ b/test/CodeGen/2002-07-31-SubregFailure.c
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+typedef union {
+   long (*ap)[4];
+} ptrs;
+
+void DoAssignIteration() {
+  ptrs abase;
+  abase.ap+=27;
+  Assignment(*abase.ap);
+}
+
+
diff --git a/test/CodeGen/2002-08-19-RecursiveLocals.c b/test/CodeGen/2002-08-19-RecursiveLocals.c
new file mode 100644
index 0000000..89c67ba
--- /dev/null
+++ b/test/CodeGen/2002-08-19-RecursiveLocals.c
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+/* This testcase doesn't actually test a bug, it's just the result of me 
+ * figuring out the syntax for forward declaring a static variable. */
+struct list {
+  int x;
+  struct list *Next;
+};
+
+static struct list B;  /* Forward declare static */
+static struct list A = { 7, &B };
+static struct list B = { 8, &A };
+
+extern struct list D;  /* forward declare normal var */
+
+struct list C = { 7, &D };
+struct list D = { 8, &C };
+
diff --git a/test/CodeGen/2002-09-08-PointerShifts.c b/test/CodeGen/2002-09-08-PointerShifts.c
new file mode 100644
index 0000000..7d1ba6e
--- /dev/null
+++ b/test/CodeGen/2002-09-08-PointerShifts.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+int foo(int *A, unsigned X) {
+  return A[X];
+}
diff --git a/test/CodeGen/2002-09-18-UnionProblem.c b/test/CodeGen/2002-09-18-UnionProblem.c
new file mode 100644
index 0000000..d299c19
--- /dev/null
+++ b/test/CodeGen/2002-09-18-UnionProblem.c
@@ -0,0 +1,26 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+struct DWstruct {
+  char high, low;
+};
+
+typedef union {
+  struct DWstruct s;
+  short ll;
+} DWunion;
+
+short __udivmodhi4 (char n1, char bm) {
+  DWunion rr;
+
+  if (bm == 0)
+    {
+      rr.s.high = n1;
+    }
+  else
+    {
+      rr.s.high = bm;
+    }
+
+  return rr.ll;
+}
diff --git a/test/CodeGen/2002-10-12-TooManyArguments.c b/test/CodeGen/2002-10-12-TooManyArguments.c
new file mode 100644
index 0000000..2324c2a
--- /dev/null
+++ b/test/CodeGen/2002-10-12-TooManyArguments.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+void foo() {}
+
+void bar() {
+  foo(1, 2, 3);  /* Too many arguments passed */
+}
diff --git a/test/CodeGen/2002-12-15-GlobalBoolTest.c b/test/CodeGen/2002-12-15-GlobalBoolTest.c
new file mode 100644
index 0000000..3c4133f
--- /dev/null
+++ b/test/CodeGen/2002-12-15-GlobalBoolTest.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+_Bool X = 0;
+
diff --git a/test/CodeGen/2002-12-15-GlobalConstantTest.c b/test/CodeGen/2002-12-15-GlobalConstantTest.c
new file mode 100644
index 0000000..8203f56
--- /dev/null
+++ b/test/CodeGen/2002-12-15-GlobalConstantTest.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+const char *W = "foo";
+const int X = 7;
+int Y = 8;
+const char * const Z = "bar";
+
diff --git a/test/CodeGen/2002-12-15-GlobalRedefinition.c b/test/CodeGen/2002-12-15-GlobalRedefinition.c
new file mode 100644
index 0000000..646e91e
--- /dev/null
+++ b/test/CodeGen/2002-12-15-GlobalRedefinition.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+extern char algbrfile[9];
+char algbrfile[9] = "abcdefgh";
+
diff --git a/test/CodeGen/2002-12-15-StructParameters.c b/test/CodeGen/2002-12-15-StructParameters.c
new file mode 100644
index 0000000..f6b59de
--- /dev/null
+++ b/test/CodeGen/2002-12-15-StructParameters.c
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+typedef struct
+{
+  void *stack;
+  unsigned size;
+  unsigned avail;
+} compile_stack_type;
+
+void foo(void*);
+void bar(compile_stack_type T, unsigned);
+
+void test() {
+  compile_stack_type CST;
+  foo(&CST);
+
+  bar(CST, 12);
+}
diff --git a/test/CodeGen/2003-01-30-UnionInit.c b/test/CodeGen/2003-01-30-UnionInit.c
new file mode 100644
index 0000000..98aee72
--- /dev/null
+++ b/test/CodeGen/2003-01-30-UnionInit.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm %s -o /dev/null
+
+union foo {
+  struct { char A, B; } X;
+  int C;
+};
+
+union foo V = { {1, 2} };
diff --git a/test/CodeGen/2003-03-03-DeferredType.c b/test/CodeGen/2003-03-03-DeferredType.c
new file mode 100644
index 0000000..a7a4ce3
--- /dev/null
+++ b/test/CodeGen/2003-03-03-DeferredType.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+
+
+struct foo A;
+
+struct foo {
+  int x;
+double D;
+};
+
diff --git a/test/CodeGen/2003-06-22-UnionCrash.c b/test/CodeGen/2003-06-22-UnionCrash.c
new file mode 100644
index 0000000..eb5014c
--- /dev/null
+++ b/test/CodeGen/2003-06-22-UnionCrash.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+struct Blend_Map_Entry {
+  union {
+   float Colour[5];
+   double Point_Slope[2];
+  } Vals;
+};
+
+void test(struct Blend_Map_Entry* Foo)
+{
+}
+
diff --git a/test/CodeGen/2003-06-23-GCC-fold-infinite-recursion.c b/test/CodeGen/2003-06-23-GCC-fold-infinite-recursion.c
new file mode 100644
index 0000000..51d4824
--- /dev/null
+++ b/test/CodeGen/2003-06-23-GCC-fold-infinite-recursion.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+double Test(double A, double B, double C, double D) {
+  return -(A-B) - (C-D);
+}
+
diff --git a/test/CodeGen/2003-06-26-CFECrash.c b/test/CodeGen/2003-06-26-CFECrash.c
new file mode 100644
index 0000000..dd874b7
--- /dev/null
+++ b/test/CodeGen/2003-06-26-CFECrash.c
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+typedef struct min_info {
+  long offset;
+  unsigned file_attr;
+} min_info;
+
+typedef struct Globals {
+  char answerbuf;
+  min_info info[1];
+  min_info *pInfo;
+} Uz_Globs;
+
+extern Uz_Globs G;
+
+int extract_or_test_files() {  
+  G.pInfo = G.info;
+}
+
diff --git a/test/CodeGen/2003-06-29-MultipleFunctionDefinition.c b/test/CodeGen/2003-06-29-MultipleFunctionDefinition.c
new file mode 100644
index 0000000..99b3a7f
--- /dev/null
+++ b/test/CodeGen/2003-06-29-MultipleFunctionDefinition.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -std=gnu89 -emit-llvm %s  -o /dev/null
+
+/* This is apparently legal C.
+ */
+extern __inline__ void test() { }
+
+void test() {
+}
diff --git a/test/CodeGen/2003-07-22-ArrayAccessTypeSafety.c b/test/CodeGen/2003-07-22-ArrayAccessTypeSafety.c
new file mode 100644
index 0000000..d0703ef
--- /dev/null
+++ b/test/CodeGen/2003-07-22-ArrayAccessTypeSafety.c
@@ -0,0 +1,7 @@
+/* RUN: %clang_cc1  %s -emit-llvm -o - | grep -v alloca | not grep bitcast
+ */
+
+void test(int* array, long long N) {
+    array[N] = N[array] = 33;
+}
+
diff --git a/test/CodeGen/2003-08-06-BuiltinSetjmpLongjmp.c b/test/CodeGen/2003-08-06-BuiltinSetjmpLongjmp.c
new file mode 100644
index 0000000..12bce26
--- /dev/null
+++ b/test/CodeGen/2003-08-06-BuiltinSetjmpLongjmp.c
@@ -0,0 +1,14 @@
+/* RUN: %clang_cc1  %s -emit-llvm -o - | not grep __builtin_
+ *
+ * __builtin_longjmp/setjmp should get transformed into llvm.setjmp/longjmp 
+ * just like explicit setjmp/longjmp calls are.
+ */
+
+void jumpaway(int *ptr) {
+  __builtin_longjmp(ptr,1);
+}
+    
+int main(void) {
+  __builtin_setjmp(0);
+  jumpaway(0);
+}
diff --git a/test/CodeGen/2003-08-17-DeadCodeShortCircuit.c b/test/CodeGen/2003-08-17-DeadCodeShortCircuit.c
new file mode 100644
index 0000000..031b530
--- /dev/null
+++ b/test/CodeGen/2003-08-17-DeadCodeShortCircuit.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -x c %s -emit-llvm -o /dev/null
+
+int test(_Bool pos, _Bool color) {
+  return 0;
+  return (pos && color);
+}
diff --git a/test/CodeGen/2003-08-18-StructAsValue.c b/test/CodeGen/2003-08-18-StructAsValue.c
new file mode 100644
index 0000000..9b8b5a2
--- /dev/null
+++ b/test/CodeGen/2003-08-18-StructAsValue.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+typedef struct {
+  int op;
+} event_t;
+
+event_t test(int X) {
+  event_t foo = { 1 }, bar = { 2 };
+  return X ? foo : bar;
+}
diff --git a/test/CodeGen/2003-08-20-BadBitfieldRef.c b/test/CodeGen/2003-08-20-BadBitfieldRef.c
new file mode 100644
index 0000000..a001546
--- /dev/null
+++ b/test/CodeGen/2003-08-20-BadBitfieldRef.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+void foo()
+{
+  char *ap;
+  ap[1] == '-' && ap[2] == 0;
+}
+
diff --git a/test/CodeGen/2003-08-20-PrototypeMismatch.c b/test/CodeGen/2003-08-20-PrototypeMismatch.c
new file mode 100644
index 0000000..fa42ca5
--- /dev/null
+++ b/test/CodeGen/2003-08-20-PrototypeMismatch.c
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+
+static int foo(int);
+
+static int foo(C)
+char C;
+{
+  return C;
+}
+
+void test() {
+  foo(7);
+}
diff --git a/test/CodeGen/2003-08-20-vfork-bug.c b/test/CodeGen/2003-08-20-vfork-bug.c
new file mode 100644
index 0000000..7ec0048
--- /dev/null
+++ b/test/CodeGen/2003-08-20-vfork-bug.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+extern int vfork(void);
+test() {
+  vfork();
+}
diff --git a/test/CodeGen/2003-08-21-BinOp-Type-Mismatch.c b/test/CodeGen/2003-08-21-BinOp-Type-Mismatch.c
new file mode 100644
index 0000000..d86b024
--- /dev/null
+++ b/test/CodeGen/2003-08-21-BinOp-Type-Mismatch.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+struct bar;
+
+void foo()
+{
+  unsigned int frame, focus;
+  (struct bar *) focus == (focus ? ((struct bar *) frame) : 0);
+}
+
diff --git a/test/CodeGen/2003-08-21-StmtExpr.c b/test/CodeGen/2003-08-21-StmtExpr.c
new file mode 100644
index 0000000..39db694
--- /dev/null
+++ b/test/CodeGen/2003-08-21-StmtExpr.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+typedef struct {
+  unsigned long val;
+} structty;
+
+void bar(structty new_mask);
+static void foo() {
+  bar(({ structty mask; mask; }));
+}
+
diff --git a/test/CodeGen/2003-08-23-LocalUnionTest.c b/test/CodeGen/2003-08-23-LocalUnionTest.c
new file mode 100644
index 0000000..50b01e4
--- /dev/null
+++ b/test/CodeGen/2003-08-23-LocalUnionTest.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+
+union foo { int X; };
+
+int test(union foo* F) {
+  {
+    union foo { float X; } A;
+  }
+}
diff --git a/test/CodeGen/2003-08-29-BitFieldStruct.c b/test/CodeGen/2003-08-29-BitFieldStruct.c
new file mode 100644
index 0000000..d8995ea
--- /dev/null
+++ b/test/CodeGen/2003-08-29-BitFieldStruct.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+struct Word {
+  short bar;
+  short baz;
+  int final:1;
+  short quux;
+} *word_limit;
+
+void foo ()
+{
+  word_limit->final = (word_limit->final && word_limit->final);
+}
diff --git a/test/CodeGen/2003-08-29-HugeCharConst.c b/test/CodeGen/2003-08-29-HugeCharConst.c
new file mode 100644
index 0000000..cd3eb54
--- /dev/null
+++ b/test/CodeGen/2003-08-29-HugeCharConst.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+void foo() {
+  unsigned char int_latin1[] = "f\200\372b\200\343\200\340";
+}
diff --git a/test/CodeGen/2003-08-30-AggregateInitializer.c b/test/CodeGen/2003-08-30-AggregateInitializer.c
new file mode 100644
index 0000000..5beb14e
--- /dev/null
+++ b/test/CodeGen/2003-08-30-AggregateInitializer.c
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -emit-llvm %s -o /dev/null
+
+struct istruct {
+  unsigned char C;
+};
+
+struct foo {
+  unsigned int I:1;
+  struct istruct J;
+  unsigned char L[1];
+  unsigned int K:1;
+};
+
+struct foo F = { 1, { 7 }, { 123 } , 1 };
+
+
diff --git a/test/CodeGen/2003-09-30-StructLayout.c b/test/CodeGen/2003-09-30-StructLayout.c
new file mode 100644
index 0000000..45ef69c
--- /dev/null
+++ b/test/CodeGen/2003-09-30-StructLayout.c
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+enum En {
+  ENUM_VAL
+};
+
+struct St {
+  unsigned char A;
+  enum En B;
+  unsigned char C;
+  enum En D;
+  float E;
+};
+
+
+void func(struct St* A) {
+  A->D = ENUM_VAL;
+}
diff --git a/test/CodeGen/2003-10-09-UnionInitializerBug.c b/test/CodeGen/2003-10-09-UnionInitializerBug.c
new file mode 100644
index 0000000..a14fd08
--- /dev/null
+++ b/test/CodeGen/2003-10-09-UnionInitializerBug.c
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+struct Foo {
+    unsigned a;
+    unsigned b;
+    unsigned c;
+};
+
+struct Bar {
+    union {
+        void **a;
+        struct Foo b;
+    }u;
+};
+
+struct Bar test = {0};
+
diff --git a/test/CodeGen/2003-10-28-ident.c b/test/CodeGen/2003-10-28-ident.c
new file mode 100644
index 0000000..d1e5447
--- /dev/null
+++ b/test/CodeGen/2003-10-28-ident.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+#ident "foo"
diff --git a/test/CodeGen/2003-10-29-AsmRename.c b/test/CodeGen/2003-10-29-AsmRename.c
new file mode 100644
index 0000000..565985d
--- /dev/null
+++ b/test/CodeGen/2003-10-29-AsmRename.c
@@ -0,0 +1,22 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+struct foo { int X; };
+struct bar { int Y; };
+
+extern int Func(struct foo*) __asm__("Func64");
+extern int Func64(struct bar*);
+
+int Func(struct foo *F) {
+  return 1;
+}
+
+int Func64(struct bar* B) {
+  return 0;
+}
+
+
+int test() {
+  Func(0);    /* should be renamed to call Func64 */
+  Func64(0);
+}
diff --git a/test/CodeGen/2003-11-01-C99-CompoundLiteral.c b/test/CodeGen/2003-11-01-C99-CompoundLiteral.c
new file mode 100644
index 0000000..f4d3824
--- /dev/null
+++ b/test/CodeGen/2003-11-01-C99-CompoundLiteral.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+typedef struct { int foo; } spinlock_t;
+typedef struct wait_queue_head_t { spinlock_t lock; } wait_queue_head_t;
+void call_usermodehelper(void) { 
+  struct wait_queue_head_t work = { lock: (spinlock_t) { 0 }, }; 
+}
+
diff --git a/test/CodeGen/2003-11-01-EmptyStructCrash.c b/test/CodeGen/2003-11-01-EmptyStructCrash.c
new file mode 100644
index 0000000..e0f231a
--- /dev/null
+++ b/test/CodeGen/2003-11-01-EmptyStructCrash.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+typedef struct { } the_coolest_struct_in_the_world;
+extern the_coolest_struct_in_the_world xyzzy;
+void *foo() { return &xyzzy; }
+
diff --git a/test/CodeGen/2003-11-01-GlobalUnionInit.c b/test/CodeGen/2003-11-01-GlobalUnionInit.c
new file mode 100644
index 0000000..8290379
--- /dev/null
+++ b/test/CodeGen/2003-11-01-GlobalUnionInit.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+union bdflush_param {
+    struct { int x; } b_un;
+    int y[1];
+} bdf_prm = {{30}};
+
diff --git a/test/CodeGen/2003-11-03-AddrArrayElement.c b/test/CodeGen/2003-11-03-AddrArrayElement.c
new file mode 100644
index 0000000..50e81d6
--- /dev/null
+++ b/test/CodeGen/2003-11-03-AddrArrayElement.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+// This should be turned into a tasty getelementptr instruction, not a nasty
+// series of casts and address arithmetic.
+
+char Global[100];
+
+char *test1(unsigned i) {
+  // CHECK: getelementptr
+  return &Global[i];
+}
diff --git a/test/CodeGen/2003-11-04-EmptyStruct.c b/test/CodeGen/2003-11-04-EmptyStruct.c
new file mode 100644
index 0000000..e771b88
--- /dev/null
+++ b/test/CodeGen/2003-11-04-EmptyStruct.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+typedef struct { } rwlock_t;
+struct fs_struct { rwlock_t lock; int umask; };
+void __copy_fs_struct(struct fs_struct *fs) { fs->lock = (rwlock_t) { }; }
+
diff --git a/test/CodeGen/2003-11-04-OutOfMemory.c b/test/CodeGen/2003-11-04-OutOfMemory.c
new file mode 100644
index 0000000..579c93d
--- /dev/null
+++ b/test/CodeGen/2003-11-04-OutOfMemory.c
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+void schedule_timeout(signed long timeout)
+{
+ switch (timeout)
+ {
+ case ((long)(~0UL>>1)): break;
+ }
+}
diff --git a/test/CodeGen/2003-11-08-PointerSubNotGetelementptr.c b/test/CodeGen/2003-11-08-PointerSubNotGetelementptr.c
new file mode 100644
index 0000000..9a9c642
--- /dev/null
+++ b/test/CodeGen/2003-11-08-PointerSubNotGetelementptr.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+char *test(char* C) {
+  // CHECK: getelementptr
+  return C-1;   // Should turn into a GEP
+}
+
+int *test2(int* I) {
+  return I-1;
+}
diff --git a/test/CodeGen/2003-11-12-VoidString.c b/test/CodeGen/2003-11-12-VoidString.c
new file mode 100644
index 0000000..d22e9f4
--- /dev/null
+++ b/test/CodeGen/2003-11-12-VoidString.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+void query_newnamebuf(void) { ((void)"query_newnamebuf"); }
+
diff --git a/test/CodeGen/2003-11-18-CondExprLValue.c b/test/CodeGen/2003-11-18-CondExprLValue.c
new file mode 100644
index 0000000..62968e5
--- /dev/null
+++ b/test/CodeGen/2003-11-18-CondExprLValue.c
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+typedef struct { unsigned long pgprot; } pgprot_t;
+
+void split_large_page(unsigned long addr, pgprot_t prot)
+{
+  (addr ? prot : ((pgprot_t) { 0x001 } )).pgprot;
+}
+
diff --git a/test/CodeGen/2003-11-19-AddressOfRegister.c b/test/CodeGen/2003-11-19-AddressOfRegister.c
new file mode 100644
index 0000000..e80ff65
--- /dev/null
+++ b/test/CodeGen/2003-11-19-AddressOfRegister.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 %s -emit-llvm -o /dev/null
+
+struct item {
+  short delta[4];
+};
+
+int TEST(int nt) {
+ register struct item *aa;
+ aa[nt].delta;
+ return 1;
+}
diff --git a/test/CodeGen/2003-11-19-BitFieldArray.c b/test/CodeGen/2003-11-19-BitFieldArray.c
new file mode 100644
index 0000000..8411563
--- /dev/null
+++ b/test/CodeGen/2003-11-19-BitFieldArray.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+struct _GIOChannel {
+  int write_buf;
+  char partial_write_buf[6];
+  int d :1;
+};
+
+void g_io_channel_init (struct _GIOChannel *channel) {
+  channel->partial_write_buf[0];
+}
+
diff --git a/test/CodeGen/2003-11-20-Bitfields.c b/test/CodeGen/2003-11-20-Bitfields.c
new file mode 100644
index 0000000..5284cde
--- /dev/null
+++ b/test/CodeGen/2003-11-20-Bitfields.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+struct face_cachel {
+  unsigned int reverse :1;
+  unsigned char font_specified[1];
+};
+
+void
+ensure_face_cachel_contains_charset (struct face_cachel *cachel) {
+  cachel->font_specified[0] = 0;
+}
+
diff --git a/test/CodeGen/2003-11-20-ComplexDivision.c b/test/CodeGen/2003-11-20-ComplexDivision.c
new file mode 100644
index 0000000..ecd780b
--- /dev/null
+++ b/test/CodeGen/2003-11-20-ComplexDivision.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+int test() {
+  __complex__ double C;
+  double D;
+  C / D;
+}
diff --git a/test/CodeGen/2003-11-20-UnionBitfield.c b/test/CodeGen/2003-11-20-UnionBitfield.c
new file mode 100644
index 0000000..6ffe76a
--- /dev/null
+++ b/test/CodeGen/2003-11-20-UnionBitfield.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+struct printf_spec {
+  unsigned int minus_flag:1;
+  char converter;
+};
+
+void parse_doprnt_spec () {
+  struct printf_spec spec;
+  spec.minus_flag = 1;
+}
+
diff --git a/test/CodeGen/2003-11-26-PointerShift.c b/test/CodeGen/2003-11-26-PointerShift.c
new file mode 100644
index 0000000..530759e
--- /dev/null
+++ b/test/CodeGen/2003-11-26-PointerShift.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+unsigned long do_csum(const unsigned char *buff, int len, unsigned long result) {
+  if (2 & (unsigned long) buff) result += 1;
+  return result;
+}
diff --git a/test/CodeGen/2003-11-27-ConstructorCast.c b/test/CodeGen/2003-11-27-ConstructorCast.c
new file mode 100644
index 0000000..f04fa21
--- /dev/null
+++ b/test/CodeGen/2003-11-27-ConstructorCast.c
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+struct i387_soft_struct {
+  long cwd;
+};
+union i387_union {
+  struct i387_soft_struct soft;
+};
+struct thread_struct {
+  union i387_union i387;
+};
+void _init_task_union(void) {
+   struct thread_struct thread = (struct thread_struct) { {{0}} };
+}
diff --git a/test/CodeGen/2003-11-27-UnionCtorInitialization.c b/test/CodeGen/2003-11-27-UnionCtorInitialization.c
new file mode 100644
index 0000000..ca80173
--- /dev/null
+++ b/test/CodeGen/2003-11-27-UnionCtorInitialization.c
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+struct i387_soft_struct {
+ long cwd;
+ long twd;
+ long fip;
+};
+union i387_union {
+ struct i387_soft_struct soft;
+};
+struct thread_struct {
+ union i387_union i387;
+};
+void _init_task_union(void) {
+  struct thread_struct thread = (struct thread_struct) { {{0}} };
+}
diff --git a/test/CodeGen/2003-12-14-ExternInlineSupport.c b/test/CodeGen/2003-12-14-ExternInlineSupport.c
new file mode 100644
index 0000000..eb3859c
--- /dev/null
+++ b/test/CodeGen/2003-12-14-ExternInlineSupport.c
@@ -0,0 +1,3 @@
+// RUN: %clang_cc1 -std=gnu89 %s -emit-llvm -o - | not grep dead_function
+
+extern __inline__ void dead_function() {}
diff --git a/test/CodeGen/2004-01-01-UnknownInitSize.c b/test/CodeGen/2004-01-01-UnknownInitSize.c
new file mode 100644
index 0000000..25ddebd
--- /dev/null
+++ b/test/CodeGen/2004-01-01-UnknownInitSize.c
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -emit-llvm %s -o /dev/null
+
+/*
+ * This regression test ensures that the C front end can compile initializers
+ * even when it cannot determine the size (as below).
+*/
+struct one
+{
+  int a;
+  int values [];
+};
+
+struct one hobbit = {5, {1, 2, 3}};
+
diff --git a/test/CodeGen/2004-02-12-LargeAggregateCopy.c b/test/CodeGen/2004-02-12-LargeAggregateCopy.c
new file mode 100644
index 0000000..811ee8e
--- /dev/null
+++ b/test/CodeGen/2004-02-12-LargeAggregateCopy.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1  %s -emit-llvm -o - | FileCheck %s
+
+struct X { int V[10000]; };
+struct X Global1, Global2;
+void test() {
+  // CHECK: llvm.memcpy
+  Global2 = Global1;
+}
diff --git a/test/CodeGen/2004-02-13-BuiltinFrameReturnAddress.c b/test/CodeGen/2004-02-13-BuiltinFrameReturnAddress.c
new file mode 100644
index 0000000..8c0b7ba
--- /dev/null
+++ b/test/CodeGen/2004-02-13-BuiltinFrameReturnAddress.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1  %s -emit-llvm -o - | FileCheck %s
+
+void *test1() {
+  // CHECK: call i8* @llvm.returnaddress
+  return __builtin_return_address(1);
+}
+void *test2() {
+  // CHECK: call i8* @llvm.frameaddress
+  return __builtin_frame_address(0);
+}
diff --git a/test/CodeGen/2004-02-13-Memset.c b/test/CodeGen/2004-02-13-Memset.c
new file mode 100644
index 0000000..fe01fde
--- /dev/null
+++ b/test/CodeGen/2004-02-13-Memset.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1  %s -emit-llvm -o - | grep llvm.memset | count 3
+
+void *memset(void*, int, unsigned long);
+void bzero(void*, unsigned long);
+
+void test(int* X, char *Y) {
+  // CHECK: call i8* llvm.memset
+  memset(X, 4, 1000);
+  // CHECK: call void bzero
+  bzero(Y, 100);
+}
diff --git a/test/CodeGen/2004-02-14-ZeroInitializer.c b/test/CodeGen/2004-02-14-ZeroInitializer.c
new file mode 100644
index 0000000..3379a06
--- /dev/null
+++ b/test/CodeGen/2004-02-14-ZeroInitializer.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1  %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: zeroinitializer
+int X[1000];
diff --git a/test/CodeGen/2004-03-07-ComplexDivEquals.c b/test/CodeGen/2004-03-07-ComplexDivEquals.c
new file mode 100644
index 0000000..e2cd539
--- /dev/null
+++ b/test/CodeGen/2004-03-07-ComplexDivEquals.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+void test(__complex__ double D, double X) {
+  D /= X;
+}
diff --git a/test/CodeGen/2004-03-07-ExternalConstant.c b/test/CodeGen/2004-03-07-ExternalConstant.c
new file mode 100644
index 0000000..2de3a69
--- /dev/null
+++ b/test/CodeGen/2004-03-07-ExternalConstant.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1  %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: @a = external constan
+extern const int a[];   // 'a' should be marked constant even though it's external!
+int foo () {
+  return a[0];
+}
diff --git a/test/CodeGen/2004-03-09-LargeArrayInitializers.c b/test/CodeGen/2004-03-09-LargeArrayInitializers.c
new file mode 100644
index 0000000..b34af0d
--- /dev/null
+++ b/test/CodeGen/2004-03-09-LargeArrayInitializers.c
@@ -0,0 +1,32 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+// Test that these initializers are handled efficiently
+
+int test(int x) {
+  const int XX[1000] = { 0, 0 };
+  const char S [1000] = "foo";
+
+  const int array[] = {
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+     17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 17, 23, 123, 123, 49, 
+   };
+   return array[x];
+} 
diff --git a/test/CodeGen/2004-03-16-AsmRegisterCrash.c b/test/CodeGen/2004-03-16-AsmRegisterCrash.c
new file mode 100644
index 0000000..c727808
--- /dev/null
+++ b/test/CodeGen/2004-03-16-AsmRegisterCrash.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+int foo() {
+#ifdef __ppc__
+  register int X __asm__("r1");
+#else
+  register int X __asm__("ebx");
+#endif
+  return X;
+}
diff --git a/test/CodeGen/2004-05-07-VarArrays.c b/test/CodeGen/2004-05-07-VarArrays.c
new file mode 100644
index 0000000..1ef5cf3
--- /dev/null
+++ b/test/CodeGen/2004-05-07-VarArrays.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+int foo(int len, char arr[][len], int X) {
+  return arr[X][0];
+}
diff --git a/test/CodeGen/2004-05-21-IncompleteEnum.c b/test/CodeGen/2004-05-21-IncompleteEnum.c
new file mode 100644
index 0000000..41652d1
--- /dev/null
+++ b/test/CodeGen/2004-05-21-IncompleteEnum.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 -w -emit-llvm %s  -o /dev/null
+
+void test(enum foo *X) {
+}
+
diff --git a/test/CodeGen/2004-06-08-OpaqueStructArg.c b/test/CodeGen/2004-06-08-OpaqueStructArg.c
new file mode 100644
index 0000000..cec4459
--- /dev/null
+++ b/test/CodeGen/2004-06-08-OpaqueStructArg.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+   struct fu;
+   void foo(struct fu);
+   void bar() {
+      foo;
+   }
diff --git a/test/CodeGen/2004-06-17-UnorderedBuiltins.c b/test/CodeGen/2004-06-17-UnorderedBuiltins.c
new file mode 100644
index 0000000..90360c4
--- /dev/null
+++ b/test/CodeGen/2004-06-17-UnorderedBuiltins.c
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+_Bool A, B, C, D, E, F, G, H;
+void TestF(float X, float Y) {
+  A = __builtin_isgreater(X, Y);
+  B = __builtin_isgreaterequal(X, Y);
+  C = __builtin_isless(X, Y);
+  D = __builtin_islessequal(X, Y);
+  E = __builtin_islessgreater(X, Y);
+  F = __builtin_isunordered(X, Y);
+  //G = __builtin_isordered(X, Y);    // Our current snapshot of GCC doesn't include this builtin
+  H = __builtin_isunordered(X, Y);
+}
+void TestD(double X, double Y) {
+  A = __builtin_isgreater(X, Y);
+  B = __builtin_isgreaterequal(X, Y);
+  C = __builtin_isless(X, Y);
+  D = __builtin_islessequal(X, Y);
+  E = __builtin_islessgreater(X, Y);
+  F = __builtin_isunordered(X, Y);
+  //G = __builtin_isordered(X, Y);    // Our current snapshot doesn't include this builtin.  FIXME
+  H = __builtin_isunordered(X, Y);
+}
diff --git a/test/CodeGen/2004-06-18-VariableLengthArrayOfStructures.c b/test/CodeGen/2004-06-18-VariableLengthArrayOfStructures.c
new file mode 100644
index 0000000..abf78fb
--- /dev/null
+++ b/test/CodeGen/2004-06-18-VariableLengthArrayOfStructures.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+struct S { };
+
+int xxxx(int a) {
+  struct S comps[a];
+  comps[0];
+}
+
diff --git a/test/CodeGen/2004-07-06-FunctionCast.c b/test/CodeGen/2004-07-06-FunctionCast.c
new file mode 100644
index 0000000..32931e2
--- /dev/null
+++ b/test/CodeGen/2004-07-06-FunctionCast.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+static int unused_func(void) {
+  return 1;
+}
+
+int foo(void) {
+  (void)unused_func; /* avoid compiler warning */
+  return 2;
+}
diff --git a/test/CodeGen/2004-08-06-LargeStructTest.c b/test/CodeGen/2004-08-06-LargeStructTest.c
new file mode 100644
index 0000000..ee57f0b
--- /dev/null
+++ b/test/CodeGen/2004-08-06-LargeStructTest.c
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+
+
+#define A(X) int X;
+#define B(X) A(X##0) A(X##1) A(X##2) A(X##3) A(X##4) A(X##5) A(X##6) A(X##7) \
+             A(X##8) A(X##9) A(X##A) A(X##B) A(X##C) A(X##D) A(X##E) A(X##F)
+#define C(X) B(X##0) B(X##1) B(X##2) B(X##3) B(X##4) B(X##5) B(X##6) B(X##7) \
+             B(X##8) B(X##9) B(X##A) B(X##B) B(X##C) B(X##D) B(X##E) B(X##F)
+
+struct foo {
+  C(x);   // 256
+  C(y);   // 256
+  C(z);
+};
+
+
+int test(struct foo *F) {
+   return F->xA1 + F->yFF + F->zC4;
+}
diff --git a/test/CodeGen/2004-11-25-UnnamedBitfieldPadding.c b/test/CodeGen/2004-11-25-UnnamedBitfieldPadding.c
new file mode 100644
index 0000000..a6af2a5
--- /dev/null
+++ b/test/CodeGen/2004-11-25-UnnamedBitfieldPadding.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm %s -o /dev/null
+// This is a testcase for PR461
+typedef struct {
+  unsigned min_align: 1;
+  unsigned : 1;
+} addr_diff_vec_flags;
+
+addr_diff_vec_flags X;
diff --git a/test/CodeGen/2004-11-27-StaticFunctionRedeclare.c b/test/CodeGen/2004-11-27-StaticFunctionRedeclare.c
new file mode 100644
index 0000000..55efa86
--- /dev/null
+++ b/test/CodeGen/2004-11-27-StaticFunctionRedeclare.c
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | \
+// RUN:   opt -std-compile-opts -emit-llvm | not grep {declare i32.*func}
+
+// There should not be an unresolved reference to func here.  Believe it or not,
+// the "expected result" is a function named 'func' which is internal and 
+// referenced by bar().
+
+// This is PR244
+
+static int func();
+void bar() {
+  int func();
+  foo(func);
+}
+static int func(char** A, char ** B) {}
diff --git a/test/CodeGen/2005-01-02-ConstantInits.c b/test/CodeGen/2005-01-02-ConstantInits.c
new file mode 100644
index 0000000..d85f519
--- /dev/null
+++ b/test/CodeGen/2005-01-02-ConstantInits.c
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+// This tests all kinds of hard cases with initializers and
+// array subscripts.  This corresponds to PR487.
+
+struct X { int a[2]; };
+
+int test() {
+  static int i23 = (int) &(((struct X *)0)->a[1]);
+  return i23;
+}
+
+int i = (int) &( ((struct X *)0) -> a[1]);
+
+int Arr[100];
+
+int foo(int i) { return bar(&Arr[49])+bar(&Arr[i]); }
+int foo2(int i) { 
+  static const int *X = &Arr[49];
+   static int i23 = (int) &( ((struct X *)0) -> a[0]);
+  int *P = Arr;
+  ++P;
+  return bar(Arr+i);
+}
diff --git a/test/CodeGen/2005-01-02-PointerDifference.c b/test/CodeGen/2005-01-02-PointerDifference.c
new file mode 100644
index 0000000..1114ef5
--- /dev/null
+++ b/test/CodeGen/2005-01-02-PointerDifference.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1  %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: sdiv exact
+int Diff(int *P, int *Q) { return P-Q; }
diff --git a/test/CodeGen/2005-02-27-MarkGlobalConstant.c b/test/CodeGen/2005-02-27-MarkGlobalConstant.c
new file mode 100644
index 0000000..adcb6eb
--- /dev/null
+++ b/test/CodeGen/2005-02-27-MarkGlobalConstant.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1  %s -emit-llvm -o - | FileCheck %s
+// XFAIL: *
+// PR10414
+
+// The synthetic global made by the CFE for big initializer should be marked
+// constant.
+
+void bar();
+void foo() {
+  // CHECK: private unnamed_addr constant
+  char Blah[] = "asdlfkajsdlfkajsd;lfkajds;lfkjasd;flkajsd;lkfja;sdlkfjasd";
+  bar(Blah);
+}
diff --git a/test/CodeGen/2005-03-05-OffsetOfHack.c b/test/CodeGen/2005-03-05-OffsetOfHack.c
new file mode 100644
index 0000000..4420981
--- /dev/null
+++ b/test/CodeGen/2005-03-05-OffsetOfHack.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - 
+
+struct s {
+  unsigned long int field[0];
+};
+
+#define OFFS \
+        (((char *) &((struct s *) 0)->field[0]) - (char *) 0)
+
+int foo[OFFS];
+
+
diff --git a/test/CodeGen/2005-03-06-OffsetOfStructCrash.c b/test/CodeGen/2005-03-06-OffsetOfStructCrash.c
new file mode 100644
index 0000000..46968bb
--- /dev/null
+++ b/test/CodeGen/2005-03-06-OffsetOfStructCrash.c
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+struct Y {};
+struct XXX {
+  struct  Y F;
+};
+
+void test1() {
+   (int)&((struct XXX*)(((void *)0)))->F;
+}
+
+void test2() {
+   &((struct XXX*)(((void *)0)))->F;
+}
diff --git a/test/CodeGen/2005-03-11-Prefetch.c b/test/CodeGen/2005-03-11-Prefetch.c
new file mode 100644
index 0000000..8d7d12e
--- /dev/null
+++ b/test/CodeGen/2005-03-11-Prefetch.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+void foo(int *P) {
+  // CHECK: llvm.prefetch
+  __builtin_prefetch(P);
+  __builtin_prefetch(P, 1);
+}
diff --git a/test/CodeGen/2005-05-06-CountBuiltins.c b/test/CodeGen/2005-05-06-CountBuiltins.c
new file mode 100644
index 0000000..4c12100
--- /dev/null
+++ b/test/CodeGen/2005-05-06-CountBuiltins.c
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 %s -emit-llvm -o %t
+// RUN: not grep call*__builtin %t
+
+int G, H, I;
+void foo(int P) {
+  G = __builtin_clz(P);
+  H = __builtin_ctz(P);
+  I = __builtin_popcount(P);
+}
+
+long long g, h, i;
+void fooll(float P) {
+  g = __builtin_clzll(P);
+  g = __builtin_clzll(P);
+  h = __builtin_ctzll(P);
+  i = __builtin_popcountll(P);
+}
diff --git a/test/CodeGen/2005-05-10-GlobalUnionInit.c b/test/CodeGen/2005-05-10-GlobalUnionInit.c
new file mode 100644
index 0000000..ddd7f5e
--- /dev/null
+++ b/test/CodeGen/2005-05-10-GlobalUnionInit.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+union A {                    // { uint }
+  union B { double *C; } D;
+} E = { { (double*)12312 } };
+
diff --git a/test/CodeGen/2005-07-26-UnionInitCrash.c b/test/CodeGen/2005-07-26-UnionInitCrash.c
new file mode 100644
index 0000000..5572240
--- /dev/null
+++ b/test/CodeGen/2005-07-26-UnionInitCrash.c
@@ -0,0 +1,3 @@
+// PR607
+// RUN: %clang_cc1 %s -emit-llvm -o -
+union { char bytes[8]; double alignment; }EQ1 = {0,0,0,0,0,0,0,0};
diff --git a/test/CodeGen/2005-07-28-IncorrectWeakGlobal.c b/test/CodeGen/2005-07-28-IncorrectWeakGlobal.c
new file mode 100644
index 0000000..cbacf22
--- /dev/null
+++ b/test/CodeGen/2005-07-28-IncorrectWeakGlobal.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | grep TheGlobal | not grep weak
+
+extern int TheGlobal;
+int foo() { return TheGlobal; }
+int TheGlobal = 1;
diff --git a/test/CodeGen/2005-09-20-ComplexConstants.c b/test/CodeGen/2005-09-20-ComplexConstants.c
new file mode 100644
index 0000000..a23ccee
--- /dev/null
+++ b/test/CodeGen/2005-09-20-ComplexConstants.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1 %s -emit-llvm  -o /dev/null
+
+const double _Complex x[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 
+
diff --git a/test/CodeGen/2005-09-24-AsmUserPrefix.c b/test/CodeGen/2005-09-24-AsmUserPrefix.c
new file mode 100644
index 0000000..1628313
--- /dev/null
+++ b/test/CodeGen/2005-09-24-AsmUserPrefix.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | opt -std-compile-opts | llc | \
+// RUN:    not grep _foo2
+
+void foo() __asm__("foo2");
+
+void bar() {
+  foo();
+}
diff --git a/test/CodeGen/2005-09-24-BitFieldCrash.c b/test/CodeGen/2005-09-24-BitFieldCrash.c
new file mode 100644
index 0000000..d687d2f
--- /dev/null
+++ b/test/CodeGen/2005-09-24-BitFieldCrash.c
@@ -0,0 +1,33 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - 
+
+struct tree_common {};
+
+struct tree_int_cst {
+ struct tree_common common;
+  struct tree_int_cst_lowhi {
+    unsigned long long low;
+    long long high;
+  } int_cst;
+};
+
+enum XXX { yyy };
+
+struct tree_function_decl {
+  struct tree_common common;
+  long long locus, y;
+  __extension__ enum  XXX built_in_class : 2;
+
+};
+
+
+union tree_node {
+  struct tree_int_cst int_cst;
+  struct tree_function_decl function_decl;
+};
+
+
+void foo (union tree_node * decl) {
+  decl->function_decl.built_in_class != 0;
+}
+
+
diff --git a/test/CodeGen/2005-12-04-AttributeUsed.c b/test/CodeGen/2005-12-04-AttributeUsed.c
new file mode 100644
index 0000000..4be6b79
--- /dev/null
+++ b/test/CodeGen/2005-12-04-AttributeUsed.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: @llvm.used = appending global [2 x i8*] [i8* bitcast (void ()* @foo to i8*), i8* bitcast (i32* @X to i8*)], section "llvm.metadata"
+int X __attribute__((used));
+int Y;
+
+__attribute__((used)) void foo() {}
diff --git a/test/CodeGen/2005-12-04-DeclarationLineNumbers.c b/test/CodeGen/2005-12-04-DeclarationLineNumbers.c
new file mode 100644
index 0000000..596d3ee
--- /dev/null
+++ b/test/CodeGen/2005-12-04-DeclarationLineNumbers.c
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 %s -emit-llvm -g -o - | grep DW_TAG_compile_unit | count 1
+// PR664: ensure that line #'s are emitted for declarations
+
+
+short test(short br_data_0,
+short br_data_1,
+short br_data_2,
+short br_data_3,
+short br_data_4,
+short br_data_5,
+short br_data_6,
+short br_data_7) {
+
+short sm07 = br_data_0 + br_data_7;
+short sm16 = br_data_1 + br_data_6;
+short sm25 = br_data_2 + br_data_5;
+short sm34 = br_data_3 + br_data_4;
+short s0734 = sm07 + sm34;
+short s1625 = sm16 + sm25;
+
+return s0734 + s1625;
+}
+
diff --git a/test/CodeGen/2006-01-13-StackSave.c b/test/CodeGen/2006-01-13-StackSave.c
new file mode 100644
index 0000000..7c506b3
--- /dev/null
+++ b/test/CodeGen/2006-01-13-StackSave.c
@@ -0,0 +1,11 @@
+// PR691
+// RUN: %clang_cc1 %s -emit-llvm -o - | opt -std-compile-opts | \
+// RUN:    llvm-dis | grep llvm.stacksave
+
+void test(int N) {
+  int i;
+  for (i = 0; i < N; ++i) {
+    int VLA[i];
+    external(VLA);
+  }
+}
diff --git a/test/CodeGen/2006-01-16-BitCountIntrinsicsUnsigned.c b/test/CodeGen/2006-01-16-BitCountIntrinsicsUnsigned.c
new file mode 100644
index 0000000..ba7820a
--- /dev/null
+++ b/test/CodeGen/2006-01-16-BitCountIntrinsicsUnsigned.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s
+
+unsigned t2(unsigned X) {
+  // CHECK: t2
+  // CHECK: llvm.ctlz.i32
+  return __builtin_clz(X);
+}
+int t1(int X) {
+  // CHECK: t1
+  // CHECK: llvm.ctlz.i32
+  return __builtin_clz(X);
+}
diff --git a/test/CodeGen/2006-01-23-FileScopeAsm.c b/test/CodeGen/2006-01-23-FileScopeAsm.c
new file mode 100644
index 0000000..472b464
--- /dev/null
+++ b/test/CodeGen/2006-01-23-FileScopeAsm.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: module asm "foo1"
+__asm__ ("foo1");
+// CHECK: module asm "foo2"
+__asm__ ("foo2");
+// CHECK: module asm "foo3"
+__asm__ ("foo3");
+// CHECK: module asm "foo4"
+__asm__ ("foo4");
+// CHECK: module asm "foo5"
+__asm__ ("foo5");
diff --git a/test/CodeGen/2006-03-03-MissingInitializer.c b/test/CodeGen/2006-03-03-MissingInitializer.c
new file mode 100644
index 0000000..d2317d3
--- /dev/null
+++ b/test/CodeGen/2006-03-03-MissingInitializer.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+struct X { int *XX; int Y;};
+
+void foo() {
+  // CHECK: @foo.nate = internal global i32 0
+  static int nate = 0;
+  struct X bob = { &nate, 14 };
+  bar(&bob);
+}
diff --git a/test/CodeGen/2006-03-16-VectorCtor.c b/test/CodeGen/2006-03-16-VectorCtor.c
new file mode 100644
index 0000000..c04d4b9
--- /dev/null
+++ b/test/CodeGen/2006-03-16-VectorCtor.c
@@ -0,0 +1,10 @@
+// Test that basic generic vector support works
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+typedef int v4si __attribute__ ((__vector_size__ (16)));
+void test(v4si *P, v4si *Q, float X) {
+  *P = (v4si){ X, X, X, X } * *Q;
+}
+
+v4si G = (v4si){ 0.1, 1.2, 4.2, 17.2 };
+
diff --git a/test/CodeGen/2006-03-17-KnRMismatch.c b/test/CodeGen/2006-03-17-KnRMismatch.c
new file mode 100644
index 0000000..f678e9f
--- /dev/null
+++ b/test/CodeGen/2006-03-17-KnRMismatch.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+void regnode(int op);
+
+void regnode(op)
+char op;
+{
+}
diff --git a/test/CodeGen/2006-05-19-SingleEltReturn.c b/test/CodeGen/2006-05-19-SingleEltReturn.c
new file mode 100644
index 0000000..819237c
--- /dev/null
+++ b/test/CodeGen/2006-05-19-SingleEltReturn.c
@@ -0,0 +1,23 @@
+// Test returning a single element aggregate value containing a double.
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+struct X {
+  double D;
+};
+
+struct Y { 
+  struct X x; 
+};
+
+struct Y bar();
+
+void foo(struct Y *P) {
+  *P = bar();
+}
+
+struct Y bar() {
+  struct Y a;
+  a.x.D = 0;
+  return a;
+}
+
diff --git a/test/CodeGen/2006-07-31-PR854.c b/test/CodeGen/2006-07-31-PR854.c
new file mode 100644
index 0000000..b3b4d8e
--- /dev/null
+++ b/test/CodeGen/2006-07-31-PR854.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -triple i686-linux-gnu -w %s -emit-llvm -o -
+
+// PR854
+  struct kernel_symbol {
+    unsigned long value;
+  };
+  unsigned long loops_per_jiffy = (1<<12);
+  static const char __kstrtab_loops_per_jiffy[]
+__attribute__((section("__ksymtab_strings"))) = "loops_per_jiffy";
+  static const struct kernel_symbol __ksymtab_loops_per_jiffy
+__attribute__((__used__)) __attribute__((section("__ksymtab"))) = { (unsigned
+long)&loops_per_jiffy, __kstrtab_loops_per_jiffy };
diff --git a/test/CodeGen/2006-09-11-BitfieldRefCrash.c b/test/CodeGen/2006-09-11-BitfieldRefCrash.c
new file mode 100644
index 0000000..3d45d8b
--- /dev/null
+++ b/test/CodeGen/2006-09-11-BitfieldRefCrash.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+// PR906
+
+struct state_struct {
+  unsigned long long phys_frame: 50;
+  unsigned valid : 2;
+} s;
+
+int mem_access(struct state_struct *p) {
+  return p->valid;
+}
+
diff --git a/test/CodeGen/2006-09-18-fwrite-cast-crash.c b/test/CodeGen/2006-09-18-fwrite-cast-crash.c
new file mode 100644
index 0000000..a12fd0b
--- /dev/null
+++ b/test/CodeGen/2006-09-18-fwrite-cast-crash.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 %s -emit-llvm -o /dev/null
+// PR910
+
+struct l_struct_2E_FILE { char x; };
+unsigned fwrite(signed char *, unsigned , unsigned , signed char *);
+static signed char str301[39];
+static void Usage(signed char *ltmp_611_6) {
+  struct l_struct_2E_FILE *ltmp_6202_16;
+  unsigned ltmp_6203_92;
+  ltmp_6203_92 =  /*tail*/ ((unsigned  (*) (signed char *, unsigned , unsigned ,
+struct l_struct_2E_FILE *))(void*)fwrite)((&(str301[0u])), 38u, 1u, ltmp_6202_16);
+}
diff --git a/test/CodeGen/2006-09-21-IncompleteElementType.c b/test/CodeGen/2006-09-21-IncompleteElementType.c
new file mode 100644
index 0000000..1c71ea1
--- /dev/null
+++ b/test/CodeGen/2006-09-21-IncompleteElementType.c
@@ -0,0 +1,3 @@
+// RUN: not %clang_cc1 %s -emit-llvm -o /dev/null
+
+struct A X[(927 - 37) / sizeof(struct A)];
diff --git a/test/CodeGen/2006-09-25-DebugFilename.c b/test/CodeGen/2006-09-25-DebugFilename.c
new file mode 100644
index 0000000..2edb63f
--- /dev/null
+++ b/test/CodeGen/2006-09-25-DebugFilename.c
@@ -0,0 +1,4 @@
+// RUN: not %clang_cc1  %s -emit-llvm -o /dev/null
+#include "2006-09-25-DebugFilename.h"
+int func1() { return hfunc1(); }
+int func2() { fluffy; return hfunc1(); } // expected-error {{use of undeclared identifier 'fluffy'}}
diff --git a/test/CodeGen/2006-09-25-DebugFilename.h b/test/CodeGen/2006-09-25-DebugFilename.h
new file mode 100644
index 0000000..9b03666
--- /dev/null
+++ b/test/CodeGen/2006-09-25-DebugFilename.h
@@ -0,0 +1,6 @@
+extern int exfunc(int a);
+
+static inline int hfunc1()
+{
+  return exfunc(1);
+}
diff --git a/test/CodeGen/2006-09-28-SimpleAsm.c b/test/CodeGen/2006-09-28-SimpleAsm.c
new file mode 100644
index 0000000..c3983af
--- /dev/null
+++ b/test/CodeGen/2006-09-28-SimpleAsm.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+// PR924
+
+void bar() {
+  // Extended asm
+  // CHECK: call void asm sideeffect "ext: xorl %eax, eax; movl eax, fs; movl eax, gs  %blah
+  asm volatile ("ext: xorl %%eax, eax; movl eax, fs; movl eax, gs  %%blah %= %\
+% " : : "r"(1));
+  // CHECK: call void asm sideeffect "nonext: xorl %eax, %eax; movl %eax, %fs; movl %eax, %gs  %%blah %= %%
+  // Non-extended asm.
+  asm volatile ("nonext: xorl %eax, %eax; movl %eax, %fs; movl %eax, %gs  %%blah %= %% ");
+}
diff --git a/test/CodeGen/2006-10-30-ArrayCrash.c b/test/CodeGen/2006-10-30-ArrayCrash.c
new file mode 100644
index 0000000..67446fd
--- /dev/null
+++ b/test/CodeGen/2006-10-30-ArrayCrash.c
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -O3 -emit-llvm -o - %s
+// PR954, PR911
+
+extern void foo();
+
+struct S {
+  short        f1[3];
+  unsigned int f2 : 1;
+};
+
+void bar()
+{
+  struct S *A;
+
+  if (A->f2)
+    foo();
+}
diff --git a/test/CodeGen/2006-12-14-ordered_expr.c b/test/CodeGen/2006-12-14-ordered_expr.c
new file mode 100644
index 0000000..c46ba85
--- /dev/null
+++ b/test/CodeGen/2006-12-14-ordered_expr.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -O3 -emit-llvm %s -o - | FileCheck %s
+
+int test2(float X, float Y) {
+  // CHECK: fcmp ord float %X, %Y
+  return !__builtin_isunordered(X, Y);
+}
diff --git a/test/CodeGen/2007-01-06-KNR-Proto.c b/test/CodeGen/2007-01-06-KNR-Proto.c
new file mode 100644
index 0000000..d56a786
--- /dev/null
+++ b/test/CodeGen/2007-01-06-KNR-Proto.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -emit-llvm -o - %s
+// PR1083
+
+int svc_register (void (*dispatch) (int));
+
+int svc_register (dispatch)
+     void (*dispatch) ();
+{
+}
+
diff --git a/test/CodeGen/2007-01-20-VectorICE.c b/test/CodeGen/2007-01-20-VectorICE.c
new file mode 100644
index 0000000..286b8a1
--- /dev/null
+++ b/test/CodeGen/2007-01-20-VectorICE.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - 
+
+typedef float __m128 __attribute__((__vector_size__(16)));
+typedef long long __v2di __attribute__((__vector_size__(16)));
+typedef int __v4si __attribute__((__vector_size__(16)));
+
+__v2di  bar(void);
+void foo(int X, __v4si *P) {
+	*P = X == 2 ? bar() : bar();
+}
+
diff --git a/test/CodeGen/2007-01-24-InlineAsmCModifier.c b/test/CodeGen/2007-01-24-InlineAsmCModifier.c
new file mode 100644
index 0000000..5158898
--- /dev/null
+++ b/test/CodeGen/2007-01-24-InlineAsmCModifier.c
@@ -0,0 +1,12 @@
+// Verify that the %c modifier works and strips off any prefixes from
+// immediates.
+// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s
+
+void foo() {
+  // CHECK: i32 789514
+  __asm__         volatile("/* " "pickANumber" ": %c0 */"::"i"(0xC0C0A));
+
+  // Check that non-c modifiers work also
+  // CHECK: i32 123
+   __asm__         volatile("/* " "pickANumber2 " ": %0 */"::"i"(123));
+}
diff --git a/test/CodeGen/2007-02-04-AddrLValue-2.c b/test/CodeGen/2007-02-04-AddrLValue-2.c
new file mode 100644
index 0000000..bc44d14
--- /dev/null
+++ b/test/CodeGen/2007-02-04-AddrLValue-2.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 %s -O3 -emit-llvm -o -
+// PR1173
+
+struct S { char s; };
+struct T { struct S t; };
+
+struct S *const p = &((struct T * const) (0x4000))->t;
+
+void
+foo (void)
+{
+  p->s = 0;
+}
diff --git a/test/CodeGen/2007-02-04-AddrLValue.c b/test/CodeGen/2007-02-04-AddrLValue.c
new file mode 100644
index 0000000..400dcb6
--- /dev/null
+++ b/test/CodeGen/2007-02-04-AddrLValue.c
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 %s -O3 -emit-llvm -o -
+// PR1176
+
+typedef struct
+{
+  char *key;
+  char *value;
+} T1;
+
+typedef struct
+{
+  long type;
+  char *value;
+} T3;
+
+T1 a[] =
+{
+  {
+    "",
+    ((char *)&((T3) {1, (char *) 1}))
+  }
+};
+
diff --git a/test/CodeGen/2007-02-04-EmptyStruct.c b/test/CodeGen/2007-02-04-EmptyStruct.c
new file mode 100644
index 0000000..2b2896f
--- /dev/null
+++ b/test/CodeGen/2007-02-04-EmptyStruct.c
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 %s -O3 -emit-llvm -o -
+// PR1175
+
+struct empty { };
+
+void foo(struct empty *p) {
+   p++;
+}
+
diff --git a/test/CodeGen/2007-02-16-VoidPtrDiff.c b/test/CodeGen/2007-02-16-VoidPtrDiff.c
new file mode 100644
index 0000000..c9f6714
--- /dev/null
+++ b/test/CodeGen/2007-02-16-VoidPtrDiff.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+void foo(void *ptr, int test) {
+  (ptr - ((void *) test + 0x2000));
+}
diff --git a/test/CodeGen/2007-02-25-C-DotDotDot.c b/test/CodeGen/2007-02-25-C-DotDotDot.c
new file mode 100644
index 0000000..7b2e418
--- /dev/null
+++ b/test/CodeGen/2007-02-25-C-DotDotDot.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -O0 %s -emit-llvm -o - | FileCheck %s
+
+// Make sure the call to foo is compiled as:
+//  call float @foo()
+// not
+//  call float (...)* bitcast (float ()* @foo to float (...)*)( )
+
+static float foo() { return 0.0; }
+// CHECK: call float @foo
+float bar() { return foo()*10.0;}
diff --git a/test/CodeGen/2007-03-01-VarSizeArrayIdx.c b/test/CodeGen/2007-03-01-VarSizeArrayIdx.c
new file mode 100644
index 0000000..7a9f89a
--- /dev/null
+++ b/test/CodeGen/2007-03-01-VarSizeArrayIdx.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 %s -O3 -emit-llvm -o - | grep mul
+// PR1233
+
+float foo(int w, float A[][w], int g, int h) {
+  return A[g][0];
+}
+
diff --git a/test/CodeGen/2007-03-26-BitfieldAfterZeroWidth.c b/test/CodeGen/2007-03-26-BitfieldAfterZeroWidth.c
new file mode 100644
index 0000000..b4a42d9
--- /dev/null
+++ b/test/CodeGen/2007-03-26-BitfieldAfterZeroWidth.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+struct W {};
+struct Y {
+  struct W w;
+  int i:1;
+} __attribute__ ((packed)) y;
diff --git a/test/CodeGen/2007-03-26-ZeroWidthBitfield.c b/test/CodeGen/2007-03-26-ZeroWidthBitfield.c
new file mode 100644
index 0000000..0bf42ad
--- /dev/null
+++ b/test/CodeGen/2007-03-26-ZeroWidthBitfield.c
@@ -0,0 +1,2 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+struct Z { int :0; } z;
diff --git a/test/CodeGen/2007-03-27-VarLengthArray.c b/test/CodeGen/2007-03-27-VarLengthArray.c
new file mode 100644
index 0000000..dde5245
--- /dev/null
+++ b/test/CodeGen/2007-03-27-VarLengthArray.c
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s
+
+// CHECK: getelementptr inbounds i32* %vla
+extern void f(int *);
+int e(int m, int n) {
+  int x[n];
+  f(x);
+  return x[m];
+}
diff --git a/test/CodeGen/2007-04-05-PackedBitFields-2.c b/test/CodeGen/2007-04-05-PackedBitFields-2.c
new file mode 100644
index 0000000..41e6b7d
--- /dev/null
+++ b/test/CodeGen/2007-04-05-PackedBitFields-2.c
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+# define pck __attribute__((packed))
+
+
+struct pck F { 
+  unsigned long long i : 12, 
+    j : 23, 
+    k : 27, 
+    l; 
+}; 
+struct F f1;
+
+void foo() {
+	f1.l = 5;
+}
diff --git a/test/CodeGen/2007-04-05-PackedBitFields.c b/test/CodeGen/2007-04-05-PackedBitFields.c
new file mode 100644
index 0000000..5c824a3
--- /dev/null
+++ b/test/CodeGen/2007-04-05-PackedBitFields.c
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+# define pck __attribute__((packed))
+
+
+struct pck E { 
+  unsigned long long l, 
+    i : 12, 
+    j : 23, 
+    k : 29; };
+
+struct E e1;
+
+void foo() {
+	e1.k = 5;
+}
diff --git a/test/CodeGen/2007-04-05-PackedStruct.c b/test/CodeGen/2007-04-05-PackedStruct.c
new file mode 100644
index 0000000..1e9171e
--- /dev/null
+++ b/test/CodeGen/2007-04-05-PackedStruct.c
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+#pragma pack(push, 2)
+
+enum {
+  tA = 0,
+  tB = 1
+};
+
+struct MyStruct {
+  unsigned long A;
+  char C;
+  void * B;
+};
+
+void bar(){
+struct MyStruct MS = { tB, 0 };
+}
diff --git a/test/CodeGen/2007-04-05-PadBeforeZeroLengthField.c b/test/CodeGen/2007-04-05-PadBeforeZeroLengthField.c
new file mode 100644
index 0000000..f3005b5
--- /dev/null
+++ b/test/CodeGen/2007-04-05-PadBeforeZeroLengthField.c
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+struct c__ { unsigned int type:4; };
+union A { struct c__ c;  } __attribute__((aligned(8)));
+struct B {
+    unsigned int retainCount;
+    union A objects[];
+};
+void foo(union A * objects, struct B *array, unsigned long k)
+{  array->objects[k] = objects[k]; }
diff --git a/test/CodeGen/2007-04-11-InlineAsmStruct.c b/test/CodeGen/2007-04-11-InlineAsmStruct.c
new file mode 100644
index 0000000..d617fee
--- /dev/null
+++ b/test/CodeGen/2007-04-11-InlineAsmStruct.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+struct V { short X, Y; };
+int bar() {
+  struct V bar;
+  __asm__ volatile("foo %0\n" : "=r"(bar));
+  return bar.X;
+}
diff --git a/test/CodeGen/2007-04-11-InlineAsmUnion.c b/test/CodeGen/2007-04-11-InlineAsmUnion.c
new file mode 100644
index 0000000..6d24d93
--- /dev/null
+++ b/test/CodeGen/2007-04-11-InlineAsmUnion.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+union U { int x; float p; };
+void foo() {
+  union U bar;
+  __asm__ volatile("foo %0\n" : "=r"(bar));
+}
diff --git a/test/CodeGen/2007-04-13-InlineAsmStruct2.c b/test/CodeGen/2007-04-13-InlineAsmStruct2.c
new file mode 100644
index 0000000..c9a87ff
--- /dev/null
+++ b/test/CodeGen/2007-04-13-InlineAsmStruct2.c
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+struct V { short X, Y; };
+int bar() {
+  struct V bar;
+  // CHECK: call void asm
+  __asm__ volatile("foo %0\n" :: "r"(bar));
+  return bar.X;
+}
diff --git a/test/CodeGen/2007-04-13-InlineAsmUnion2.c b/test/CodeGen/2007-04-13-InlineAsmUnion2.c
new file mode 100644
index 0000000..a8983b6
--- /dev/null
+++ b/test/CodeGen/2007-04-13-InlineAsmUnion2.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+union U { int x; char* p; };
+void foo() {
+  union U bar;
+  // CHECK: call void asm
+  __asm__ volatile("foo %0\n" :: "r"(bar));
+}
diff --git a/test/CodeGen/2007-04-14-FNoBuiltin.c b/test/CodeGen/2007-04-14-FNoBuiltin.c
new file mode 100644
index 0000000..a5fda63
--- /dev/null
+++ b/test/CodeGen/2007-04-14-FNoBuiltin.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -emit-llvm %s -O2 -fno-builtin -o - | grep call.*printf
+// Check that -fno-builtin is honored.
+
+extern int printf(const char*, ...);
+void foo(const char *msg) {
+	printf("%s\n",msg);
+}
diff --git a/test/CodeGen/2007-04-17-ZeroSizeBitFields.c b/test/CodeGen/2007-04-17-ZeroSizeBitFields.c
new file mode 100644
index 0000000..91b4582
--- /dev/null
+++ b/test/CodeGen/2007-04-17-ZeroSizeBitFields.c
@@ -0,0 +1,4 @@
+// PR 1332
+// RUN: %clang_cc1 %s -emit-llvm -o /dev/null
+
+struct Z { int a:1; int :0; int c:1; } z;
diff --git a/test/CodeGen/2007-04-24-bit-not-expr.c b/test/CodeGen/2007-04-24-bit-not-expr.c
new file mode 100644
index 0000000..9d99caf
--- /dev/null
+++ b/test/CodeGen/2007-04-24-bit-not-expr.c
@@ -0,0 +1,7 @@
+// PR 1346
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+extern bar(void *);
+
+void f(void *cd) {
+  bar(((void *)((unsigned long)(cd) ^ -1)));
+}
diff --git a/test/CodeGen/2007-05-07-PaddingElements.c b/test/CodeGen/2007-05-07-PaddingElements.c
new file mode 100644
index 0000000..574a377
--- /dev/null
+++ b/test/CodeGen/2007-05-07-PaddingElements.c
@@ -0,0 +1,12 @@
+// PR 1278
+// RUN: %clang_cc1 %s -emit-llvm -O0 -o - | grep {struct.s} | not grep "4 x i8] zeroinitializer"
+// RUN: %clang_cc1 %s -emit-llvm -O0 -o - | not grep "i32 0, i32 2"
+struct s {
+  double d1;
+  int s1;
+};
+
+struct s foo(void) {
+  struct s S = {1.1, 2};
+  return S;
+}
diff --git a/test/CodeGen/2007-05-08-PCH.c b/test/CodeGen/2007-05-08-PCH.c
new file mode 100644
index 0000000..c45d57c
--- /dev/null
+++ b/test/CodeGen/2007-05-08-PCH.c
@@ -0,0 +1,7 @@
+// PR 1400
+// RUN: %clang_cc1 -x c-header %s -o /dev/null
+
+int main() {
+  return 0;
+}
+
diff --git a/test/CodeGen/2007-05-15-PaddingElement.c b/test/CodeGen/2007-05-15-PaddingElement.c
new file mode 100644
index 0000000..5aa4f2e
--- /dev/null
+++ b/test/CodeGen/2007-05-15-PaddingElement.c
@@ -0,0 +1,23 @@
+// PR 1419
+
+// RUN: %clang_cc1   -O2 %s -emit-llvm -o - | grep "ret i32 1"
+struct A {
+  short x;
+  long long :0;
+};
+
+struct B {
+  char a;
+  char b;
+  unsigned char i;
+};
+
+union X { struct A a; struct B b; };
+
+int check(void) {
+  union X x, y;
+
+  y.b.i = 0xff;
+  x = y;
+  return (x.b.i == 0xff);
+}
diff --git a/test/CodeGen/2007-05-16-EmptyStruct.c b/test/CodeGen/2007-05-16-EmptyStruct.c
new file mode 100644
index 0000000..14aaff0
--- /dev/null
+++ b/test/CodeGen/2007-05-16-EmptyStruct.c
@@ -0,0 +1,5 @@
+// PR 1417
+// RUN: %clang_cc1   %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: global %struct.anon* null
+struct { } *X;
diff --git a/test/CodeGen/2007-05-29-UnionCopy.c b/test/CodeGen/2007-05-29-UnionCopy.c
new file mode 100644
index 0000000..9f71687
--- /dev/null
+++ b/test/CodeGen/2007-05-29-UnionCopy.c
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -emit-llvm -o - %s | grep memcpy
+// PR1421
+
+struct A {
+  char c;
+  int i;
+};
+
+struct B {
+  int c;
+  unsigned char x;
+};
+
+union U { struct A a; struct B b; };
+
+void check(union U *u, union U *v) {
+  *u = *v;
+}
diff --git a/test/CodeGen/2007-06-15-AnnotateAttribute.c b/test/CodeGen/2007-06-15-AnnotateAttribute.c
new file mode 100644
index 0000000..324b975
--- /dev/null
+++ b/test/CodeGen/2007-06-15-AnnotateAttribute.c
@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep llvm.global.annotations
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep llvm.var.annotation | count 3
+
+// XFAIL: *
+#include <stdio.h>
+
+/* Global variable with attribute */
+int X __attribute__((annotate("GlobalValAnnotation")));
+
+/* Function with attribute */
+int foo(int y) __attribute__((annotate("GlobalValAnnotation")))
+               __attribute__((noinline));
+
+int foo(int y __attribute__((annotate("LocalValAnnotation")))) {
+  int x __attribute__((annotate("LocalValAnnotation")));
+  x = 34;
+  return y + x;
+}
+
+int main() {
+  static int a __attribute__((annotate("GlobalValAnnotation")));
+  a = foo(2);
+  printf("hello world%d\n", a);
+  return 0;
+}
diff --git a/test/CodeGen/2007-06-18-SextAttrAggregate.c b/test/CodeGen/2007-06-18-SextAttrAggregate.c
new file mode 100644
index 0000000..27ae6a9
--- /dev/null
+++ b/test/CodeGen/2007-06-18-SextAttrAggregate.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 %s -o - -emit-llvm | FileCheck %s
+// PR1513
+
+struct s{
+long a;
+long b;
+};
+
+void f(struct s a, char *b, signed char C) {
+  // CHECK: i8 signext
+
+}
diff --git a/test/CodeGen/2007-07-29-RestrictPtrArg.c b/test/CodeGen/2007-07-29-RestrictPtrArg.c
new file mode 100644
index 0000000..b6d61a7
--- /dev/null
+++ b/test/CodeGen/2007-07-29-RestrictPtrArg.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep noalias
+
+void foo(int * __restrict myptr1, int * myptr2) {
+  myptr1[0] = 0;
+  myptr2[0] = 0;
+}
diff --git a/test/CodeGen/2007-08-01-LoadStoreAlign.c b/test/CodeGen/2007-08-01-LoadStoreAlign.c
new file mode 100644
index 0000000..87cf163
--- /dev/null
+++ b/test/CodeGen/2007-08-01-LoadStoreAlign.c
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s
+
+struct p {
+  char a;
+  int b;
+} __attribute__ ((packed));
+
+struct p t = { 1, 10 };
+struct p u;
+
+int main () {
+  // CHECK: align 1
+  // CHECK: align 1
+  int tmp = t.b;
+  u.b = tmp;
+  return tmp;
+
+}
diff --git a/test/CodeGen/2007-08-21-ComplexCst.c b/test/CodeGen/2007-08-21-ComplexCst.c
new file mode 100644
index 0000000..cd9ceb1
--- /dev/null
+++ b/test/CodeGen/2007-08-21-ComplexCst.c
@@ -0,0 +1,3 @@
+// RUN: %clang_cc1 -O2 -emit-llvm %s -o /dev/null
+void f(_Complex float z);
+void g() { f(1.0i); }
diff --git a/test/CodeGen/2007-08-22-CTTZ.c b/test/CodeGen/2007-08-22-CTTZ.c
new file mode 100644
index 0000000..9067c5a
--- /dev/null
+++ b/test/CodeGen/2007-08-22-CTTZ.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s
+
+int bork(unsigned long long x) {
+  // CHECK: llvm.cttz.i64
+  // CHECK: llvm.cttz.i64
+  // CHECK-NOT: lshr
+  return __builtin_ctzll(x);
+}
diff --git a/test/CodeGen/2007-09-05-ConstCtor.c b/test/CodeGen/2007-09-05-ConstCtor.c
new file mode 100644
index 0000000..138b818
--- /dev/null
+++ b/test/CodeGen/2007-09-05-ConstCtor.c
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1  -Os -emit-llvm %s -o /dev/null
+// PR1641
+
+struct A {
+  unsigned long l;
+};
+
+void bar(struct A *a);
+
+void bork() {
+  const unsigned long vcgt = 1234;
+  struct A a = { vcgt };
+  bar(&a);
+}
diff --git a/test/CodeGen/2007-09-14-NegatePointer.c b/test/CodeGen/2007-09-14-NegatePointer.c
new file mode 100644
index 0000000..52367e6
--- /dev/null
+++ b/test/CodeGen/2007-09-14-NegatePointer.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - 
+// PR1662
+
+int foo(unsigned char *test) {
+  return 0U - (unsigned int )test;
+}
+
diff --git a/test/CodeGen/2007-09-26-Alignment.c b/test/CodeGen/2007-09-26-Alignment.c
new file mode 100644
index 0000000..8ab130b
--- /dev/null
+++ b/test/CodeGen/2007-09-26-Alignment.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s
+extern p(int *);
+int q(void) {
+  // CHECK: alloca i32, align 16
+  int x __attribute__ ((aligned (16)));
+  p(&x);
+  return x;
+}
diff --git a/test/CodeGen/2007-09-28-PackedUnionMember.c b/test/CodeGen/2007-09-28-PackedUnionMember.c
new file mode 100644
index 0000000..943480e
--- /dev/null
+++ b/test/CodeGen/2007-09-28-PackedUnionMember.c
@@ -0,0 +1,38 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+#pragma pack(push, 2)
+struct H {
+  unsigned long f1;
+  unsigned long f2;
+  union {
+    struct opaque1 *f3;
+    struct opaque2 *f4;
+    struct {
+      struct opaque3 *f5;
+      unsigned short  f6;
+    } f7;
+  } f8;
+};
+#pragma pack(pop)
+
+struct E {
+  unsigned long f1;
+  unsigned long f2;
+};
+
+typedef long (*FuncPtr) ();
+
+extern long bork(FuncPtr handler, const struct E *list);
+
+static long hndlr()
+{
+  struct H cmd = { 4, 412 };
+  return 0;
+}
+void foo(void *inWindow) {
+  static const struct E events[] = {
+    { 123124, 1 }
+  };
+  bork(hndlr, events);
+}
+
diff --git a/test/CodeGen/2007-10-02-VolatileArray.c b/test/CodeGen/2007-10-02-VolatileArray.c
new file mode 100644
index 0000000..b1dcb7e
--- /dev/null
+++ b/test/CodeGen/2007-10-02-VolatileArray.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep volatile
+// PR1647
+
+void foo(volatile int *p)
+{
+p[0] = 0;
+}
diff --git a/test/CodeGen/2007-10-15-VoidPtr.c b/test/CodeGen/2007-10-15-VoidPtr.c
new file mode 100644
index 0000000..0bbff3d
--- /dev/null
+++ b/test/CodeGen/2007-10-15-VoidPtr.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1 -emit-llvm %s -o /dev/null
+void bork(void **data) {
+  (*(unsigned short *) (&(data[37])[927]) = 0);
+}
diff --git a/test/CodeGen/2007-10-30-Volatile.c b/test/CodeGen/2007-10-30-Volatile.c
new file mode 100644
index 0000000..17aac1a
--- /dev/null
+++ b/test/CodeGen/2007-10-30-Volatile.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s -o /dev/null -Wall -Werror
+void bork() {
+  char * volatile p = 0;
+  volatile int cc = 0;
+  p += cc;
+}
diff --git a/test/CodeGen/2007-11-07-AlignedMemcpy.c b/test/CodeGen/2007-11-07-AlignedMemcpy.c
new file mode 100644
index 0000000..829b60c
--- /dev/null
+++ b/test/CodeGen/2007-11-07-AlignedMemcpy.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1 -emit-llvm %s -o /dev/null
+void bork() {
+  int Qux[33] = {0};
+}
diff --git a/test/CodeGen/2007-11-07-CopyAggregateAlign.c b/test/CodeGen/2007-11-07-CopyAggregateAlign.c
new file mode 100644
index 0000000..d6caf78
--- /dev/null
+++ b/test/CodeGen/2007-11-07-CopyAggregateAlign.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s
+struct A { char s, t, u, v; short a; };
+// CHECK: %a = alloca %struct.A, align 2
+// CHECK: %b = alloca %struct.A, align 2
+// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp, i8* %tmp1, i64 6, i32 2, i1 false)
+
+void q() { struct A a, b; a = b; }
diff --git a/test/CodeGen/2007-11-07-ZeroAggregateAlign.c b/test/CodeGen/2007-11-07-ZeroAggregateAlign.c
new file mode 100644
index 0000000..fa5ab31
--- /dev/null
+++ b/test/CodeGen/2007-11-07-ZeroAggregateAlign.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s
+struct A { short s; short t; int i; };
+// CHECK: %a = alloca %struct.A, align 4
+// CHECK: call void @llvm.memset.p0i8.i64(i8* %tmp, i8 0, i64 8, i32 4, i1 false)
+void q() { struct A a = {0}; }
diff --git a/test/CodeGen/2007-11-28-GlobalInitializer.c b/test/CodeGen/2007-11-28-GlobalInitializer.c
new file mode 100644
index 0000000..a79ccdd
--- /dev/null
+++ b/test/CodeGen/2007-11-28-GlobalInitializer.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - 
+// PR1744
+typedef struct foo { int x; char *p; } FOO;
+extern FOO yy[];
+
+int *y = &((yy + 1)->x);
+void *z = &((yy + 1)->x);
+
diff --git a/test/CodeGen/2007-12-16-AsmNoUnwind.c b/test/CodeGen/2007-12-16-AsmNoUnwind.c
new file mode 100644
index 0000000..de078a2
--- /dev/null
+++ b/test/CodeGen/2007-12-16-AsmNoUnwind.c
@@ -0,0 +1,3 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | grep nounwind
+
+void bar() { asm (""); }
diff --git a/test/CodeGen/2008-01-07-UnusualIntSize.c b/test/CodeGen/2008-01-07-UnusualIntSize.c
new file mode 100644
index 0000000..2842830
--- /dev/null
+++ b/test/CodeGen/2008-01-07-UnusualIntSize.c
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+// PR1721
+
+struct s {
+  unsigned long long u33: 33;
+} a, b;
+
+// This should have %0 and %1 truncated to 33 bits before any operation.
+// This can be done using i33 or an explicit and.
+_Bool test(void) {
+  // CHECK: and i64 %0, 8589934591
+  // CHECK: and i64 %1, 8589934591
+  return a.u33 + b.u33 != 0;
+}
diff --git a/test/CodeGen/2008-01-11-ChainConsistency.c b/test/CodeGen/2008-01-11-ChainConsistency.c
new file mode 100644
index 0000000..9ae021f
--- /dev/null
+++ b/test/CodeGen/2008-01-11-ChainConsistency.c
@@ -0,0 +1,3 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - -fnested-functions | not grep nest
+
+void n1(void) { void a(void) { a(); } a(); }
diff --git a/test/CodeGen/2008-01-21-PackedBitFields.c b/test/CodeGen/2008-01-21-PackedBitFields.c
new file mode 100644
index 0000000..a649475
--- /dev/null
+++ b/test/CodeGen/2008-01-21-PackedBitFields.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+typedef double Al1Double __attribute__((aligned(1)));
+struct x { int a:23; Al1Double v; };
+struct x X = { 5, 3.0 };
+double foo() { return X.v; }
+
diff --git a/test/CodeGen/2008-01-21-PackedStructField.c b/test/CodeGen/2008-01-21-PackedStructField.c
new file mode 100644
index 0000000..aa1bee4
--- /dev/null
+++ b/test/CodeGen/2008-01-21-PackedStructField.c
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+struct X { long double b; unsigned char c; double __attribute__((packed)) d; };
+struct X x = { 3.0L, 5, 3.0 };
+
+
+struct S2504 {
+  int e:17;
+    __attribute__((packed)) unsigned long long int f; 
+} ;
+int fails;
+ extern struct S2504 s2504; 
+void check2504va (int z) { 
+  struct S2504 arg, *p;
+  long long int i = 0; 
+  arg.f = i;
+}
+
diff --git a/test/CodeGen/2008-01-24-StructAlignAndBitFields.c b/test/CodeGen/2008-01-24-StructAlignAndBitFields.c
new file mode 100644
index 0000000..eae48b3
--- /dev/null
+++ b/test/CodeGen/2008-01-24-StructAlignAndBitFields.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+struct U { char a; short b; int c:25; char d; } u;
+
diff --git a/test/CodeGen/2008-01-25-ByValReadNone.c b/test/CodeGen/2008-01-25-ByValReadNone.c
new file mode 100644
index 0000000..b4053c0
--- /dev/null
+++ b/test/CodeGen/2008-01-25-ByValReadNone.c
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -O3 -emit-llvm -o - %s | not grep readonly
+// RUN: %clang_cc1 -O3 -emit-llvm -o - %s | not grep readnone
+
+
+// The struct being passed byval means that we cannot mark the
+// function readnone.  Readnone would allow stores to the arg to
+// be deleted in the caller.  We also don't allow readonly since
+// the callee might write to the byval parameter.  The inliner
+// would have to assume the worse and introduce an explicit
+// temporary when inlining such a function, which is costly for
+// the common case in which the byval argument is not written.
+struct S { int A[1000]; };
+int __attribute__ ((const)) f(struct S x) { x.A[1] = 0; return x.A[0]; }
+int g(struct S x) __attribute__ ((pure));
+int h(struct S x) { return g(x); }
diff --git a/test/CodeGen/2008-01-25-ZeroSizedAggregate.c b/test/CodeGen/2008-01-25-ZeroSizedAggregate.c
new file mode 100644
index 0000000..d905985
--- /dev/null
+++ b/test/CodeGen/2008-01-25-ZeroSizedAggregate.c
@@ -0,0 +1,39 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+// Aggregates of size zero should be dropped from argument list.
+typedef long int Tlong;
+struct S2411 {
+  __attribute__((aligned)) Tlong:0;
+};
+
+extern struct S2411 a2411[5];
+extern void checkx2411(struct S2411);
+void test2411(void) {
+  checkx2411(a2411[0]);
+}
+
+// Proper handling of zero sized fields during type conversion.
+typedef unsigned long long int Tal2ullong __attribute__((aligned(2)));
+struct S2525 {
+ Tal2ullong: 0;
+ struct {
+ } e;
+};
+struct S2525 s2525;
+
+struct {
+  signed char f;
+  char :0;
+  struct{}h;
+  char * i[5];
+} data; 
+
+// Taking address of a zero sized field.
+struct Z {};
+struct Y {
+  int i;
+  struct Z z;
+};
+void *f(struct Y *y) {
+  return &y->z;
+}
diff --git a/test/CodeGen/2008-01-28-PragmaMark.c b/test/CodeGen/2008-01-28-PragmaMark.c
new file mode 100644
index 0000000..399af95
--- /dev/null
+++ b/test/CodeGen/2008-01-28-PragmaMark.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -Werror -emit-llvm %s -o /dev/null
+#pragma mark LLVM's world
+#ifdef DO_ERROR
+#error LLVM's world
+#endif
+int i;
diff --git a/test/CodeGen/2008-01-28-UnionSize.c b/test/CodeGen/2008-01-28-UnionSize.c
new file mode 100644
index 0000000..14f363d
--- /dev/null
+++ b/test/CodeGen/2008-01-28-UnionSize.c
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+// PR 1861
+
+typedef unsigned char __u8;
+typedef unsigned int __u32;
+typedef unsigned short u16;
+typedef __u32 __le32;
+struct bcm43xx_plcp_hdr6 {
+  union {
+    __le32 data;
+    __u8 raw[6];
+  }
+    __attribute__((__packed__));
+}
+  __attribute__((__packed__));
+struct bcm43xx_txhdr {
+  union {
+    struct {
+      struct bcm43xx_plcp_hdr6 plcp;
+    };
+  };
+}
+  __attribute__((__packed__));
+static void bcm43xx_generate_rts(struct bcm43xx_txhdr *txhdr ) { }
diff --git a/test/CodeGen/2008-03-03-CtorAttrType.c b/test/CodeGen/2008-03-03-CtorAttrType.c
new file mode 100644
index 0000000..dbd7bc0
--- /dev/null
+++ b/test/CodeGen/2008-03-03-CtorAttrType.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | grep llvm.global_ctors
+int __attribute__((constructor)) foo(void) {
+  return 0;
+}
+void __attribute__((constructor)) bar(void) {}
+
diff --git a/test/CodeGen/2008-03-05-syncPtr.c b/test/CodeGen/2008-03-05-syncPtr.c
new file mode 100644
index 0000000..3cabcfe
--- /dev/null
+++ b/test/CodeGen/2008-03-05-syncPtr.c
@@ -0,0 +1,27 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | grep llvm.atomic
+// XFAIL: sparc-sun-solaris2|arm
+// Feature currently implemented only for x86, alpha, powerpc.
+
+int* foo(int** a, int* b, int* c) {
+return __sync_val_compare_and_swap (a, b, c);
+}
+
+int foo2(int** a, int* b, int* c) {
+return __sync_bool_compare_and_swap (a, b, c);
+}
+
+int* foo3(int** a, int b) {
+  return __sync_fetch_and_add (a, b);
+}
+
+int* foo4(int** a, int b) {
+  return __sync_fetch_and_sub (a, b);
+}
+
+int* foo5(int** a, int* b) {
+  return __sync_lock_test_and_set (a, b);
+}
+
+int* foo6(int** a, int*** b) {
+  return __sync_lock_test_and_set (a, b);
+}
diff --git a/test/CodeGen/2008-03-24-BitField-And-Alloca.c b/test/CodeGen/2008-03-24-BitField-And-Alloca.c
new file mode 100644
index 0000000..cb80d76
--- /dev/null
+++ b/test/CodeGen/2008-03-24-BitField-And-Alloca.c
@@ -0,0 +1,89 @@
+// RUN: %clang_cc1 -O2 -emit-llvm %s -o - | not grep alloca
+// RUN: %clang_cc1 -m32 -O2 -emit-llvm %s -o - | not grep {store }
+
+enum {
+ PP_C,
+ PP_D,
+ PP_R,
+ PP_2D,
+ PP_1D,
+ PP_SR,
+ PP_S2D,
+ PP_S1D,
+ PP_SC
+};
+
+enum {
+ G_VP,
+ G_FP,
+ G_VS,
+ G_GS,
+ G_FS
+};
+
+enum {
+ G_NONE,
+ G_B,
+ G_R
+};
+
+typedef union _Key {
+ struct {
+  unsigned int count : 2;
+  unsigned int Aconst : 1;
+  unsigned int Bconst : 1;
+  unsigned int Cconst : 1;
+  unsigned int Xused : 1;
+  unsigned int Yused : 1;
+  unsigned int Zused : 1;
+  unsigned int Wused : 1;
+  unsigned int ttype : 3;
+  unsigned int scalar : 1;
+  unsigned int AType : 4;
+  unsigned int BType : 4;
+  unsigned int CType : 4;
+  unsigned int RType : 4;
+  unsigned int Size : 2;
+  unsigned int prec : 1;
+
+  unsigned int ASize : 2;
+  unsigned int BSize : 2;
+  unsigned int CSize : 2;
+  unsigned int tTex : 4;
+  unsigned int proj : 1;
+  unsigned int lod : 2;
+  unsigned int dvts : 1;
+  unsigned int uipad : 18;
+ } key_io;
+ struct {
+  unsigned int key0;
+  unsigned int key1;
+ } key;
+ unsigned long long lkey;
+} Key;
+
+static void foo(const Key iospec, int* ret)
+{
+  *ret=0;
+ if(((iospec.key_io.lod == G_B) &&
+  (iospec.key_io.ttype != G_VS) &&
+  (iospec.key_io.ttype != G_GS) &&
+  (iospec.key_io.ttype != G_FS)) ||
+
+  (((iospec.key_io.tTex == PP_C) ||
+    (iospec.key_io.tTex == PP_SC)) &&
+   ((iospec.key_io.tTex == PP_SR) ||
+    (iospec.key_io.tTex == PP_S2D) ||
+    (iospec.key_io.tTex == PP_S1D) ||
+    (iospec.key_io.tTex == PP_SC))))
+  *ret=1;
+}
+
+
+extern int bar(unsigned long long key_token2)
+{
+ int ret;
+ __attribute__ ((unused)) Key iospec = (Key) key_token2;
+ foo(iospec, &ret);
+ return ret;
+}
diff --git a/test/CodeGen/2008-03-26-PackedBitFields.c b/test/CodeGen/2008-03-26-PackedBitFields.c
new file mode 100644
index 0000000..72e5cb1
--- /dev/null
+++ b/test/CodeGen/2008-03-26-PackedBitFields.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+
+struct S1757 { 
+  long double c;
+  long int __attribute__((packed)) e:28;
+} x;
diff --git a/test/CodeGen/2008-04-08-NoExceptions.c b/test/CodeGen/2008-04-08-NoExceptions.c
new file mode 100644
index 0000000..6d5d20f
--- /dev/null
+++ b/test/CodeGen/2008-04-08-NoExceptions.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s
+
+void f(void);
+void g(void) {
+  // CHECK: define void @g() nounwind
+  // CHECK-NOT: call void @f() nounwind
+  f();
+}
+
+// CHECK-NOT: declare void @f() nounwind
diff --git a/test/CodeGen/2008-05-06-CFECrash.c b/test/CodeGen/2008-05-06-CFECrash.c
new file mode 100644
index 0000000..1177567
--- /dev/null
+++ b/test/CodeGen/2008-05-06-CFECrash.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1 -emit-llvm -O2 %s -o /dev/null
+// PR2292.
+__inline__ __attribute__ ((__pure__)) int g (void) {}
+void f (int k) { k = g (); }
diff --git a/test/CodeGen/2008-05-12-TempUsedBeforeDef.c b/test/CodeGen/2008-05-12-TempUsedBeforeDef.c
new file mode 100644
index 0000000..bc2886e
--- /dev/null
+++ b/test/CodeGen/2008-05-12-TempUsedBeforeDef.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -w -emit-llvm -o /dev/null %s
+// PR2264.
+unsigned foo = 8L;
+unsigned bar = 0L;
+volatile unsigned char baz = 6L;
+int test() {
+  char qux = 1L;
+  for (; baz >= -29; baz--)
+    bork(bar && foo, qux);
+}
diff --git a/test/CodeGen/2008-05-19-AlwaysInline.c b/test/CodeGen/2008-05-19-AlwaysInline.c
new file mode 100644
index 0000000..73a7691
--- /dev/null
+++ b/test/CodeGen/2008-05-19-AlwaysInline.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 %s -emit-llvm -fno-unit-at-a-time -O0 -o - | not grep sabrina
+// RUN: %clang_cc1 %s -emit-llvm -funit-at-a-time -O0 -o - | not grep sabrina
+
+static inline int sabrina (void) __attribute__((always_inline));
+static inline int sabrina (void)
+{
+  return 13;
+}
+int bar (void)
+{
+  return sabrina () + 68;
+}
diff --git a/test/CodeGen/2008-08-07-AlignPadding1.c b/test/CodeGen/2008-08-07-AlignPadding1.c
new file mode 100644
index 0000000..5beae3e
--- /dev/null
+++ b/test/CodeGen/2008-08-07-AlignPadding1.c
@@ -0,0 +1,32 @@
+/* RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+The FE must generate padding here both at the end of each PyG_Head and
+between array elements.  Reduced from Python. */
+
+typedef union _gc_head {
+  struct {
+    union _gc_head *gc_next;
+    union _gc_head *gc_prev;
+    long gc_refs;
+  } gc;
+  int dummy __attribute__((aligned(16)));
+} PyGC_Head;
+
+struct gc_generation {
+  PyGC_Head head;
+  int threshold;
+  int count;
+};
+
+#define GEN_HEAD(n) (&generations[n].head)
+
+// The idea is that there are 6 undefs in this structure initializer to cover
+// the padding between elements.
+// CHECK: @generations = global [3 x %struct.gc_generation] [%struct.gc_generation { %union._gc_head { %struct.anon { %union._gc_head* getelementptr inbounds ([3 x %struct.gc_generation]* @generations, i32 0, i32 0, i32 0), %union._gc_head* getelementptr inbounds ([3 x %struct.gc_generation]* @generations, i32 0, i32 0, i32 0), i64 0 }, [8 x i8] undef }, i32 700, i32 0, [8 x i8] undef }, %struct.gc_generation { %union._gc_head { %struct.anon { %union._gc_head* bitcast (i8* getelementptr (i8* bitcast ([3 x %struct.gc_generation]* @generations to i8*), i64 48) to %union._gc_head*), %union._gc_head* bitcast (i8* getelementptr (i8* bitcast ([3 x %struct.gc_generation]* @generations to i8*), i64 48) to %union._gc_head*), i64 0 }, [8 x i8] undef }, i32 10, i32 0, [8 x i8] undef }, %struct.gc_generation { %union._gc_head { %struct.anon { %union._gc_head* bitcast (i8* getelementptr (i8* bitcast ([3 x %struct.gc_generation]* @generations to i8*), i64 96) to %union._gc_head*), %union._gc_head* bitcast (i8* getelementptr (i8* bitcast ([3 x %struct.gc_generation]* @generations to i8*), i64 96) to %union._gc_head*), i64 0 }, [8 x i8] undef }, i32 10, i32 0, [8 x i8] undef }]
+/* linked lists of container objects */
+struct gc_generation generations[3] = {
+        /* 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/2008-08-07-AlignPadding2.c b/test/CodeGen/2008-08-07-AlignPadding2.c
new file mode 100644
index 0000000..ecf28dd
--- /dev/null
+++ b/test/CodeGen/2008-08-07-AlignPadding2.c
@@ -0,0 +1,18 @@
+/* RUN: %clang_cc1 %s -emit-llvm -o - -O0 | grep zeroinitializer | count 1
+
+The FE must not generate padding here between array elements.  PR 2533. */
+
+typedef struct {
+ const char *name;
+ int flags;
+ union {
+   int x;
+ } u;
+} OptionDef;
+
+const OptionDef options[] = {
+ /* main options */
+ { "a", 0, {3} },
+ { "b", 0, {4} },
+ { 0, },
+};
diff --git a/test/CodeGen/2008-08-07-GEPIntToPtr.c b/test/CodeGen/2008-08-07-GEPIntToPtr.c
new file mode 100644
index 0000000..6892be0
--- /dev/null
+++ b/test/CodeGen/2008-08-07-GEPIntToPtr.c
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s
+// PR2603
+
+struct A {
+  char num_fields;
+};
+
+struct B {
+  char a, b[1];
+};
+
+const struct A Foo = {
+  // CHECK: i8 1
+  (char *)(&( (struct B *)(16) )->b[0]) - (char *)(16)
+};
diff --git a/test/CodeGen/2008-09-03-WeakAlias.c b/test/CodeGen/2008-09-03-WeakAlias.c
new file mode 100644
index 0000000..4712a01
--- /dev/null
+++ b/test/CodeGen/2008-09-03-WeakAlias.c
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -emit-llvm -O1 -o - %s | grep icmp
+// PR1678
+extern void B (void);
+static __typeof(B) A __attribute__ ((__weakref__("B")));
+int active (void)
+{
+  static void *const p = __extension__ (void *) &A;
+  return p != 0;
+}
diff --git a/test/CodeGen/2008-10-13-FrontendCrash.c b/test/CodeGen/2008-10-13-FrontendCrash.c
new file mode 100644
index 0000000..cdd1229
--- /dev/null
+++ b/test/CodeGen/2008-10-13-FrontendCrash.c
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+// PR2797
+
+unsigned int
+func_48 (signed char p_49)
+{
+  signed char l_340;
+  func_44 (1&((1 ^ 1 == (lshift_u_s (1)) != (l_340 < 1)) & 1L));
+}
diff --git a/test/CodeGen/2008-10-30-ZeroPlacement.c b/test/CodeGen/2008-10-30-ZeroPlacement.c
new file mode 100644
index 0000000..f3806d4
--- /dev/null
+++ b/test/CodeGen/2008-10-30-ZeroPlacement.c
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -emit-llvm %s -o -
+// PR2987
+struct S2045
+{
+  unsigned short int a;
+  union { } b;
+  union __attribute__ ((aligned (4))) { } c[0];
+};
+struct S2045 s2045;
diff --git a/test/CodeGen/2008-11-02-WeakAlias.c b/test/CodeGen/2008-11-02-WeakAlias.c
new file mode 100644
index 0000000..63fd4e1
--- /dev/null
+++ b/test/CodeGen/2008-11-02-WeakAlias.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -triple=i686-pc-linux-gnu -emit-llvm -o - %s | FileCheck %s
+// PR2691
+
+// CHECK: weak
+void init_IRQ(void) __attribute__((weak, alias("native_init_IRQ")));
+void native_init_IRQ(void) {}
diff --git a/test/CodeGen/2008-11-08-InstCombineSelect.c b/test/CodeGen/2008-11-08-InstCombineSelect.c
new file mode 100644
index 0000000..3f4428e
--- /dev/null
+++ b/test/CodeGen/2008-11-08-InstCombineSelect.c
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 %s -emit-llvm -O2 -o -
+// PR3028
+
+int g_187;
+int g_204;
+int g_434;
+
+int func_89 (void)
+{
+  return 1;
+}
+
+void func_20 (int p_22)
+{
+  if (1 & p_22 | g_204 & (1 < g_187) - func_89 ())
+    g_434 = 1;
+}
diff --git a/test/CodeGen/2009-01-05-BlockInlining.c b/test/CodeGen/2009-01-05-BlockInlining.c
new file mode 100644
index 0000000..2ae9b70
--- /dev/null
+++ b/test/CodeGen/2009-01-05-BlockInlining.c
@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 %s -emit-llvm -fblocks -o - | FileCheck %s
+// rdar://5865221
+
+// These will be inlined by the optimizers provided the block descriptors
+// and block literals are internal constants.
+// CHECK: @__block_descriptor_tmp = internal constant
+// CHECK: @__block_literal_global = internal constant
+// CHECK: @__block_descriptor_tmp1 = internal constant
+// CHECK: @__block_literal_global2 = internal constant
+static int fun(int x) {
+	return x+1;
+}
+
+static int block(int x) {
+	return (^(int x){return x+1;})(x);
+}
+
+static void print(int result) {
+    printf("%d\n", result);
+}
+
+int main (int argc, const char * argv[]) {
+    int	x = argc-1;
+    print(fun(x));
+    print(block(x));
+    int	(^block_inline)(int) = ^(int x){return x+1;};
+    print(block_inline(x));
+    return 0;
+}
diff --git a/test/CodeGen/2009-01-21-InvalidIterator.c b/test/CodeGen/2009-01-21-InvalidIterator.c
new file mode 100644
index 0000000..f857b4d
--- /dev/null
+++ b/test/CodeGen/2009-01-21-InvalidIterator.c
@@ -0,0 +1,74 @@
+// RUN: %clang_cc1 %s -emit-llvm -g -o /dev/null
+
+typedef long unsigned int size_t;
+typedef unsigned short int uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long int uint64_t;
+typedef uint16_t Elf64_Half;
+typedef uint32_t Elf64_Word;
+typedef uint64_t Elf64_Xword;
+typedef uint64_t Elf64_Addr;
+typedef uint64_t Elf64_Off;
+typedef struct
+{
+  Elf64_Word p_type;
+  Elf64_Off p_offset;
+  Elf64_Addr p_vaddr;
+  Elf64_Xword p_align;
+}
+Elf64_Phdr;
+struct dl_phdr_info
+{
+  const char *dlpi_name;
+  const Elf64_Phdr *dlpi_phdr;
+  Elf64_Half dlpi_phnum;
+  unsigned long long int dlpi_adds;
+};
+typedef unsigned _Unwind_Ptr;
+struct object
+{
+  union
+  {
+    const struct dwarf_fde *single;
+    struct dwarf_fde **array;
+    struct fde_vector *sort;
+  }
+  u;
+  union
+  {
+    struct
+    {
+    }
+    b;
+  }
+  s;
+  struct object *next;
+};
+typedef int sword;
+typedef unsigned int uword;
+struct dwarf_fde
+{
+  uword length;
+  sword CIE_delta;
+  unsigned char pc_begin[];
+};
+typedef struct dwarf_fde fde;
+struct unw_eh_callback_data
+{
+  const fde *ret;
+  struct frame_hdr_cache_element *link;
+}
+frame_hdr_cache[8];
+
+_Unwind_Ptr
+base_from_cb_data (struct unw_eh_callback_data *data)
+{
+}
+
+void
+_Unwind_IteratePhdrCallback (struct dl_phdr_info *info, size_t size, void *ptr)
+{
+  const unsigned char *p;
+  const struct unw_eh_frame_hdr *hdr;
+  struct object ob;
+}
diff --git a/test/CodeGen/2009-02-13-zerosize-union-field-ppc.c b/test/CodeGen/2009-02-13-zerosize-union-field-ppc.c
new file mode 100644
index 0000000..21b4705
--- /dev/null
+++ b/test/CodeGen/2009-02-13-zerosize-union-field-ppc.c
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 %s -m32 -emit-llvm -o - | grep {i32 32} | count 3
+// XFAIL: *
+// XTARGET: powerpc
+//  Every printf has 'i32 0' for the GEP of the string; no point counting those.
+typedef unsigned int Foo __attribute__((aligned(32)));
+typedef union{Foo:0;}a;
+typedef union{int x; Foo:0;}b;
+extern int printf(const char*, ...);
+main() {
+  printf("%ld\n", sizeof(a));
+  printf("%ld\n", __alignof__(a));
+  printf("%ld\n", sizeof(b));
+  printf("%ld\n", __alignof__(b));
+}
diff --git a/test/CodeGen/2009-02-13-zerosize-union-field.c b/test/CodeGen/2009-02-13-zerosize-union-field.c
new file mode 100644
index 0000000..b39a231
--- /dev/null
+++ b/test/CodeGen/2009-02-13-zerosize-union-field.c
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 %s -triple i686-apple-darwin -emit-llvm -o - | FileCheck %s
+// Every printf has 'i32 0' for the GEP of the string; no point counting those.
+typedef unsigned int Foo __attribute__((aligned(32)));
+typedef union{Foo:0;}a;
+typedef union{int x; Foo:0;}b;
+extern int printf(const char*, ...);
+int main() {
+  // CHECK: getelementptr inbounds ([5 x i8]* @.str, i32 0, i32 0), i32 0
+  printf("%ld\n", sizeof(a));
+  // CHECK: getelementptr inbounds ([5 x i8]* @.str, i32 0, i32 0), i32 1
+  printf("%ld\n", __alignof__(a));
+  // CHECK: getelementptr inbounds ([5 x i8]* @.str, i32 0, i32 0), i32 4
+  printf("%ld\n", sizeof(b));
+  // CHECK: getelementptr inbounds ([5 x i8]* @.str, i32 0, i32 0), i32 4
+  printf("%ld\n", __alignof__(b));
+}
diff --git a/test/CodeGen/2009-03-01-MallocNoAlias.c b/test/CodeGen/2009-03-01-MallocNoAlias.c
new file mode 100644
index 0000000..1c4878a
--- /dev/null
+++ b/test/CodeGen/2009-03-01-MallocNoAlias.c
@@ -0,0 +1,3 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | grep noalias
+
+void * __attribute__ ((malloc)) foo (void) { return 0; }
diff --git a/test/CodeGen/2009-03-08-ZeroEltStructCrash.c b/test/CodeGen/2009-03-08-ZeroEltStructCrash.c
new file mode 100644
index 0000000..b530eb7
--- /dev/null
+++ b/test/CodeGen/2009-03-08-ZeroEltStructCrash.c
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - 
+// PR3744
+struct Empty {};
+struct Union {
+ union {
+   int zero_arr[0];
+ } contents;
+};
+static inline void Foo(struct Union *u) {
+ int *array = u->contents.zero_arr;
+}
+static void Bar(struct Union *u) {
+ Foo(u);
+}
diff --git a/test/CodeGen/2009-03-13-dbg.c b/test/CodeGen/2009-03-13-dbg.c
new file mode 100644
index 0000000..8326bc6
--- /dev/null
+++ b/test/CodeGen/2009-03-13-dbg.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 %s -emit-llvm -g -o /dev/null
+// XTARGET: darwin,linux
+// XFAIL: *
+void foo() {}
+
diff --git a/test/CodeGen/2009-04-28-UnionArrayCrash.c b/test/CodeGen/2009-04-28-UnionArrayCrash.c
new file mode 100644
index 0000000..4296b91
--- /dev/null
+++ b/test/CodeGen/2009-04-28-UnionArrayCrash.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - 
+// PR4082
+union U {
+  int I;
+  double F;
+};
+
+union U arr[] = { { .I = 4 }, { .F = 123.} };
+union U *P = &arr[0];
+
+
diff --git a/test/CodeGen/2009-05-04-EnumInreg.c b/test/CodeGen/2009-05-04-EnumInreg.c
new file mode 100644
index 0000000..2abc747
--- /dev/null
+++ b/test/CodeGen/2009-05-04-EnumInreg.c
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -emit-llvm -triple i686-apple-darwin -mregparm 3 %s -o - | FileCheck %s
+// PR3967
+
+enum kobject_action {
+        KOBJ_ADD,
+        KOBJ_REMOVE,
+        KOBJ_CHANGE,
+        KOBJ_MOVE,
+        KOBJ_ONLINE,
+        KOBJ_OFFLINE,
+        KOBJ_MAX
+};
+
+struct kobject;
+
+// CHECK: i32 inreg %action
+int kobject_uevent(struct kobject *kobj, enum kobject_action action) {}
diff --git a/test/CodeGen/2009-06-14-HighlyAligned.c b/test/CodeGen/2009-06-14-HighlyAligned.c
new file mode 100644
index 0000000..b5a7f5e
--- /dev/null
+++ b/test/CodeGen/2009-06-14-HighlyAligned.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 %s -emit-llvm -o /dev/null
+// PR4332
+
+static int highly_aligned __attribute__((aligned(4096)));
+
+int f() {
+	return highly_aligned;
+}
diff --git a/test/CodeGen/2009-06-18-StaticInitTailPadPack.c b/test/CodeGen/2009-06-18-StaticInitTailPadPack.c
new file mode 100644
index 0000000..be103ec
--- /dev/null
+++ b/test/CodeGen/2009-06-18-StaticInitTailPadPack.c
@@ -0,0 +1,26 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+// rdar://6983634
+
+  typedef struct A *Foo;
+#pragma pack(push, 2)
+  struct Bar {
+    Foo             f1;
+    unsigned short  f2;
+    float           f3;
+  };
+  struct Baz {
+    struct Bar   f1;
+    struct Bar   f2;
+  };
+  struct Qux {
+    unsigned long   f1;
+    struct Baz             f2;
+  };
+extern const struct Qux Bork;
+const struct Qux Bork = {
+  0,
+  {
+    {0},
+    {0}
+  }
+};
diff --git a/test/CodeGen/2009-07-14-VoidPtr.c b/test/CodeGen/2009-07-14-VoidPtr.c
new file mode 100644
index 0000000..5e8b23d
--- /dev/null
+++ b/test/CodeGen/2009-07-14-VoidPtr.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s -o -
+// PR4556
+
+extern void foo;
+void *bar = &foo;
+
diff --git a/test/CodeGen/2009-07-22-StructLayout.c b/test/CodeGen/2009-07-22-StructLayout.c
new file mode 100644
index 0000000..7b7b82c
--- /dev/null
+++ b/test/CodeGen/2009-07-22-StructLayout.c
@@ -0,0 +1,34 @@
+// RUN: %clang_cc1 %s -triple i686-pc-linux-gnu -emit-llvm -o /dev/null
+// PR4590
+
+typedef unsigned char __u8;
+typedef unsigned int __le32;
+typedef unsigned int __u32;
+typedef unsigned short __le16;
+typedef unsigned short __u16;
+
+struct usb_cdc_ether_desc {
+ __u8 bLength;
+ __u8 bDescriptorType;
+ __u8 bDescriptorSubType;
+
+ __u8 iMACAddress;
+ __le32 bmEthernetStatistics;
+ __le16 wMaxSegmentSize;
+ __le16 wNumberMCFilters;
+ __u8 bNumberPowerFilters;
+} __attribute__ ((packed));
+
+
+static struct usb_cdc_ether_desc ecm_desc __attribute__ ((__section__(".init.data"))) = {
+ .bLength = sizeof ecm_desc,
+ .bDescriptorType = ((0x01 << 5) | 0x04),
+ .bDescriptorSubType = 0x0f,
+
+
+
+ .bmEthernetStatistics = (( __le32)(__u32)(0)),
+ .wMaxSegmentSize = (( __le16)(__u16)(1514)),
+ .wNumberMCFilters = (( __le16)(__u16)(0)),
+ .bNumberPowerFilters = 0,
+};
diff --git a/test/CodeGen/2009-12-07-BitFieldAlignment.c b/test/CodeGen/2009-12-07-BitFieldAlignment.c
new file mode 100644
index 0000000..72c30e1
--- /dev/null
+++ b/test/CodeGen/2009-12-07-BitFieldAlignment.c
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -triple i686-apple-darwin %s -emit-llvm -o - | FileCheck %s
+// Set alignment on bitfield accesses.
+
+struct S {
+  int a, b;
+  void *c;
+  unsigned d : 8;
+  unsigned e : 8;
+};
+
+void f0(struct S *a) {
+// CHECK: load {{.*}}, align 4
+// CHECK: store {{.*}}, align 4
+  a->e = 0;
+}
diff --git a/test/CodeGen/2010-01-13-MemBarrier.c b/test/CodeGen/2010-01-13-MemBarrier.c
new file mode 100644
index 0000000..32ad97c
--- /dev/null
+++ b/test/CodeGen/2010-01-13-MemBarrier.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+// XFAIL: sparc
+// rdar://7536390
+
+unsigned t(unsigned *ptr, unsigned val) {
+  // CHECK:      @t
+  // CHECK:      call void @llvm.memory.barrier
+  // CHECK-NEXT: call i32 @llvm.atomic.swap.i32
+  // CHECK-NEXT: call void @llvm.memory.barrier
+  return __sync_lock_test_and_set(ptr, val);
+}
diff --git a/test/CodeGen/2010-01-14-FnType-DebugInfo.c b/test/CodeGen/2010-01-14-FnType-DebugInfo.c
new file mode 100644
index 0000000..964c031
--- /dev/null
+++ b/test/CodeGen/2010-01-14-FnType-DebugInfo.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1 %s -emit-llvm -g -o /dev/null
+typedef void (*sigcatch_t)( struct sigcontext *);
+sigcatch_t sigcatch[50] = {(sigcatch_t) 0};
+
diff --git a/test/CodeGen/2010-01-18-Inlined-Debug.c b/test/CodeGen/2010-01-18-Inlined-Debug.c
new file mode 100644
index 0000000..cf00be7
--- /dev/null
+++ b/test/CodeGen/2010-01-18-Inlined-Debug.c
@@ -0,0 +1,12 @@
+// PR: 6058
+// RUN: %clang_cc1 -g -emit-llvm %s  -O0 -o /dev/null
+
+static inline int foo(double) __attribute__ ((always_inline));
+static inline int foo(double __x) { return __x; }
+
+void bar(double x) {
+  foo(x);
+}
+
+
+
diff --git a/test/CodeGen/2010-02-10-PointerName.c b/test/CodeGen/2010-02-10-PointerName.c
new file mode 100644
index 0000000..910dd30
--- /dev/null
+++ b/test/CodeGen/2010-02-10-PointerName.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 %s -emit-llvm -g -o - | grep DW_TAG_pointer_type | grep -v char
+
+char i = 1;
+void foo() {
+  char *cp = &i;
+}
+
diff --git a/test/CodeGen/2010-02-15-DbgStaticVar.c b/test/CodeGen/2010-02-15-DbgStaticVar.c
new file mode 100644
index 0000000..facd14e
--- /dev/null
+++ b/test/CodeGen/2010-02-15-DbgStaticVar.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -g -emit-llvm %s -o - | grep "metadata ..b., metadata ..b., metadata ...,"
+// Test to check intentionally empty linkage name for a static variable.
+// Radar 7651244.
+static int foo(int a)
+{
+	static int b = 1;
+	return b+a;
+}
+
+int main() {
+	int j = foo(1);
+	return 0;
+}
diff --git a/test/CodeGen/2010-03-10-arm-asmreg.c b/test/CodeGen/2010-03-10-arm-asmreg.c
new file mode 100644
index 0000000..919a92a
--- /dev/null
+++ b/test/CodeGen/2010-03-10-arm-asmreg.c
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 %s -emit-llvm -O0 -o - | FileCheck %s
+// pr6552
+
+// XFAIL: *
+// XTARGET: arm
+
+extern void bar(unsigned int ip);
+
+// CHECK: mov r0, r12
+void foo(void)
+{
+  register unsigned int ip __asm ("ip");
+  bar(ip);
+}
+
diff --git a/test/CodeGen/2010-03-5-LexicalScope.c b/test/CodeGen/2010-03-5-LexicalScope.c
new file mode 100644
index 0000000..0f63ff6
--- /dev/null
+++ b/test/CodeGen/2010-03-5-LexicalScope.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -emit-llvm -O0 -g %s -o - | grep DW_TAG_lexical_block | count 3
+int foo(int i) {
+	if (i) {
+		int j = 2;
+	}
+	else {
+		int j = 3;
+	}
+	return i;
+}
diff --git a/test/CodeGen/2010-05-26-AsmSideEffect.c b/test/CodeGen/2010-05-26-AsmSideEffect.c
new file mode 100644
index 0000000..c26fd14
--- /dev/null
+++ b/test/CodeGen/2010-05-26-AsmSideEffect.c
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+// Radar 8026855
+
+int test (void *src) {
+  register int w0 asm ("0");
+  // CHECK: call i32 asm "ldr $0, [$1]", "={ax},r,~{dirflag},~{fpsr},~{flags}"(i8* %tmp)
+  asm ("ldr %0, [%1]": "=r" (w0): "r" (src));
+  return w0;
+}
diff --git a/test/CodeGen/2010-06-11-SaveExpr.c b/test/CodeGen/2010-06-11-SaveExpr.c
new file mode 100644
index 0000000..bfe0f35
--- /dev/null
+++ b/test/CodeGen/2010-06-11-SaveExpr.c
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -emit-llvm %s -o -
+// Test case by Eric Postpischil!
+void foo(void)
+{
+  char a[1];
+  int t = 1;
+  ((char (*)[t]) a)[0][0] = 0;
+}
diff --git a/test/CodeGen/2010-06-17-asmcrash.c b/test/CodeGen/2010-06-17-asmcrash.c
new file mode 100644
index 0000000..8e9485b
--- /dev/null
+++ b/test/CodeGen/2010-06-17-asmcrash.c
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -emit-llvm -o - %s | llc -mtriple=x86_64-apple-darwin | FileCheck %s
+// XFAIL: *
+// XTARGET: x86,i386,i686
+
+typedef long long int64_t;
+typedef unsigned char uint8_t;
+typedef int64_t x86_reg;
+
+void avg_pixels8_mmx2(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+{
+	__asm__ volatile("# %0 %1 %2 %3"
+     :"+g"(h), "+S"(pixels), "+D"(block)
+     :"r" ((x86_reg)line_size)         
+     :"%""rax", "memory");
+// CHECK: # %ecx %rsi %rdi %rdx
+ }
diff --git a/test/CodeGen/2010-07-08-DeclDebugLineNo.c b/test/CodeGen/2010-07-08-DeclDebugLineNo.c
new file mode 100644
index 0000000..1637a49
--- /dev/null
+++ b/test/CodeGen/2010-07-08-DeclDebugLineNo.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -emit-llvm -O0 -g %s -o - | FileCheck %s
+// Insure that dbg.declare lines for locals refer to correct line number records.
+// Radar 8152866.
+void foo() {
+  int l = 0;    // line #4: CHECK: {{call.*llvm.dbg.declare.*%l.*\!dbg }}[[variable_l:![0-9]+]]
+  int p = 0;    // line #5: CHECK: {{call.*llvm.dbg.declare.*%p.*\!dbg }}[[variable_p:![0-9]+]]
+}
+// Now match the line number records:
+// CHECK: {{^}}[[variable_l]]{{ = metadata ![{]i32 5,}}
+// CHECK: {{^}}[[variable_p]]{{ = metadata ![{]i32 6,}}
diff --git a/test/CodeGen/2010-07-14-overconservative-align.c b/test/CodeGen/2010-07-14-overconservative-align.c
new file mode 100644
index 0000000..a98a905
--- /dev/null
+++ b/test/CodeGen/2010-07-14-overconservative-align.c
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 %s -triple x86_64-apple-darwin -emit-llvm -o - | FileCheck %s
+// PR 5995
+struct s {
+  int word;
+  struct {
+    int filler __attribute__ ((aligned (8)));
+  };
+};
+
+void func (struct s *s)
+{
+  // CHECK: load %struct.s** %s.addr, align 8
+  s->word = 0;
+}
diff --git a/test/CodeGen/2010-08-12-asm-aggr-arg.c b/test/CodeGen/2010-08-12-asm-aggr-arg.c
new file mode 100644
index 0000000..5ddc412
--- /dev/null
+++ b/test/CodeGen/2010-08-12-asm-aggr-arg.c
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 %s -emit-llvm -O0 -o - | FileCheck %s
+// Radar 8288710: A small aggregate can be passed as an integer.  Make sure
+// we don't get an error with "input constraint with a matching output
+// constraint of incompatible type!" 
+
+struct wrapper {
+  int i;
+};
+
+// CHECK: xyz
+int test(int i) {
+  struct wrapper w;
+  w.i = i;
+  __asm__("xyz" : "=r" (w) : "0" (w));
+  return w.i;
+}
diff --git a/test/CodeGen/2010-12-01-CommonGlobal.c b/test/CodeGen/2010-12-01-CommonGlobal.c
new file mode 100644
index 0000000..5eadbae
--- /dev/null
+++ b/test/CodeGen/2010-12-01-CommonGlobal.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+// Don't crash on a common-linkage constant global.
+extern const int kABSourceTypeProperty;
+int foo(void) {
+  return kABSourceTypeProperty;
+}
+const int kABSourceTypeProperty;
diff --git a/test/CodeGen/2011-02-21-DATA-common.c b/test/CodeGen/2011-02-21-DATA-common.c
new file mode 100644
index 0000000..5079561
--- /dev/null
+++ b/test/CodeGen/2011-02-21-DATA-common.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 -emit-llvm %s -o /dev/null
+struct rtxc_snapshot {
+  int a, b, c, d;
+};
+__attribute__ ((section("__DATA, __common"))) static struct rtxc_snapshot rtxc_log_A[4];
diff --git a/test/CodeGen/2011-03-02-UnionInitializer.c b/test/CodeGen/2011-03-02-UnionInitializer.c
new file mode 100644
index 0000000..3c112e0
--- /dev/null
+++ b/test/CodeGen/2011-03-02-UnionInitializer.c
@@ -0,0 +1,2 @@
+// RUN: %clang_cc1 -emit-llvm %s -o -
+union { int :3; double f; } u17_017 = {17.17};
diff --git a/test/CodeGen/2011-03-08-ZeroFieldUnionInitializer.c b/test/CodeGen/2011-03-08-ZeroFieldUnionInitializer.c
new file mode 100644
index 0000000..bb66d21
--- /dev/null
+++ b/test/CodeGen/2011-03-08-ZeroFieldUnionInitializer.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -emit-llvm %s -o 0
+typedef struct {
+  union {
+    struct { } __attribute((packed));
+  };
+} fenv_t;
+const fenv_t _FE_DFL_ENV = {{{ 0, 0, 0, 0 }}};
diff --git a/test/CodeGen/Atomics.c b/test/CodeGen/Atomics.c
new file mode 100644
index 0000000..4b55595
--- /dev/null
+++ b/test/CodeGen/Atomics.c
@@ -0,0 +1,212 @@
+// Test frontend handling of __sync builtins.
+// Modified from a gcc testcase.
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep atomic | count 172
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep p0i8 | count 43
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep p0i16 | count 43
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep p0i32 | count 43
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep volatile | count 8
+
+// Currently this is implemented only for Alpha, X86, PowerPC.
+// Add your target here if it doesn't work.
+// PPC32 does not translate the long long variants, so fails this test.
+// XFAIL: sparc,arm,powerpc
+
+signed char sc;
+unsigned char uc;
+signed short ss;
+unsigned short us;
+signed int si;
+unsigned int ui;
+signed long long sll;
+unsigned long long ull;
+
+void test_op_ignore (void)
+{
+  (void) __sync_fetch_and_add (&sc, 1);
+  (void) __sync_fetch_and_add (&uc, 1);
+  (void) __sync_fetch_and_add (&ss, 1);
+  (void) __sync_fetch_and_add (&us, 1);
+  (void) __sync_fetch_and_add (&si, 1);
+  (void) __sync_fetch_and_add (&ui, 1);
+  (void) __sync_fetch_and_add (&sll, 1);
+  (void) __sync_fetch_and_add (&ull, 1);
+
+  (void) __sync_fetch_and_sub (&sc, 1);
+  (void) __sync_fetch_and_sub (&uc, 1);
+  (void) __sync_fetch_and_sub (&ss, 1);
+  (void) __sync_fetch_and_sub (&us, 1);
+  (void) __sync_fetch_and_sub (&si, 1);
+  (void) __sync_fetch_and_sub (&ui, 1);
+  (void) __sync_fetch_and_sub (&sll, 1);
+  (void) __sync_fetch_and_sub (&ull, 1);
+
+  (void) __sync_fetch_and_or (&sc, 1);
+  (void) __sync_fetch_and_or (&uc, 1);
+  (void) __sync_fetch_and_or (&ss, 1);
+  (void) __sync_fetch_and_or (&us, 1);
+  (void) __sync_fetch_and_or (&si, 1);
+  (void) __sync_fetch_and_or (&ui, 1);
+  (void) __sync_fetch_and_or (&sll, 1);
+  (void) __sync_fetch_and_or (&ull, 1);
+
+  (void) __sync_fetch_and_xor (&sc, 1);
+  (void) __sync_fetch_and_xor (&uc, 1);
+  (void) __sync_fetch_and_xor (&ss, 1);
+  (void) __sync_fetch_and_xor (&us, 1);
+  (void) __sync_fetch_and_xor (&si, 1);
+  (void) __sync_fetch_and_xor (&ui, 1);
+  (void) __sync_fetch_and_xor (&sll, 1);
+  (void) __sync_fetch_and_xor (&ull, 1);
+
+  (void) __sync_fetch_and_and (&sc, 1);
+  (void) __sync_fetch_and_and (&uc, 1);
+  (void) __sync_fetch_and_and (&ss, 1);
+  (void) __sync_fetch_and_and (&us, 1);
+  (void) __sync_fetch_and_and (&si, 1);
+  (void) __sync_fetch_and_and (&ui, 1);
+  (void) __sync_fetch_and_and (&sll, 1);
+  (void) __sync_fetch_and_and (&ull, 1);
+
+}
+
+void test_fetch_and_op (void)
+{
+  sc = __sync_fetch_and_add (&sc, 11);
+  uc = __sync_fetch_and_add (&uc, 11);
+  ss = __sync_fetch_and_add (&ss, 11);
+  us = __sync_fetch_and_add (&us, 11);
+  si = __sync_fetch_and_add (&si, 11);
+  ui = __sync_fetch_and_add (&ui, 11);
+  sll = __sync_fetch_and_add (&sll, 11);
+  ull = __sync_fetch_and_add (&ull, 11);
+
+  sc = __sync_fetch_and_sub (&sc, 11);
+  uc = __sync_fetch_and_sub (&uc, 11);
+  ss = __sync_fetch_and_sub (&ss, 11);
+  us = __sync_fetch_and_sub (&us, 11);
+  si = __sync_fetch_and_sub (&si, 11);
+  ui = __sync_fetch_and_sub (&ui, 11);
+  sll = __sync_fetch_and_sub (&sll, 11);
+  ull = __sync_fetch_and_sub (&ull, 11);
+
+  sc = __sync_fetch_and_or (&sc, 11);
+  uc = __sync_fetch_and_or (&uc, 11);
+  ss = __sync_fetch_and_or (&ss, 11);
+  us = __sync_fetch_and_or (&us, 11);
+  si = __sync_fetch_and_or (&si, 11);
+  ui = __sync_fetch_and_or (&ui, 11);
+  sll = __sync_fetch_and_or (&sll, 11);
+  ull = __sync_fetch_and_or (&ull, 11);
+
+  sc = __sync_fetch_and_xor (&sc, 11);
+  uc = __sync_fetch_and_xor (&uc, 11);
+  ss = __sync_fetch_and_xor (&ss, 11);
+  us = __sync_fetch_and_xor (&us, 11);
+  si = __sync_fetch_and_xor (&si, 11);
+  ui = __sync_fetch_and_xor (&ui, 11);
+  sll = __sync_fetch_and_xor (&sll, 11);
+  ull = __sync_fetch_and_xor (&ull, 11);
+
+  sc = __sync_fetch_and_and (&sc, 11);
+  uc = __sync_fetch_and_and (&uc, 11);
+  ss = __sync_fetch_and_and (&ss, 11);
+  us = __sync_fetch_and_and (&us, 11);
+  si = __sync_fetch_and_and (&si, 11);
+  ui = __sync_fetch_and_and (&ui, 11);
+  sll = __sync_fetch_and_and (&sll, 11);
+  ull = __sync_fetch_and_and (&ull, 11);
+
+}
+
+void test_op_and_fetch (void)
+{
+  sc = __sync_add_and_fetch (&sc, uc);
+  uc = __sync_add_and_fetch (&uc, uc);
+  ss = __sync_add_and_fetch (&ss, uc);
+  us = __sync_add_and_fetch (&us, uc);
+  si = __sync_add_and_fetch (&si, uc);
+  ui = __sync_add_and_fetch (&ui, uc);
+  sll = __sync_add_and_fetch (&sll, uc);
+  ull = __sync_add_and_fetch (&ull, uc);
+
+  sc = __sync_sub_and_fetch (&sc, uc);
+  uc = __sync_sub_and_fetch (&uc, uc);
+  ss = __sync_sub_and_fetch (&ss, uc);
+  us = __sync_sub_and_fetch (&us, uc);
+  si = __sync_sub_and_fetch (&si, uc);
+  ui = __sync_sub_and_fetch (&ui, uc);
+  sll = __sync_sub_and_fetch (&sll, uc);
+  ull = __sync_sub_and_fetch (&ull, uc);
+
+  sc = __sync_or_and_fetch (&sc, uc);
+  uc = __sync_or_and_fetch (&uc, uc);
+  ss = __sync_or_and_fetch (&ss, uc);
+  us = __sync_or_and_fetch (&us, uc);
+  si = __sync_or_and_fetch (&si, uc);
+  ui = __sync_or_and_fetch (&ui, uc);
+  sll = __sync_or_and_fetch (&sll, uc);
+  ull = __sync_or_and_fetch (&ull, uc);
+
+  sc = __sync_xor_and_fetch (&sc, uc);
+  uc = __sync_xor_and_fetch (&uc, uc);
+  ss = __sync_xor_and_fetch (&ss, uc);
+  us = __sync_xor_and_fetch (&us, uc);
+  si = __sync_xor_and_fetch (&si, uc);
+  ui = __sync_xor_and_fetch (&ui, uc);
+  sll = __sync_xor_and_fetch (&sll, uc);
+  ull = __sync_xor_and_fetch (&ull, uc);
+
+  sc = __sync_and_and_fetch (&sc, uc);
+  uc = __sync_and_and_fetch (&uc, uc);
+  ss = __sync_and_and_fetch (&ss, uc);
+  us = __sync_and_and_fetch (&us, uc);
+  si = __sync_and_and_fetch (&si, uc);
+  ui = __sync_and_and_fetch (&ui, uc);
+  sll = __sync_and_and_fetch (&sll, uc);
+  ull = __sync_and_and_fetch (&ull, uc);
+
+}
+
+void test_compare_and_swap (void)
+{
+  sc = __sync_val_compare_and_swap (&sc, uc, sc);
+  uc = __sync_val_compare_and_swap (&uc, uc, sc);
+  ss = __sync_val_compare_and_swap (&ss, uc, sc);
+  us = __sync_val_compare_and_swap (&us, uc, sc);
+  si = __sync_val_compare_and_swap (&si, uc, sc);
+  ui = __sync_val_compare_and_swap (&ui, uc, sc);
+  sll = __sync_val_compare_and_swap (&sll, uc, sc);
+  ull = __sync_val_compare_and_swap (&ull, uc, sc);
+
+  ui = __sync_bool_compare_and_swap (&sc, uc, sc);
+  ui = __sync_bool_compare_and_swap (&uc, uc, sc);
+  ui = __sync_bool_compare_and_swap (&ss, uc, sc);
+  ui = __sync_bool_compare_and_swap (&us, uc, sc);
+  ui = __sync_bool_compare_and_swap (&si, uc, sc);
+  ui = __sync_bool_compare_and_swap (&ui, uc, sc);
+  ui = __sync_bool_compare_and_swap (&sll, uc, sc);
+  ui = __sync_bool_compare_and_swap (&ull, uc, sc);
+}
+
+void test_lock (void)
+{
+  sc = __sync_lock_test_and_set (&sc, 1);
+  uc = __sync_lock_test_and_set (&uc, 1);
+  ss = __sync_lock_test_and_set (&ss, 1);
+  us = __sync_lock_test_and_set (&us, 1);
+  si = __sync_lock_test_and_set (&si, 1);
+  ui = __sync_lock_test_and_set (&ui, 1);
+  sll = __sync_lock_test_and_set (&sll, 1);
+  ull = __sync_lock_test_and_set (&ull, 1);
+
+  __sync_synchronize ();
+
+  __sync_lock_release (&sc);
+  __sync_lock_release (&uc);
+  __sync_lock_release (&ss);
+  __sync_lock_release (&us);
+  __sync_lock_release (&si);
+  __sync_lock_release (&ui);
+  __sync_lock_release (&sll);
+  __sync_lock_release (&ull);
+}
diff --git a/test/CodeGen/BasicInstrs.c b/test/CodeGen/BasicInstrs.c
new file mode 100644
index 0000000..2b8a6f6
--- /dev/null
+++ b/test/CodeGen/BasicInstrs.c
@@ -0,0 +1,25 @@
+// This file can be used to see what a native C compiler is generating for a
+// variety of interesting operations.
+//
+// RUN: %clang_cc1 -emit-llvm %s -o -
+
+unsigned int udiv(unsigned int X, unsigned int Y) {
+  return X/Y;
+}
+int sdiv(int X, int Y) {
+  return X/Y;
+}
+unsigned int urem(unsigned int X, unsigned int Y) {
+  return X%Y;
+}
+int srem(int X, int Y) {
+  return X%Y;
+}
+
+_Bool setlt(int X, int Y) {
+  return X < Y;
+}
+
+_Bool setgt(int X, int Y) {
+  return X > Y;
+}
diff --git a/test/CodeGen/always-inline.c b/test/CodeGen/always-inline.c
new file mode 100644
index 0000000..dc74be5
--- /dev/null
+++ b/test/CodeGen/always-inline.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep call | not grep foo
+
+void bar() {
+}
+
+inline void __attribute__((__always_inline__)) foo() {
+  bar();
+}
+
+void i_want_bar() {
+  foo();
+}
diff --git a/test/CodeGen/arrayderef.c b/test/CodeGen/arrayderef.c
new file mode 100644
index 0000000..effc0a6
--- /dev/null
+++ b/test/CodeGen/arrayderef.c
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 %s -emit-llvm -O1 -o - | FileCheck %s
+// The load here was getting lost because this code was close
+// enough to the traditional (wrong) implementation of offsetof
+// to confuse the gcc FE.  8629268.
+
+struct foo {
+  int x;
+  int *y;
+};
+
+struct foo Foo[1];
+
+int * bar(unsigned int ix) {
+// CHECK: load
+  return &Foo->y[ix];
+}
diff --git a/test/CodeGen/asm-reg-var-local.c b/test/CodeGen/asm-reg-var-local.c
new file mode 100644
index 0000000..435df2f
--- /dev/null
+++ b/test/CodeGen/asm-reg-var-local.c
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 %s -triple x86_64-apple-darwin -emit-llvm -o - | FileCheck %s
+// Exercise various use cases for local asm "register variables".
+
+int foo() {
+// CHECK: %a = alloca i32
+
+  register int a asm("rsi")=5;
+// CHECK: store i32 5, i32* %a
+
+  asm volatile("; %0 This asm defines rsi" : "=r"(a));
+// CHECK: %0 = call i32 asm sideeffect "; $0 This asm defines rsi", "={rsi},~{dirflag},~{fpsr},~{flags}"()
+// CHECK: store i32 %0, i32* %a
+
+  a = 42;
+// CHECK:  store i32 42, i32* %a
+
+  asm volatile("; %0 This asm uses rsi" : : "r"(a));
+// CHECK:  %tmp = load i32* %a
+// CHECK:  call void asm sideeffect "; $0 This asm uses rsi", "{rsi},~{dirflag},~{fpsr},~{flags}"(i32 %tmp)
+
+  return a;
+// CHECK:  %tmp1 = load i32* %a
+// CHECK:  ret i32 %tmp1
+}
diff --git a/test/CodeGen/attribute_constructor.c b/test/CodeGen/attribute_constructor.c
new file mode 100644
index 0000000..c82c263
--- /dev/null
+++ b/test/CodeGen/attribute_constructor.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | grep llvm.global_ctors
+
+void foo() __attribute__((constructor));
+void foo() {
+  bar();
+}
diff --git a/test/CodeGen/block-copy.c b/test/CodeGen/block-copy.c
new file mode 100644
index 0000000..fba76ad
--- /dev/null
+++ b/test/CodeGen/block-copy.c
@@ -0,0 +1,20 @@
+/* RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+ This should compile into a memcpy from a global, not 128 stores. */
+
+
+
+void foo();
+
+float bar() {
+  float lookupTable[] = {-1,-1,-1,0, -1,-1,0,-1, -1,-1,0,1, -1,-1,1,0,
+			 -1,0,-1,-1, -1,0,-1,1, -1,0,1,-1, -1,0,1,1,
+			 -1,1,-1,0, -1,1,0,-1, -1,1,0,1, -1,1,1,0,
+			 0,-1,-1,-1, 0,-1,-1,1, 0,-1,1,-1, 0,-1,1,1,
+			 1,-1,-1,0, 1,-1,0,-1, 1,-1,0,1, 1,-1,1,0,
+			 1,0,-1,-1, 1,0,-1,1, 1,0,1,-1, 1,0,1,1,
+			 1,1,-1,0, 1,1,0,-1, 1,1,0,1, 1,1,1,0,
+			 0,1,-1,-1, 0,1,-1,1, 0,1,1,-1, 0,1,1,1};
+  // CHECK: memcpy
+  foo(lookupTable);
+}
diff --git a/test/CodeGen/exact-div-expr.c b/test/CodeGen/exact-div-expr.c
new file mode 100644
index 0000000..a2c12a0
--- /dev/null
+++ b/test/CodeGen/exact-div-expr.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - -O1 | grep ashr
+// RUN: %clang_cc1 -emit-llvm %s -o - -O1 | not grep sdiv
+
+long long test(int *A, int *B) {
+  return A-B;
+}
diff --git a/test/CodeGen/extern-weak.c b/test/CodeGen/extern-weak.c
new file mode 100644
index 0000000..6a78a33
--- /dev/null
+++ b/test/CodeGen/extern-weak.c
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -O3 -emit-llvm -o - %s | grep extern_weak
+// RUN: %clang_cc1 -O3 -emit-llvm -o - %s | llc
+
+#if !defined(__linux__) && !defined(__FreeBSD__) && \
+    !defined(__OpenBSD__) && !defined(__CYGWIN__) && !defined(__DragonFly__)
+void foo() __attribute__((weak_import));
+#else
+void foo() __attribute__((weak));
+#endif
+
+void bar() { foo(); }
+
diff --git a/test/CodeGen/func-aligned.c b/test/CodeGen/func-aligned.c
new file mode 100644
index 0000000..f8a4a29
--- /dev/null
+++ b/test/CodeGen/func-aligned.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+// rdar://7270273
+void foo() __attribute__((aligned (64)));
+void foo() {
+// CHECK: define void @foo() {{.*}} align 64
+}
diff --git a/test/CodeGen/funccall.c b/test/CodeGen/funccall.c
new file mode 100644
index 0000000..9735e34
--- /dev/null
+++ b/test/CodeGen/funccall.c
@@ -0,0 +1,17 @@
+
+static int q;
+
+void foo() {
+  int t = q;
+  q = t + 1;
+}
+int main() {
+  q = 0;
+  foo();
+  q = q - 1;
+
+  return q;
+}
+
+// This is the source that corresponds to funccall.ll
+// RUN: echo foo
diff --git a/test/CodeGen/hidden-visibility.c b/test/CodeGen/hidden-visibility.c
new file mode 100644
index 0000000..65e6616
--- /dev/null
+++ b/test/CodeGen/hidden-visibility.c
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+// CHECK: hidden global
+int X __attribute__ ((__visibility__ ("hidden"))) = 123;
diff --git a/test/CodeGen/implicit-arg.c b/test/CodeGen/implicit-arg.c
new file mode 100644
index 0000000..52ab58e
--- /dev/null
+++ b/test/CodeGen/implicit-arg.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 %s -emit-llvm -O0 -o -
+// RUN: %clang_cc1 %s -emit-llvm -O1 -o -
+// rdar://6518089
+
+static int bar();
+void foo() {
+  int a = bar();
+}
+int bar(unsigned a) {
+}
diff --git a/test/CodeGen/libcalls-d.c b/test/CodeGen/libcalls-d.c
new file mode 100644
index 0000000..b375f2b
--- /dev/null
+++ b/test/CodeGen/libcalls-d.c
@@ -0,0 +1,16 @@
+// llvm-gcc -O1+ should run simplify libcalls, O0 shouldn't
+// and -fno-builtins shouldn't.
+// -fno-math-errno should emit an llvm intrinsic, -fmath-errno should not.
+// RUN: %clang_cc1 %s -emit-llvm -fno-math-errno -O0 -o - | grep {call.*exp2\\.f64}
+// RUN: %clang_cc1 %s -emit-llvm -fmath-errno -O0 -o - | grep {call.*exp2}
+// RUN: %clang_cc1 %s -emit-llvm -O1 -o - | grep {call.*ldexp}
+// RUN: %clang_cc1 %s -emit-llvm -O3 -fno-builtin -o - | grep {call.*exp2}
+
+// clang doesn't support this yet.
+// XFAIL: *
+
+double exp2(double);
+
+double t4(unsigned char x) {
+  return exp2(x);
+}
diff --git a/test/CodeGen/libcalls-ld.c b/test/CodeGen/libcalls-ld.c
new file mode 100644
index 0000000..2758761
--- /dev/null
+++ b/test/CodeGen/libcalls-ld.c
@@ -0,0 +1,19 @@
+// llvm-gcc -O1+ should run simplify libcalls, O0 shouldn't
+// and -fno-builtins shouldn't.
+// -fno-math-errno should emit an llvm intrinsic, -fmath-errno should not.
+// RUN: %clang_cc1 %s -emit-llvm -fno-math-errno -O0 -o - | grep {call.*exp2\\..*f}
+// RUN: %clang_cc1 %s -emit-llvm -fmath-errno -O0 -o - | grep {call.*exp2l}
+// RUN: %clang_cc1 %s -emit-llvm -O1 -o - | grep {call.*ldexp}
+// RUN: %clang_cc1 %s -emit-llvm -O3 -fno-builtin -o - | grep {call.*exp2l}
+
+// clang doesn't support this yet.
+// XFAIL: *
+
+// If this fails for you because your target doesn't support long double,
+// please xfail the test.
+
+long double exp2l(long double);
+
+long double t4(unsigned char x) {
+  return exp2l(x);
+}
diff --git a/test/CodeGen/misaligned-param.c b/test/CodeGen/misaligned-param.c
new file mode 100644
index 0000000..53f1f29
--- /dev/null
+++ b/test/CodeGen/misaligned-param.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 %s -triple i386-apple-darwin -emit-llvm -o - | FileCheck %s
+// Misaligned parameter must be memcpy'd to correctly aligned temporary.
+
+struct s { int x; long double y; };
+long double foo(struct s x, int i, struct s y) {
+// CHECK: foo
+// CHECK: %x = alloca %struct.s, align 16
+// CHECK: %y = alloca %struct.s, align 16
+// CHECK: memcpy
+// CHECK: memcpy
+// CHECK: bar
+  return bar(&x, &y);
+}
diff --git a/test/CodeGen/pr2394.c b/test/CodeGen/pr2394.c
new file mode 100644
index 0000000..e43281a
--- /dev/null
+++ b/test/CodeGen/pr2394.c
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+struct __attribute((packed)) x {int a : 24;};
+int a(struct x* g) {
+  // CHECK: load i16
+  // CHECK: load i8
+  return g->a;
+}
diff --git a/test/CodeGen/pr3518.c b/test/CodeGen/pr3518.c
new file mode 100644
index 0000000..f96a5aa
--- /dev/null
+++ b/test/CodeGen/pr3518.c
@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 %s -emit-llvm -O0 -o - | FileCheck %s
+// PR 3518
+// Some of the objects were coming out as unintialized (external) before 3518
+// was fixed.  Internal names are different between llvm-gcc and clang so they
+// are not tested.
+
+extern void abort (void);
+
+// CHECK: @.compoundliteral = internal global %struct.A { i32 1, i32 2 }
+// CHECK: @.compoundliteral1 = internal global %struct.A { i32 3, i32 4 }
+// CHECK: @.compoundliteral2 = internal global %struct.B { %struct.A* @.compoundliteral, %struct.A* @.compoundliteral1 }
+// CHECK: @.compoundliteral3 = internal global %struct.A { i32 5, i32 6 }
+
+struct A { int i; int j; };
+struct B { struct A *a; struct A *b; };
+struct C { struct B *c; struct A *d; };
+struct C e = { &(struct B) { &(struct A) { 1, 2 }, &(struct A) { 3, 4 } }, &(struct A) { 5, 6 } };
+
+int
+main (void)
+{
+  if (e.c->a->i != 1 || e.c->a->j != 2)
+    abort ();
+  if (e.c->b->i != 3 || e.c->b->j != 4)
+    abort ();
+  if (e.d->i != 5 || e.d->j != 6)
+    abort ();
+  return 0;
+}
diff --git a/test/CodeGen/pr4349.c b/test/CodeGen/pr4349.c
new file mode 100644
index 0000000..94b4fbd
--- /dev/null
+++ b/test/CodeGen/pr4349.c
@@ -0,0 +1,38 @@
+// RUN: %clang_cc1 %s -emit-llvm -O0 -o - | FileCheck %s
+// PR 4349
+
+union reg
+{
+    unsigned char b[2][2];
+    unsigned short w[2];
+    unsigned int d;
+};
+struct cpu
+{
+    union reg pc;
+};
+extern struct cpu cpu;
+struct svar
+{
+    void *ptr;
+};
+// CHECK: @svars1 = global [1 x %struct.svar] [%struct.svar { i8* bitcast (%struct.cpu* @cpu to i8*) }]
+struct svar svars1[] =
+{
+    { &((cpu.pc).w[0]) }
+};
+// CHECK: @svars2 = global [1 x %struct.svar] [%struct.svar { i8* getelementptr (i8* bitcast (%struct.cpu* @cpu to i8*), i64 1) }]
+struct svar svars2[] =
+{
+    { &((cpu.pc).b[0][1]) }
+};
+// CHECK: @svars3 = global [1 x %struct.svar] [%struct.svar { i8* getelementptr (i8* bitcast (%struct.cpu* @cpu to i8*), i64 2) }]
+struct svar svars3[] =
+{
+    { &((cpu.pc).w[1]) }
+};
+// CHECK: @svars4 = global [1 x %struct.svar] [%struct.svar { i8* getelementptr (i8* bitcast (%struct.cpu* @cpu to i8*), i64 3) }]
+struct svar svars4[] =
+{
+    { &((cpu.pc).b[1][1]) }
+};
diff --git a/test/CodeGen/pr5406.c b/test/CodeGen/pr5406.c
new file mode 100644
index 0000000..9cf4203
--- /dev/null
+++ b/test/CodeGen/pr5406.c
@@ -0,0 +1,20 @@
+// RUN: %clang_cc1 %s -emit-llvm -O0 -o - | FileCheck %s
+// PR 5406
+
+// XFAIL: *
+// XTARGET: arm
+
+typedef struct { char x[3]; } A0;
+void foo (int i, ...);
+
+
+// CHECK: call void (i32, ...)* @foo(i32 1, i32 {{.*}}) nounwind
+int main (void)
+{
+  A0 a3;
+  a3.x[0] = 0;
+  a3.x[0] = 0;
+  a3.x[2] = 26;
+  foo (1,  a3 );
+  return 0;
+}
diff --git a/test/CodeGen/redef-ext-inline.c b/test/CodeGen/redef-ext-inline.c
new file mode 100644
index 0000000..b8e2f36
--- /dev/null
+++ b/test/CodeGen/redef-ext-inline.c
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - -std=gnu89
+// rdar://7208839
+
+extern inline int f1 (void) {return 1;}
+int f3 (void) {return f1();}
+int f1 (void) {return 0;}
diff --git a/test/CodeGen/sret.c b/test/CodeGen/sret.c
new file mode 100644
index 0000000..ed1f9a4
--- /dev/null
+++ b/test/CodeGen/sret.c
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 %s -emit-llvm -O0 -o - | grep sret | count 5
+
+struct abc {
+ long a;
+ long b;
+ long c;
+};
+ 
+struct abc foo1(void);
+struct abc foo2();
+
+void bar() {
+  struct abc dummy1 = foo1();
+  struct abc dummy2 = foo2();
+}
diff --git a/test/CodeGen/struct-matching-constraint.c b/test/CodeGen/struct-matching-constraint.c
new file mode 100644
index 0000000..0e93eb8
--- /dev/null
+++ b/test/CodeGen/struct-matching-constraint.c
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -emit-llvm -march=armv7a %s 
+
+// XFAIL: *
+// XTARGET: arm
+
+typedef struct __simd128_uint16_t
+{
+  __neon_uint16x8_t val;
+} uint16x8_t;
+
+void b(uint16x8_t sat, uint16x8_t luma)
+{
+  __asm__("vmov.16 %1, %0   \n\t"
+                                           "vtrn.16 %0, %1   \n\t"
+   :"=w"(luma), "=w"(sat)
+   :"0"(luma)
+   );
+
+}
diff --git a/test/CodeGen/unaligned-memcpy.c b/test/CodeGen/unaligned-memcpy.c
new file mode 100644
index 0000000..0373b56
--- /dev/null
+++ b/test/CodeGen/unaligned-memcpy.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 %s -emit-llvm -o -
+
+void bork() {
+  char Qux[33] = {0};
+}
diff --git a/test/CodeGen/union-align.c b/test/CodeGen/union-align.c
new file mode 100644
index 0000000..89a9456
--- /dev/null
+++ b/test/CodeGen/union-align.c
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep load | grep "4 x float" | not grep "align 4"
+// RUN: %clang_cc1 -emit-llvm %s -o - | grep load | grep "4 x float" | grep "align 16"
+// PR3432
+// rdar://6536377
+
+typedef float __m128 __attribute__ ((__vector_size__ (16)));
+
+typedef union
+{
+  int i[4];
+  float f[4];
+  __m128 v;
+} u_t;
+
+__m128 t(u_t *a) {
+  return a->v;
+}
diff --git a/test/CodeGen/vla-2.c b/test/CodeGen/vla-2.c
new file mode 100644
index 0000000..0a74907
--- /dev/null
+++ b/test/CodeGen/vla-2.c
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -std=gnu99 %s -emit-llvm -o - | grep ".*alloca.*align 16"
+
+extern void bar(int[]);
+
+void foo(int a)
+{
+  int var[a] __attribute__((__aligned__(16)));
+  bar(var);
+  return;
+}
diff --git a/test/CodeGen/vla-3.c b/test/CodeGen/vla-3.c
new file mode 100644
index 0000000..4927b46
--- /dev/null
+++ b/test/CodeGen/vla-3.c
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -std=gnu99 %s -emit-llvm -o - | grep ".*alloca.*align 16"
+
+void adr(char *);
+
+void vlaalign(int size)
+{
+    char __attribute__((aligned(16))) tmp[size+32];
+    char tmp2[size+16];
+
+    adr(tmp);
+}
diff --git a/test/CodeGen/weak_constant.c b/test/CodeGen/weak_constant.c
new file mode 100644
index 0000000..726d2ef
--- /dev/null
+++ b/test/CodeGen/weak_constant.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -w -emit-llvm %s -O1 -o - | FileCheck %s
+// Check for bug compatibility with gcc.
+
+const int x __attribute((weak)) = 123;
+
+int* f(void) {
+  return &x;
+}
+
+int g(void) {
+  // CHECK: ret i32 123
+  return *f();
+}