[hwasan] Add definitions for missing operator delete functions

[mcgrathr]

lgtm

[mcgrathr]

This indicates a lack of testing coverage for the runtime. We should add runtime tests that use all the allocator signatures explicitly.

[leonardchan]

In D144030#4126713, @mcgrathr wrote:

This indicates a lack of testing coverage for the runtime. We should add runtime tests that use all the allocator signatures explicitly.

Added tests for the suite of operator new/delete functions. I'll give it a day to see if anyone else has comments before landing.

[vitalybuka]

@kstoimenov Can be this the cause of false leaks?

[thakis]

As far as I can tell this doesn't build: http://45.33.8.238/linux/99657/step_10.txt

[dyung]

It also failed with a similar error on our bot https://lab.llvm.org/buildbot/#/builders/247/builds/1627

compiler-rt/lib/hwasan/hwasan_new_delete.cpp

 INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
     void *ptr, std::nothrow_t const &) {
   OPERATOR_DELETE_BODY;
 }
 INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
     void *ptr, std::nothrow_t const &) {
   OPERATOR_DELETE_BODY;
 }
+INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
+    void *ptr, size_t) NOEXCEPT {
+  OPERATOR_DELETE_BODY;
+}
+INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
+    void *ptr, size_t) NOEXCEPT {
+  OPERATOR_DELETE_BODY;
+}
 
 #endif  // OPERATOR_NEW_BODY
 
 #ifdef OPERATOR_NEW_ALIGN_BODY
 
 namespace std {
 enum class align_val_t : size_t {};
 }  // namespace std

 INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
     void *ptr, std::align_val_t, std::nothrow_t const &) NOEXCEPT {
   OPERATOR_DELETE_BODY;
 }
 INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
     void *ptr, std::align_val_t, std::nothrow_t const &) NOEXCEPT {
   OPERATOR_DELETE_BODY;
 }
+INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete(
+    void *ptr, size_t, std::align_val_t, std::nothrow_t const &) NOEXCEPT {
+  OPERATOR_DELETE_BODY;
+}
+INTERCEPTOR_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void operator delete[](
+    void *ptr, size_t, std::align_val_t, std::nothrow_t const &) NOEXCEPT {
+  OPERATOR_DELETE_BODY;
+}
 
 #endif  // OPERATOR_NEW_ALIGN_BODY

compiler-rt/test/hwasan/TestCases/new-test.cpp

 // Test basic new functionality.
 // RUN: %clangxx_hwasan -std=c++17 %s -o %t
 // RUN: %run %t
 
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
 #include <new>
 #include <sanitizer/allocator_interface.h>
 #include <sanitizer/hwasan_interface.h>
 
+void operator_new_delete(size_t size) {
+  void *alloc = operator new(size);
+  assert(alloc != nullptr);
+  assert(__sanitizer_get_allocated_size(alloc) == size);
+  operator delete(alloc);
+
+  alloc = operator new(size);
+  assert(alloc != nullptr);
+  assert(__sanitizer_get_allocated_size(alloc) == size);
+  operator delete(alloc, size);
+}
+
+void operator_new_delete_array(size_t size) {
+  void *alloc = operator new[](size);
+  assert(alloc != nullptr);
+  assert(__sanitizer_get_allocated_size(alloc) == size);
+  operator delete[](alloc);
+
+  alloc = operator new[](size);
+  assert(alloc != nullptr);
+  assert(__sanitizer_get_allocated_size(alloc) == size);
+  operator delete[](alloc, size);
+}
+
+void operator_new_delete(size_t size, std::align_val_t align) {
+  void *alloc = operator new(size, align);
+  assert(alloc != nullptr);
+  assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
+  assert(__sanitizer_get_allocated_size(alloc) >= size);
+  operator delete(alloc, align);
+
+  alloc = operator new(size, align);
+  assert(alloc != nullptr);
+  assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
+  assert(__sanitizer_get_allocated_size(alloc) >= size);
+  operator delete(alloc, size, align);
+}
+
+void operator_new_delete_array(size_t size, std::align_val_t align) {
+  void *alloc = operator new[](size, align);
+  assert(alloc != nullptr);
+  assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
+  assert(__sanitizer_get_allocated_size(alloc) >= size);
+  operator delete[](alloc, align);
+
+  alloc = operator new[](size, align);
+  assert(alloc != nullptr);
+  assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
+  assert(__sanitizer_get_allocated_size(alloc) >= size);
+  operator delete[](alloc, size, align);
+}
+
+void operator_new_delete(size_t size, const std::nothrow_t &tag) {
+  void *alloc = operator new(size, tag);
+  assert(alloc != nullptr);
+  assert(__sanitizer_get_allocated_size(alloc) == size);
+  operator delete(alloc, tag);
+}
+
+void operator_new_delete_array(size_t size, const std::nothrow_t &tag) {
+  void *alloc = operator new[](size, tag);
+  assert(alloc != nullptr);
+  assert(__sanitizer_get_allocated_size(alloc) == size);
+  operator delete[](alloc, tag);
+}
+
+void operator_new_delete(size_t size, std::align_val_t align, const std::nothrow_t &tag) {
+  void *alloc = operator new(size, align, tag);
+  assert(alloc != nullptr);
+  assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
+  assert(__sanitizer_get_allocated_size(alloc) >= size);
+  operator delete(alloc, align, tag);
+}
+
+void operator_new_delete_array(size_t size, std::align_val_t align, const std::nothrow_t &tag) {
+  void *alloc = operator new[](size, align, tag);
+  assert(alloc != nullptr);
+  assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
+  assert(__sanitizer_get_allocated_size(alloc) >= size);
+  operator delete[](alloc, align, tag);
+}
+
+void operator_new_delete(size_t size, void *ptr) {
+  void *alloc = operator new(size, ptr);
+  assert(alloc == ptr);
+  operator delete(alloc, ptr);
+}
+
+void operator_new_delete_array(size_t size, void *ptr) {
+  void *alloc = operator new[](size, ptr);
+  assert(alloc == ptr);
+  operator delete[](alloc, ptr);
+}
+
 int main() {
   __hwasan_enable_allocator_tagging();
 
   size_t volatile n = 0;
   char *a1 = new char[n];
   assert(a1 != nullptr);
   assert(__sanitizer_get_allocated_size(a1) == 1);
   delete[] a1;
 
+  constexpr size_t kSize = 8;
+  operator_new_delete(kSize);
+  operator_new_delete_array(kSize);
+  operator_new_delete(kSize, std::nothrow);
+  operator_new_delete_array(kSize, std::nothrow);
+
+  char buffer[kSize];
+  operator_new_delete(kSize, buffer);
+  operator_new_delete_array(kSize, buffer);
+
 #if defined(__cpp_aligned_new) &&                                              \
     (!defined(__GLIBCXX__) ||                                                  \
      (defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE >= 7))
   // Aligned new/delete
   constexpr auto kAlign = std::align_val_t{8};
   void *a2 = ::operator new(4, kAlign);
   assert(a2 != nullptr);
   assert(reinterpret_cast<uintptr_t>(a2) % static_cast<uintptr_t>(kAlign) == 0);
   assert(__sanitizer_get_allocated_size(a2) >= 4);
   ::operator delete(a2, kAlign);
+
+  operator_new_delete(kSize, std::align_val_t{kSize});
+  operator_new_delete_array(kSize, std::align_val_t{kSize});
+  operator_new_delete(kSize, std::align_val_t{kSize * 2});
+  operator_new_delete_array(kSize, std::align_val_t{kSize * 2});
+  operator_new_delete(kSize, std::align_val_t{kSize}, std::nothrow);
+  operator_new_delete_array(kSize, std::align_val_t{kSize}, std::nothrow);
+  operator_new_delete(kSize, std::align_val_t{kSize * 2}, std::nothrow);
+  operator_new_delete_array(kSize, std::align_val_t{kSize * 2}, std::nothrow);
 #endif
 }