[lldb-dev] [Lldb-commits] [lldb] r277011 - Clean up vestigial remnants of locking primitives
Todd Fiala via lldb-dev
lldb-dev at lists.llvm.org
Thu Jul 28 10:52:34 PDT 2016
clang: error: no such file or directory: '/Volumes/Data/src/
lldb-llvm.org/lldb/source/Host/common/Condition.cpp'
clang: error: no input files
$ find . -name Condition.cpp
$
On Thu, Jul 28, 2016 at 10:49 AM, Todd Fiala <todd.fiala at gmail.com> wrote:
> Hi Saleem,
>
> It looks like you're missing Condition.cpp from your checkin @277011? Can
> you add it?
>
> -Todd
>
> On Thu, Jul 28, 2016 at 10:32 AM, Saleem Abdulrasool via lldb-commits <
> lldb-commits at lists.llvm.org> wrote:
>
>> Author: compnerd
>> Date: Thu Jul 28 12:32:20 2016
>> New Revision: 277011
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=277011&view=rev
>> Log:
>> Clean up vestigial remnants of locking primitives
>>
>> This finally removes the use of the Mutex and Condition classes. This is
>> an
>> intricate patch as the Mutex and Condition classes were tied together.
>> Furthermore, many places had slightly differing uses of time values.
>> Convert
>> timeout values to relative everywhere to permit the use of
>> std::chrono::duration, which is required for the use of
>> std::condition_variable's timeout. Adjust all Condition and related Mutex
>> classes over to std::{,recursive_}mutex and std::condition_variable.
>>
>> This change primarily comes at the cost of breaking the TracingMutex
>> which was
>> based around the Mutex class. It would be possible to write a wrapper to
>> provide similar functionality, but that is beyond the scope of this
>> change.
>>
>> Removed:
>> lldb/trunk/include/lldb/Host/Condition.h
>> lldb/trunk/include/lldb/Host/Mutex.h
>> lldb/trunk/source/Host/common/Condition.cpp
>> lldb/trunk/source/Host/common/Mutex.cpp
>> lldb/trunk/source/Host/windows/Condition.cpp
>> lldb/trunk/source/Host/windows/Mutex.cpp
>> Modified:
>> lldb/trunk/include/lldb/Core/Event.h
>> lldb/trunk/include/lldb/Core/Listener.h
>> lldb/trunk/include/lldb/Core/ThreadSafeDenseMap.h
>> lldb/trunk/include/lldb/Core/ThreadSafeDenseSet.h
>> lldb/trunk/include/lldb/Host/Editline.h
>> lldb/trunk/include/lldb/Host/Predicate.h
>> lldb/trunk/include/lldb/Host/ProcessRunLock.h
>> lldb/trunk/include/lldb/Target/Process.h
>> lldb/trunk/source/API/SBListener.cpp
>> lldb/trunk/source/Core/Communication.cpp
>> lldb/trunk/source/Core/Debugger.cpp
>> lldb/trunk/source/Core/Listener.cpp
>> lldb/trunk/source/Host/CMakeLists.txt
>> lldb/trunk/source/Host/common/Host.cpp
>> lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp
>>
>> lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h
>> lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp
>> lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
>> lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h
>> lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
>>
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
>>
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
>>
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
>>
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
>> lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
>> lldb/trunk/source/Target/Process.cpp
>> lldb/trunk/source/Target/Target.cpp
>>
>> Modified: lldb/trunk/include/lldb/Core/Event.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/Event.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/include/lldb/Core/Event.h (original)
>> +++ lldb/trunk/include/lldb/Core/Event.h Thu Jul 28 12:32:20 2016
>> @@ -12,6 +12,7 @@
>>
>> // C Includes
>> // C++ Includes
>> +#include <chrono>
>> #include <memory>
>> #include <string>
>>
>> @@ -141,7 +142,8 @@ public:
>> }
>>
>> bool
>> - WaitForEventReceived (const TimeValue *abstime = nullptr, bool
>> *timed_out = nullptr)
>> + WaitForEventReceived(const std::chrono::microseconds &abstime =
>> std::chrono::microseconds(0),
>> + bool *timed_out = nullptr)
>> {
>> return m_predicate.WaitForValueEqualTo(true, abstime, timed_out);
>> }
>>
>> Modified: lldb/trunk/include/lldb/Core/Listener.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/Listener.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/include/lldb/Core/Listener.h (original)
>> +++ lldb/trunk/include/lldb/Core/Listener.h Thu Jul 28 12:32:20 2016
>> @@ -12,6 +12,7 @@
>>
>> // C Includes
>> // C++ Includes
>> +#include <chrono>
>> #include <list>
>> #include <map>
>> #include <mutex>
>> @@ -21,8 +22,6 @@
>> // Other libraries and framework includes
>> // Project includes
>> #include "lldb/lldb-private.h"
>> -#include "lldb/Core/Broadcaster.h"
>> -#include "lldb/Host/Condition.h"
>> #include "lldb/Core/Event.h"
>>
>> namespace lldb_private {
>> @@ -87,19 +86,15 @@ public:
>>
>> // Returns true if an event was received, false if we timed out.
>> bool
>> - WaitForEvent (const TimeValue *timeout,
>> - lldb::EventSP &event_sp);
>> + WaitForEvent(const std::chrono::microseconds &timeout, lldb::EventSP
>> &event_sp);
>>
>> bool
>> - WaitForEventForBroadcaster (const TimeValue *timeout,
>> - Broadcaster *broadcaster,
>> - lldb::EventSP &event_sp);
>> + WaitForEventForBroadcaster(const std::chrono::microseconds &timeout,
>> Broadcaster *broadcaster,
>> + lldb::EventSP &event_sp);
>>
>> bool
>> - WaitForEventForBroadcasterWithType (const TimeValue *timeout,
>> - Broadcaster *broadcaster,
>> - uint32_t event_type_mask,
>> - lldb::EventSP &event_sp);
>> + WaitForEventForBroadcasterWithType(const std::chrono::microseconds
>> &timeout, Broadcaster *broadcaster,
>> + uint32_t event_type_mask,
>> lldb::EventSP &event_sp);
>>
>> Event *
>> PeekAtNextEvent ();
>> @@ -151,13 +146,10 @@ private:
>> typedef std::vector<lldb::BroadcasterManagerWP>
>> broadcaster_manager_collection;
>>
>> bool
>> - FindNextEventInternal(Mutex::Locker& lock,
>> + FindNextEventInternal(std::unique_lock<std::mutex> &lock,
>> Broadcaster *broadcaster, // nullptr for any
>> broadcaster
>> const ConstString *sources, // nullptr for any
>> event
>> - uint32_t num_sources,
>> - uint32_t event_type_mask,
>> - lldb::EventSP &event_sp,
>> - bool remove);
>> + uint32_t num_sources, uint32_t
>> event_type_mask, lldb::EventSP &event_sp, bool remove);
>>
>> bool
>> GetNextEventInternal(Broadcaster *broadcaster, // nullptr for any
>> broadcaster
>> @@ -167,19 +159,17 @@ private:
>> lldb::EventSP &event_sp);
>>
>> bool
>> - WaitForEventsInternal(const TimeValue *timeout,
>> + WaitForEventsInternal(const std::chrono::microseconds &timeout,
>> Broadcaster *broadcaster, // nullptr for any
>> broadcaster
>> const ConstString *sources, // nullptr for any
>> event
>> - uint32_t num_sources,
>> - uint32_t event_type_mask,
>> - lldb::EventSP &event_sp);
>> + uint32_t num_sources, uint32_t
>> event_type_mask, lldb::EventSP &event_sp);
>>
>> std::string m_name;
>> broadcaster_collection m_broadcasters;
>> std::recursive_mutex m_broadcasters_mutex; // Protects m_broadcasters
>> event_collection m_events;
>> - Mutex m_events_mutex; // Protects m_broadcasters and m_events
>> - Condition m_events_condition;
>> + std::mutex m_events_mutex; // Protects m_broadcasters and m_events
>> + std::condition_variable m_events_condition;
>> broadcaster_manager_collection m_broadcaster_managers;
>>
>> void
>>
>> Modified: lldb/trunk/include/lldb/Core/ThreadSafeDenseMap.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/ThreadSafeDenseMap.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/include/lldb/Core/ThreadSafeDenseMap.h (original)
>> +++ lldb/trunk/include/lldb/Core/ThreadSafeDenseMap.h Thu Jul 28 12:32:20
>> 2016
>> @@ -12,46 +12,41 @@
>>
>> // C Includes
>> // C++ Includes
>> +#include <mutex>
>>
>> // Other libraries and framework includes
>> #include "llvm/ADT/DenseMap.h"
>>
>> // Project includes
>> -#include "lldb/Host/Mutex.h"
>>
>> namespace lldb_private {
>>
>> -template <typename _KeyType, typename _ValueType>
>> +template <typename _KeyType, typename _ValueType, typename _MutexType =
>> std::mutex>
>> class ThreadSafeDenseMap
>> {
>> public:
>> typedef llvm::DenseMap<_KeyType,_ValueType> LLVMMapType;
>> -
>> - ThreadSafeDenseMap(unsigned map_initial_capacity = 0,
>> - Mutex::Type mutex_type = Mutex::eMutexTypeNormal)
>> :
>> - m_map(map_initial_capacity),
>> - m_mutex(mutex_type)
>> - {
>> - }
>> -
>> +
>> + ThreadSafeDenseMap(unsigned map_initial_capacity = 0) :
>> m_map(map_initial_capacity), m_mutex() {}
>> +
>> void
>> Insert (_KeyType k, _ValueType v)
>> {
>> - Mutex::Locker locker(m_mutex);
>> + std::lock_guard<_MutexType> guard(m_mutex);
>> m_map.insert(std::make_pair(k,v));
>> }
>>
>> void
>> Erase (_KeyType k)
>> {
>> - Mutex::Locker locker(m_mutex);
>> + std::lock_guard<_MutexType> guard(m_mutex);
>> m_map.erase(k);
>> }
>>
>> _ValueType
>> Lookup (_KeyType k)
>> {
>> - Mutex::Locker locker(m_mutex);
>> + std::lock_guard<_MutexType> guard(m_mutex);
>> return m_map.lookup(k);
>> }
>>
>> @@ -59,7 +54,7 @@ public:
>> Lookup (_KeyType k,
>> _ValueType& v)
>> {
>> - Mutex::Locker locker(m_mutex);
>> + std::lock_guard<_MutexType> guard(m_mutex);
>> auto iter = m_map.find(k),
>> end = m_map.end();
>> if (iter == end)
>> @@ -71,13 +66,13 @@ public:
>> void
>> Clear ()
>> {
>> - Mutex::Locker locker(m_mutex);
>> + std::lock_guard<_MutexType> guard(m_mutex);
>> m_map.clear();
>> }
>>
>> protected:
>> LLVMMapType m_map;
>> - Mutex m_mutex;
>> + _MutexType m_mutex;
>> };
>>
>> } // namespace lldb_private
>>
>> Modified: lldb/trunk/include/lldb/Core/ThreadSafeDenseSet.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/ThreadSafeDenseSet.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/include/lldb/Core/ThreadSafeDenseSet.h (original)
>> +++ lldb/trunk/include/lldb/Core/ThreadSafeDenseSet.h Thu Jul 28 12:32:20
>> 2016
>> @@ -12,61 +12,56 @@
>>
>> // C Includes
>> // C++ Includes
>> +#include <mutex>
>>
>> // Other libraries and framework includes
>> #include "llvm/ADT/DenseSet.h"
>>
>> // Project includes
>> -#include "lldb/Host/Mutex.h"
>>
>> namespace lldb_private {
>> -
>> - template <typename _ElementType>
>> - class ThreadSafeDenseSet
>> +
>> +template <typename _ElementType, typename _MutexType = std::mutex>
>> +class ThreadSafeDenseSet
>> +{
>> +public:
>> + typedef llvm::DenseSet<_ElementType> LLVMSetType;
>> +
>> + ThreadSafeDenseSet(unsigned set_initial_capacity = 0) :
>> m_set(set_initial_capacity), m_mutex() {}
>> +
>> + void
>> + Insert(_ElementType e)
>> {
>> - public:
>> - typedef llvm::DenseSet<_ElementType> LLVMSetType;
>> -
>> - ThreadSafeDenseSet(unsigned set_initial_capacity = 0,
>> - Mutex::Type mutex_type =
>> Mutex::eMutexTypeNormal) :
>> - m_set(set_initial_capacity),
>> - m_mutex(mutex_type)
>> - {
>> - }
>> -
>> - void
>> - Insert (_ElementType e)
>> - {
>> - Mutex::Locker locker(m_mutex);
>> - m_set.insert(e);
>> - }
>> -
>> - void
>> - Erase (_ElementType e)
>> - {
>> - Mutex::Locker locker(m_mutex);
>> - m_set.erase(e);
>> - }
>> -
>> - bool
>> - Lookup (_ElementType e)
>> - {
>> - Mutex::Locker locker(m_mutex);
>> - return (m_set.count(e) > 0);
>> - }
>> -
>> - void
>> - Clear ()
>> - {
>> - Mutex::Locker locker(m_mutex);
>> - m_set.clear();
>> - }
>> -
>> - protected:
>> - LLVMSetType m_set;
>> - Mutex m_mutex;
>> - };
>> -
>> + std::lock_guard<_MutexType> guard(m_mutex);
>> + m_set.insert(e);
>> + }
>> +
>> + void
>> + Erase(_ElementType e)
>> + {
>> + std::lock_guard<_MutexType> guard(m_mutex);
>> + m_set.erase(e);
>> + }
>> +
>> + bool
>> + Lookup(_ElementType e)
>> + {
>> + std::lock_guard<_MutexType> guard(m_mutex);
>> + return (m_set.count(e) > 0);
>> + }
>> +
>> + void
>> + Clear()
>> + {
>> + stds::lock_guard<_MutexType> guard(m_mutex);
>> + m_set.clear();
>> + }
>> +
>> +protected:
>> + LLVMSetType m_set;
>> + _MutexType m_mutex;
>> +};
>> +
>> } // namespace lldb_private
>>
>> #endif // liblldb_ThreadSafeDenseSet_h_
>>
>> Removed: lldb/trunk/include/lldb/Host/Condition.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Host/Condition.h?rev=277010&view=auto
>>
>> ==============================================================================
>> --- lldb/trunk/include/lldb/Host/Condition.h (original)
>> +++ lldb/trunk/include/lldb/Host/Condition.h (removed)
>> @@ -1,123 +0,0 @@
>> -//===-- Condition.h ---------------------------------------------*- C++
>> -*-===//
>> -//
>> -// The LLVM Compiler Infrastructure
>> -//
>> -// This file is distributed under the University of Illinois Open Source
>> -// License. See LICENSE.TXT for details.
>> -//
>>
>> -//===----------------------------------------------------------------------===//
>> -
>> -#ifndef liblldb_Condition_h_
>> -#define liblldb_Condition_h_
>> -
>> -// C Includes
>> -// C++ Includes
>> -// Other libraries and framework includes
>> -// Project includes
>> -#include "lldb/lldb-types.h"
>> -#include "lldb/Host/Mutex.h"
>> -
>> -namespace lldb_private {
>> -
>> -class TimeValue;
>> -
>> -//----------------------------------------------------------------------
>> -/// @class Condition Condition.h "lldb/Host/Condition.h"
>> -/// @brief A C++ wrapper class for pthread condition variables.
>> -///
>> -/// A class that wraps up a pthread condition (pthread_cond_t). The
>> -/// class will create a pthread condition when an instance is
>> -/// constructed, and destroy it when it is destructed. It also provides
>> -/// access to the standard pthread condition calls.
>> -//----------------------------------------------------------------------
>> -class Condition
>> -{
>> -public:
>> - //------------------------------------------------------------------
>> - /// Default constructor
>> - ///
>> - /// The default constructor will initialize a new pthread condition
>> - /// and maintain the condition in the object state.
>> - //------------------------------------------------------------------
>> - Condition ();
>> -
>> - //------------------------------------------------------------------
>> - /// Destructor
>> - ///
>> - /// Destroys the pthread condition that the object owns.
>> - //------------------------------------------------------------------
>> - ~Condition ();
>> -
>> - //------------------------------------------------------------------
>> - /// Unblock all threads waiting for a condition variable
>> - ///
>> - /// @return
>> - /// The return value from \c pthread_cond_broadcast()
>> - //------------------------------------------------------------------
>> - int
>> - Broadcast ();
>> -
>> - //------------------------------------------------------------------
>> - /// Unblocks one thread waiting for the condition variable
>> - ///
>> - /// @return
>> - /// The return value from \c pthread_cond_signal()
>> - //------------------------------------------------------------------
>> - int
>> - Signal ();
>> -
>> - //------------------------------------------------------------------
>> - /// Wait for the condition variable to be signaled.
>> - ///
>> - /// The Wait() function atomically blocks the current thread
>> - /// waiting on this object's condition variable, and unblocks
>> - /// \a mutex. The waiting thread unblocks only after another thread
>> - /// signals or broadcasts this object's condition variable.
>> - ///
>> - /// If \a abstime is non-nullptr, this function will return when the
>> - /// system time reaches the time specified in \a abstime if the
>> - /// condition variable doesn't get unblocked. If \a abstime is
>> nullptr
>> - /// this function will wait for an infinite amount of time for the
>> - /// condition variable to be unblocked.
>> - ///
>> - /// The current thread re-acquires the lock on \a mutex following
>> - /// the wait.
>> - ///
>> - /// @param[in] mutex
>> - /// The mutex to use in the \c pthread_cond_timedwait() or
>> - /// \c pthread_cond_wait() calls.
>> - ///
>> - /// @param[in] abstime
>> - /// An absolute time at which to stop waiting if non-nullptr,
>> else
>> - /// wait an infinite amount of time for the condition variable
>> - /// toget signaled.
>> - ///
>> - /// @param[out] timed_out
>> - /// If not nullptr, will be set to true if the wait timed out,
>> and
>> - // false otherwise.
>> - ///
>> - /// @see Condition::Broadcast()
>> - /// @see Condition::Signal()
>> - //------------------------------------------------------------------
>> - int
>> - Wait(Mutex &mutex, const TimeValue *abstime = nullptr, bool
>> *timed_out = nullptr);
>> -
>> -protected:
>> - //------------------------------------------------------------------
>> - // Member variables
>> - //------------------------------------------------------------------
>> - lldb::condition_t m_condition; ///< The condition variable.
>> -
>> - //------------------------------------------------------------------
>> - /// Get accessor to the pthread condition object.
>> - ///
>> - /// @return
>> - /// A pointer to the condition variable owned by this object.
>> - //------------------------------------------------------------------
>> - lldb::condition_t *
>> - GetCondition ();
>> -};
>> -
>> -} // namespace lldb_private
>> -
>> -#endif // liblldb_Condition_h_
>>
>> Modified: lldb/trunk/include/lldb/Host/Editline.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Host/Editline.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/include/lldb/Host/Editline.h (original)
>> +++ lldb/trunk/include/lldb/Host/Editline.h Thu Jul 28 12:32:20 2016
>> @@ -54,7 +54,6 @@
>> #include <string>
>> #include <vector>
>>
>> -#include "lldb/Host/Condition.h"
>> #include "lldb/Host/ConnectionFileDescriptor.h"
>> #include "lldb/Host/FileSpec.h"
>> #include "lldb/Host/Predicate.h"
>>
>> Removed: lldb/trunk/include/lldb/Host/Mutex.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Host/Mutex.h?rev=277010&view=auto
>>
>> ==============================================================================
>> --- lldb/trunk/include/lldb/Host/Mutex.h (original)
>> +++ lldb/trunk/include/lldb/Host/Mutex.h (removed)
>> @@ -1,313 +0,0 @@
>> -//===-- Mutex.h -------------------------------------------------*- C++
>> -*-===//
>> -//
>> -// The LLVM Compiler Infrastructure
>> -//
>> -// This file is distributed under the University of Illinois Open Source
>> -// License. See LICENSE.TXT for details.
>> -//
>>
>> -//===----------------------------------------------------------------------===//
>> -
>> -#ifndef liblldb_Mutex_h_
>> -#define liblldb_Mutex_h_
>> -
>> -// C Includes
>> -// C++ Includes
>> -#ifdef LLDB_CONFIGURATION_DEBUG
>> -#include <string>
>> -#endif
>> -
>> -// Other libraries and framework includes
>> -// Project includes
>> -#include "lldb/lldb-types.h"
>> -
>> -namespace lldb_private {
>> -
>> -//----------------------------------------------------------------------
>> -/// @class Mutex Mutex.h "lldb/Host/Mutex.h"
>> -/// @brief A C++ wrapper class for pthread mutexes.
>> -//----------------------------------------------------------------------
>> -class Mutex
>> -{
>> -public:
>> - friend class Locker;
>> - friend class Condition;
>> -
>> - enum Type
>> - {
>> - eMutexTypeNormal, ///< Mutex that can't recursively
>> entered by the same thread
>> - eMutexTypeRecursive ///< Mutex can be recursively entered by
>> the same thread
>> - };
>> -
>> - //------------------------------------------------------------------
>> - /// @class Mutex::Locker
>> - ///
>> - /// A scoped locking class that allows a variety of pthread mutex
>> - /// objects to have a mutex locked when an Mutex::Locker
>> - /// object is created, and unlocked when it goes out of scope or
>> - /// when the Mutex::Locker::Reset(pthread_mutex_t *)
>> - /// is called. This provides an exception safe way to lock a mutex
>> - /// in a scope.
>> - //------------------------------------------------------------------
>> - class Locker
>> - {
>> - public:
>> - //--------------------------------------------------------------
>> - /// Default constructor.
>> - ///
>> - /// This will create a scoped mutex locking object that doesn't
>> - /// have a mutex to lock. One will need to be provided using the
>> - /// Mutex::Locker::Reset(pthread_mutex_t *) method.
>> - ///
>> - /// @see Mutex::Locker::Reset(pthread_mutex_t *)
>> - //--------------------------------------------------------------
>> - Locker();
>> -
>> - //--------------------------------------------------------------
>> - /// Constructor with a Mutex object.
>> - ///
>> - /// This will create a scoped mutex locking object that extracts
>> - /// the mutex owned by \a m and locks it.
>> - ///
>> - /// @param[in] m
>> - /// An instance of a Mutex object that contains a
>> - /// valid mutex object.
>> - //--------------------------------------------------------------
>> - Locker(Mutex& m);
>> -
>> - //--------------------------------------------------------------
>> - /// Constructor with a Mutex object pointer.
>> - ///
>> - /// This will create a scoped mutex locking object that extracts
>> - /// the mutex owned by a m and locks it.
>> - ///
>> - /// @param[in] m
>> - /// A pointer to instance of a Mutex object that
>> - /// contains a valid mutex object.
>> - //--------------------------------------------------------------
>> - Locker(Mutex* m);
>> -
>> - //--------------------------------------------------------------
>> - /// Destructor
>> - ///
>> - /// Unlocks any valid pthread_mutex_t that this object may
>> - /// contain.
>> - //--------------------------------------------------------------
>> - ~Locker();
>> -
>> - //--------------------------------------------------------------
>> - /// Change the contained mutex.
>> - ///
>> - /// Unlock the current mutex in this object (if it contains a
>> - /// valid mutex) and lock the new \a mutex object if it is
>> - /// non-nullptr.
>> - //--------------------------------------------------------------
>> - void
>> - Lock (Mutex &mutex);
>> -
>> - void
>> - Lock (Mutex *mutex)
>> - {
>> - if (mutex)
>> - Lock(*mutex);
>> - }
>> -
>> - //--------------------------------------------------------------
>> - /// Change the contained mutex only if the mutex can be locked.
>> - ///
>> - /// Unlock the current mutex in this object (if it contains a
>> - /// valid mutex) and try to lock \a mutex. If \a mutex can be
>> - /// locked this object will take ownership of the lock and will
>> - /// unlock it when it goes out of scope or Reset or TryLock are
>> - /// called again. If the mutex is already locked, this object
>> - /// will not take ownership of the mutex.
>> - ///
>> - /// @return
>> - /// Returns \b true if the lock was acquired and the this
>> - /// object will unlock the mutex when it goes out of scope,
>> - /// returns \b false otherwise.
>> - //--------------------------------------------------------------
>> - bool
>> - TryLock(Mutex &mutex, const char *failure_message = nullptr);
>> -
>> - bool
>> - TryLock(Mutex *mutex, const char *failure_message = nullptr)
>> - {
>> - if (mutex)
>> - return TryLock(*mutex, failure_message);
>> - else
>> - return false;
>> - }
>> -
>> - void
>> - Unlock ();
>> -
>> - protected:
>> - //--------------------------------------------------------------
>> - /// Member variables
>> - //--------------------------------------------------------------
>> - Mutex *m_mutex_ptr;
>> -
>> - private:
>> - Locker(const Locker&);
>> - const Locker& operator=(const Locker&);
>> - };
>> -
>> - //------------------------------------------------------------------
>> - /// Default constructor.
>> - ///
>> - /// Creates a pthread mutex with no attributes.
>> - //------------------------------------------------------------------
>> - Mutex();
>> -
>> - //------------------------------------------------------------------
>> - /// Default constructor.
>> - ///
>> - /// Creates a pthread mutex with \a type as the mutex type.
>> - /// Valid values for \a type include:
>> - /// @li Mutex::Type::eMutexTypeNormal
>> - /// @li Mutex::Type::eMutexTypeRecursive
>> - ///
>> - /// @param[in] type
>> - /// The type of the mutex.
>> - ///
>> - /// @see ::pthread_mutexattr_settype()
>> - //------------------------------------------------------------------
>> - Mutex(Mutex::Type type);
>> -
>> - //------------------------------------------------------------------
>> - /// Destructor.
>> - ///
>> - /// Destroys the mutex owned by this object.
>> - //------------------------------------------------------------------
>> -#ifdef LLDB_CONFIGURATION_DEBUG
>> - virtual
>> -#endif
>> - ~Mutex();
>> -
>> - //------------------------------------------------------------------
>> - /// Lock the mutex.
>> - ///
>> - /// Locks the mutex owned by this object. If the mutex is already
>> - /// locked, the calling thread will block until the mutex becomes
>> - /// available.
>> - ///
>> - /// @return
>> - /// The error code from \c pthread_mutex_lock().
>> - //------------------------------------------------------------------
>> -#ifdef LLDB_CONFIGURATION_DEBUG
>> - virtual
>> -#endif
>> - int
>> - Lock();
>> -
>> - //------------------------------------------------------------------
>> - /// Try to lock the mutex.
>> - ///
>> - /// Attempts to lock the mutex owned by this object without blocking.
>> - /// If the mutex is already locked, TryLock() will not block waiting
>> - /// for the mutex, but will return an error condition.
>> - ///
>> - /// @return
>> - /// The error code from \c pthread_mutex_trylock().
>> - //------------------------------------------------------------------
>> -#ifdef LLDB_CONFIGURATION_DEBUG
>> - virtual
>> -#endif
>> - int
>> - TryLock(const char *failure_message = nullptr);
>> -
>> - //------------------------------------------------------------------
>> - /// Unlock the mutex.
>> - ///
>> - /// If the current thread holds the lock on the owned mutex, then
>> - /// Unlock() will unlock the mutex. Calling Unlock() on this object
>> - /// when the calling thread does not hold the lock will result in
>> - /// undefined behavior.
>> - ///
>> - /// @return
>> - /// The error code from \c pthread_mutex_unlock().
>> - //------------------------------------------------------------------
>> -#ifdef LLDB_CONFIGURATION_DEBUG
>> - virtual
>> -#endif
>> - int
>> - Unlock();
>> -
>> -protected:
>> - //------------------------------------------------------------------
>> - // Member variables
>> - //------------------------------------------------------------------
>> - // TODO: Hide the mutex in the implementation file in case we ever
>> need to port to an
>> - // architecture that doesn't have pthread mutexes.
>> - lldb::mutex_t m_mutex; ///< The OS mutex object.
>> -
>> -private:
>> - //------------------------------------------------------------------
>> - /// Mutex get accessor.
>> - ///
>> - /// @return
>> - /// A pointer to the pthread mutex object owned by this object.
>> - //------------------------------------------------------------------
>> - lldb::mutex_t *
>> - GetMutex();
>> -
>> - Mutex(const Mutex&);
>> - const Mutex& operator=(const Mutex&);
>> -};
>> -
>> -#ifdef LLDB_CONFIGURATION_DEBUG
>> -class TrackingMutex : public Mutex
>> -{
>> -public:
>> - TrackingMutex() : Mutex() {}
>> - TrackingMutex(Mutex::Type type) : Mutex (type) {}
>> -
>> - virtual
>> - ~TrackingMutex() = default;
>> -
>> - virtual int
>> - Unlock ();
>> -
>> - virtual int
>> - TryLock(const char *failure_message = nullptr)
>> - {
>> - int return_value = Mutex::TryLock();
>> - if (return_value != 0 && failure_message != nullptr)
>> - {
>> - m_failure_message.assign(failure_message);
>> - m_thread_that_tried = pthread_self();
>> - }
>> - return return_value;
>> - }
>> -
>> -protected:
>> - pthread_t m_thread_that_tried;
>> - std::string m_failure_message;
>> -};
>> -
>> -class LoggingMutex : public Mutex
>> -{
>> -public:
>> - LoggingMutex() : Mutex(),m_locked(false) {}
>> - LoggingMutex(Mutex::Type type) : Mutex (type),m_locked(false) {}
>> -
>> - virtual
>> - ~LoggingMutex() = default;
>> -
>> - virtual int
>> - Lock ();
>> -
>> - virtual int
>> - Unlock ();
>> -
>> - virtual int
>> - TryLock(const char *failure_message = nullptr);
>> -
>> -protected:
>> - bool m_locked;
>> -};
>> -#endif // LLDB_CONFIGURATION_DEBUG
>> -
>> -} // namespace lldb_private
>> -
>> -#endif // liblldb_Mutex_h_
>>
>> Modified: lldb/trunk/include/lldb/Host/Predicate.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Host/Predicate.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/include/lldb/Host/Predicate.h (original)
>> +++ lldb/trunk/include/lldb/Host/Predicate.h Thu Jul 28 12:32:20 2016
>> @@ -15,11 +15,12 @@
>> #include <time.h>
>>
>> // C++ Includes
>> +#include <condition_variable>
>> +#include <mutex>
>> +
>> // Other libraries and framework includes
>> // Project includes
>> #include "lldb/lldb-defines.h"
>> -#include "lldb/Host/Mutex.h"
>> -#include "lldb/Host/Condition.h"
>>
>> //#define DB_PTHREAD_LOG_EVENTS
>>
>> @@ -97,7 +98,7 @@ public:
>> T
>> GetValue () const
>> {
>> - Mutex::Locker locker(m_mutex);
>> + std::lock_guard<std::mutex> guard(m_mutex);
>> T value = m_value;
>> return value;
>> }
>> @@ -120,7 +121,7 @@ public:
>> void
>> SetValue (T value, PredicateBroadcastType broadcast_type)
>> {
>> - Mutex::Locker locker(m_mutex);
>> + std::lock_guard<std::mutex> guard(m_mutex);
>> #ifdef DB_PTHREAD_LOG_EVENTS
>> printf("%s (value = 0x%8.8x, broadcast_type = %i)\n",
>> __FUNCTION__, value, broadcast_type);
>> #endif
>> @@ -148,7 +149,7 @@ public:
>> void
>> SetValueBits (T bits, PredicateBroadcastType broadcast_type)
>> {
>> - Mutex::Locker locker(m_mutex);
>> + std::lock_guard<std::mutex> guard(m_mutex);
>> #ifdef DB_PTHREAD_LOG_EVENTS
>> printf("%s (bits = 0x%8.8x, broadcast_type = %i)\n",
>> __FUNCTION__, bits, broadcast_type);
>> #endif
>> @@ -176,7 +177,7 @@ public:
>> void
>> ResetValueBits (T bits, PredicateBroadcastType broadcast_type)
>> {
>> - Mutex::Locker locker(m_mutex);
>> + std::lock_guard<std::mutex> guard(m_mutex);
>> #ifdef DB_PTHREAD_LOG_EVENTS
>> printf("%s (bits = 0x%8.8x, broadcast_type = %i)\n",
>> __FUNCTION__, bits, broadcast_type);
>> #endif
>> @@ -213,21 +214,30 @@ public:
>> /// occurred.
>> //------------------------------------------------------------------
>> T
>> - WaitForSetValueBits(T bits, const TimeValue *abstime = nullptr)
>> + WaitForSetValueBits(T bits, const std::chrono::microseconds &timeout
>> = std::chrono::microseconds(0))
>> {
>> - int err = 0;
>> // pthread_cond_timedwait() or pthread_cond_wait() will
>> atomically
>> // unlock the mutex and wait for the condition to be set. When
>> either
>> // function returns, they will re-lock the mutex. We use an auto
>> lock/unlock
>> - // class (Mutex::Locker) to allow us to return at any point in
>> this
>> + // class (std::lock_guard) to allow us to return at any point in
>> this
>> // function and not have to worry about unlocking the mutex.
>> - Mutex::Locker locker(m_mutex);
>> + std::unique_lock<std::mutex> lock(m_mutex);
>> #ifdef DB_PTHREAD_LOG_EVENTS
>> - printf("%s (bits = 0x%8.8x, abstime = %p), m_value = 0x%8.8x\n",
>> __FUNCTION__, bits, abstime, m_value);
>> + printf("%s (bits = 0x%8.8x, timeout = %llu), m_value =
>> 0x%8.8x\n", __FUNCTION__, bits, timeout.count(),
>> + m_value);
>> #endif
>> - while (err == 0 && ((m_value & bits) == 0))
>> + while ((m_value & bits) == 0)
>> {
>> - err = m_condition.Wait (m_mutex, abstime);
>> + if (timeout == std::chrono::microseconds(0))
>> + {
>> + m_condition.wait(lock);
>> + }
>> + else
>> + {
>> + std::cv_status result = m_condition.wait_for(lock,
>> timeout);
>> + if (result == std::cv_status::timeout)
>> + break;
>> + }
>> }
>> #ifdef DB_PTHREAD_LOG_EVENTS
>> printf("%s (bits = 0x%8.8x), m_value = 0x%8.8x, returning
>> 0x%8.8x\n", __FUNCTION__, bits, m_value, m_value & bits);
>> @@ -262,23 +272,31 @@ public:
>> /// unrecoverable error occurs.
>> //------------------------------------------------------------------
>> T
>> - WaitForResetValueBits(T bits, const TimeValue *abstime = nullptr)
>> + WaitForResetValueBits(T bits, const std::chrono::microseconds
>> &timeout = std::chrono::microseconds(0))
>> {
>> - int err = 0;
>> -
>> // pthread_cond_timedwait() or pthread_cond_wait() will
>> atomically
>> // unlock the mutex and wait for the condition to be set. When
>> either
>> // function returns, they will re-lock the mutex. We use an auto
>> lock/unlock
>> - // class (Mutex::Locker) to allow us to return at any point in
>> this
>> + // class (std::lock_guard) to allow us to return at any point in
>> this
>> // function and not have to worry about unlocking the mutex.
>> - Mutex::Locker locker(m_mutex);
>> + std::unique_lock<std::mutex> lock(m_mutex);
>>
>> #ifdef DB_PTHREAD_LOG_EVENTS
>> - printf("%s (bits = 0x%8.8x, abstime = %p), m_value = 0x%8.8x\n",
>> __FUNCTION__, bits, abstime, m_value);
>> + printf("%s (bits = 0x%8.8x, timeout = %llu), m_value =
>> 0x%8.8x\n", __FUNCTION__, bits, timeout.count(),
>> + m_value);
>> #endif
>> - while (err == 0 && ((m_value & bits) != 0))
>> + while ((m_value & bits) != 0)
>> {
>> - err = m_condition.Wait (m_mutex, abstime);
>> + if (timeout == std::chrono::microseconds(0))
>> + {
>> + m_condition.wait(lock);
>> + }
>> + else
>> + {
>> + std::cv_status result = m_condition.wait_for(lock,
>> timeout);
>> + if (result == std::cv_status::timeout)
>> + break;
>> + }
>> }
>>
>> #ifdef DB_PTHREAD_LOG_EVENTS
>> @@ -317,25 +335,39 @@ public:
>> /// @li \b false otherwise
>> //------------------------------------------------------------------
>> bool
>> - WaitForValueEqualTo(T value, const TimeValue *abstime = nullptr,
>> bool *timed_out = nullptr)
>> + WaitForValueEqualTo(T value, const std::chrono::microseconds
>> &timeout = std::chrono::microseconds(0),
>> + bool *timed_out = nullptr)
>> {
>> - int err = 0;
>> // pthread_cond_timedwait() or pthread_cond_wait() will
>> atomically
>> // unlock the mutex and wait for the condition to be set. When
>> either
>> // function returns, they will re-lock the mutex. We use an auto
>> lock/unlock
>> - // class (Mutex::Locker) to allow us to return at any point in
>> this
>> + // class (std::lock_guard) to allow us to return at any point in
>> this
>> // function and not have to worry about unlocking the mutex.
>> - Mutex::Locker locker(m_mutex);
>> + std::unique_lock<std::mutex> lock(m_mutex);
>>
>> #ifdef DB_PTHREAD_LOG_EVENTS
>> - printf("%s (value = 0x%8.8x, abstime = %p), m_value =
>> 0x%8.8x\n", __FUNCTION__, value, abstime, m_value);
>> + printf("%s (value = 0x%8.8x, timeout = %llu), m_value =
>> 0x%8.8x\n", __FUNCTION__, value, timeout.count(),
>> + m_value);
>> #endif
>> if (timed_out)
>> *timed_out = false;
>>
>> - while (err == 0 && m_value != value)
>> + while (m_value != value)
>> {
>> - err = m_condition.Wait (m_mutex, abstime, timed_out);
>> + if (timeout == std::chrono::microseconds(0))
>> + {
>> + m_condition.wait(lock);
>> + }
>> + else
>> + {
>> + std::cv_status result = m_condition.wait_for(lock,
>> timeout);
>> + if (result == std::cv_status::timeout)
>> + {
>> + if (timed_out)
>> + *timed_out = true;
>> + break;
>> + }
>> + }
>> }
>>
>> return m_value == value;
>> @@ -378,26 +410,39 @@ public:
>> //------------------------------------------------------------------
>> bool
>> WaitForValueEqualToAndSetValueTo(T wait_value, T new_value,
>> - const TimeValue *abstime = nullptr,
>> + const std::chrono::microseconds
>> &timeout = std::chrono::microseconds(0),
>> bool *timed_out = nullptr)
>> {
>> - int err = 0;
>> // pthread_cond_timedwait() or pthread_cond_wait() will
>> atomically
>> // unlock the mutex and wait for the condition to be set. When
>> either
>> // function returns, they will re-lock the mutex. We use an auto
>> lock/unlock
>> - // class (Mutex::Locker) to allow us to return at any point in
>> this
>> + // class (std::lock_guard) to allow us to return at any point in
>> this
>> // function and not have to worry about unlocking the mutex.
>> - Mutex::Locker locker(m_mutex);
>> + std::unique_lock<std::mutex> lock(m_mutex);
>>
>> #ifdef DB_PTHREAD_LOG_EVENTS
>> - printf("%s (wait_value = 0x%8.8x, new_value = 0x%8.8x, abstime =
>> %p), m_value = 0x%8.8x\n", __FUNCTION__, wait_value, new_value, abstime,
>> m_value);
>> + printf("%s (wait_value = 0x%8.8x, new_value = 0x%8.8x, timeout =
>> %llu), m_value = 0x%8.8x\n", __FUNCTION__,
>> + wait_value, new_value, timeout.count(), m_value);
>> #endif
>> if (timed_out)
>> *timed_out = false;
>>
>> - while (err == 0 && m_value != wait_value)
>> + while (m_value != wait_value)
>> {
>> - err = m_condition.Wait (m_mutex, abstime, timed_out);
>> + if (timeout == std::chrono::microseconds(0))
>> + {
>> + m_condition.wait(lock);
>> + }
>> + else
>> + {
>> + std::cv_status result = m_condition.wait_for(m_mutex,
>> timeout);
>> + if (result == std::cv_status::timeout)
>> + {
>> + if (timed_out)
>> + *timed_out = true;
>> + break;
>> + }
>> + }
>> }
>>
>> if (m_value == wait_value)
>> @@ -438,21 +483,31 @@ public:
>> /// @li \b false otherwise
>> //------------------------------------------------------------------
>> bool
>> - WaitForValueNotEqualTo(T value, T &new_value, const TimeValue
>> *abstime = nullptr)
>> + WaitForValueNotEqualTo(T value, T &new_value,
>> + const std::chrono::microseconds &timeout =
>> std::chrono::microseconds(0))
>> {
>> - int err = 0;
>> // pthread_cond_timedwait() or pthread_cond_wait() will
>> atomically
>> // unlock the mutex and wait for the condition to be set. When
>> either
>> // function returns, they will re-lock the mutex. We use an auto
>> lock/unlock
>> - // class (Mutex::Locker) to allow us to return at any point in
>> this
>> + // class (std::lock_guard) to allow us to return at any point in
>> this
>> // function and not have to worry about unlocking the mutex.
>> - Mutex::Locker locker(m_mutex);
>> + std::unique_lock<std::mutex> lock(m_mutex);
>> #ifdef DB_PTHREAD_LOG_EVENTS
>> - printf("%s (value = 0x%8.8x, abstime = %p), m_value =
>> 0x%8.8x\n", __FUNCTION__, value, abstime, m_value);
>> + printf("%s (value = 0x%8.8x, timeout = %llu), m_value =
>> 0x%8.8x\n", __FUNCTION__, value, timeout.count(),
>> + m_value);
>> #endif
>> - while (err == 0 && m_value == value)
>> + while (m_value == value)
>> {
>> - err = m_condition.Wait (m_mutex, abstime);
>> + if (timeout == std::chrono::microseconds(0))
>> + {
>> + m_condition.wait(lock);
>> + }
>> + else
>> + {
>> + std::cv_status result = m_condition.wait_for(lock,
>> timeout);
>> + if (result == std::cv_status::timeout)
>> + break;
>> + }
>> }
>>
>> if (m_value != value)
>> @@ -469,8 +524,9 @@ protected:
>> // blocking between the main thread and the spotlight index thread.
>>
>> //----------------------------------------------------------------------
>> T m_value; ///< The templatized value T that we are
>> protecting access to
>> - mutable Mutex m_mutex; ///< The mutex to use when accessing the
>> data
>> - Condition m_condition; ///< The pthread condition variable to
>> use for signaling that data available or changed.
>> + mutable std::mutex m_mutex; ///< The mutex to use when accessing the
>> data
>> + std::condition_variable
>> + m_condition; ///< The pthread condition variable to use for
>> signaling that data available or changed.
>>
>> private:
>> //------------------------------------------------------------------
>> @@ -496,7 +552,7 @@ private:
>> printf("%s (old_value = 0x%8.8x, broadcast_type = %i) m_value =
>> 0x%8.8x, broadcast = %u\n", __FUNCTION__, old_value, broadcast_type,
>> m_value, broadcast);
>> #endif
>> if (broadcast)
>> - m_condition.Broadcast();
>> + m_condition.notify_all();
>> }
>>
>> DISALLOW_COPY_AND_ASSIGN(Predicate);
>>
>> Modified: lldb/trunk/include/lldb/Host/ProcessRunLock.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Host/ProcessRunLock.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/include/lldb/Host/ProcessRunLock.h (original)
>> +++ lldb/trunk/include/lldb/Host/ProcessRunLock.h Thu Jul 28 12:32:20 2016
>> @@ -18,7 +18,6 @@
>> // Other libraries and framework includes
>> // Project includes
>> #include "lldb/lldb-defines.h"
>> -#include "lldb/Host/Condition.h"
>>
>> //----------------------------------------------------------------------
>> /// Enumerations for broadcasting.
>>
>> Modified: lldb/trunk/include/lldb/Target/Process.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/Process.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/include/lldb/Target/Process.h (original)
>> +++ lldb/trunk/include/lldb/Target/Process.h Thu Jul 28 12:32:20 2016
>> @@ -16,6 +16,7 @@
>> #include <limits.h>
>>
>> // C++ Includes
>> +#include <chrono>
>> #include <list>
>> #include <memory>
>> #include <mutex>
>> @@ -2920,12 +2921,9 @@ public:
>> // function releases the run lock after the stop. Setting
>> use_run_lock to false
>> // will avoid this behavior.
>> lldb::StateType
>> - WaitForProcessToStop(const TimeValue *timeout,
>> - lldb::EventSP *event_sp_ptr = nullptr,
>> - bool wait_always = true,
>> - lldb::ListenerSP hijack_listener =
>> lldb::ListenerSP(),
>> - Stream *stream = nullptr,
>> - bool use_run_lock = true);
>> + WaitForProcessToStop(const std::chrono::microseconds &timeout,
>> lldb::EventSP *event_sp_ptr = nullptr,
>> + bool wait_always = true, lldb::ListenerSP
>> hijack_listener = lldb::ListenerSP(),
>> + Stream *stream = nullptr, bool use_run_lock =
>> true);
>>
>> uint32_t
>> GetIOHandlerID () const
>> @@ -2947,8 +2945,7 @@ public:
>> SyncIOHandler (uint32_t iohandler_id, uint64_t timeout_msec);
>>
>> lldb::StateType
>> - WaitForStateChangedEvents(const TimeValue *timeout,
>> - lldb::EventSP &event_sp,
>> + WaitForStateChangedEvents(const std::chrono::microseconds &timeout,
>> lldb::EventSP &event_sp,
>> lldb::ListenerSP hijack_listener); // Pass
>> an empty ListenerSP to use builtin listener
>>
>>
>> //--------------------------------------------------------------------------------------
>> @@ -3538,21 +3535,20 @@ protected:
>> HaltPrivate();
>>
>> lldb::StateType
>> - WaitForProcessStopPrivate (const TimeValue *timeout, lldb::EventSP
>> &event_sp);
>> + WaitForProcessStopPrivate(const std::chrono::microseconds &timeout,
>> lldb::EventSP &event_sp);
>>
>> // This waits for both the state change broadcaster, and the control
>> broadcaster.
>> // If control_only, it only waits for the control broadcaster.
>>
>> bool
>> - WaitForEventsPrivate (const TimeValue *timeout, lldb::EventSP
>> &event_sp, bool control_only);
>> + WaitForEventsPrivate(const std::chrono::microseconds &timeout,
>> lldb::EventSP &event_sp, bool control_only);
>>
>> lldb::StateType
>> - WaitForStateChangedEventsPrivate (const TimeValue *timeout,
>> lldb::EventSP &event_sp);
>> + WaitForStateChangedEventsPrivate(const std::chrono::microseconds
>> &timeout, lldb::EventSP &event_sp);
>>
>> lldb::StateType
>> - WaitForState (const TimeValue *timeout,
>> - const lldb::StateType *match_states,
>> - const uint32_t num_match_states);
>> + WaitForState(const std::chrono::microseconds &timeout, const
>> lldb::StateType *match_states,
>> + const uint32_t num_match_states);
>>
>> size_t
>> WriteMemoryPrivate (lldb::addr_t addr, const void *buf, size_t size,
>> Error &error);
>>
>> Modified: lldb/trunk/source/API/SBListener.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBListener.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/API/SBListener.cpp (original)
>> +++ lldb/trunk/source/API/SBListener.cpp Thu Jul 28 12:32:20 2016
>> @@ -17,7 +17,6 @@
>> #include "lldb/Core/Listener.h"
>> #include "lldb/Core/Log.h"
>> #include "lldb/Core/StreamString.h"
>> -#include "lldb/Host/TimeValue.h"
>>
>>
>> using namespace lldb;
>> @@ -202,15 +201,14 @@ SBListener::WaitForEvent (uint32_t timeo
>>
>> if (m_opaque_sp)
>> {
>> - TimeValue time_value;
>> + std::chrono::microseconds timeout = std::chrono::microseconds(0);
>> if (timeout_secs != UINT32_MAX)
>> {
>> assert (timeout_secs != 0); // Take this out after all calls
>> with timeout set to zero have been removed....
>> - time_value = TimeValue::Now();
>> - time_value.OffsetWithSeconds (timeout_secs);
>> + timeout = std::chrono::seconds(timeout_secs);
>> }
>> EventSP event_sp;
>> - if (m_opaque_sp->WaitForEvent (time_value.IsValid() ?
>> &time_value : NULL, event_sp))
>> + if (m_opaque_sp->WaitForEvent(timeout, event_sp))
>> {
>> event.reset (event_sp);
>> success = true;
>> @@ -247,16 +245,11 @@ SBListener::WaitForEventForBroadcaster
>> {
>> if (m_opaque_sp && broadcaster.IsValid())
>> {
>> - TimeValue time_value;
>> + std::chrono::microseconds timeout = std::chrono::microseconds(0);
>> if (num_seconds != UINT32_MAX)
>> - {
>> - time_value = TimeValue::Now();
>> - time_value.OffsetWithSeconds (num_seconds);
>> - }
>> + timeout = std::chrono::seconds(num_seconds);
>> EventSP event_sp;
>> - if (m_opaque_sp->WaitForEventForBroadcaster
>> (time_value.IsValid() ? &time_value : NULL,
>> -
>> broadcaster.get(),
>> - event_sp))
>> + if (m_opaque_sp->WaitForEventForBroadcaster(timeout,
>> broadcaster.get(), event_sp))
>> {
>> event.reset (event_sp);
>> return true;
>> @@ -278,17 +271,11 @@ SBListener::WaitForEventForBroadcasterWi
>> {
>> if (m_opaque_sp && broadcaster.IsValid())
>> {
>> - TimeValue time_value;
>> + std::chrono::microseconds timeout = std::chrono::microseconds(0);
>> if (num_seconds != UINT32_MAX)
>> - {
>> - time_value = TimeValue::Now();
>> - time_value.OffsetWithSeconds (num_seconds);
>> - }
>> + timeout = std::chrono::seconds(num_seconds);
>> EventSP event_sp;
>> - if (m_opaque_sp->WaitForEventForBroadcasterWithType
>> (time_value.IsValid() ? &time_value : NULL,
>> -
>> broadcaster.get(),
>> -
>> event_type_mask,
>> - event_sp))
>> + if (m_opaque_sp->WaitForEventForBroadcasterWithType(timeout,
>> broadcaster.get(), event_type_mask, event_sp))
>> {
>> event.reset (event_sp);
>> return true;
>>
>> Modified: lldb/trunk/source/Core/Communication.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/Communication.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Core/Communication.cpp (original)
>> +++ lldb/trunk/source/Core/Communication.cpp Thu Jul 28 12:32:20 2016
>> @@ -156,18 +156,14 @@ Communication::Read (void *dst, size_t d
>> status = eConnectionStatusNoConnection;
>> return 0;
>> }
>> - // Set the timeout appropriately
>> - TimeValue timeout_time;
>> - if (timeout_usec != UINT32_MAX)
>> - {
>> - timeout_time = TimeValue::Now();
>> - timeout_time.OffsetWithMicroSeconds (timeout_usec);
>> - }
>>
>> ListenerSP
>> listener_sp(Listener::MakeListener("Communication::Read"));
>> listener_sp->StartListeningForEvents (this,
>> eBroadcastBitReadThreadGotBytes | eBroadcastBitReadThreadDidExit);
>> EventSP event_sp;
>> - while (listener_sp->WaitForEvent (timeout_time.IsValid() ?
>> &timeout_time : nullptr, event_sp))
>> + std::chrono::microseconds timeout = std::chrono::microseconds(0);
>> + if (timeout_usec != UINT32_MAX)
>> + timeout = std::chrono::microseconds(timeout_usec);
>> + while (listener_sp->WaitForEvent(timeout, event_sp))
>> {
>> const uint32_t event_type = event_sp->GetType();
>> if (event_type & eBroadcastBitReadThreadGotBytes)
>> @@ -439,7 +435,7 @@ Communication::SynchronizeWithReadThread
>>
>> // Wait for the synchronization event.
>> EventSP event_sp;
>> - listener_sp->WaitForEvent(nullptr, event_sp);
>> + listener_sp->WaitForEvent(std::chrono::microseconds(0), event_sp);
>> }
>>
>> void
>>
>> Modified: lldb/trunk/source/Core/Debugger.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/Debugger.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Core/Debugger.cpp (original)
>> +++ lldb/trunk/source/Core/Debugger.cpp Thu Jul 28 12:32:20 2016
>> @@ -1608,7 +1608,7 @@ Debugger::DefaultEventHandler()
>> while (!done)
>> {
>> EventSP event_sp;
>> - if (listener_sp->WaitForEvent(nullptr, event_sp))
>> + if (listener_sp->WaitForEvent(std::chrono::microseconds(0),
>> event_sp))
>> {
>> if (event_sp)
>> {
>> @@ -1705,7 +1705,7 @@ Debugger::StartEventHandlerThread()
>> // eBroadcastBitEventThreadIsListening so we don't need to check
>> the event, we just need
>> // to wait an infinite amount of time for it (nullptr timeout as
>> the first parameter)
>> lldb::EventSP event_sp;
>> - listener_sp->WaitForEvent(nullptr, event_sp);
>> + listener_sp->WaitForEvent(std::chrono::microseconds(0),
>> event_sp);
>> }
>> return m_event_handler_thread.IsJoinable();
>> }
>>
>> Modified: lldb/trunk/source/Core/Listener.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/Listener.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Core/Listener.cpp (original)
>> +++ lldb/trunk/source/Core/Listener.cpp Thu Jul 28 12:32:20 2016
>> @@ -19,7 +19,6 @@
>> #include "lldb/Core/Log.h"
>> #include "lldb/Core/StreamString.h"
>> #include "lldb/Core/Event.h"
>> -#include "lldb/Host/TimeValue.h"
>>
>> using namespace lldb;
>> using namespace lldb_private;
>> @@ -41,7 +40,7 @@ namespace
>> } // anonymous namespace
>>
>> Listener::Listener(const char *name)
>> - : m_name(name), m_broadcasters(), m_broadcasters_mutex(),
>> m_events(), m_events_mutex(Mutex::eMutexTypeNormal)
>> + : m_name(name), m_broadcasters(), m_broadcasters_mutex(),
>> m_events(), m_events_mutex()
>> {
>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>> (LIBLLDB_LOG_OBJECT));
>> if (log != nullptr)
>> @@ -63,7 +62,7 @@ void
>> Listener::Clear()
>> {
>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>> (LIBLLDB_LOG_OBJECT));
>> - std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
>> + std::lock_guard<std::recursive_mutex>
>> broadcasters_guard(m_broadcasters_mutex);
>> broadcaster_collection::iterator pos, end = m_broadcasters.end();
>> for (pos = m_broadcasters.begin(); pos != end; ++pos)
>> {
>> @@ -73,7 +72,7 @@ Listener::Clear()
>> }
>> m_broadcasters.clear();
>>
>> - Mutex::Locker event_locker(m_events_mutex);
>> + std::lock_guard<std::mutex> events_guard(m_events_mutex);
>> m_events.clear();
>> size_t num_managers = m_broadcaster_managers.size();
>>
>> @@ -96,7 +95,7 @@ Listener::StartListeningForEvents (Broad
>> // Scope for "locker"
>> // Tell the broadcaster to add this object as a listener
>> {
>> - std::lock_guard<std::recursive_mutex>
>> guard(m_broadcasters_mutex);
>> + std::lock_guard<std::recursive_mutex>
>> broadcasters_guard(m_broadcasters_mutex);
>> Broadcaster::BroadcasterImplWP
>> impl_wp(broadcaster->GetBroadcasterImpl());
>> m_broadcasters.insert(std::make_pair(impl_wp,
>> BroadcasterInfo(event_mask)));
>> }
>> @@ -123,7 +122,7 @@ Listener::StartListeningForEvents (Broad
>> // Scope for "locker"
>> // Tell the broadcaster to add this object as a listener
>> {
>> - std::lock_guard<std::recursive_mutex>
>> guard(m_broadcasters_mutex);
>> + std::lock_guard<std::recursive_mutex>
>> broadcasters_guard(m_broadcasters_mutex);
>> Broadcaster::BroadcasterImplWP
>> impl_wp(broadcaster->GetBroadcasterImpl());
>> m_broadcasters.insert(std::make_pair(impl_wp,
>>
>> BroadcasterInfo(event_mask, callback, callback_user_data)));
>> @@ -154,7 +153,7 @@ Listener::StopListeningForEvents (Broadc
>> {
>> // Scope for "locker"
>> {
>> - std::lock_guard<std::recursive_mutex>
>> guard(m_broadcasters_mutex);
>> + std::lock_guard<std::recursive_mutex>
>> broadcasters_guard(m_broadcasters_mutex);
>> m_broadcasters.erase (broadcaster->GetBroadcasterImpl());
>> }
>> // Remove the broadcaster from our set of broadcasters
>> @@ -171,13 +170,13 @@ Listener::BroadcasterWillDestruct (Broad
>> {
>> // Scope for "broadcasters_locker"
>> {
>> - std::lock_guard<std::recursive_mutex>
>> guard(m_broadcasters_mutex);
>> + std::lock_guard<std::recursive_mutex>
>> broadcasters_guard(m_broadcasters_mutex);
>> m_broadcasters.erase (broadcaster->GetBroadcasterImpl());
>> }
>>
>> // Scope for "event_locker"
>> {
>> - Mutex::Locker event_locker(m_events_mutex);
>> + std::lock_guard<std::mutex> events_guard(m_events_mutex);
>> // Remove all events for this broadcaster object.
>> event_collection::iterator pos = m_events.begin();
>> while (pos != m_events.end())
>> @@ -212,9 +211,9 @@ Listener::AddEvent (EventSP &event_sp)
>> static_cast<void*>(this), m_name.c_str(),
>> static_cast<void*>(event_sp.get()));
>>
>> - Mutex::Locker locker(m_events_mutex);
>> + std::lock_guard<std::mutex> guard(m_events_mutex);
>> m_events.push_back (event_sp);
>> - m_events_condition.Broadcast();
>> + m_events_condition.notify_all();
>> }
>>
>> class EventBroadcasterMatches
>> @@ -279,15 +278,11 @@ private:
>> };
>>
>> bool
>> -Listener::FindNextEventInternal
>> -(
>> - Mutex::Locker& lock,
>> - Broadcaster *broadcaster, // nullptr for any broadcaster
>> - const ConstString *broadcaster_names, // nullptr for any event
>> - uint32_t num_broadcaster_names,
>> - uint32_t event_type_mask,
>> - EventSP &event_sp,
>> - bool remove)
>> +Listener::FindNextEventInternal(std::unique_lock<std::mutex> &lock,
>> + Broadcaster *broadcaster, //
>> nullptr for any broadcaster
>> + const ConstString *broadcaster_names, //
>> nullptr for any event
>> + uint32_t num_broadcaster_names, uint32_t
>> event_type_mask, EventSP &event_sp,
>> + bool remove)
>> {
>> // NOTE: callers of this function must lock m_events_mutex using a
>> Mutex::Locker
>> // and pass the locker as the first argument. m_events_mutex is no
>> longer recursive.
>> @@ -325,7 +320,7 @@ Listener::FindNextEventInternal
>> // Unlock the event queue here. We've removed this event
>> and are about to return
>> // it so it should be okay to get the next event off the
>> queue here - and it might
>> // be useful to do that in the "DoOnRemoval".
>> - lock.Unlock();
>> + lock.unlock();
>> event_sp->DoOnRemoval();
>> }
>> return true;
>> @@ -338,9 +333,9 @@ Listener::FindNextEventInternal
>> Event *
>> Listener::PeekAtNextEvent ()
>> {
>> - Mutex::Locker lock(m_events_mutex);
>> + std::unique_lock<std::mutex> guard(m_events_mutex);
>> EventSP event_sp;
>> - if (FindNextEventInternal(lock, nullptr, nullptr, 0, 0, event_sp,
>> false))
>> + if (FindNextEventInternal(guard, nullptr, nullptr, 0, 0, event_sp,
>> false))
>> return event_sp.get();
>> return nullptr;
>> }
>> @@ -348,9 +343,9 @@ Listener::PeekAtNextEvent ()
>> Event *
>> Listener::PeekAtNextEventForBroadcaster (Broadcaster *broadcaster)
>> {
>> - Mutex::Locker lock(m_events_mutex);
>> + std::unique_lock<std::mutex> guard(m_events_mutex);
>> EventSP event_sp;
>> - if (FindNextEventInternal(lock, broadcaster, nullptr, 0, 0,
>> event_sp, false))
>> + if (FindNextEventInternal(guard, broadcaster, nullptr, 0, 0,
>> event_sp, false))
>> return event_sp.get();
>> return nullptr;
>> }
>> @@ -358,9 +353,9 @@ Listener::PeekAtNextEventForBroadcaster
>> Event *
>> Listener::PeekAtNextEventForBroadcasterWithType (Broadcaster
>> *broadcaster, uint32_t event_type_mask)
>> {
>> - Mutex::Locker lock(m_events_mutex);
>> + std::unique_lock<std::mutex> guard(m_events_mutex);
>> EventSP event_sp;
>> - if (FindNextEventInternal(lock, broadcaster, nullptr, 0,
>> event_type_mask, event_sp, false))
>> + if (FindNextEventInternal(guard, broadcaster, nullptr, 0,
>> event_type_mask, event_sp, false))
>> return event_sp.get();
>> return nullptr;
>> }
>> @@ -372,8 +367,9 @@ Listener::GetNextEventInternal(Broadcast
>> uint32_t event_type_mask,
>> EventSP &event_sp)
>> {
>> - Mutex::Locker lock(m_events_mutex);
>> - return FindNextEventInternal (lock, broadcaster, broadcaster_names,
>> num_broadcaster_names, event_type_mask, event_sp, true);
>> + std::unique_lock<std::mutex> guard(m_events_mutex);
>> + return FindNextEventInternal(guard, broadcaster, broadcaster_names,
>> num_broadcaster_names, event_type_mask,
>> + event_sp, true);
>> }
>>
>> bool
>> @@ -395,20 +391,17 @@ Listener::GetNextEventForBroadcasterWith
>> }
>>
>> bool
>> -Listener::WaitForEventsInternal(const TimeValue *timeout,
>> +Listener::WaitForEventsInternal(const std::chrono::microseconds &timeout,
>> Broadcaster *broadcaster, //
>> nullptr for any broadcaster
>> const ConstString *broadcaster_names, //
>> nullptr for any event
>> - uint32_t num_broadcaster_names,
>> - uint32_t event_type_mask,
>> - EventSP &event_sp)
>> + uint32_t num_broadcaster_names, uint32_t
>> event_type_mask, EventSP &event_sp)
>> {
>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>> (LIBLLDB_LOG_EVENTS));
>> if (log != nullptr)
>> - log->Printf ("%p Listener::WaitForEventsInternal (timeout = { %p
>> }) for %s",
>> - static_cast<void*>(this), static_cast<const
>> void*>(timeout),
>> - m_name.c_str());
>> + log->Printf("%p Listener::WaitForEventsInternal (timeout = %llu
>> us) for %s", static_cast<void *>(this),
>> + static_cast<unsigned long long>(timeout.count()),
>> m_name.c_str());
>>
>> - Mutex::Locker lock(m_events_mutex);
>> + std::unique_lock<std::mutex> lock(m_events_mutex);
>>
>> while (true)
>> {
>> @@ -418,23 +411,26 @@ Listener::WaitForEventsInternal(const Ti
>> }
>> else
>> {
>> - bool timed_out = false;
>> - if (m_events_condition.Wait(m_events_mutex, timeout,
>> &timed_out) != 0)
>> + std::cv_status result = std::cv_status::no_timeout;
>> + if (timeout == std::chrono::microseconds(0))
>> + m_events_condition.wait(lock);
>> + else
>> + result = m_events_condition.wait_for(lock, timeout);
>> +
>> + if (result == std::cv_status::timeout)
>> {
>> - if (timed_out)
>> - {
>> - log = lldb_private::GetLogIfAllCategoriesSet
>> (LIBLLDB_LOG_EVENTS);
>> - if (log != nullptr)
>> - log->Printf ("%p
>> Listener::WaitForEventsInternal() timed out for %s",
>> - static_cast<void*>(this),
>> m_name.c_str());
>> - }
>> - else
>> - {
>> - log = lldb_private::GetLogIfAllCategoriesSet
>> (LIBLLDB_LOG_EVENTS);
>> - if (log != nullptr)
>> - log->Printf ("%p
>> Listener::WaitForEventsInternal() unknown error for %s",
>> - static_cast<void*>(this),
>> m_name.c_str());
>> - }
>> + log =
>> lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
>> + if (log)
>> + log->Printf("%p Listener::WaitForEventsInternal()
>> timed out for %s", static_cast<void *>(this),
>> + m_name.c_str());
>> + return false;
>> + }
>> + else if (result != std::cv_status::no_timeout)
>> + {
>> + log =
>> lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
>> + if (log)
>> + log->Printf("%p Listener::WaitForEventsInternal()
>> unknown error for %s", static_cast<void *>(this),
>> + m_name.c_str());
>> return false;
>> }
>> }
>> @@ -444,24 +440,21 @@ Listener::WaitForEventsInternal(const Ti
>> }
>>
>> bool
>> -Listener::WaitForEventForBroadcasterWithType(const TimeValue *timeout,
>> - Broadcaster *broadcaster,
>> - uint32_t event_type_mask,
>> - EventSP &event_sp)
>> +Listener::WaitForEventForBroadcasterWithType(const
>> std::chrono::microseconds &timeout, Broadcaster *broadcaster,
>> + uint32_t event_type_mask,
>> EventSP &event_sp)
>> {
>> return WaitForEventsInternal(timeout, broadcaster, nullptr, 0,
>> event_type_mask, event_sp);
>> }
>>
>> bool
>> -Listener::WaitForEventForBroadcaster(const TimeValue *timeout,
>> - Broadcaster *broadcaster,
>> +Listener::WaitForEventForBroadcaster(const std::chrono::microseconds
>> &timeout, Broadcaster *broadcaster,
>> EventSP &event_sp)
>> {
>> return WaitForEventsInternal(timeout, broadcaster, nullptr, 0, 0,
>> event_sp);
>> }
>>
>> bool
>> -Listener::WaitForEvent (const TimeValue *timeout, EventSP &event_sp)
>> +Listener::WaitForEvent(const std::chrono::microseconds &timeout, EventSP
>> &event_sp)
>> {
>> return WaitForEventsInternal(timeout, nullptr, nullptr, 0, 0,
>> event_sp);
>> }
>>
>> Modified: lldb/trunk/source/Host/CMakeLists.txt
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/CMakeLists.txt?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Host/CMakeLists.txt (original)
>> +++ lldb/trunk/source/Host/CMakeLists.txt Thu Jul 28 12:32:20 2016
>> @@ -4,7 +4,6 @@ macro(add_host_subdirectory group)
>> endmacro()
>>
>> add_host_subdirectory(common
>> - common/Condition.cpp
>> common/File.cpp
>> common/FileCache.cpp
>> common/FileSpec.cpp
>> @@ -17,7 +16,6 @@ add_host_subdirectory(common
>> common/HostThread.cpp
>> common/IOObject.cpp
>> common/LockFileBase.cpp
>> - common/Mutex.cpp
>> common/MonitoringProcessLauncher.cpp
>> common/NativeBreakpoint.cpp
>> common/NativeBreakpointList.cpp
>> @@ -60,7 +58,6 @@ add_host_subdirectory(posix
>>
>> if (CMAKE_SYSTEM_NAME MATCHES "Windows")
>> add_host_subdirectory(windows
>> - windows/Condition.cpp
>> windows/ConnectionGenericFileWindows.cpp
>> windows/EditLineWin.cpp
>> windows/FileSystem.cpp
>> @@ -69,7 +66,6 @@ if (CMAKE_SYSTEM_NAME MATCHES "Windows")
>> windows/HostProcessWindows.cpp
>> windows/HostThreadWindows.cpp
>> windows/LockFileWindows.cpp
>> - windows/Mutex.cpp
>> windows/PipeWindows.cpp
>> windows/ProcessLauncherWindows.cpp
>> windows/ProcessRunLock.cpp
>>
>> Removed: lldb/trunk/source/Host/common/Condition.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/common/Condition.cpp?rev=277010&view=auto
>>
>> ==============================================================================
>> --- lldb/trunk/source/Host/common/Condition.cpp (original)
>> +++ lldb/trunk/source/Host/common/Condition.cpp (removed)
>> @@ -1,108 +0,0 @@
>> -//===-- Condition.cpp -------------------------------------------*- C++
>> -*-===//
>> -//
>> -// The LLVM Compiler Infrastructure
>> -//
>> -// This file is distributed under the University of Illinois Open Source
>> -// License. See LICENSE.TXT for details.
>> -//
>>
>> -//===----------------------------------------------------------------------===//
>> -
>> -#include <errno.h>
>> -
>> -#include "lldb/Host/Condition.h"
>> -#include "lldb/Host/TimeValue.h"
>> -
>> -
>> -using namespace lldb_private;
>> -
>> -#ifndef _WIN32
>> -
>> -//----------------------------------------------------------------------
>> -// Default constructor
>> -//
>> -// The default constructor will initialize a new pthread condition
>> -// and maintain the condition in the object state.
>> -//----------------------------------------------------------------------
>> -Condition::Condition () :
>> - m_condition()
>> -{
>> - ::pthread_cond_init (&m_condition, NULL);
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Destructor
>> -//
>> -// Destroys the pthread condition that the object owns.
>> -//----------------------------------------------------------------------
>> -Condition::~Condition ()
>> -{
>> - ::pthread_cond_destroy (&m_condition);
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Unblock all threads waiting for a condition variable
>> -//----------------------------------------------------------------------
>> -int
>> -Condition::Broadcast ()
>> -{
>> - return ::pthread_cond_broadcast (&m_condition);
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Unblocks one thread waiting for the condition variable
>> -//----------------------------------------------------------------------
>> -int
>> -Condition::Signal ()
>> -{
>> - return ::pthread_cond_signal (&m_condition);
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// The Wait() function atomically blocks the current thread
>> -// waiting on the owned condition variable, and unblocks the mutex
>> -// specified by "mutex". The waiting thread unblocks only after
>> -// another thread calls Signal(), or Broadcast() with the same
>> -// condition variable, or if "abstime" is valid (non-NULL) this
>> -// function will return when the system time reaches the time
>> -// specified in "abstime". If "abstime" is NULL this function will
>> -// wait for an infinite amount of time for the condition variable
>> -// to be signaled or broadcasted.
>> -//
>> -// The current thread re-acquires the lock on "mutex".
>> -//----------------------------------------------------------------------
>> -int
>> -Condition::Wait (Mutex &mutex, const TimeValue *abstime, bool *timed_out)
>> -{
>> - int err = 0;
>> - do
>> - {
>> - if (abstime && abstime->IsValid())
>> - {
>> - struct timespec abstime_ts = abstime->GetAsTimeSpec();
>> - err = ::pthread_cond_timedwait (&m_condition,
>> mutex.GetMutex(), &abstime_ts);
>> - }
>> - else
>> - err = ::pthread_cond_wait (&m_condition, mutex.GetMutex());
>> - } while (err == EINTR);
>> -
>> - if (timed_out != NULL)
>> - {
>> - if (err == ETIMEDOUT)
>> - *timed_out = true;
>> - else
>> - *timed_out = false;
>> - }
>> -
>> - return err;
>> -}
>> -
>> -#endif
>> -
>> -//----------------------------------------------------------------------
>> -// Get accessor to the pthread condition object
>> -//----------------------------------------------------------------------
>> -lldb::condition_t *
>> -Condition::GetCondition()
>> -{
>> - return &m_condition;
>> -}
>>
>> Modified: lldb/trunk/source/Host/common/Host.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/common/Host.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Host/common/Host.cpp (original)
>> +++ lldb/trunk/source/Host/common/Host.cpp Thu Jul 28 12:32:20 2016
>> @@ -620,14 +620,8 @@ Host::RunShellCommand(const Args &args,
>>
>> if (error.Success())
>> {
>> - TimeValue *timeout_ptr = nullptr;
>> - TimeValue timeout_time(TimeValue::Now());
>> - if (timeout_sec > 0) {
>> - timeout_time.OffsetWithSeconds(timeout_sec);
>> - timeout_ptr = &timeout_time;
>> - }
>> bool timed_out = false;
>> - shell_info_sp->process_reaped.WaitForValueEqualTo(true,
>> timeout_ptr, &timed_out);
>> + shell_info_sp->process_reaped.WaitForValueEqualTo(true,
>> std::chrono::seconds(timeout_sec), &timed_out);
>> if (timed_out)
>> {
>> error.SetErrorString("timed out waiting for shell command to
>> complete");
>> @@ -635,10 +629,8 @@ Host::RunShellCommand(const Args &args,
>> // Kill the process since it didn't complete within the
>> timeout specified
>> Kill (pid, SIGKILL);
>> // Wait for the monitor callback to get the message
>> - timeout_time = TimeValue::Now();
>> - timeout_time.OffsetWithSeconds(1);
>> timed_out = false;
>> - shell_info_sp->process_reaped.WaitForValueEqualTo(true,
>> &timeout_time, &timed_out);
>> + shell_info_sp->process_reaped.WaitForValueEqualTo(true,
>> std::chrono::seconds(1), &timed_out);
>> }
>> else
>> {
>>
>> Removed: lldb/trunk/source/Host/common/Mutex.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/common/Mutex.cpp?rev=277010&view=auto
>>
>> ==============================================================================
>> --- lldb/trunk/source/Host/common/Mutex.cpp (original)
>> +++ lldb/trunk/source/Host/common/Mutex.cpp (removed)
>> @@ -1,398 +0,0 @@
>> -//===-- Mutex.cpp -----------------------------------------------*- C++
>> -*-===//
>> -//
>> -// The LLVM Compiler Infrastructure
>> -//
>> -// This file is distributed under the University of Illinois Open Source
>> -// License. See LICENSE.TXT for details.
>> -//
>>
>> -//===----------------------------------------------------------------------===//
>> -
>> -#include "lldb/Host/Mutex.h"
>> -#include "lldb/Host/Host.h"
>> -
>> -#ifndef _WIN32
>> -#include <pthread.h>
>> -#endif
>> -#include <string.h>
>> -#include <stdio.h>
>> -
>> -#if 0
>> -// This logging is way too verbose to enable even for a log channel.
>> -// This logging can be enabled by changing the "#if 0", but should be
>> -// reverted prior to checking in.
>> -#include <cstdio>
>> -#define DEBUG_LOG(fmt, ...) printf(fmt, ## __VA_ARGS__)
>> -#else
>> -#define DEBUG_LOG(fmt, ...)
>> -#endif
>> -
>> -// Enable extra mutex error checking
>> -#if 0 // LLDB_CONFIGURATION_DEBUG
>> -#define ENABLE_MUTEX_ERROR_CHECKING 1
>> -#include <inttypes.h>
>> -#endif
>> -
>> -#if ENABLE_MUTEX_ERROR_CHECKING
>> -#include <set>
>> -
>> -enum MutexAction
>> -{
>> - eMutexActionInitialized,
>> - eMutexActionDestroyed,
>> - eMutexActionAssertInitialized
>> -};
>> -
>> -static bool
>> -error_check_mutex (pthread_mutex_t *m, MutexAction action)
>> -{
>> - typedef std::set<pthread_mutex_t *> mutex_set;
>> - static pthread_mutex_t g_mutex_set_mutex = PTHREAD_MUTEX_INITIALIZER;
>> - static mutex_set g_initialized_mutex_set;
>> - static mutex_set g_destroyed_mutex_set;
>> -
>> - bool success = true;
>> - int err;
>> - // Manually call lock so we don't to any of this error checking
>> - err = ::pthread_mutex_lock (&g_mutex_set_mutex);
>> - assert(err == 0);
>> - switch (action)
>> - {
>> - case eMutexActionInitialized:
>> - // Make sure this isn't already in our initialized mutex
>> set...
>> - assert (g_initialized_mutex_set.find(m) ==
>> g_initialized_mutex_set.end());
>> - // Remove this from the destroyed set in case it was ever in
>> there
>> - g_destroyed_mutex_set.erase(m);
>> - // Add the mutex to the initialized set
>> - g_initialized_mutex_set.insert(m);
>> - break;
>> -
>> - case eMutexActionDestroyed:
>> - // Make sure this isn't already in our destroyed mutex set...
>> - assert (g_destroyed_mutex_set.find(m) ==
>> g_destroyed_mutex_set.end());
>> - // Remove this from the initialized so we can put it into
>> the destroyed set
>> - g_initialized_mutex_set.erase(m);
>> - // Add the mutex to the destroyed set
>> - g_destroyed_mutex_set.insert(m);
>> - break;
>> - case eMutexActionAssertInitialized:
>> - // This function will return true if "m" is in the
>> initialized mutex set
>> - success = g_initialized_mutex_set.find(m) !=
>> g_initialized_mutex_set.end();
>> - assert (success);
>> - break;
>> - }
>> - // Manually call unlock so we don't to any of this error checking
>> - err = ::pthread_mutex_unlock (&g_mutex_set_mutex);
>> - assert(err == 0);
>> - return success;
>> -}
>> -
>> -#endif
>> -
>> -using namespace lldb_private;
>> -
>> -//----------------------------------------------------------------------
>> -// Default constructor.
>> -//
>> -// This will create a scoped mutex locking object that doesn't have
>> -// a mutex to lock. One will need to be provided using the Reset()
>> -// method.
>> -//----------------------------------------------------------------------
>> -Mutex::Locker::Locker () :
>> - m_mutex_ptr(NULL)
>> -{
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Constructor with a Mutex object.
>> -//
>> -// This will create a scoped mutex locking object that extracts the
>> -// mutex owned by "m" and locks it.
>> -//----------------------------------------------------------------------
>> -Mutex::Locker::Locker (Mutex& m) :
>> - m_mutex_ptr(NULL)
>> -{
>> - Lock (m);
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Constructor with a Mutex object pointer.
>> -//
>> -// This will create a scoped mutex locking object that extracts the
>> -// mutex owned by "m" and locks it.
>> -//----------------------------------------------------------------------
>> -Mutex::Locker::Locker (Mutex* m) :
>> - m_mutex_ptr(NULL)
>> -{
>> - if (m)
>> - Lock (m);
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Destructor
>> -//
>> -// Unlocks any owned mutex object (if it is valid).
>> -//----------------------------------------------------------------------
>> -Mutex::Locker::~Locker ()
>> -{
>> - Unlock();
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Unlock the current mutex in this object (if this owns a valid
>> -// mutex) and lock the new "mutex" object if it is non-NULL.
>> -//----------------------------------------------------------------------
>> -void
>> -Mutex::Locker::Lock (Mutex &mutex)
>> -{
>> - // We already have this mutex locked or both are NULL...
>> - if (m_mutex_ptr == &mutex)
>> - return;
>> -
>> - Unlock ();
>> -
>> - m_mutex_ptr = &mutex;
>> - m_mutex_ptr->Lock();
>> -}
>> -
>> -void
>> -Mutex::Locker::Unlock ()
>> -{
>> - if (m_mutex_ptr)
>> - {
>> - m_mutex_ptr->Unlock ();
>> - m_mutex_ptr = NULL;
>> - }
>> -}
>> -
>> -bool
>> -Mutex::Locker::TryLock (Mutex &mutex, const char *failure_message)
>> -{
>> - // We already have this mutex locked!
>> - if (m_mutex_ptr == &mutex)
>> - return true;
>> -
>> - Unlock ();
>> -
>> - if (mutex.TryLock(failure_message) == 0)
>> - m_mutex_ptr = &mutex;
>> -
>> - return m_mutex_ptr != NULL;
>> -}
>> -
>> -#ifndef _WIN32
>> -
>> -//----------------------------------------------------------------------
>> -// Default constructor.
>> -//
>> -// Creates a pthread mutex with no attributes.
>> -//----------------------------------------------------------------------
>> -Mutex::Mutex () :
>> - m_mutex()
>> -{
>> - int err;
>> - err = ::pthread_mutex_init (&m_mutex, NULL);
>> -#if ENABLE_MUTEX_ERROR_CHECKING
>> - if (err == 0)
>> - error_check_mutex (&m_mutex, eMutexActionInitialized);
>> -#endif
>> - assert(err == 0);
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Default constructor.
>> -//
>> -// Creates a pthread mutex with "type" as the mutex type.
>> -//----------------------------------------------------------------------
>> -Mutex::Mutex (Mutex::Type type) :
>> - m_mutex()
>> -{
>> - int err;
>> - ::pthread_mutexattr_t attr;
>> - err = ::pthread_mutexattr_init (&attr);
>> - assert(err == 0);
>> - switch (type)
>> - {
>> - case eMutexTypeNormal:
>> -#if ENABLE_MUTEX_ERROR_CHECKING
>> - err = ::pthread_mutexattr_settype (&attr,
>> PTHREAD_MUTEX_ERRORCHECK);
>> -#else
>> - err = ::pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_NORMAL);
>> -#endif
>> - break;
>> -
>> - case eMutexTypeRecursive:
>> - err = ::pthread_mutexattr_settype (&attr,
>> PTHREAD_MUTEX_RECURSIVE);
>> - break;
>> - }
>> - assert(err == 0);
>> - err = ::pthread_mutex_init (&m_mutex, &attr);
>> -#if ENABLE_MUTEX_ERROR_CHECKING
>> - if (err == 0)
>> - error_check_mutex (&m_mutex, eMutexActionInitialized);
>> -#endif
>> - assert(err == 0);
>> - err = ::pthread_mutexattr_destroy (&attr);
>> - assert(err == 0);
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Destructor.
>> -//
>> -// Destroys the mutex owned by this object.
>> -//----------------------------------------------------------------------
>> -Mutex::~Mutex()
>> -{
>> -#if ENABLE_MUTEX_ERROR_CHECKING
>> - int err = ::pthread_mutex_destroy (&m_mutex);
>> - assert(err == 0);
>> - if (err == 0)
>> - error_check_mutex (&m_mutex, eMutexActionDestroyed);
>> - else
>> - {
>> - Host::SetCrashDescriptionWithFormat ("%s error:
>> pthread_mutex_destroy() => err = %i (%s)", __PRETTY_FUNCTION__, err,
>> strerror(err));
>> - assert(err == 0);
>> - }
>> - memset (&m_mutex, '\xba', sizeof(m_mutex));
>> -#else
>> - ::pthread_mutex_destroy (&m_mutex);
>> -#endif
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Locks the mutex owned by this object, if the mutex is already
>> -// locked, the calling thread will block until the mutex becomes
>> -// available.
>> -//
>> -// RETURNS
>> -// The error code from the pthread_mutex_lock() function call.
>> -//----------------------------------------------------------------------
>> -int
>> -Mutex::Lock()
>> -{
>> - DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_lock
>> (%p)...\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(),
>> &m_mutex);
>> -
>> -#if ENABLE_MUTEX_ERROR_CHECKING
>> - error_check_mutex (&m_mutex, eMutexActionAssertInitialized);
>> -#endif
>> -
>> - int err = ::pthread_mutex_lock (&m_mutex);
>> -
>> -
>> -#if ENABLE_MUTEX_ERROR_CHECKING
>> - if (err)
>> - {
>> - Host::SetCrashDescriptionWithFormat ("%s error:
>> pthread_mutex_lock(%p) => err = %i (%s)", __PRETTY_FUNCTION__, &m_mutex,
>> err, strerror(err));
>> - assert(err == 0);
>> - }
>> -#endif
>> - DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_lock (%p)
>> => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(),
>> &m_mutex, err);
>> - return err;
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Attempts to lock the mutex owned by this object without blocking.
>> -// If the mutex is already locked, TryLock() will not block waiting
>> -// for the mutex, but will return an error condition.
>> -//
>> -// RETURNS
>> -// The error code from the pthread_mutex_trylock() function call.
>> -//----------------------------------------------------------------------
>> -int
>> -Mutex::TryLock(const char *failure_message)
>> -{
>> -#if ENABLE_MUTEX_ERROR_CHECKING
>> - error_check_mutex (&m_mutex, eMutexActionAssertInitialized);
>> -#endif
>> -
>> - int err = ::pthread_mutex_trylock (&m_mutex);
>> - DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_trylock
>> (%p) => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(),
>> &m_mutex, err);
>> - return err;
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// If the current thread holds the lock on the owned mutex, then
>> -// Unlock() will unlock the mutex. Calling Unlock() on this object
>> -// that the calling thread does not hold will result in undefined
>> -// behavior.
>> -//
>> -// RETURNS
>> -// The error code from the pthread_mutex_unlock() function call.
>> -//----------------------------------------------------------------------
>> -int
>> -Mutex::Unlock()
>> -{
>> -#if ENABLE_MUTEX_ERROR_CHECKING
>> - error_check_mutex (&m_mutex, eMutexActionAssertInitialized);
>> -#endif
>> -
>> - int err = ::pthread_mutex_unlock (&m_mutex);
>> -
>> -#if ENABLE_MUTEX_ERROR_CHECKING
>> - if (err)
>> - {
>> - Host::SetCrashDescriptionWithFormat ("%s error:
>> pthread_mutex_unlock(%p) => err = %i (%s)", __PRETTY_FUNCTION__, &m_mutex,
>> err, strerror(err));
>> - assert(err == 0);
>> - }
>> -#endif
>> - DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_unlock
>> (%p) => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(),
>> &m_mutex, err);
>> - return err;
>> -}
>> -
>> -#endif
>> -
>> -//----------------------------------------------------------------------
>> -// Mutex get accessor.
>> -//----------------------------------------------------------------------
>> -lldb::mutex_t *
>> -Mutex::GetMutex()
>> -{
>> - return &m_mutex;
>> -}
>> -
>> -#ifdef LLDB_CONFIGURATION_DEBUG
>> -int
>> -TrackingMutex::Unlock ()
>> -{
>> - if (!m_failure_message.empty())
>> - Host::SetCrashDescriptionWithFormat ("Unlocking lock (on thread
>> %p) that thread: %p failed to get: %s",
>> - pthread_self(),
>> - m_thread_that_tried,
>> - m_failure_message.c_str());
>> - assert (m_failure_message.empty());
>> - return Mutex::Unlock();
>> -}
>> -
>> -int
>> -LoggingMutex::Lock ()
>> -{
>> - printf("locking mutex %p by [%4.4" PRIx64 "/%4.4" PRIx64 "]...",
>> this, Host::GetCurrentProcessID(), Host::GetCurrentThreadID());
>> - int x = Mutex::Lock();
>> - m_locked = true;
>> - printf("%d\n",x);
>> - return x;
>> -}
>> -
>> -int
>> -LoggingMutex::Unlock ()
>> -{
>> - printf("unlocking mutex %p by [%4.4" PRIx64 "/%4.4" PRIx64 "]...",
>> this, Host::GetCurrentProcessID(), Host::GetCurrentThreadID());
>> - int x = Mutex::Unlock();
>> - m_locked = false;
>> - printf("%d\n",x);
>> - return x;
>> -}
>> -
>> -int
>> -LoggingMutex::TryLock (const char *failure_message)
>> -{
>> - printf("trylocking mutex %p by [%4.4" PRIx64 "/%4.4" PRIx64 "]...",
>> this, Host::GetCurrentProcessID(), Host::GetCurrentThreadID());
>> - int x = Mutex::TryLock(failure_message);
>> - if (x == 0)
>> - m_locked = true;
>> - printf("%d\n",x);
>> - return x;
>> -}
>> -
>> -#endif
>> -
>> -
>>
>> Modified: lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp
>> (original)
>> +++ lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp Thu
>> Jul 28 12:32:20 2016
>> @@ -877,11 +877,7 @@ ConnectionFileDescriptor::GetListeningPo
>> if (timeout_sec == UINT32_MAX)
>> m_port_predicate.WaitForValueNotEqualTo(0, bound_port);
>> else
>> - {
>> - TimeValue timeout = TimeValue::Now();
>> - timeout.OffsetWithSeconds(timeout_sec);
>> - m_port_predicate.WaitForValueNotEqualTo(0, bound_port, &timeout);
>> - }
>> + m_port_predicate.WaitForValueNotEqualTo(0, bound_port,
>> std::chrono::seconds(timeout_sec));
>> return bound_port;
>> }
>>
>>
>> Removed: lldb/trunk/source/Host/windows/Condition.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/windows/Condition.cpp?rev=277010&view=auto
>>
>> ==============================================================================
>> --- lldb/trunk/source/Host/windows/Condition.cpp (original)
>> +++ lldb/trunk/source/Host/windows/Condition.cpp (removed)
>> @@ -1,98 +0,0 @@
>> -//===-- Condition.cpp -------------------------------------------*- C++
>> -*-===//
>> -//
>> -// The LLVM Compiler Infrastructure
>> -//
>> -// This file is distributed under the University of Illinois Open Source
>> -// License. See LICENSE.TXT for details.
>> -//
>>
>> -//===----------------------------------------------------------------------===//
>> -
>> -#include <errno.h>
>> -
>> -#include "lldb/Host/Condition.h"
>> -#include "lldb/Host/TimeValue.h"
>> -#include "lldb/Host/windows/windows.h"
>> -
>> -
>> -using namespace lldb_private;
>> -
>> -//----------------------------------------------------------------------
>> -// Default constructor
>> -//
>> -// The default constructor will initialize a new pthread condition
>> -// and maintain the condition in the object state.
>> -//----------------------------------------------------------------------
>> -Condition::Condition () :
>> - m_condition()
>> -{
>> - m_condition =
>> static_cast<PCONDITION_VARIABLE>(malloc(sizeof(CONDITION_VARIABLE)));
>> -
>> InitializeConditionVariable(static_cast<PCONDITION_VARIABLE>(m_condition));
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Destructor
>> -//
>> -// Destroys the pthread condition that the object owns.
>> -//----------------------------------------------------------------------
>> -Condition::~Condition ()
>> -{
>> - free(m_condition);
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Unblock all threads waiting for a condition variable
>> -//----------------------------------------------------------------------
>> -int
>> -Condition::Broadcast ()
>> -{
>> -
>> WakeAllConditionVariable(static_cast<PCONDITION_VARIABLE>(m_condition));
>> - return 0;
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Unblocks one thread waiting for the condition variable
>> -//----------------------------------------------------------------------
>> -int
>> -Condition::Signal ()
>> -{
>> - WakeConditionVariable(static_cast<PCONDITION_VARIABLE>(m_condition));
>> - return 0;
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// The Wait() function atomically blocks the current thread
>> -// waiting on the owned condition variable, and unblocks the mutex
>> -// specified by "mutex". The waiting thread unblocks only after
>> -// another thread calls Signal(), or Broadcast() with the same
>> -// condition variable, or if "abstime" is valid (non-NULL) this
>> -// function will return when the system time reaches the time
>> -// specified in "abstime". If "abstime" is NULL this function will
>> -// wait for an infinite amount of time for the condition variable
>> -// to be signaled or broadcasted.
>> -//
>> -// The current thread re-acquires the lock on "mutex".
>> -//----------------------------------------------------------------------
>> -int
>> -Condition::Wait (Mutex &mutex, const TimeValue *abstime, bool *timed_out)
>> -{
>> - DWORD wait = INFINITE;
>> - if (abstime != NULL) {
>> - int wval = (*abstime - TimeValue::Now()) / 1000000;
>> - if (wval < 0) wval = 0;
>> -
>> - wait = wval;
>> - }
>> -
>> - int err =
>> SleepConditionVariableCS(static_cast<PCONDITION_VARIABLE>(m_condition),
>> static_cast<PCRITICAL_SECTION>(mutex.m_mutex), wait);
>> -
>> - if (timed_out != NULL)
>> - {
>> - if ((err == 0) && GetLastError() == ERROR_TIMEOUT)
>> - *timed_out = true;
>> - else
>> - *timed_out = false;
>> - }
>> -
>> - return err == 0;
>> -}
>> -
>>
>> Removed: lldb/trunk/source/Host/windows/Mutex.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/windows/Mutex.cpp?rev=277010&view=auto
>>
>> ==============================================================================
>> --- lldb/trunk/source/Host/windows/Mutex.cpp (original)
>> +++ lldb/trunk/source/Host/windows/Mutex.cpp (removed)
>> @@ -1,109 +0,0 @@
>> -//===-- Mutex.cpp -----------------------------------------------*- C++
>> -*-===//
>> -//
>> -// The LLVM Compiler Infrastructure
>> -//
>> -// This file is distributed under the University of Illinois Open Source
>> -// License. See LICENSE.TXT for details.
>> -//
>>
>> -//===----------------------------------------------------------------------===//
>> -
>> -#include "lldb/Host/Mutex.h"
>> -#include "lldb/Host/Host.h"
>> -#include "lldb/Host/windows/windows.h"
>> -
>> -#include <string.h>
>> -#include <stdio.h>
>> -
>> -#if 0
>> -// This logging is way too verbose to enable even for a log channel.
>> -// This logging can be enabled by changing the "#if 0", but should be
>> -// reverted prior to checking in.
>> -#include <cstdio>
>> -#define DEBUG_LOG(fmt, ...) printf(fmt, ## __VA_ARGS__)
>> -#else
>> -#define DEBUG_LOG(fmt, ...)
>> -#endif
>> -
>> -using namespace lldb_private;
>> -
>> -//----------------------------------------------------------------------
>> -// Default constructor.
>> -//
>> -// Creates a pthread mutex with no attributes.
>> -//----------------------------------------------------------------------
>> -Mutex::Mutex () :
>> - m_mutex()
>> -{
>> - m_mutex =
>> static_cast<PCRITICAL_SECTION>(malloc(sizeof(CRITICAL_SECTION)));
>> - InitializeCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex));
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Default constructor.
>> -//
>> -// Creates a pthread mutex with "type" as the mutex type.
>> -//----------------------------------------------------------------------
>> -Mutex::Mutex (Mutex::Type type) :
>> - m_mutex()
>> -{
>> - m_mutex =
>> static_cast<PCRITICAL_SECTION>(malloc(sizeof(CRITICAL_SECTION)));
>> - InitializeCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex));
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Destructor.
>> -//
>> -// Destroys the mutex owned by this object.
>> -//----------------------------------------------------------------------
>> -Mutex::~Mutex()
>> -{
>> - DeleteCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex));
>> - free(m_mutex);
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Locks the mutex owned by this object, if the mutex is already
>> -// locked, the calling thread will block until the mutex becomes
>> -// available.
>> -//
>> -// RETURNS
>> -// The error code from the pthread_mutex_lock() function call.
>> -//----------------------------------------------------------------------
>> -int
>> -Mutex::Lock()
>> -{
>> - DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_lock
>> (%p)...\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(),
>> m_mutex);
>> -
>> - EnterCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex));
>> - return 0;
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// Attempts to lock the mutex owned by this object without blocking.
>> -// If the mutex is already locked, TryLock() will not block waiting
>> -// for the mutex, but will return an error condition.
>> -//
>> -// RETURNS
>> -// The error code from the pthread_mutex_trylock() function call.
>> -//----------------------------------------------------------------------
>> -int
>> -Mutex::TryLock(const char *failure_message)
>> -{
>> - return
>> TryEnterCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex)) == 0;
>> -}
>> -
>> -//----------------------------------------------------------------------
>> -// If the current thread holds the lock on the owned mutex, then
>> -// Unlock() will unlock the mutex. Calling Unlock() on this object
>> -// that the calling thread does not hold will result in undefined
>> -// behavior.
>> -//
>> -// RETURNS
>> -// The error code from the pthread_mutex_unlock() function call.
>> -//----------------------------------------------------------------------
>> -int
>> -Mutex::Unlock()
>> -{
>> - LeaveCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex));
>> - return 0;
>> -}
>>
>> Modified:
>> lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> ---
>> lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h
>> (original)
>> +++
>> lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h
>> Thu Jul 28 12:32:20 2016
>> @@ -22,7 +22,6 @@
>> #include "lldb/Host/FileSpec.h"
>> #include "lldb/Core/StructuredData.h"
>> #include "lldb/Core/UUID.h"
>> -#include "lldb/Host/Mutex.h"
>> #include "lldb/Target/Process.h"
>> #include "lldb/Utility/SafeMachO.h"
>>
>>
>> Modified: lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp (original)
>> +++ lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp Thu Jul 28
>> 12:32:20 2016
>> @@ -699,7 +699,8 @@ PlatformLinux::DebugProcess (ProcessLaun
>> // Handle the hijacking of process events.
>> if (listener_sp)
>> {
>> - const StateType state = process_sp->WaitForProcessToStop
>> (NULL, NULL, false, listener_sp);
>> + const StateType state =
>> +
>> process_sp->WaitForProcessToStop(std::chrono::microseconds(0), NULL, false,
>> listener_sp);
>>
>> if (state == eStateStopped)
>> {
>>
>> Modified:
>> lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
>> (original)
>> +++ lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
>> Thu Jul 28 12:32:20 2016
>> @@ -210,11 +210,10 @@ CommunicationKDP::GetSequenceMutex(std::
>> return (lock =
>> std::unique_lock<std::recursive_mutex>(m_sequence_mutex,
>> std::try_to_lock)).owns_lock();
>> }
>>
>> -
>> bool
>> -CommunicationKDP::WaitForNotRunningPrivate (const TimeValue *timeout_ptr)
>> +CommunicationKDP::WaitForNotRunningPrivate(const
>> std::chrono::microseconds &timeout)
>> {
>> - return m_is_running.WaitForValueEqualTo (false, timeout_ptr, NULL);
>> + return m_is_running.WaitForValueEqualTo(false, timoeut, NULL);
>> }
>>
>> size_t
>>
>> Modified:
>> lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h
>> (original)
>> +++ lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h
>> Thu Jul 28 12:32:20 2016
>> @@ -249,7 +249,7 @@ protected:
>> uint32_t timeout_usec);
>>
>> bool
>> - WaitForNotRunningPrivate (const lldb_private::TimeValue
>> *timeout_ptr);
>> + WaitForNotRunningPrivate(const std::chrono::microseconds &timeout);
>>
>> void
>> MakeRequestPacketHeader (CommandType request_type,
>>
>> Modified: lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
>> (original)
>> +++ lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp Thu
>> Jul 28 12:32:20 2016
>> @@ -941,7 +941,7 @@ ProcessKDP::AsyncThread (void *arg)
>> if (log)
>> log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64
>> ") listener.WaitForEvent (NULL, event_sp)...",
>> pid);
>> - if (listener_sp->WaitForEvent (NULL, event_sp))
>> + if (listener_sp->WaitForEvent(stsd::chrono::micrseconds(0),
>> event_sp))
>> {
>> uint32_t event_type = event_sp->GetType();
>> if (log)
>>
>> Modified:
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> ---
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
>> (original)
>> +++
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp Thu
>> Jul 28 12:32:20 2016
>> @@ -152,23 +152,22 @@ GDBRemoteCommunication::History::Dump (L
>> //----------------------------------------------------------------------
>> // GDBRemoteCommunication constructor
>> //----------------------------------------------------------------------
>> -GDBRemoteCommunication::GDBRemoteCommunication(const char *comm_name,
>> - const char
>> *listener_name) :
>> - Communication(comm_name),
>> +GDBRemoteCommunication::GDBRemoteCommunication(const char *comm_name,
>> const char *listener_name)
>> + : Communication(comm_name),
>> #ifdef LLDB_CONFIGURATION_DEBUG
>> - m_packet_timeout (1000),
>> + m_packet_timeout(1000),
>> #else
>> - m_packet_timeout (1),
>> + m_packet_timeout(1),
>> #endif
>> - m_echo_number(0),
>> - m_supports_qEcho (eLazyBoolCalculate),
>> - m_sequence_mutex (Mutex::eMutexTypeRecursive),
>> - m_public_is_running (false),
>> - m_private_is_running (false),
>> - m_history (512),
>> - m_send_acks (true),
>> - m_compression_type (CompressionType::None),
>> - m_listen_url ()
>> + m_echo_number(0),
>> + m_supports_qEcho(eLazyBoolCalculate),
>> + m_sequence_mutex(),
>> + m_public_is_running(false),
>> + m_private_is_running(false),
>> + m_history(512),
>> + m_send_acks(true),
>> + m_compression_type(CompressionType::None),
>> + m_listen_url()
>> {
>> }
>>
>> @@ -229,7 +228,7 @@ GDBRemoteCommunication::SendNack ()
>> GDBRemoteCommunication::PacketResult
>> GDBRemoteCommunication::SendPacket (const char *payload, size_t
>> payload_length)
>> {
>> - Mutex::Locker locker(m_sequence_mutex);
>> + std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex);
>> return SendPacketNoLock (payload, payload_length);
>> }
>>
>> @@ -323,20 +322,19 @@ GDBRemoteCommunication::GetAck ()
>> }
>>
>> bool
>> -GDBRemoteCommunication::GetSequenceMutex (Mutex::Locker& locker, const
>> char *failure_message)
>> +GDBRemoteCommunication::GetSequenceMutex(std::unique_lock<std::recursive_mutex>
>> &lock, const char *failure_message)
>> {
>> if (IsRunning())
>> - return locker.TryLock (m_sequence_mutex, failure_message);
>> + return (lock =
>> std::unique_lock<std::recursive_mutex>(m_sequence_mutex,
>> std::try_to_lock)).owns_lock();
>>
>> - locker.Lock (m_sequence_mutex);
>> + lock = std::unique_lock<std::recursive_mutex>(m_sequence_mutex);
>> return true;
>> }
>>
>> -
>> bool
>> -GDBRemoteCommunication::WaitForNotRunningPrivate (const TimeValue
>> *timeout_ptr)
>> +GDBRemoteCommunication::WaitForNotRunningPrivate(const
>> std::chrono::microseconds &timeout)
>> {
>> - return m_private_is_running.WaitForValueEqualTo (false, timeout_ptr,
>> NULL);
>> + return m_private_is_running.WaitForValueEqualTo(false, timeout,
>> NULL);
>> }
>>
>> GDBRemoteCommunication::PacketResult
>> @@ -356,20 +354,22 @@ GDBRemoteCommunication::ReadPacket (Stri
>> GDBRemoteCommunication::PacketResult
>> GDBRemoteCommunication::PopPacketFromQueue (StringExtractorGDBRemote
>> &response, uint32_t timeout_usec)
>> {
>> - // Calculate absolute timeout value
>> - TimeValue timeout = TimeValue::Now();
>> - timeout.OffsetWithMicroSeconds(timeout_usec);
>> + auto until = std::chrono::system_clock::now() +
>> std::chrono::microseconds(timeout_usec);
>>
>> - do
>> + while (true)
>> {
>> // scope for the mutex
>> {
>> // lock down the packet queue
>> - Mutex::Locker locker(m_packet_queue_mutex);
>> + std::unique_lock<std::mutex> lock(m_packet_queue_mutex);
>>
>> // Wait on condition variable.
>> if (m_packet_queue.size() == 0)
>> - m_condition_queue_not_empty.Wait(m_packet_queue_mutex,
>> &timeout);
>> + {
>> + std::cv_status result =
>> m_condition_queue_not_empty.wait_until(lock, until);
>> + if (result == std::cv_status::timeout)
>> + break;
>> + }
>>
>> if (m_packet_queue.size() > 0)
>> {
>> @@ -389,7 +389,7 @@ GDBRemoteCommunication::PopPacketFromQue
>> return PacketResult::ErrorDisconnected;
>>
>> // Loop while not timed out
>> - } while (TimeValue::Now() < timeout);
>> + }
>>
>> return PacketResult::ErrorReplyTimeout;
>> }
>> @@ -1479,12 +1479,11 @@ void GDBRemoteCommunication::AppendBytes
>> // scope for the mutex
>> {
>> // lock down the packet queue
>> - Mutex::Locker locker(m_packet_queue_mutex);
>> + std::lock_guard<std::mutex> guard(m_packet_queue_mutex);
>> // push a new packet into the queue
>> m_packet_queue.push(packet);
>> // Signal condition variable that we have a packet
>> - m_condition_queue_not_empty.Signal();
>> -
>> + m_condition_queue_not_empty.notify_one();
>> }
>> }
>>
>>
>> Modified:
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
>> (original)
>> +++ lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
>> Thu Jul 28 12:32:20 2016
>> @@ -12,6 +12,8 @@
>>
>> // C Includes
>> // C++ Includes
>> +#include <condition_variable>
>> +#include <mutex>
>> #include <string>
>> #include <queue>
>> #include <vector>
>> @@ -22,7 +24,6 @@
>> #include "lldb/Core/Communication.h"
>> #include "lldb/Core/Listener.h"
>> #include "lldb/Host/HostThread.h"
>> -#include "lldb/Host/Mutex.h"
>> #include "lldb/Host/Predicate.h"
>> #include "lldb/Host/TimeValue.h"
>> #include "lldb/Interpreter/Args.h"
>> @@ -114,7 +115,7 @@ public:
>> size_t payload_length);
>>
>> bool
>> - GetSequenceMutex(Mutex::Locker& locker, const char *failure_message
>> = nullptr);
>> + GetSequenceMutex(std::unique_lock<std::recursive_mutex> &lock, const
>> char *failure_message = nullptr);
>>
>> PacketType
>> CheckForPacket (const uint8_t *src,
>> @@ -285,9 +286,9 @@ protected:
>> uint32_t m_echo_number;
>> LazyBool m_supports_qEcho;
>> #ifdef ENABLE_MUTEX_ERROR_CHECKING
>> - TrackingMutex m_sequence_mutex;
>> +#error TrackingMutex is no longer supported
>> #else
>> - Mutex m_sequence_mutex; // Restrict access to sending/receiving
>> packets to a single thread at a time
>> + std::recursive_mutex m_sequence_mutex; // Restrict access to
>> sending/receiving packets to a single thread at a time
>> #endif
>> Predicate<bool> m_public_is_running;
>> Predicate<bool> m_private_is_running;
>> @@ -320,7 +321,7 @@ protected:
>> bool sync_on_timeout);
>>
>> bool
>> - WaitForNotRunningPrivate (const TimeValue *timeout_ptr);
>> + WaitForNotRunningPrivate(const std::chrono::microseconds &timeout);
>>
>> bool
>> CompressionIsEnabled ()
>> @@ -364,8 +365,8 @@ protected:
>>
>> private:
>> std::queue<StringExtractorGDBRemote> m_packet_queue; // The packet
>> queue
>> - lldb_private::Mutex m_packet_queue_mutex; // Mutex for
>> accessing queue
>> - Condition m_condition_queue_not_empty; // Condition
>> variable to wait for packets
>> + std::mutex m_packet_queue_mutex; // Mutex for
>> accessing queue
>> + std::condition_variable m_condition_queue_not_empty; // Condition
>> variable to wait for packets
>>
>> HostThread m_listen_thread;
>> std::string m_listen_url;
>>
>> Modified:
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> ---
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
>> (original)
>> +++
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
>> Thu Jul 28 12:32:20 2016
>> @@ -720,9 +720,10 @@ GDBRemoteCommunicationClient::SendPacket
>> std::string &response_string
>> )
>> {
>> - Mutex::Locker locker;
>> - if (!GetSequenceMutex(locker,
>> -
>> "ProcessGDBRemote::SendPacketsAndConcatenateResponses() failed due to not
>> getting the sequence mutex"))
>> + std::unique_lock<std::recursive_mutex> lock;
>> + if (!GetSequenceMutex(
>> + lock,
>> + "ProcessGDBRemote::SendPacketsAndConcatenateResponses()
>> failed due to not getting the sequence mutex"))
>> {
>> Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet
>> (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
>> if (log)
>> @@ -821,7 +822,7 @@ GDBRemoteCommunicationClient::SendPacket
>> )
>> {
>> PacketResult packet_result = PacketResult::ErrorSendFailed;
>> - Mutex::Locker locker;
>> + std::unique_lock<std::recursive_mutex> lock;
>> Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet
>> (GDBR_LOG_PROCESS));
>>
>> // In order to stop async notifications from being processed in the
>> middle of the
>> @@ -829,7 +830,7 @@ GDBRemoteCommunicationClient::SendPacket
>> static ListenerSP
>> hijack_listener_sp(Listener::MakeListener("lldb.NotifyHijacker"));
>> HijackBroadcaster(hijack_listener_sp,
>> eBroadcastBitGdbReadThreadGotNotify);
>>
>> - if (GetSequenceMutex (locker))
>> + if (GetSequenceMutex(lock))
>> {
>> packet_result = SendPacketAndWaitForResponseNoLock (payload,
>> payload_length, response);
>> }
>> @@ -848,19 +849,22 @@ GDBRemoteCommunicationClient::SendPacket
>> log->Printf ("async: async packet = %s",
>> m_async_packet.c_str());
>>
>> bool timed_out = false;
>> - if (SendInterrupt(locker, 2, timed_out))
>> + if (SendInterrupt(lock, 2, timed_out))
>> {
>> if (m_interrupt_sent)
>> {
>> m_interrupt_sent = false;
>> - TimeValue timeout_time;
>> - timeout_time = TimeValue::Now();
>> - timeout_time.OffsetWithSeconds
>> (m_packet_timeout);
>> +
>> +
>> std::chrono::time_point<std::chrono::system_clock> until;
>> + until = std::chrono::system_clock::now() +
>> std::chrono::seconds(m_packet_timeout);
>>
>> if (log)
>> log->Printf ("async: sent interrupt");
>>
>> - if (m_async_packet_predicate.WaitForValueEqualTo
>> (false, &timeout_time, &timed_out))
>> + if (m_async_packet_predicate.WaitForValueEqualTo(
>> + false,
>> std::chrono::duration_cast<std::chrono::microseconds>(
>> + until -
>> std::chrono::system_clock::now()),
>> + &timed_out))
>> {
>> if (log)
>> log->Printf ("async: got response");
>> @@ -876,7 +880,10 @@ GDBRemoteCommunicationClient::SendPacket
>> }
>>
>> // Make sure we wait until the continue packet
>> has been sent again...
>> - if (m_private_is_running.WaitForValueEqualTo
>> (true, &timeout_time, &timed_out))
>> + if (m_private_is_running.WaitForValueEqualTo(
>> + true,
>> std::chrono::duration_cast<std::chrono::microseconds>(
>> + until -
>> std::chrono::system_clock::now()),
>> + &timed_out))
>> {
>> if (log)
>> {
>> @@ -1045,7 +1052,7 @@ GDBRemoteCommunicationClient::SendvContP
>> log->Printf("GDBRemoteCommunicationClient::%s ()", __FUNCTION__);
>>
>> // we want to lock down packet sending while we continue
>> - Mutex::Locker locker(m_sequence_mutex);
>> + std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex);
>>
>> // here we broadcast this before we even send the packet!!
>> // this signals doContinue() to exit
>> @@ -1094,7 +1101,7 @@ GDBRemoteCommunicationClient::SendContin
>> if (log)
>> log->Printf ("GDBRemoteCommunicationClient::%s ()",
>> __FUNCTION__);
>>
>> - Mutex::Locker locker(m_sequence_mutex);
>> + std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex);
>> StateType state = eStateRunning;
>>
>> m_public_is_running.SetValue (true, eBroadcastNever);
>> @@ -1394,8 +1401,8 @@ GDBRemoteCommunicationClient::SendAsyncS
>> std::lock_guard<std::recursive_mutex> guard(m_async_mutex);
>> m_async_signal = signo;
>> bool timed_out = false;
>> - Mutex::Locker locker;
>> - if (SendInterrupt (locker, 1, timed_out))
>> + std::unique_lock<std::recursive_mutex> lock;
>> + if (SendInterrupt(lock, 1, timed_out))
>> return true;
>> m_async_signal = -1;
>> return false;
>> @@ -1412,12 +1419,8 @@ GDBRemoteCommunicationClient::SendAsyncS
>> // (gdb remote protocol requires this), and do what we need to do, then
>> resume.
>>
>> bool
>> -GDBRemoteCommunicationClient::SendInterrupt
>> -(
>> - Mutex::Locker& locker,
>> - uint32_t seconds_to_wait_for_stop,
>> - bool &timed_out
>> -)
>> +GDBRemoteCommunicationClient::SendInterrupt(std::unique_lock<std::recursive_mutex>
>> &lock,
>> + uint32_t
>> seconds_to_wait_for_stop, bool &timed_out)
>> {
>> timed_out = false;
>> Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet
>> (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
>> @@ -1425,7 +1428,7 @@ GDBRemoteCommunicationClient::SendInterr
>> if (IsRunning())
>> {
>> // Only send an interrupt if our debugserver is running...
>> - if (GetSequenceMutex (locker))
>> + if (GetSequenceMutex(lock))
>> {
>> if (log)
>> log->Printf ("SendInterrupt () - got sequence mutex
>> without having to interrupt");
>> @@ -1444,13 +1447,8 @@ GDBRemoteCommunicationClient::SendInterr
>> m_interrupt_sent = true;
>> if (seconds_to_wait_for_stop)
>> {
>> - TimeValue timeout;
>> - if (seconds_to_wait_for_stop)
>> - {
>> - timeout = TimeValue::Now();
>> - timeout.OffsetWithSeconds
>> (seconds_to_wait_for_stop);
>> - }
>> - if (m_private_is_running.WaitForValueEqualTo (false,
>> &timeout, &timed_out))
>> + if (m_private_is_running.WaitForValueEqualTo(false,
>> std::chrono::seconds(seconds_to_wait_for_stop),
>> +
>> &timed_out))
>> {
>> if (log)
>> log->PutCString ("SendInterrupt () - sent
>> interrupt, private state stopped");
>> @@ -3653,10 +3651,10 @@ size_t
>> GDBRemoteCommunicationClient::GetCurrentThreadIDs
>> (std::vector<lldb::tid_t> &thread_ids,
>> bool
>> &sequence_mutex_unavailable)
>> {
>> - Mutex::Locker locker;
>> + std::unique_lock<std::recursive_mutex> lock;
>> thread_ids.clear();
>> -
>> - if (GetSequenceMutex (locker, "ProcessGDBRemote::UpdateThreadList()
>> failed due to not getting the sequence mutex"))
>> +
>> + if (GetSequenceMutex(lock, "ProcessGDBRemote::UpdateThreadList()
>> failed due to not getting the sequence mutex"))
>> {
>> sequence_mutex_unavailable = false;
>> StringExtractorGDBRemote response;
>> @@ -4203,8 +4201,8 @@ GDBRemoteCommunicationClient::AvoidGPack
>> bool
>> GDBRemoteCommunicationClient::ReadRegister(lldb::tid_t tid, uint32_t
>> reg, StringExtractorGDBRemote &response)
>> {
>> - Mutex::Locker locker;
>> - if (GetSequenceMutex (locker, "Didn't get sequence mutex for p
>> packet."))
>> + std::unique_lock<std::recursive_mutex> lock;
>> + if (GetSequenceMutex(lock, "Didn't get sequence mutex for p
>> packet."))
>> {
>> const bool thread_suffix_supported = GetThreadSuffixSupported();
>>
>> @@ -4228,8 +4226,8 @@ GDBRemoteCommunicationClient::ReadRegist
>> bool
>> GDBRemoteCommunicationClient::ReadAllRegisters (lldb::tid_t tid,
>> StringExtractorGDBRemote &response)
>> {
>> - Mutex::Locker locker;
>> - if (GetSequenceMutex (locker, "Didn't get sequence mutex for g
>> packet."))
>> + std::unique_lock<std::recursive_mutex> lock;
>> + if (GetSequenceMutex(lock, "Didn't get sequence mutex for g
>> packet."))
>> {
>> const bool thread_suffix_supported = GetThreadSuffixSupported();
>>
>> @@ -4256,8 +4254,8 @@ GDBRemoteCommunicationClient::SaveRegist
>> return false;
>>
>> m_supports_QSaveRegisterState = eLazyBoolYes;
>> - Mutex::Locker locker;
>> - if (GetSequenceMutex (locker, "Didn't get sequence mutex for
>> QSaveRegisterState."))
>> + std::unique_lock<std::recursive_mutex> lock;
>> + if (GetSequenceMutex(lock, "Didn't get sequence mutex for
>> QSaveRegisterState."))
>> {
>> const bool thread_suffix_supported = GetThreadSuffixSupported();
>> if (thread_suffix_supported || SetCurrentThread(tid))
>> @@ -4298,9 +4296,9 @@ GDBRemoteCommunicationClient::RestoreReg
>> // order to be useful
>> if (m_supports_QSaveRegisterState == eLazyBoolNo)
>> return false;
>> -
>> - Mutex::Locker locker;
>> - if (GetSequenceMutex (locker, "Didn't get sequence mutex for
>> QRestoreRegisterState."))
>> +
>> + std::unique_lock<std::recursive_mutex> lock;
>> + if (GetSequenceMutex(lock, "Didn't get sequence mutex for
>> QRestoreRegisterState."))
>> {
>> const bool thread_suffix_supported = GetThreadSuffixSupported();
>> if (thread_suffix_supported || SetCurrentThread(tid))
>> @@ -4530,8 +4528,10 @@ GDBRemoteCommunicationClient::ServeSymbo
>>
>> if (m_supports_qSymbol && m_qSymbol_requests_done == false)
>> {
>> - Mutex::Locker locker;
>> - if (GetSequenceMutex(locker,
>> "GDBRemoteCommunicationClient::ServeSymbolLookups() failed due to not
>> getting the sequence mutex"))
>> + std::unique_lock<std::recursive_mutex> lock;
>> + if (GetSequenceMutex(
>> + lock,
>> + "GDBRemoteCommunicationClient::ServeSymbolLookups()
>> failed due to not getting the sequence mutex"))
>> {
>> StreamString packet;
>> packet.PutCString ("qSymbol::");
>>
>> Modified:
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> ---
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
>> (original)
>> +++
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
>> Thu Jul 28 12:32:20 2016
>> @@ -105,9 +105,7 @@ public:
>> SendAsyncSignal (int signo);
>>
>> bool
>> - SendInterrupt (Mutex::Locker &locker,
>> - uint32_t seconds_to_wait_for_stop,
>> - bool &timed_out);
>> + SendInterrupt(std::unique_lock<std::recursive_mutex> &lock, uint32_t
>> seconds_to_wait_for_stop, bool &timed_out);
>>
>> lldb::pid_t
>> GetCurrentProcessID (bool allow_lazy = true);
>>
>> Modified:
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> ---
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
>> (original)
>> +++
>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
>> Thu Jul 28 12:32:20 2016
>> @@ -401,8 +401,8 @@ GDBRemoteRegisterContext::WriteRegisterB
>> reg_info->byte_size, // dst
>> length
>> m_reg_data.GetByteOrder())) // dst
>> byte order
>> {
>> - Mutex::Locker locker;
>> - if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence
>> mutex for write register."))
>> + std::unique_lock<std::recursive_mutex> lock;
>> + if (gdb_comm.GetSequenceMutex(lock, "Didn't get sequence mutex
>> for write register."))
>> {
>> const bool thread_suffix_supported =
>> gdb_comm.GetThreadSuffixSupported();
>> ProcessSP process_sp (m_thread.GetProcess());
>> @@ -570,8 +570,8 @@ GDBRemoteRegisterContext::ReadAllRegiste
>>
>> const bool use_g_packet = gdb_comm.AvoidGPackets ((ProcessGDBRemote
>> *)process) == false;
>>
>> - Mutex::Locker locker;
>> - if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex
>> for read all registers."))
>> + std::unique_lock<std::recursive_mutex> lock;
>> + if (gdb_comm.GetSequenceMutex(lock, "Didn't get sequence mutex for
>> read all registers."))
>> {
>> SyncThreadState(process);
>>
>> @@ -679,8 +679,8 @@ GDBRemoteRegisterContext::WriteAllRegist
>> const bool use_g_packet = gdb_comm.AvoidGPackets ((ProcessGDBRemote
>> *)process) == false;
>>
>> StringExtractorGDBRemote response;
>> - Mutex::Locker locker;
>> - if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex
>> for write all registers."))
>> + std::unique_lock<std::recursive_mutex> lock;
>> + if (gdb_comm.GetSequenceMutex(lock, "Didn't get sequence mutex for
>> write all registers."))
>> {
>> const bool thread_suffix_supported =
>> gdb_comm.GetThreadSuffixSupported();
>> ProcessSP process_sp (m_thread.GetProcess());
>>
>> Modified:
>> lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
>> (original)
>> +++ lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp Thu
>> Jul 28 12:32:20 2016
>> @@ -1590,9 +1590,6 @@ ProcessGDBRemote::DoResume ()
>> else
>> {
>> EventSP event_sp;
>> - TimeValue timeout;
>> - timeout = TimeValue::Now();
>> - timeout.OffsetWithSeconds (5);
>> if (!m_async_thread.IsJoinable())
>> {
>> error.SetErrorString ("Trying to resume but the async
>> thread is dead.");
>> @@ -1603,7 +1600,7 @@ ProcessGDBRemote::DoResume ()
>>
>> m_async_broadcaster.BroadcastEvent
>> (eBroadcastBitAsyncContinue, new EventDataBytes (continue_packet.GetData(),
>> continue_packet.GetSize()));
>>
>> - if (listener_sp->WaitForEvent (&timeout, event_sp) == false)
>> + if (listener_sp->WaitForEvent(std::chrono::seconds(5),
>> event_sp) == false)
>> {
>> error.SetErrorString("Resume timed out.");
>> if (log)
>> @@ -2717,7 +2714,7 @@ ProcessGDBRemote::DoHalt (bool &caused_s
>> Error error;
>>
>> bool timed_out = false;
>> - Mutex::Locker locker;
>> + std::unique_lock<std::recursive_mutex> lock;
>>
>> if (m_public_state.GetValue() == eStateAttaching)
>> {
>> @@ -2727,7 +2724,7 @@ ProcessGDBRemote::DoHalt (bool &caused_s
>> }
>> else
>> {
>> - if (!m_gdb_comm.SendInterrupt (locker, 2, timed_out))
>> + if (!m_gdb_comm.SendInterrupt(lock, 2, timed_out))
>> {
>> if (timed_out)
>> error.SetErrorString("timed out sending interrupt
>> packet");
>> @@ -3860,7 +3857,7 @@ ProcessGDBRemote::AsyncThread (void *arg
>> {
>> if (log)
>> log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %"
>> PRIu64 ") listener.WaitForEvent (NULL, event_sp)...", __FUNCTION__, arg,
>> process->GetID());
>> - if (process->m_async_listener_sp->WaitForEvent (NULL, event_sp))
>> + if
>> (process->m_async_listener_sp->WaitForEvent(std::chrono::microseconds(0),
>> event_sp))
>> {
>> const uint32_t event_type = event_sp->GetType();
>> if (event_sp->BroadcasterIs (&process->m_async_broadcaster))
>>
>> Modified: lldb/trunk/source/Target/Process.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Process.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Target/Process.cpp (original)
>> +++ lldb/trunk/source/Target/Process.cpp Thu Jul 28 12:32:20 2016
>> @@ -978,10 +978,8 @@ Process::SyncIOHandler (uint32_t iohandl
>> if (!m_process_input_reader)
>> return;
>>
>> - TimeValue timeout = TimeValue::Now();
>> - timeout.OffsetWithMicroSeconds(timeout_msec*1000);
>> uint32_t new_iohandler_id = 0;
>> - m_iohandler_sync.WaitForValueNotEqualTo(iohandler_id,
>> new_iohandler_id, &timeout);
>> + m_iohandler_sync.WaitForValueNotEqualTo(iohandler_id,
>> new_iohandler_id, std::chrono::milliseconds(timeout_msec));
>>
>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>> (LIBLLDB_LOG_PROCESS));
>> if (log)
>> @@ -989,12 +987,8 @@ Process::SyncIOHandler (uint32_t iohandl
>> }
>>
>> StateType
>> -Process::WaitForProcessToStop (const TimeValue *timeout,
>> - EventSP *event_sp_ptr,
>> - bool wait_always,
>> - ListenerSP hijack_listener_sp,
>> - Stream *stream,
>> - bool use_run_lock)
>> +Process::WaitForProcessToStop(const std::chrono::microseconds &timeout,
>> EventSP *event_sp_ptr, bool wait_always,
>> + ListenerSP hijack_listener_sp, Stream
>> *stream, bool use_run_lock)
>> {
>> // We can't just wait for a "stopped" event, because the stopped
>> event may have restarted the target.
>> // We have to actually check each event, and in the case of a
>> stopped event check the restarted flag
>> @@ -1009,8 +1003,7 @@ Process::WaitForProcessToStop (const Tim
>>
>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>> (LIBLLDB_LOG_PROCESS));
>> if (log)
>> - log->Printf ("Process::%s (timeout = %p)", __FUNCTION__,
>> - static_cast<const void*>(timeout));
>> + log->Printf("Process::%s (timeout = %llu)", __FUNCTION__,
>> static_cast<unsigned long long>(timeout.count()));
>>
>> if (!wait_always &&
>> StateIsStoppedState(state, true) &&
>> @@ -1029,7 +1022,7 @@ Process::WaitForProcessToStop (const Tim
>> while (state != eStateInvalid)
>> {
>> EventSP event_sp;
>> - state = WaitForStateChangedEvents (timeout, event_sp,
>> hijack_listener_sp);
>> + state = WaitForStateChangedEvents(std::chrono::milliseconds(0),
>> event_sp, hijack_listener_sp);
>> if (event_sp_ptr && event_sp)
>> *event_sp_ptr = event_sp;
>>
>> @@ -1265,8 +1258,7 @@ Process::HandleProcessStateChangedEvent
>> }
>>
>> StateType
>> -Process::WaitForState(const TimeValue *timeout,
>> - const StateType *match_states,
>> +Process::WaitForState(const std::chrono::microseconds &timeout, const
>> StateType *match_states,
>> const uint32_t num_match_states)
>> {
>> EventSP event_sp;
>> @@ -1307,13 +1299,14 @@ Process::RestoreProcessEvents ()
>> }
>>
>> StateType
>> -Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP
>> &event_sp, ListenerSP hijack_listener_sp)
>> +Process::WaitForStateChangedEvents(const std::chrono::microseconds
>> &timeout, EventSP &event_sp,
>> + ListenerSP hijack_listener_sp)
>> {
>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>> (LIBLLDB_LOG_PROCESS));
>>
>> if (log)
>> - log->Printf ("Process::%s (timeout = %p, event_sp)...",
>> __FUNCTION__,
>> - static_cast<const void*>(timeout));
>> + log->Printf("Process::%s (timeout = %llu, event_sp)...",
>> __FUNCTION__,
>> + static_cast<unsigned long long>(timeout.count()));
>>
>> ListenerSP listener_sp = hijack_listener_sp;
>> if (!listener_sp)
>> @@ -1332,9 +1325,8 @@ Process::WaitForStateChangedEvents (cons
>> }
>>
>> if (log)
>> - log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
>> - __FUNCTION__, static_cast<const void*>(timeout),
>> - StateAsCString(state));
>> + log->Printf("Process::%s (timeout = %llu, event_sp) => %s",
>> __FUNCTION__,
>> + static_cast<unsigned long long>(timeout.count()),
>> StateAsCString(state));
>> return state;
>> }
>>
>> @@ -1367,13 +1359,13 @@ Process::PeekAtStateChangedEvents ()
>> }
>>
>> StateType
>> -Process::WaitForStateChangedEventsPrivate (const TimeValue *timeout,
>> EventSP &event_sp)
>> +Process::WaitForStateChangedEventsPrivate(const
>> std::chrono::microseconds &timeout, EventSP &event_sp)
>> {
>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>> (LIBLLDB_LOG_PROCESS));
>>
>> if (log)
>> - log->Printf ("Process::%s (timeout = %p, event_sp)...",
>> __FUNCTION__,
>> - static_cast<const void*>(timeout));
>> + log->Printf("Process::%s (timeout = %llu, event_sp)...",
>> __FUNCTION__,
>> + static_cast<unsigned long long>(timeout.count()));
>>
>> StateType state = eStateInvalid;
>> if (m_private_state_listener_sp->WaitForEventForBroadcasterWithType
>> (timeout,
>> @@ -1387,20 +1379,20 @@ Process::WaitForStateChangedEventsPrivat
>> // to the command-line, and that could disable the log, which would
>> render the
>> // log we got above invalid.
>> if (log)
>> - log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
>> - __FUNCTION__, static_cast<const void *>(timeout),
>> - state == eStateInvalid ? "TIMEOUT" :
>> StateAsCString(state));
>> + log->Printf("Process::%s (timeout = %llu, event_sp) => %s",
>> __FUNCTION__,
>> + static_cast<unsigned long long>(timeout.count()),
>> + state == eStateInvalid ? "TIMEOUT" :
>> StateAsCString(state));
>> return state;
>> }
>>
>> bool
>> -Process::WaitForEventsPrivate (const TimeValue *timeout, EventSP
>> &event_sp, bool control_only)
>> +Process::WaitForEventsPrivate(const std::chrono::microseconds &timeout,
>> EventSP &event_sp, bool control_only)
>> {
>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>> (LIBLLDB_LOG_PROCESS));
>>
>> if (log)
>> - log->Printf ("Process::%s (timeout = %p, event_sp)...",
>> __FUNCTION__,
>> - static_cast<const void*>(timeout));
>> + log->Printf("Process::%s (timeout = %llu, event_sp)...",
>> __FUNCTION__,
>> + static_cast<unsigned long long>(timeout.count()));
>>
>> if (control_only)
>> return
>> m_private_state_listener_sp->WaitForEventForBroadcaster(timeout,
>> &m_private_state_control_broadcaster, event_sp);
>> @@ -1751,7 +1743,7 @@ Process::ResumeSynchronous (Stream *stre
>> Error error = PrivateResume();
>> if (error.Success())
>> {
>> - StateType state = WaitForProcessToStop (NULL, NULL, true,
>> listener_sp, stream);
>> + StateType state =
>> WaitForProcessToStop(std::chrono::microseconds(0), NULL, true, listener_sp,
>> stream);
>> const bool must_be_alive = false; // eStateExited is ok, so this
>> must be false
>> if (!StateIsStoppedState(state, must_be_alive))
>> error.SetErrorStringWithFormat("process not in stopped state
>> after synchronous resume: %s", StateAsCString(state));
>> @@ -2891,7 +2883,7 @@ Process::DisableWatchpoint (Watchpoint *
>> }
>>
>> StateType
>> -Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP
>> &event_sp)
>> +Process::WaitForProcessStopPrivate(const std::chrono::microseconds
>> &timeout, EventSP &event_sp)
>> {
>> StateType state;
>> // Now wait for the process to launch and return control to us, and
>> then
>> @@ -2987,10 +2979,7 @@ Process::Launch (ProcessLaunchInfo &laun
>> else
>> {
>> EventSP event_sp;
>> - TimeValue timeout_time;
>> - timeout_time = TimeValue::Now();
>> - timeout_time.OffsetWithSeconds(10);
>> - StateType state =
>> WaitForProcessStopPrivate(&timeout_time, event_sp);
>> + StateType state =
>> WaitForProcessStopPrivate(std::chrono::seconds(10), event_sp);
>>
>> if (state == eStateInvalid || !event_sp)
>> {
>> @@ -3083,7 +3072,7 @@ Process::LoadCore ()
>>
>> // Wait indefinitely for a stopped event since we just posted
>> one above...
>> lldb::EventSP event_sp;
>> - listener_sp->WaitForEvent (nullptr, event_sp);
>> + listener_sp->WaitForEvent(std::chrono::microseconds(0),
>> event_sp);
>> StateType state =
>> ProcessEventData::GetStateFromEvent(event_sp.get());
>>
>> if (!StateIsStoppedState (state, false))
>> @@ -3502,8 +3491,8 @@ Process::ConnectRemote (Stream *strm, co
>> if (GetID() != LLDB_INVALID_PROCESS_ID)
>> {
>> EventSP event_sp;
>> - StateType state = WaitForProcessStopPrivate(nullptr,
>> event_sp);
>> -
>> + StateType state =
>> WaitForProcessStopPrivate(std::chrono::microseconds(0), event_sp);
>> +
>> if (state == eStateStopped || state == eStateCrashed)
>> {
>> // If we attached and actually have a process on the
>> other end, then
>> @@ -3612,11 +3601,8 @@ Process::Halt (bool clear_thread_plans,
>> }
>>
>> // Wait for 10 second for the process to stop.
>> - TimeValue timeout_time;
>> - timeout_time = TimeValue::Now();
>> - timeout_time.OffsetWithSeconds(10);
>> - StateType state = WaitForProcessToStop(&timeout_time, &event_sp,
>> true, halt_listener_sp,
>> - nullptr, use_run_lock);
>> + StateType state =
>> + WaitForProcessToStop(std::chrono::seconds(10), &event_sp, true,
>> halt_listener_sp, nullptr, use_run_lock);
>> RestoreProcessEvents();
>>
>> if (state == eStateInvalid || ! event_sp)
>> @@ -3649,10 +3635,7 @@ Process::StopForDestroyOrDetach(lldb::Ev
>> SendAsyncInterrupt();
>>
>> // Consume the interrupt event.
>> - TimeValue timeout (TimeValue::Now());
>> - timeout.OffsetWithSeconds(10);
>> -
>> - StateType state = WaitForProcessToStop (&timeout,
>> &exit_event_sp, true, listener_sp);
>> + StateType state = WaitForProcessToStop(std::chrono::seconds(10),
>> &exit_event_sp, true, listener_sp);
>>
>> RestoreProcessEvents();
>>
>> @@ -4125,12 +4108,9 @@ Process::ControlPrivateStateThread (uint
>> while (!receipt_received)
>> {
>> bool timed_out = false;
>> - TimeValue timeout_time;
>> - timeout_time = TimeValue::Now();
>> - timeout_time.OffsetWithSeconds(2);
>> // Check for a receipt for 2 seconds and then check if
>> the private state
>> // thread is still around.
>> - receipt_received =
>> event_receipt_sp->WaitForEventReceived (&timeout_time, &timed_out);
>> + receipt_received =
>> event_receipt_sp->WaitForEventReceived(std::chrono::seconds(2), &timed_out);
>> if (!receipt_received)
>> {
>> // Check if the private state thread is still
>> around. If it isn't then we are done waiting
>> @@ -4326,7 +4306,7 @@ Process::RunPrivateStateThread (bool is_
>> while (!exit_now)
>> {
>> EventSP event_sp;
>> - WaitForEventsPrivate(nullptr, event_sp, control_only);
>> + WaitForEventsPrivate(std::chrono::microseconds(0), event_sp,
>> control_only);
>> if
>> (event_sp->BroadcasterIs(&m_private_state_control_broadcaster))
>> {
>> if (log)
>> @@ -5351,9 +5331,6 @@ Process::RunThreadPlan(ExecutionContext
>> lldb::EventSP event_sp;
>> lldb::StateType stop_state = lldb::eStateInvalid;
>>
>> - TimeValue* timeout_ptr = nullptr;
>> - TimeValue real_timeout;
>> -
>> bool before_first_timeout = true; // This is set to false the
>> first time that we have to halt the target.
>> bool do_resume = true;
>> bool handle_running_event = true;
>> @@ -5454,6 +5431,7 @@ Process::RunThreadPlan(ExecutionContext
>> #endif
>> TimeValue one_thread_timeout;
>> TimeValue final_timeout;
>> + std::chrono::microseconds timeout = std::chrono::microseconds(0);
>>
>> while (true)
>> {
>> @@ -5484,10 +5462,7 @@ Process::RunThreadPlan(ExecutionContext
>> }
>> }
>>
>> - TimeValue resume_timeout = TimeValue::Now();
>> - resume_timeout.OffsetWithMicroSeconds(500000);
>> -
>> - got_event = listener_sp->WaitForEvent(&resume_timeout,
>> event_sp);
>> + got_event =
>> listener_sp->WaitForEvent(std::chrono::microseconds(500000), event_sp);
>> if (!got_event)
>> {
>> if (log)
>> @@ -5552,33 +5527,16 @@ Process::RunThreadPlan(ExecutionContext
>> if (before_first_timeout)
>> {
>> if (options.GetTryAllThreads())
>> - {
>> - one_thread_timeout = TimeValue::Now();
>> -
>> one_thread_timeout.OffsetWithMicroSeconds(one_thread_timeout_usec);
>> - timeout_ptr = &one_thread_timeout;
>> - }
>> + timeout =
>> std::chrono::microseconds(one_thread_timeout_usec);
>> else
>> - {
>> - if (timeout_usec == 0)
>> - timeout_ptr = nullptr;
>> - else
>> - {
>> - final_timeout = TimeValue::Now();
>> - final_timeout.OffsetWithMicroSeconds
>> (timeout_usec);
>> - timeout_ptr = &final_timeout;
>> - }
>> - }
>> + timeout = std::chrono::microseconds(timeout_usec);
>> }
>> else
>> {
>> if (timeout_usec == 0)
>> - timeout_ptr = nullptr;
>> + timeout = std::chrono::microseconds(0);
>> else
>> - {
>> - final_timeout = TimeValue::Now();
>> - final_timeout.OffsetWithMicroSeconds
>> (all_threads_timeout_usec);
>> - timeout_ptr = &final_timeout;
>> - }
>> + timeout =
>> std::chrono::microseconds(all_threads_timeout_usec);
>> }
>>
>> do_resume = true;
>> @@ -5589,11 +5547,15 @@ Process::RunThreadPlan(ExecutionContext
>>
>> if (log)
>> {
>> - if (timeout_ptr)
>> + if (timeout.count())
>> {
>> - log->Printf ("Process::RunThreadPlan(): about to
>> wait - now is %" PRIu64 " - endpoint is %" PRIu64,
>> -
>> TimeValue::Now().GetAsMicroSecondsSinceJan1_1970(),
>> -
>> timeout_ptr->GetAsMicroSecondsSinceJan1_1970());
>> + log->Printf(
>> + "Process::RunThreadPlan(): about to wait - now
>> is %llu - endpoint is %llu",
>> + static_cast<unsigned long
>> long>(std::chrono::system_clock::now().time_since_epoch().count()),
>> + static_cast<unsigned long long>(
>> +
>> std::chrono::time_point<std::chrono::system_clock,
>> std::chrono::microseconds>(timeout)
>> + .time_since_epoch()
>> + .count()));
>> }
>> else
>> {
>> @@ -5611,7 +5573,7 @@ Process::RunThreadPlan(ExecutionContext
>> }
>> else
>> #endif
>> - got_event = listener_sp->WaitForEvent (timeout_ptr,
>> event_sp);
>> + got_event = listener_sp->WaitForEvent(timeout, event_sp);
>>
>> if (got_event)
>> {
>> @@ -5810,10 +5772,7 @@ Process::RunThreadPlan(ExecutionContext
>> if (log)
>> log->PutCString ("Process::RunThreadPlan():
>> Halt succeeded.");
>>
>> - real_timeout = TimeValue::Now();
>> - real_timeout.OffsetWithMicroSeconds(500000);
>> -
>> - got_event =
>> listener_sp->WaitForEvent(&real_timeout, event_sp);
>> + got_event =
>> listener_sp->WaitForEvent(std::chrono::microseconds(500000), event_sp);
>>
>> if (got_event)
>> {
>>
>> Modified: lldb/trunk/source/Target/Target.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Target.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>
>> ==============================================================================
>> --- lldb/trunk/source/Target/Target.cpp (original)
>> +++ lldb/trunk/source/Target/Target.cpp Thu Jul 28 12:32:20 2016
>> @@ -3103,8 +3103,9 @@ Target::Launch (ProcessLaunchInfo &launc
>> m_process_sp->HijackProcessEvents(hijack_listener_sp);
>> }
>>
>> - StateType state =
>> m_process_sp->WaitForProcessToStop(nullptr, nullptr, false,
>> hijack_listener_sp, nullptr);
>> -
>> + StateType state =
>> m_process_sp->WaitForProcessToStop(std::chrono::microseconds(0), nullptr,
>> false,
>> +
>> hijack_listener_sp, nullptr);
>> +
>> if (state == eStateStopped)
>> {
>> if (!launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
>> @@ -3114,7 +3115,8 @@ Target::Launch (ProcessLaunchInfo &launc
>> error = m_process_sp->PrivateResume();
>> if (error.Success())
>> {
>> - state =
>> m_process_sp->WaitForProcessToStop(nullptr, nullptr, true,
>> hijack_listener_sp, stream);
>> + state =
>> m_process_sp->WaitForProcessToStop(std::chrono::microseconds(0), nullptr,
>> true,
>> +
>> hijack_listener_sp, stream);
>> const bool must_be_alive = false; //
>> eStateExited is ok, so this must be false
>> if (!StateIsStoppedState(state,
>> must_be_alive))
>> {
>> @@ -3243,7 +3245,8 @@ Target::Attach (ProcessAttachInfo &attac
>> }
>> else
>> {
>> - state = process_sp->WaitForProcessToStop (nullptr, nullptr,
>> false, attach_info.GetHijackListener(), stream);
>> + state =
>> process_sp->WaitForProcessToStop(std::chrono::microseconds(0), nullptr,
>> false,
>> +
>> attach_info.GetHijackListener(), stream);
>> process_sp->RestoreProcessEvents ();
>>
>> if (state != eStateStopped)
>>
>>
>> _______________________________________________
>> lldb-commits mailing list
>> lldb-commits at lists.llvm.org
>> http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
>>
>
>
>
> --
> -Todd
>
--
-Todd
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/lldb-dev/attachments/20160728/c551b46f/attachment-0001.html>
More information about the lldb-dev
mailing list