Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Support/UniqueLock.h
Line
Count
Source (jump to first uncovered line)
1
//===- Support/UniqueLock.h - Acquire/Release Mutex In Scope ----*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This file defines a guard for a block of code that ensures a Mutex is locked
10
// upon construction and released upon destruction.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_SUPPORT_UNIQUE_LOCK_H
15
#define LLVM_SUPPORT_UNIQUE_LOCK_H
16
17
#include <cassert>
18
19
namespace llvm {
20
21
  /// A pared-down imitation of std::unique_lock from C++11. Contrary to the
22
  /// name, it's really more of a wrapper for a lock. It may or may not have
23
  /// an associated mutex, which is guaranteed to be locked upon creation
24
  /// and unlocked after destruction. unique_lock can also unlock the mutex
25
  /// and re-lock it freely during its lifetime.
26
  /// Guard a section of code with a mutex.
27
  template<typename MutexT>
28
  class unique_lock {
29
    MutexT *M = nullptr;
30
    bool locked = false;
31
32
  public:
33
292k
    unique_lock() = default;
34
37
    explicit unique_lock(MutexT &m) : M(&m), locked(true) { M->lock(); }
35
    unique_lock(const unique_lock &) = delete;
36
     unique_lock &operator=(const unique_lock &) = delete;
37
38
6
    void operator=(unique_lock &&o) {
39
6
      if (owns_lock())
40
0
        M->unlock();
41
6
      M = o.M;
42
6
      locked = o.locked;
43
6
      o.M = nullptr;
44
6
      o.locked = false;
45
6
    }
46
47
292k
    ~unique_lock() { if (owns_lock()) 
M->unlock()6
; }
48
49
    void lock() {
50
      assert(!locked && "mutex already locked!");
51
      assert(M && "no associated mutex!");
52
      M->lock();
53
      locked = true;
54
    }
55
56
    void unlock() {
57
      assert(locked && "unlocking a mutex that isn't locked!");
58
      assert(M && "no associated mutex!");
59
      M->unlock();
60
      locked = false;
61
    }
62
63
292k
    bool owns_lock() { return locked; }
64
  };
65
66
} // end namespace llvm
67
68
#endif // LLVM_SUPPORT_UNIQUE_LOCK_H