Function push_lock

src/sync.cpp:152–194

template <typename MutexType>
static void push_lock(MutexType* c, const CLockLocation& locklocation)
{
    constexpr bool is_recursive_mutex =
        std::is_base_of<RecursiveMutex, MutexType>::value ||
        std::is_base_of<std::recursive_mutex, MutexType>::value;

    LockData& lockdata = GetLockData();
    std::lock_guard<std::mutex> lock(lockdata.dd_mutex);

    LockStack& lock_stack = lockdata.m_lock_stacks[std::this_thread::get_id()];
    lock_stack.emplace_back(c, locklocation);
    for (size_t j = 0; j < lock_stack.size() - 1; ++j) {
        const LockStackItem& i = lock_stack[j];
        if (i.first == c) {
            if (is_recursive_mutex) {
                break;
            }
            // It is not a recursive mutex and it appears in the stack two times:
            // at position `j` and at the end (which we added just before this loop).
            // Can't allow locking the same (non-recursive) mutex two times from the
            // same thread as that results in an undefined behavior.
            auto lock_stack_copy = lock_stack;
            lock_stack.pop_back();
            double_lock_detected(c, lock_stack_copy);
            // double_lock_detected() does not return.
        }

        const LockPair p1 = std::make_pair(i.first, c);
        if (lockdata.lockorders.count(p1))
            continue;

        const LockPair p2 = std::make_pair(c, i.first);
        if (lockdata.lockorders.count(p2)) {
            auto lock_stack_copy = lock_stack;
            lock_stack.pop_back();
            potential_deadlock_detected(p1, lockdata.lockorders[p2], lock_stack_copy);
            // potential_deadlock_detected() does not return.
        }

        lockdata.lockorders.emplace(p1, lock_stack);
        lockdata.invlockorders.insert(p2);
    }
}

static void pop_lock()
{