Initial check in of EH/SEH tests

Initial tests included with a rudimentary of harnesses in the SEH directory.
These tests cover stress scenarios for WinEH and are intended to help the
community implement a solution compatible with the runtime.

Author: russellhadley

LICENSE.TXT

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,20 @@
+Microsoft compiler-tests
+========================
+
+Introduction
+------------
+This repo includes selected tests from the Microsoft compiler-tests directory. 
+The initial focus is on exception handling tests, both for C++EH and SEH, to make it easier to test WinEH implementations for compatibility with the platform.  The expectation is that this set of tests will grow and ultimately be added to the LLVM test-suite.  Opening this as a separate repo is intended as a stop gap as the work to get the LLVM test-suite to run clean on Windows progresses.
+
+Supported Platforms
+-------------------
+The first round of tests being opened are EH, the bulk of which are SEH tests.  This is naturally Windows specific.  Additionally only the most rudimentary harness is included (runtests.cmd) due to our objective to move these tests into the LLVM harness.
+
+Quick Start
+-----------
+In the EH sub directory is the C++EH torture test for object destructors.  We have more C++EH tests but there's also a large body of tests out in the community already.  This particular test targets object destructors and is one of the milestone type tests used for validating new EH work.
+In the SEH sub directory is a set of SEH tests.  The sehxxxx.c tests are actually factored out sections of the xcpt4u.c test and are included for convenience of implementers as these cut down tests are easier to debug.  
+
+Next Steps
+----------
+More tests will follow.  If there are particular areas where there are questions please open an issue and we'll see if there are tests that can meet the need.

changes.txt

@@ -0,0 +1,11 @@
+Outline of changes from the old legacy tree to clean up for the open.
+
+all
+- Removed commented out legacy code hooking to the old test.h system.
+- Formated to LLVM style.
+
+xcpt4u.c
+- Cleaned up old comments refering to old products/bug numbers.
+
+ihateeh.cxx
+- Switched main to return int.

eh/ihateeh.cxx

@@ -0,0 +1,199 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for
+// full license information.
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#define FALSE 0
+#define TRUE 1
+#define NO_CTOR_THROW 1
+#define NO_DTOR_THROW 2
+
+#define TEST_DTOR
+
+#define MAX_OBJECTS 500
+
+#define NOEXCEPT(_x)
+
+int Object[MAX_OBJECTS];
+int CurrentObjectNumber, ThrowCount, MaxObjectCount = 1;
+int Fail;
+
+void FAIL(int i) {
+  printf("FAILED on %d\n", i);
+  Fail++;
+}
+
+void dealloc(int i, int no_throw) {
+  /* Make sure i is valid, and object exists */
+  if (i < 0 || i >= MaxObjectCount || !Object[i])
+    FAIL(i);
+
+  Object[i] = 0;
+
+/* Try throw in this dtor.. */
+#ifdef TEST_DTOR
+  if (i + MaxObjectCount == ThrowCount && !no_throw) {
+    printf("Throwing\n");
+    throw(1);
+  }
+#endif
+}
+
+void alloc(int i, int no_throw) {
+  if (CurrentObjectNumber > MaxObjectCount)
+    MaxObjectCount = CurrentObjectNumber;
+
+  /* Object already exists? */
+  if (Object[i])
+    FAIL(i);
+
+  /* Try throw in this ctor.. */
+  if (i == ThrowCount && !no_throw) {
+    printf("Throwing\n");
+    throw(1);
+  }
+
+  if (i >= MAX_OBJECTS) {
+    printf("\n*** Number of objects exceeded.  Increase MAX_OBJECTS ***\n\n");
+    FAIL(i);
+    i = 0;
+  }
+
+  Object[i] = 1;
+}
+
+class B {
+public:
+  int i;
+  int flag;
+  B();
+  B(int);
+  ~B() NOEXCEPT(false);
+};
+
+B::B() {
+  i = CurrentObjectNumber++;
+  printf("B ctor.  i = %d\n", i);
+  alloc(i, FALSE);
+}
+
+B::B(int f) {
+  i = CurrentObjectNumber++;
+  flag = f;
+  printf("B ctor.  i = %d\n", i);
+  alloc(i, flag == NO_CTOR_THROW);
+}
+
+B::~B() NOEXCEPT(false) {
+  printf("B dtor.  i = %d\n", i);
+  dealloc(i, flag == NO_DTOR_THROW);
+}
+
+class A {
+public:
+  int i;
+  A();
+  A(int) {
+    i = CurrentObjectNumber++;
+    printf("A(int) ctor.  i = %d\n", i);
+    alloc(i, FALSE);
+  }
+  A operator+(A a);
+  A(const A &a) {
+    /* Try objects in ctor */
+    B b1 = NO_DTOR_THROW, b2 = NO_DTOR_THROW;
+
+    i = CurrentObjectNumber++;
+    printf("A copy ctor.  i = %d\n", i);
+    alloc(i, FALSE);
+  }
+
+  ~A() NOEXCEPT(false) {
+    /* Try objects in dtor */
+    B b1 = NO_CTOR_THROW, b2 = NO_CTOR_THROW;
+
+    printf("A dtor.  i = %d\n", i);
+    dealloc(i, FALSE);
+  };
+};
+
+A::A() {
+  i = CurrentObjectNumber++;
+  printf("A ctor.  i = %d\n", i);
+  alloc(i, FALSE);
+}
+
+A A::operator+(A a) {
+  printf("A%d + A%d\n", i, a.i);
+  return A();
+}
+
+A foo(A a1, A a2) { return a1 + a2; };
+
+int bar() {
+  A a;
+
+  return 666;
+}
+
+void foo2(int i, A a1, A a2, A a3) {
+  if (i != 666)
+    FAIL(666);
+  foo(a1, a3);
+}
+
+A test() {
+  puts("Try simple ctor");
+  A a1;
+
+  puts("Try question op ctor");
+  A a2 = (ThrowCount & 1) ? A() : ThrowCount;
+
+  puts("Try a more complex question op ctor");
+  A a3 = (ThrowCount & 1) ? A() + a1 + A() + a2 : a2 + A() + A() + ThrowCount;
+
+  puts("Try mbarg copy ctors, and return UDT");
+  A a4 = foo(a1, a2);
+
+  puts("Try a more complex mbarg copy ctors, and a function call");
+  foo2(bar(), a1 + a2, a2 + A() + a3 + a4, a3);
+
+  puts("Try temporary expressions, and return UDT");
+  return a1 + A() + a2 + A() + a3 + a4;
+}
+
+void main() {
+  int i;
+
+  /* Call test(), with a different ctor/dtor throwing each time */
+  for (ThrowCount = 0; ThrowCount < MaxObjectCount * 2; ThrowCount++) {
+    printf("ThrowCount = %d   MaxObjectCount = %d\n", ThrowCount,
+           MaxObjectCount);
+
+    CurrentObjectNumber = 0;
+
+    try {
+      test();
+    } catch (int) {
+      printf("In catch\n");
+    }
+
+    /* Any objects which didn't get dtor'd? */
+    for (i = 0; i < MaxObjectCount; i++) {
+      if (Object[i]) {
+        FAIL(i);
+        Object[i] = 0;
+      }
+    }
+
+    printf("\n");
+  }
+
+  printf("\n");
+  if (Fail)
+    printf("FAILED %d tests\n", Fail);
+  else
+    printf("Passed\n");
+}