Apply modernize-use-default to compiler-rt.

[angelgarcia]

Summary

Replace empty bodies of default constructors and destructors with '= default'.

[bkramer]

lg with comments.

lib/tsan/rtl/tsan_mutex.cc

130 ↗

(On Diff #37864)

Please keep the comments.

lib/tsan/rtl/tsan_report.cc

71 ↗

(On Diff #37864)

dito

[angelgarcia]

Put comments back.

compiler-rt/trunk/lib/asan/asan_fake_stack.h

public:
   uptr stack_size_log() const { return stack_size_log_; }
 
   void HandleNoReturn();
   void GC(uptr real_stack);
 
   void ForEachFakeFrame(RangeIteratorCallback callback, void *arg);
 
  private:
-  FakeStack() { }
+  FakeStack() = default;
   static const uptr kFlagsOffset = 4096;  // This is were the flags begin.
   // Must match the number of uses of DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID
   COMPILER_CHECK(kNumberOfSizeClasses == 11);
   static const uptr kMaxStackMallocSize = 1 << kMaxStackFrameSizeLog;
 
   uptr hint_position_[kNumberOfSizeClasses];
   uptr stack_size_log_;
   // a bit is set if something was allocated from the corresponding size class.

compiler-rt/trunk/lib/msan/msan_allocator.h

 struct MsanThreadLocalMallocStorage {
   uptr quarantine_cache[16];
   // Allocator cache contains atomic_uint64_t which must be 8-byte aligned.
   ALIGNED(8) uptr allocator_cache[96 * (512 * 8 + 16)];  // Opaque.
   void CommitBack();
 
  private:
   // These objects are allocated via mmap() and are zero-initialized.
-  MsanThreadLocalMallocStorage() {}
+  MsanThreadLocalMallocStorage() = default;
 };
 
 } // namespace __msan
 #endif // MSAN_ALLOCATOR_H

compiler-rt/trunk/lib/sanitizer_common/sanitizer_bitvector.h

public:
   }
 
   // for (BasicBitVector<>::Iterator it(bv); it.hasNext();) {
   //   uptr idx = it.next();
   //   use(idx);
   // }
   class Iterator {
    public:
-    Iterator() { }
+    Iterator() = default;
     explicit Iterator(const BasicBitVector &bv) : bv_(bv) {}
     bool hasNext() const { return !bv_.empty(); }
     uptr next() { return bv_.getAndClearFirstOne(); }
     void clear() { bv_.clear(); }
    private:
     BasicBitVector bv_;
   };
 
public:
   }
 
   // for (TwoLevelBitVector<>::Iterator it(bv); it.hasNext();) {
   //   uptr idx = it.next();
   //   use(idx);
   // }
   class Iterator {
    public:
-    Iterator() { }
+    Iterator() = default;
     explicit Iterator(const TwoLevelBitVector &bv) : bv_(bv), i0_(0), i1_(0) {
       it1_.clear();
       it2_.clear();
     }
 
     bool hasNext() const {
       if (it1_.hasNext()) return true;
       for (uptr i = i0_; i < kLevel1Size; i++)

compiler-rt/trunk/lib/tsan/rtl/tsan_clock.h

struct ClockBlock {
   static const uptr kTableSize = kSize / sizeof(u32);
   static const uptr kClockCount = kSize / sizeof(ClockElem);
 
   union {
     u32       table[kTableSize];
     ClockElem clock[kClockCount];
   };
 
-  ClockBlock() {
-  }
+  ClockBlock() = default;
 };
 
 typedef DenseSlabAlloc<ClockBlock, 1<<16, 1<<10> ClockAlloc;
 typedef DenseSlabAllocCache ClockCache;
 
 // The clock that lives in sync variables (mutexes, atomics, etc).
 class SyncClock {
  public:

compiler-rt/trunk/lib/tsan/rtl/tsan_mutex.cc

for (int i = 0; i < N; i++) {
     if (CanLockAdj2[i][i]) {
       Printf("Mutex %d participates in a cycle\n", i);
       Die();
     }
   }
 #endif
 }
 
-InternalDeadlockDetector::InternalDeadlockDetector() {
-  // Rely on zero initialization because some mutexes can be locked before ctor.
-}
+InternalDeadlockDetector::InternalDeadlockDetector() = default;
 
 #if SANITIZER_DEBUG && !SANITIZER_GO
 void InternalDeadlockDetector::Lock(MutexType t) {
   // Printf("LOCK %d @%zu\n", t, seq_ + 1);
   CHECK_GT(t, MutexTypeInvalid);
   CHECK_LT(t, MutexTypeCount);
   u64 max_seq = 0;
   u64 max_idx = MutexTypeInvalid;

compiler-rt/trunk/lib/tsan/rtl/tsan_report.cc

ReportDesc::ReportDesc()
     , sleep()
     , count() {
 }
 
 ReportMop::ReportMop()
     : mset(MBlockReportMutex) {
 }
 
-ReportDesc::~ReportDesc() {
-  // FIXME(dvyukov): it must be leaking a lot of memory.
-}
+ReportDesc::~ReportDesc() = default;
 
 #ifndef SANITIZER_GO
 
 const int kThreadBufSize = 32;
 const char *thread_name(char *buf, int tid) {
   if (tid == 0)
     return "main thread";
   internal_snprintf(buf, kThreadBufSize, "thread T%d", tid);

compiler-rt/trunk/lib/tsan/rtl/tsan_rtl_thread.cc

ThreadContext::ThreadContext(int tid)
   : ThreadContextBase(tid)
   , thr()
   , sync()
   , epoch0()
   , epoch1() {
 }
 
 #ifndef SANITIZER_GO
-ThreadContext::~ThreadContext() {
-}
+ThreadContext::~ThreadContext() = default;
 #endif
 
 void ThreadContext::OnDead() {
   CHECK_EQ(sync.size(), 0);
 }
 
 void ThreadContext::OnJoined(void *arg) {
   ThreadState *caller_thr = static_cast<ThreadState *>(arg);

compiler-rt/trunk/lib/ubsan/ubsan_diag.h

enum ArgKind {
     AK_UInt,   ///< An unsigned integer argument.
     AK_SInt,   ///< A signed integer argument.
     AK_Float,  ///< A floating-point argument.
     AK_Pointer ///< A pointer argument, displayed in hexadecimal.
   };
 
   /// An individual diagnostic message argument.
   struct Arg {
-    Arg() {}
+    Arg() = default;
     Arg(const char *String) : Kind(AK_String), String(String) {}
     Arg(TypeName TN) : Kind(AK_TypeName), String(TN.getName()) {}
     Arg(UIntMax UInt) : Kind(AK_UInt), UInt(UInt) {}
     Arg(SIntMax SInt) : Kind(AK_SInt), SInt(SInt) {}
     Arg(FloatMax Float) : Kind(AK_Float), Float(Float) {}
     Arg(const void *Pointer) : Kind(AK_Pointer), Pointer(Pointer) {}
 
     ArgKind Kind;