[Sanitizers] Export aligned new/delete from runtimes.

[alekseyshl]

Summary

Export aligned new/delete to make dynamic runtimes work again.

Remove all valid new/delete cases from ASan test, there's a test in
common for that.

compiler-rt/trunk/lib/sanitizer_common/scripts/gen_dynamic_list.py

 import sys
 import platform
 
 new_delete = set([
                   '_Znam', '_ZnamRKSt9nothrow_t',    # operator new[](unsigned long)
                   '_Znwm', '_ZnwmRKSt9nothrow_t',    # operator new(unsigned long)
                   '_Znaj', '_ZnajRKSt9nothrow_t',    # operator new[](unsigned int)
                   '_Znwj', '_ZnwjRKSt9nothrow_t',    # operator new(unsigned int)
+                  # operator new(unsigned long, std::align_val_t)
+                  '_ZnwmSt11align_val_t', '_ZnwmSt11align_val_tRKSt9nothrow_t',
+                  # operator new(unsigned int, std::align_val_t)
+                  '_ZnwjSt11align_val_t', '_ZnwjSt11align_val_tRKSt9nothrow_t',
+                  # operator new[](unsigned long, std::align_val_t)
+                  '_ZnamSt11align_val_t', '_ZnamSt11align_val_tRKSt9nothrow_t',
+                  # operator new[](unsigned int, std::align_val_t)
+                  '_ZnajSt11align_val_t', '_ZnajSt11align_val_tRKSt9nothrow_t',
                   '_ZdaPv', '_ZdaPvRKSt9nothrow_t',  # operator delete[](void *)
                   '_ZdlPv', '_ZdlPvRKSt9nothrow_t',  # operator delete(void *)
                   '_ZdaPvm',                         # operator delete[](void*, unsigned long)
                   '_ZdlPvm',                         # operator delete(void*, unsigned long)
                   '_ZdaPvj',                         # operator delete[](void*, unsigned int)
                   '_ZdlPvj',                         # operator delete(void*, unsigned int)
+                  # operator delete(void*, std::align_val_t)
+                  '_ZdlPvSt11align_val_t', '_ZdlPvSt11align_val_tRKSt9nothrow_t',
+                  # operator delete[](void*, std::align_val_t)
+                  '_ZdaPvSt11align_val_t', '_ZdaPvSt11align_val_tRKSt9nothrow_t',
+                  # operator delete(void*, unsigned long,  std::align_val_t)
+                  '_ZdlPvmSt11align_val_t',
+                  # operator delete[](void*, unsigned long, std::align_val_t)
+                  '_ZdaPvmSt11align_val_t',
+                  # operator delete(void*, unsigned int,  std::align_val_t)
+                  '_ZdlPvjSt11align_val_t',
+                  # operator delete[](void*, unsigned int, std::align_val_t)
+                  '_ZdaPvjSt11align_val_t',
                   ])
 
 versioned_functions = set(['memcpy', 'pthread_attr_getaffinity_np',
                            'pthread_cond_broadcast',
                            'pthread_cond_destroy', 'pthread_cond_init',
                            'pthread_cond_signal', 'pthread_cond_timedwait',
                            'pthread_cond_wait', 'realpath',
                            'sched_getaffinity'])

compiler-rt/trunk/test/asan/TestCases/Linux/aligned_delete_test.cc

 // RUN: %clangxx_asan -std=c++1z -faligned-allocation -fsanitize-recover=address -O0 %s -o %t
 // RUN: %env_asan_opts=new_delete_type_mismatch=1:halt_on_error=false:detect_leaks=false %run %t 2>&1 | FileCheck %s
 // RUN: %env_asan_opts=new_delete_type_mismatch=0                                        %run %t
 
 // RUN: %clangxx_asan -std=c++1z -faligned-allocation -fsized-deallocation -fsanitize-recover=address -O0 %s -o %t
 // RUN: %env_asan_opts=new_delete_type_mismatch=1:halt_on_error=false:detect_leaks=false %run %t 2>&1 | FileCheck %s
 // RUN: %env_asan_opts=new_delete_type_mismatch=0                                        %run %t
 
-// REQUIRES: asan-static-runtime
-
 #include <stdio.h>
 
 // Define all new/delete to do not depend on the version provided by the
-// plaform. The implementation is provided by ASan anyway.
+// platform. The implementation is provided by ASan anyway.
 
 namespace std {
 struct nothrow_t {};
 static const nothrow_t nothrow;
 enum class align_val_t : size_t {};
 }  // namespace std
 
 void *operator new(size_t);

 struct S12 { int a, b, c; };
 struct alignas(128) S12_128 { int a, b, c; };
 struct alignas(256) S12_256 { int a, b, c; };
 struct alignas(512) S1024_512 { char a[1024]; };
 struct alignas(1024) S1024_1024 { char a[1024]; };
 
 
 int main(int argc, char **argv) {
-  fprintf(stderr, "Testing valid cases\n");
-
-  delete break_optimization(new S12);
-  operator delete(break_optimization(new S12), std::nothrow);
-  delete [] break_optimization(new S12[100]);
-  operator delete[](break_optimization(new S12[100]), std::nothrow);
-
-  delete break_optimization(new S12_128);
-  operator delete(break_optimization(new S12_128),
-                  std::align_val_t(alignof(S12_128)));
-  operator delete(break_optimization(new S12_128),
-                  std::align_val_t(alignof(S12_128)), std::nothrow);
-  operator delete(break_optimization(new S12_128), sizeof(S12_128),
-                  std::align_val_t(alignof(S12_128)));
-
-  delete [] break_optimization(new S12_128[100]);
-  operator delete[](break_optimization(new S12_128[100]),
-                    std::align_val_t(alignof(S12_128)));
-  operator delete[](break_optimization(new S12_128[100]),
-                    std::align_val_t(alignof(S12_128)), std::nothrow);
-  operator delete[](break_optimization(new S12_128[100]), sizeof(S12_128[100]),
-                    std::align_val_t(alignof(S12_128)));
-
-  fprintf(stderr, "Done\n");
-  // CHECK: Testing valid cases
-  // CHECK-NEXT: Done
-
-  // Explicit mismatched calls.
+  // Check the mismatched calls only, all the valid cases are verified in
+  // test/sanitizer_common/TestCases/Linux/new_delete_test.cc.
 
   operator delete(break_optimization(new S12_128), std::nothrow);
   // CHECK: AddressSanitizer: new-delete-type-mismatch
   // CHECK:  object passed to delete has wrong type:
   // CHECK:  alignment of the allocated type:   128 bytes;
   // CHECK:  alignment of the deallocated type: default-aligned.
   // CHECK: SUMMARY: AddressSanitizer: new-delete-type-mismatch
 

compiler-rt/trunk/test/sanitizer_common/TestCases/Linux/new_delete_test.cc

 // RUN: %clangxx -std=c++1z -faligned-allocation -O0 %s -o %t && %run %t
 // RUN: %clangxx -std=c++1z -faligned-allocation -fsized-deallocation -O0 %s -o %t && %run %t
 
-// ubsan does not intercept new/delete, adnroid is to be fixed.
-// UNSUPPORTED: ubsan,android
+// ubsan does not intercept new/delete.
+// UNSUPPORTED: ubsan
 
 // Check that all new/delete variants are defined and work with supported
 // sanitizers. Sanitizer-specific failure modes tests are supposed to go to
 // the particular sanitizier's test suites.
 
 #include <cstddef>
 
 // Define all new/delete to do not depend on the version provided by the
-// plaform. The implementation is provided by the sanitizer anyway.
+// platform. The implementation is provided by the sanitizer anyway.
 
 namespace std {
 struct nothrow_t {};
 static const nothrow_t nothrow;
 enum class align_val_t : size_t {};
 }  // namespace std
 
 void *operator new(size_t);