[sanitizer_common] Delete some copy/move methods in InternalScopedBuffer

[vsk]

Summary

The copy assignment operator for InternalScopedBuffer hasn't been deleted properly. This patch deletes the {copy, move} {constructors, assignment operators} and does a clang-format.

This came up because I'd like to write code that takes ownership of an InternalScopedString. We'd need some kind of std::move function available in compiler-rt to do this. I rolled a custom one (since #including <utility> isn't allowed?), but would like to gather feedback on the idea before uploading more patches.

[kcc]

LGTM

When sending a patch for review, try to not mix style changes and code changes.

code that takes ownership of an InternalScopedString

I am not sure I want any kind of such complexity in this code, but let's see the patches.

(Also, please stop CC-ing samsonov in code reviews here, he is no longer working on LLVM)

[vsk]

Thanks. I'll be more careful to not include formatting changes.

About the patches for std::move: after reading libcxx's implementation, I think it would take too much additional work to write a portable version for compiler-rt. I no longer think there are enough benefits to doing this.

lib/sanitizer_common/sanitizer_common.h

 void CheckVMASize();
 void RunMallocHooks(const void *ptr, uptr size);
 void RunFreeHooks(const void *ptr);
 
 // InternalScopedBuffer can be used instead of large stack arrays to
 // keep frame size low.
 // FIXME: use InternalAlloc instead of MmapOrDie once
 // InternalAlloc is made libc-free.
-template<typename T>
+template <typename T>
 class InternalScopedBuffer {
  public:
   explicit InternalScopedBuffer(uptr cnt) {
     cnt_ = cnt;
-    ptr_ = (T*)MmapOrDie(cnt * sizeof(T), "InternalScopedBuffer");
-  }
-  ~InternalScopedBuffer() {
-    UnmapOrDie(ptr_, cnt_ * sizeof(T));
+    ptr_ = (T *)MmapOrDie(cnt * sizeof(T), "InternalScopedBuffer");
   }
+  ~InternalScopedBuffer() { UnmapOrDie(ptr_, cnt_ * sizeof(T)); }
   T &operator[](uptr i) { return ptr_[i]; }
   T *data() { return ptr_; }
   uptr size() { return cnt_ * sizeof(T); }
 
  private:
   T *ptr_;
   uptr cnt_;
-  // Disallow evil constructors.
-  InternalScopedBuffer(const InternalScopedBuffer&);
-  void operator=(const InternalScopedBuffer&);
+  // Disallow copies and moves.
+  InternalScopedBuffer(const InternalScopedBuffer &) = delete;
+  InternalScopedBuffer &operator=(const InternalScopedBuffer &) = delete;
+  InternalScopedBuffer(InternalScopedBuffer &&) = delete;
+  InternalScopedBuffer &operator=(InternalScopedBuffer &&) = delete;
 };
 
 class InternalScopedString : public InternalScopedBuffer<char> {
  public:
   explicit InternalScopedString(uptr max_length)
       : InternalScopedBuffer<char>(max_length), length_(0) {
     (*this)[0] = '\0';
   }