llvm/compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector1.cpp

//===-- sanitizer_deadlock_detector1.cpp ----------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Deadlock detector implementation based on NxN adjacency bit matrix.
//
//===----------------------------------------------------------------------===//

#include "sanitizer_deadlock_detector_interface.h"
#include "sanitizer_deadlock_detector.h"
#include "sanitizer_allocator_internal.h"
#include "sanitizer_placement_new.h"
#include "sanitizer_mutex.h"

#if SANITIZER_DEADLOCK_DETECTOR_VERSION == 1

namespace __sanitizer {

DDBV;  // DeadlockDetector's bit vector.

struct DDPhysicalThread { … };

struct DDLogicalThread { … };

struct DD final : public DDetector { … };

DDetector *DDetector::Create(const DDFlags *flags) { … }

DD::DD(const DDFlags *flags)
    : … { … }

DDPhysicalThread* DD::CreatePhysicalThread() { … }

void DD::DestroyPhysicalThread(DDPhysicalThread *pt) { … }

DDLogicalThread* DD::CreateLogicalThread(u64 ctx) { … }

void DD::DestroyLogicalThread(DDLogicalThread *lt) { … }

void DD::MutexInit(DDCallback *cb, DDMutex *m) { … }

void DD::MutexEnsureID(DDLogicalThread *lt, DDMutex *m) { … }

void DD::MutexBeforeLock(DDCallback *cb,
    DDMutex *m, bool wlock) { … }

void DD::ReportDeadlock(DDCallback *cb, DDMutex *m) { … }

void DD::MutexAfterLock(DDCallback *cb, DDMutex *m, bool wlock, bool trylock) { … }

void DD::MutexBeforeUnlock(DDCallback *cb, DDMutex *m, bool wlock) { … }

void DD::MutexDestroy(DDCallback *cb,
    DDMutex *m) { … }

DDReport *DD::GetReport(DDCallback *cb) { … }

} // namespace __sanitizer
#endif // #if SANITIZER_DEADLOCK_DETECTOR_VERSION == 1