Repress sanitization on User dtor.

[nmusgrave]

Summary

In response to bug 24578, reported against failing LLVM test.

Commit ultimately rolled back in rL246484, due to discussion about PR24578. Redundant to repress flaw that is not currently causing any noisy failures, when bug is also filed against it.

[eugenis]

include/llvm/IR/User.h

75 ↗

(On Diff #33122)

Please add a brief comment describing the problem and referencing the bug.

include/llvm/Support/Compiler.h

323 ↗

(On Diff #33122)

There is no "MEMORY_SANITIZER" definition.
Merge this with the block below.
Call it LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE.

[nmusgrave]

• Combined msan macros for simplicity.

[eugenis]

include/llvm/Support/Compiler.h

321 ↗

(On Diff #33133)

No, wait, this is still a MemorySanitizer build. Don't change this macro.

Only the attribute is no-sanitize.

[nmusgrave]

• Simplified sanitization macro.

[eugenis]

include/llvm/IR/Metadata.h

769 ↗

(On Diff #33446)

Maybe move this to MDNode::operator delete, the same as with User?

include/llvm/IR/User.h

76 ↗

(On Diff #33446)

Now this comment does not make sense. Move it to operator delete.

[nmusgrave]

• Moved attribute for repressing msan to operator delete, update comments.

llvm/trunk/include/llvm/IR/User.h

protected:
   /// N BasicBlock* allocated along with N
   void allocHungoffUses(unsigned N, bool IsPhi = false);
 
   /// \brief Grow the number of hung off uses.  Note that allocHungoffUses
   /// should be called if there are no uses.
   void growHungoffUses(unsigned N, bool IsPhi = false);
 
 public:
-  ~User() override {
-  }
+  ~User() override {}
   /// \brief Free memory allocated for User and Use objects.
   void operator delete(void *Usr);
   /// \brief Placement delete - required by std, but never called.
   void operator delete(void*, unsigned) {
     llvm_unreachable("Constructor throws?");
   }
   /// \brief Placement delete - required by std, but never called.
   void operator delete(void*, unsigned, bool) {

llvm/trunk/include/llvm/Support/Compiler.h

 # define LLVM_FUNCTION_NAME __func__
 #endif
 
 /// \macro LLVM_MEMORY_SANITIZER_BUILD
 /// \brief Whether LLVM itself is built with MemorySanitizer instrumentation.
 #if __has_feature(memory_sanitizer)
 # define LLVM_MEMORY_SANITIZER_BUILD 1
 # include <sanitizer/msan_interface.h>
+# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE __attribute__((no_sanitize_memory))
 #else
 # define LLVM_MEMORY_SANITIZER_BUILD 0
 # define __msan_allocated_memory(p, size)
 # define __msan_unpoison(p, size)
+# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE
 #endif
 
 /// \macro LLVM_ADDRESS_SANITIZER_BUILD
 /// \brief Whether LLVM itself is built with AddressSanitizer instrumentation.
 #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
 # define LLVM_ADDRESS_SANITIZER_BUILD 1
 #else
 # define LLVM_ADDRESS_SANITIZER_BUILD 0

llvm/trunk/lib/IR/Metadata.cpp

void *MDNode::operator new(size_t Size, unsigned NumOps) {
   OpSize = RoundUpToAlignment(OpSize, llvm::alignOf<uint64_t>());
   void *Ptr = reinterpret_cast<char *>(::operator new(OpSize + Size)) + OpSize;
   MDOperand *O = static_cast<MDOperand *>(Ptr);
   for (MDOperand *E = O - NumOps; O != E; --O)
     (void)new (O - 1) MDOperand;
   return Ptr;
 }
 
-void MDNode::operator delete(void *Mem) {
+// Repress memory sanitization, due to use-after-destroy by operator
+// delete. Bug report 24578 identifies this issue.
+LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE void MDNode::operator delete(void *Mem) {
   MDNode *N = static_cast<MDNode *>(Mem);
   size_t OpSize = N->NumOperands * sizeof(MDOperand);
   OpSize = RoundUpToAlignment(OpSize, llvm::alignOf<uint64_t>());
 
   MDOperand *O = static_cast<MDOperand *>(Mem);
   for (MDOperand *E = O - N->NumOperands; O != E; --O)
     (O - 1)->~MDOperand();
   ::operator delete(reinterpret_cast<char *>(Mem) - OpSize);

llvm/trunk/lib/IR/User.cpp

void *User::operator new(size_t Size) {
   *HungOffOperandList = nullptr;
   return Obj;
 }
 
 //===----------------------------------------------------------------------===//
 //                         User operator delete Implementation
 //===----------------------------------------------------------------------===//
 
-void User::operator delete(void *Usr) {
+// Repress memory sanitization, due to use-after-destroy by operator
+// delete. Bug report 24578 identifies this issue.
+LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE void User::operator delete(void *Usr) {
   // Hung off uses use a single Use* before the User, while other subclasses
   // use a Use[] allocated prior to the user.
   User *Obj = static_cast<User *>(Usr);
   if (Obj->HasHungOffUses) {
     Use **HungOffOperandList = static_cast<Use **>(Usr) - 1;
     // drop the hung off uses.
     Use::zap(*HungOffOperandList, *HungOffOperandList + Obj->NumUserOperands,
              /* Delete */ true);