Vendor import of lldb trunk r290819:vendor/lldb/lldb-trunk-r290819

https://llvm.org/svn/llvm-project/lldb/trunk@290819

493 files changed, 69583 insertions, 84003 deletions

diff --git a/include/lldb/API/LLDB.h b/include/lldb/API/LLDB.h
index b6278160dbc0..d8604cd07114 100644
--- a/include/lldb/API/LLDB.h
+++ b/include/lldb/API/LLDB.h
@@ -14,7 +14,6 @@
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBAttachInfo.h"
 #include "lldb/API/SBBlock.h"
@@ -28,6 +27,7 @@
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDeclaration.h"
+#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExecutionContext.h"
@@ -55,6 +55,7 @@
 #include "lldb/API/SBSourceManager.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
+#include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBSymbol.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/API/SBSymbolContextList.h"
@@ -76,4 +77,4 @@
 #include "lldb/API/SBVariablesOptions.h"
 #include "lldb/API/SBWatchpoint.h"
 
-#endif  // LLDB_LLDB_h_
+#endif // LLDB_LLDB_h_
diff --git a/include/lldb/API/SBAddress.h b/include/lldb/API/SBAddress.h
index 4cbbee9fd132..ddbe5a742786 100644
--- a/include/lldb/API/SBAddress.h
+++ b/include/lldb/API/SBAddress.h
@@ -15,138 +15,108 @@
 
 namespace lldb {
 
-class LLDB_API SBAddress
-{
+class LLDB_API SBAddress {
 public:
+  SBAddress();
 
-    SBAddress ();
+  SBAddress(const lldb::SBAddress &rhs);
 
-    SBAddress (const lldb::SBAddress &rhs);
+  SBAddress(lldb::SBSection section, lldb::addr_t offset);
 
-    SBAddress (lldb::SBSection section, lldb::addr_t offset);
+  // Create an address by resolving a load address using the supplied target
+  SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target);
 
-    // Create an address by resolving a load address using the supplied target
-    SBAddress (lldb::addr_t load_addr, lldb::SBTarget &target);
+  ~SBAddress();
 
-    ~SBAddress ();
+  const lldb::SBAddress &operator=(const lldb::SBAddress &rhs);
 
-    const lldb::SBAddress &
-    operator = (const lldb::SBAddress &rhs);
+  bool IsValid() const;
 
-    bool
-    IsValid () const;
+  void Clear();
 
-    void
-    Clear ();
+  addr_t GetFileAddress() const;
 
-    addr_t
-    GetFileAddress () const;
+  addr_t GetLoadAddress(const lldb::SBTarget &target) const;
 
-    addr_t
-    GetLoadAddress (const lldb::SBTarget &target) const;
+  void SetAddress(lldb::SBSection section, lldb::addr_t offset);
 
-    void
-    SetAddress (lldb::SBSection section, lldb::addr_t offset);
+  void SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target);
+  bool OffsetAddress(addr_t offset);
 
-    void
-    SetLoadAddress (lldb::addr_t load_addr, 
-                    lldb::SBTarget &target);
-    bool
-    OffsetAddress (addr_t offset);
+  bool GetDescription(lldb::SBStream &description);
 
-    bool
-    GetDescription (lldb::SBStream &description);
+  // The following queries can lookup symbol information for a given address.
+  // An address might refer to code or data from an existing module, or it
+  // might refer to something on the stack or heap. The following functions
+  // will only return valid values if the address has been resolved to a code
+  // or data address using "void SBAddress::SetLoadAddress(...)" or
+  // "lldb::SBAddress SBTarget::ResolveLoadAddress (...)".
+  lldb::SBSymbolContext GetSymbolContext(uint32_t resolve_scope);
 
-    // The following queries can lookup symbol information for a given address.
-    // An address might refer to code or data from an existing module, or it
-    // might refer to something on the stack or heap. The following functions
-    // will only return valid values if the address has been resolved to a code
-    // or data address using "void SBAddress::SetLoadAddress(...)" or 
-    // "lldb::SBAddress SBTarget::ResolveLoadAddress (...)". 
-    lldb::SBSymbolContext
-    GetSymbolContext (uint32_t resolve_scope);
+  // The following functions grab individual objects for a given address and
+  // are less efficient if you want more than one symbol related objects.
+  // Use one of the following when you want multiple debug symbol related
+  // objects for an address:
+  //    lldb::SBSymbolContext SBAddress::GetSymbolContext (uint32_t
+  //    resolve_scope);
+  //    lldb::SBSymbolContext SBTarget::ResolveSymbolContextForAddress (const
+  //    SBAddress &addr, uint32_t resolve_scope);
+  // One or more bits from the SymbolContextItem enumerations can be logically
+  // OR'ed together to more efficiently retrieve multiple symbol objects.
 
-    
-    // The following functions grab individual objects for a given address and
-    // are less efficient if you want more than one symbol related objects. 
-    // Use one of the following when you want multiple debug symbol related 
-    // objects for an address:
-    //    lldb::SBSymbolContext SBAddress::GetSymbolContext (uint32_t resolve_scope);
-    //    lldb::SBSymbolContext SBTarget::ResolveSymbolContextForAddress (const SBAddress &addr, uint32_t resolve_scope);
-    // One or more bits from the SymbolContextItem enumerations can be logically
-    // OR'ed together to more efficiently retrieve multiple symbol objects.
+  lldb::SBSection GetSection();
 
-    lldb::SBSection
-    GetSection ();
+  lldb::addr_t GetOffset();
 
-    lldb::addr_t
-    GetOffset ();
+  lldb::SBModule GetModule();
 
-    lldb::SBModule
-    GetModule ();
-    
-    lldb::SBCompileUnit
-    GetCompileUnit ();
+  lldb::SBCompileUnit GetCompileUnit();
 
-    lldb::SBFunction
-    GetFunction ();
+  lldb::SBFunction GetFunction();
 
-    lldb::SBBlock
-    GetBlock ();
+  lldb::SBBlock GetBlock();
 
-    lldb::SBSymbol
-    GetSymbol ();
+  lldb::SBSymbol GetSymbol();
 
-    lldb::SBLineEntry
-    GetLineEntry ();
-    
-    lldb::AddressClass
-    GetAddressClass ();
+  lldb::SBLineEntry GetLineEntry();
 
-protected:
+  lldb::AddressClass GetAddressClass();
 
-    friend class SBBlock;
-    friend class SBBreakpointLocation;
-    friend class SBFrame;
-    friend class SBFunction;
-    friend class SBLineEntry;
-    friend class SBInstruction;
-    friend class SBModule;
-    friend class SBSection;
-    friend class SBSymbol;
-    friend class SBSymbolContext;
-    friend class SBTarget;
-    friend class SBThread;
-    friend class SBThreadPlan;
-    friend class SBValue;
-    friend class SBQueueItem;
+protected:
+  friend class SBBlock;
+  friend class SBBreakpointLocation;
+  friend class SBFrame;
+  friend class SBFunction;
+  friend class SBLineEntry;
+  friend class SBInstruction;
+  friend class SBModule;
+  friend class SBSection;
+  friend class SBSymbol;
+  friend class SBSymbolContext;
+  friend class SBTarget;
+  friend class SBThread;
+  friend class SBThreadPlan;
+  friend class SBValue;
+  friend class SBQueueItem;
 
-    lldb_private::Address *
-    operator->();
+  lldb_private::Address *operator->();
 
-    const lldb_private::Address *
-    operator->() const;
+  const lldb_private::Address *operator->() const;
 
-    lldb_private::Address *
-    get ();
+  lldb_private::Address *get();
 
-    lldb_private::Address &
-    ref();
+  lldb_private::Address &ref();
 
-    const lldb_private::Address &
-    ref() const;
+  const lldb_private::Address &ref() const;
 
-    SBAddress (const lldb_private::Address *lldb_object_ptr);
+  SBAddress(const lldb_private::Address *lldb_object_ptr);
 
-    void
-    SetAddress (const lldb_private::Address *lldb_object_ptr);
+  void SetAddress(const lldb_private::Address *lldb_object_ptr);
 
 private:
-
-    std::unique_ptr<lldb_private::Address> m_opaque_ap;
+  std::unique_ptr<lldb_private::Address> m_opaque_ap;
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBAddress_h_
diff --git a/include/lldb/API/SBAttachInfo.h b/include/lldb/API/SBAttachInfo.h
index a246d9919cfa..6c3561615990 100644
--- a/include/lldb/API/SBAttachInfo.h
+++ b/include/lldb/API/SBAttachInfo.h
@@ -16,209 +16,175 @@ namespace lldb {
 
 class SBTarget;
 
-class LLDB_API SBAttachInfo
-{
+class LLDB_API SBAttachInfo {
 public:
-    SBAttachInfo ();
-
-    SBAttachInfo (lldb::pid_t pid);
-
-    //------------------------------------------------------------------
-    /// Attach to a process by name.
-    ///
-    /// This function implies that a future call to SBTarget::Attach(...)
-    /// will be synchronous.
-    ///
-    /// @param[in] path
-    ///     A full or partial name for the process to attach to.
-    ///
-    /// @param[in] wait_for
-    ///     If \b false, attach to an existing process whose name matches.
-    ///     If \b true, then wait for the next process whose name matches.
-    //------------------------------------------------------------------
-    SBAttachInfo (const char *path, bool wait_for);
-
-    //------------------------------------------------------------------
-    /// Attach to a process by name.
-    ///
-    /// Future calls to SBTarget::Attach(...) will be synchronous or
-    /// asynchronous depending on the \a async argument.
-    ///
-    /// @param[in] path
-    ///     A full or partial name for the process to attach to.
-    ///
-    /// @param[in] wait_for
-    ///     If \b false, attach to an existing process whose name matches.
-    ///     If \b true, then wait for the next process whose name matches.
-    ///
-    /// @param[in] async
-    ///     If \b false, then the SBTarget::Attach(...) call will be a
-    ///     synchronous call with no way to cancel the attach in
-    ///     progress.
-    ///     If \b true, then the SBTarget::Attach(...) function will
-    ///     return immediately and clients are expected to wait for a
-    ///     process eStateStopped event if a suitable process is
-    ///     eventually found. If the client wants to cancel the event,
-    ///     SBProcess::Stop() can be called and an eStateExited process
-    ///     event will be delivered.
-    //------------------------------------------------------------------
-    SBAttachInfo (const char *path, bool wait_for, bool async);
-
-    SBAttachInfo (const SBAttachInfo &rhs);
-
-    ~SBAttachInfo();
-
-    SBAttachInfo &
-    operator = (const SBAttachInfo &rhs);
-
-    lldb::pid_t
-    GetProcessID ();
-
-    void
-    SetProcessID (lldb::pid_t pid);
-
-    void
-    SetExecutable (const char *path);
-
-    void
-    SetExecutable (lldb::SBFileSpec exe_file);
-
-    bool
-    GetWaitForLaunch ();
-
-    //------------------------------------------------------------------
-    /// Set attach by process name settings.
-    ///
-    /// Designed to be used after a call to SBAttachInfo::SetExecutable().
-    /// This function implies that a call to SBTarget::Attach(...) will
-    /// be synchronous.
-    ///
-    /// @param[in] wait_for
-    ///     If \b false, attach to an existing process whose name matches.
-    ///     If \b true, then wait for the next process whose name matches.
-    //------------------------------------------------------------------
-    void
-    SetWaitForLaunch (bool b);
-
-    //------------------------------------------------------------------
-    /// Set attach by process name settings.
-    ///
-    /// Designed to be used after a call to SBAttachInfo::SetExecutable().
-    /// Future calls to SBTarget::Attach(...) will be synchronous or
-    /// asynchronous depending on the \a async argument.
-    ///
-    /// @param[in] wait_for
-    ///     If \b false, attach to an existing process whose name matches.
-    ///     If \b true, then wait for the next process whose name matches.
-    ///
-    /// @param[in] async
-    ///     If \b false, then the SBTarget::Attach(...) call will be a
-    ///     synchronous call with no way to cancel the attach in
-    ///     progress.
-    ///     If \b true, then the SBTarget::Attach(...) function will
-    ///     return immediately and clients are expected to wait for a
-    ///     process eStateStopped event if a suitable process is
-    ///     eventually found. If the client wants to cancel the event,
-    ///     SBProcess::Stop() can be called and an eStateExited process
-    ///     event will be delivered.
-    //------------------------------------------------------------------
-    void
-    SetWaitForLaunch (bool b, bool async);
-
-    bool
-    GetIgnoreExisting ();
-
-    void
-    SetIgnoreExisting (bool b);
-
-    uint32_t
-    GetResumeCount ();
-
-    void
-    SetResumeCount (uint32_t c);
-
-    const char *
-    GetProcessPluginName ();
-
-    void
-    SetProcessPluginName (const char *plugin_name);
-
-    uint32_t
-    GetUserID();
-
-    uint32_t
-    GetGroupID();
-
-    bool
-    UserIDIsValid ();
-
-    bool
-    GroupIDIsValid ();
-
-    void
-    SetUserID (uint32_t uid);
-
-    void
-    SetGroupID (uint32_t gid);
-
-    uint32_t
-    GetEffectiveUserID();
-
-    uint32_t
-    GetEffectiveGroupID();
-
-    bool
-    EffectiveUserIDIsValid ();
-
-    bool
-    EffectiveGroupIDIsValid ();
-
-    void
-    SetEffectiveUserID (uint32_t uid);
-
-    void
-    SetEffectiveGroupID (uint32_t gid);
-
-    lldb::pid_t
-    GetParentProcessID ();
-
-    void
-    SetParentProcessID (lldb::pid_t pid);
-
-    bool
-    ParentProcessIDIsValid();
-
-    //----------------------------------------------------------------------
-    /// Get the listener that will be used to receive process events.
-    ///
-    /// If no listener has been set via a call to
-    /// SBLaunchInfo::SetListener(), then an invalid SBListener will be
-    /// returned (SBListener::IsValid() will return false). If a listener
-    /// has been set, then the valid listener object will be returned.
-    //----------------------------------------------------------------------
-    SBListener
-    GetListener ();
-
-    //----------------------------------------------------------------------
-    /// Set the listener that will be used to receive process events.
-    ///
-    /// By default the SBDebugger, which has a listener, that the SBTarget
-    /// belongs to will listen for the process events. Calling this function
-    /// allows a different listener to be used to listen for process events.
-    //----------------------------------------------------------------------
-    void
-    SetListener (SBListener &listener);
+  SBAttachInfo();
+
+  SBAttachInfo(lldb::pid_t pid);
+
+  //------------------------------------------------------------------
+  /// Attach to a process by name.
+  ///
+  /// This function implies that a future call to SBTarget::Attach(...)
+  /// will be synchronous.
+  ///
+  /// @param[in] path
+  ///     A full or partial name for the process to attach to.
+  ///
+  /// @param[in] wait_for
+  ///     If \b false, attach to an existing process whose name matches.
+  ///     If \b true, then wait for the next process whose name matches.
+  //------------------------------------------------------------------
+  SBAttachInfo(const char *path, bool wait_for);
+
+  //------------------------------------------------------------------
+  /// Attach to a process by name.
+  ///
+  /// Future calls to SBTarget::Attach(...) will be synchronous or
+  /// asynchronous depending on the \a async argument.
+  ///
+  /// @param[in] path
+  ///     A full or partial name for the process to attach to.
+  ///
+  /// @param[in] wait_for
+  ///     If \b false, attach to an existing process whose name matches.
+  ///     If \b true, then wait for the next process whose name matches.
+  ///
+  /// @param[in] async
+  ///     If \b false, then the SBTarget::Attach(...) call will be a
+  ///     synchronous call with no way to cancel the attach in
+  ///     progress.
+  ///     If \b true, then the SBTarget::Attach(...) function will
+  ///     return immediately and clients are expected to wait for a
+  ///     process eStateStopped event if a suitable process is
+  ///     eventually found. If the client wants to cancel the event,
+  ///     SBProcess::Stop() can be called and an eStateExited process
+  ///     event will be delivered.
+  //------------------------------------------------------------------
+  SBAttachInfo(const char *path, bool wait_for, bool async);
+
+  SBAttachInfo(const SBAttachInfo &rhs);
+
+  ~SBAttachInfo();
+
+  SBAttachInfo &operator=(const SBAttachInfo &rhs);
+
+  lldb::pid_t GetProcessID();
+
+  void SetProcessID(lldb::pid_t pid);
+
+  void SetExecutable(const char *path);
+
+  void SetExecutable(lldb::SBFileSpec exe_file);
+
+  bool GetWaitForLaunch();
+
+  //------------------------------------------------------------------
+  /// Set attach by process name settings.
+  ///
+  /// Designed to be used after a call to SBAttachInfo::SetExecutable().
+  /// This function implies that a call to SBTarget::Attach(...) will
+  /// be synchronous.
+  ///
+  /// @param[in] wait_for
+  ///     If \b false, attach to an existing process whose name matches.
+  ///     If \b true, then wait for the next process whose name matches.
+  //------------------------------------------------------------------
+  void SetWaitForLaunch(bool b);
+
+  //------------------------------------------------------------------
+  /// Set attach by process name settings.
+  ///
+  /// Designed to be used after a call to SBAttachInfo::SetExecutable().
+  /// Future calls to SBTarget::Attach(...) will be synchronous or
+  /// asynchronous depending on the \a async argument.
+  ///
+  /// @param[in] wait_for
+  ///     If \b false, attach to an existing process whose name matches.
+  ///     If \b true, then wait for the next process whose name matches.
+  ///
+  /// @param[in] async
+  ///     If \b false, then the SBTarget::Attach(...) call will be a
+  ///     synchronous call with no way to cancel the attach in
+  ///     progress.
+  ///     If \b true, then the SBTarget::Attach(...) function will
+  ///     return immediately and clients are expected to wait for a
+  ///     process eStateStopped event if a suitable process is
+  ///     eventually found. If the client wants to cancel the event,
+  ///     SBProcess::Stop() can be called and an eStateExited process
+  ///     event will be delivered.
+  //------------------------------------------------------------------
+  void SetWaitForLaunch(bool b, bool async);
+
+  bool GetIgnoreExisting();
+
+  void SetIgnoreExisting(bool b);
+
+  uint32_t GetResumeCount();
+
+  void SetResumeCount(uint32_t c);
+
+  const char *GetProcessPluginName();
+
+  void SetProcessPluginName(const char *plugin_name);
+
+  uint32_t GetUserID();
+
+  uint32_t GetGroupID();
+
+  bool UserIDIsValid();
+
+  bool GroupIDIsValid();
 
+  void SetUserID(uint32_t uid);
+
+  void SetGroupID(uint32_t gid);
+
+  uint32_t GetEffectiveUserID();
+
+  uint32_t GetEffectiveGroupID();
+
+  bool EffectiveUserIDIsValid();
+
+  bool EffectiveGroupIDIsValid();
+
+  void SetEffectiveUserID(uint32_t uid);
+
+  void SetEffectiveGroupID(uint32_t gid);
+
+  lldb::pid_t GetParentProcessID();
+
+  void SetParentProcessID(lldb::pid_t pid);
+
+  bool ParentProcessIDIsValid();
+
+  //----------------------------------------------------------------------
+  /// Get the listener that will be used to receive process events.
+  ///
+  /// If no listener has been set via a call to
+  /// SBLaunchInfo::SetListener(), then an invalid SBListener will be
+  /// returned (SBListener::IsValid() will return false). If a listener
+  /// has been set, then the valid listener object will be returned.
+  //----------------------------------------------------------------------
+  SBListener GetListener();
+
+  //----------------------------------------------------------------------
+  /// Set the listener that will be used to receive process events.
+  ///
+  /// By default the SBDebugger, which has a listener, that the SBTarget
+  /// belongs to will listen for the process events. Calling this function
+  /// allows a different listener to be used to listen for process events.
+  //----------------------------------------------------------------------
+  void SetListener(SBListener &listener);
 
 protected:
-    friend class SBTarget;
+  friend class SBTarget;
 
-    lldb_private::ProcessAttachInfo &
-    ref ();
+  lldb_private::ProcessAttachInfo &ref();
 
-    ProcessAttachInfoSP m_opaque_sp;
+  ProcessAttachInfoSP m_opaque_sp;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBAttachInfo_h_
+#endif // LLDB_SBAttachInfo_h_
diff --git a/include/lldb/API/SBBlock.h b/include/lldb/API/SBBlock.h
index a18eab02088b..112de9673423 100644
--- a/include/lldb/API/SBBlock.h
+++ b/include/lldb/API/SBBlock.h
@@ -17,107 +17,80 @@
 
 namespace lldb {
 
-class LLDB_API SBBlock
-{
+class LLDB_API SBBlock {
 public:
+  SBBlock();
 
-    SBBlock ();
-
-    SBBlock (const lldb::SBBlock &rhs);
-
-    ~SBBlock ();
-
-    const lldb::SBBlock &
-    operator = (const lldb::SBBlock &rhs);
-
-    bool
-    IsInlined () const;
-
-    bool
-    IsValid () const;
-
-    const char *
-    GetInlinedName () const;
-
-    lldb::SBFileSpec
-    GetInlinedCallSiteFile () const;
-
-    uint32_t 
-    GetInlinedCallSiteLine () const;
-
-    uint32_t
-    GetInlinedCallSiteColumn () const;
-
-    lldb::SBBlock
-    GetParent ();
-    
-    lldb::SBBlock
-    GetSibling ();
-    
-    lldb::SBBlock
-    GetFirstChild ();
-
-    uint32_t
-    GetNumRanges ();
-
-    lldb::SBAddress
-    GetRangeStartAddress (uint32_t idx);
-
-    lldb::SBAddress
-    GetRangeEndAddress (uint32_t idx);
-
-    uint32_t
-    GetRangeIndexForBlockAddress (lldb::SBAddress block_addr);
-
-    lldb::SBValueList
-    GetVariables (lldb::SBFrame& frame,
-                  bool arguments,
-                  bool locals,
-                  bool statics,
-                  lldb::DynamicValueType use_dynamic);
-    
-    lldb::SBValueList
-    GetVariables (lldb::SBTarget& target,
-                  bool arguments,
-                  bool locals,
-                  bool statics);
-    //------------------------------------------------------------------
-    /// Get the inlined block that contains this block.
-    ///
-    /// @return
-    ///     If this block is inlined, it will return this block, else 
-    ///     parent blocks will be searched to see if any contain this 
-    ///     block and are themselves inlined. An invalid SBBlock will 
-    ///     be returned if this block nor any parent blocks are inlined
-    ///     function blocks.
-    //------------------------------------------------------------------
-    lldb::SBBlock
-    GetContainingInlinedBlock ();
-
-    bool
-    GetDescription (lldb::SBStream &description);
+  SBBlock(const lldb::SBBlock &rhs);
+
+  ~SBBlock();
+
+  const lldb::SBBlock &operator=(const lldb::SBBlock &rhs);
+
+  bool IsInlined() const;
+
+  bool IsValid() const;
+
+  const char *GetInlinedName() const;
+
+  lldb::SBFileSpec GetInlinedCallSiteFile() const;
+
+  uint32_t GetInlinedCallSiteLine() const;
+
+  uint32_t GetInlinedCallSiteColumn() const;
+
+  lldb::SBBlock GetParent();
+
+  lldb::SBBlock GetSibling();
+
+  lldb::SBBlock GetFirstChild();
+
+  uint32_t GetNumRanges();
+
+  lldb::SBAddress GetRangeStartAddress(uint32_t idx);
+
+  lldb::SBAddress GetRangeEndAddress(uint32_t idx);
+
+  uint32_t GetRangeIndexForBlockAddress(lldb::SBAddress block_addr);
+
+  lldb::SBValueList GetVariables(lldb::SBFrame &frame, bool arguments,
+                                 bool locals, bool statics,
+                                 lldb::DynamicValueType use_dynamic);
+
+  lldb::SBValueList GetVariables(lldb::SBTarget &target, bool arguments,
+                                 bool locals, bool statics);
+  //------------------------------------------------------------------
+  /// Get the inlined block that contains this block.
+  ///
+  /// @return
+  ///     If this block is inlined, it will return this block, else
+  ///     parent blocks will be searched to see if any contain this
+  ///     block and are themselves inlined. An invalid SBBlock will
+  ///     be returned if this block nor any parent blocks are inlined
+  ///     function blocks.
+  //------------------------------------------------------------------
+  lldb::SBBlock GetContainingInlinedBlock();
+
+  bool GetDescription(lldb::SBStream &description);
 
 private:
-    friend class SBAddress;
-    friend class SBFrame;
-    friend class SBFunction;
-    friend class SBSymbolContext;
+  friend class SBAddress;
+  friend class SBFrame;
+  friend class SBFunction;
+  friend class SBSymbolContext;
 
-    lldb_private::Block *
-    GetPtr ();
+  lldb_private::Block *GetPtr();
 
-    void
-    SetPtr (lldb_private::Block *lldb_object_ptr);
+  void SetPtr(lldb_private::Block *lldb_object_ptr);
 
-    SBBlock (lldb_private::Block *lldb_object_ptr);
+  SBBlock(lldb_private::Block *lldb_object_ptr);
 
-    void
-    AppendVariables (bool can_create, bool get_parent_variables, lldb_private::VariableList *var_list);
+  void AppendVariables(bool can_create, bool get_parent_variables,
+                       lldb_private::VariableList *var_list);
 
-    lldb_private::Block *m_opaque_ptr;
+  lldb_private::Block *m_opaque_ptr;
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBBlock_h_
diff --git a/include/lldb/API/SBBreakpoint.h b/include/lldb/API/SBBreakpoint.h
index c244ab8a9b48..56509c903c2d 100644
--- a/include/lldb/API/SBBreakpoint.h
+++ b/include/lldb/API/SBBreakpoint.h
@@ -12,182 +12,171 @@
 
 #include "lldb/API/SBDefines.h"
 
+class SBBreakpointListImpl;
+
 namespace lldb {
 
-class LLDB_API SBBreakpoint
-{
+class LLDB_API SBBreakpoint {
 public:
+  typedef bool (*BreakpointHitCallback)(void *baton, SBProcess &process,
+                                        SBThread &thread,
+                                        lldb::SBBreakpointLocation &location);
+
+  SBBreakpoint();
+
+  SBBreakpoint(const lldb::SBBreakpoint &rhs);
+
+  ~SBBreakpoint();
+
+  const lldb::SBBreakpoint &operator=(const lldb::SBBreakpoint &rhs);
+
+  // Tests to see if the opaque breakpoint object in this object matches the
+  // opaque breakpoint object in "rhs".
+  bool operator==(const lldb::SBBreakpoint &rhs);
+
+  bool operator!=(const lldb::SBBreakpoint &rhs);
+
+  break_id_t GetID() const;
+
+  bool IsValid() const;
+
+  void ClearAllBreakpointSites();
+
+  lldb::SBBreakpointLocation FindLocationByAddress(lldb::addr_t vm_addr);
+
+  lldb::break_id_t FindLocationIDByAddress(lldb::addr_t vm_addr);
+
+  lldb::SBBreakpointLocation FindLocationByID(lldb::break_id_t bp_loc_id);
+
+  lldb::SBBreakpointLocation GetLocationAtIndex(uint32_t index);
+
+  void SetEnabled(bool enable);
+
+  bool IsEnabled();
+
+  void SetOneShot(bool one_shot);
+
+  bool IsOneShot() const;
+
+  bool IsInternal();
+
+  uint32_t GetHitCount() const;
+
+  void SetIgnoreCount(uint32_t count);
+
+  uint32_t GetIgnoreCount() const;
+
+  void SetCondition(const char *condition);
+
+  const char *GetCondition();
+
+  void SetThreadID(lldb::tid_t sb_thread_id);
+
+  lldb::tid_t GetThreadID();
+
+  void SetThreadIndex(uint32_t index);
+
+  uint32_t GetThreadIndex() const;
+
+  void SetThreadName(const char *thread_name);
+
+  const char *GetThreadName() const;
+
+  void SetQueueName(const char *queue_name);
+
+  const char *GetQueueName() const;
 
-    typedef bool (*BreakpointHitCallback) (void *baton, 
-                                           SBProcess &process,
-                                           SBThread &thread, 
-                                           lldb::SBBreakpointLocation &location);
-
-    SBBreakpoint ();
-
-    SBBreakpoint (const lldb::SBBreakpoint& rhs);
-
-    ~SBBreakpoint();
-
-    const lldb::SBBreakpoint &
-    operator = (const lldb::SBBreakpoint& rhs);
-    
-    // Tests to see if the opaque breakpoint object in this object matches the
-    // opaque breakpoint object in "rhs".
-    bool
-    operator == (const lldb::SBBreakpoint& rhs);
-
-    bool
-    operator != (const lldb::SBBreakpoint& rhs);
-    
-    break_id_t
-    GetID () const;
-
-    bool
-    IsValid() const;
-
-    void
-    ClearAllBreakpointSites ();
-
-    lldb::SBBreakpointLocation
-    FindLocationByAddress (lldb::addr_t vm_addr);
-
-    lldb::break_id_t
-    FindLocationIDByAddress (lldb::addr_t vm_addr);
-
-    lldb::SBBreakpointLocation
-    FindLocationByID (lldb::break_id_t bp_loc_id);
-
-    lldb::SBBreakpointLocation
-    GetLocationAtIndex (uint32_t index);
-
-    void
-    SetEnabled (bool enable);
-
-    bool
-    IsEnabled ();
-    
-    void
-    SetOneShot (bool one_shot);
-
-    bool
-    IsOneShot () const;
-    
-    bool
-    IsInternal ();
-
-    uint32_t
-    GetHitCount () const;
-
-    void
-    SetIgnoreCount (uint32_t count);
-
-    uint32_t
-    GetIgnoreCount () const;
-    
-    void 
-    SetCondition (const char *condition);
-    
-    const char *
-    GetCondition ();
-
-    void
-    SetThreadID (lldb::tid_t sb_thread_id);
-
-    lldb::tid_t
-    GetThreadID ();
-    
-    void
-    SetThreadIndex (uint32_t index);
-    
-    uint32_t
-    GetThreadIndex() const;
-    
-    void
-    SetThreadName (const char *thread_name);
-    
-    const char *
-    GetThreadName () const;
-    
-    void 
-    SetQueueName (const char *queue_name);
-    
-    const char *
-    GetQueueName () const;
-
-    void
-    SetCallback (BreakpointHitCallback callback, void *baton);
-    
-    void
-    SetScriptCallbackFunction (const char *callback_function_name);
-    
-    SBError
-    SetScriptCallbackBody (const char *script_body_text);
-
-    bool
-    AddName (const char *new_name);
-
-    void
-    RemoveName (const char *name_to_remove);
-
-    bool
-    MatchesName (const char *name);
-
-    void
-    GetNames (SBStringList &names);
-    
-    size_t
-    GetNumResolvedLocations() const;
-
-    size_t
-    GetNumLocations() const;
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    static bool
-    EventIsBreakpointEvent (const lldb::SBEvent &event);
-    
-    static lldb::BreakpointEventType
-    GetBreakpointEventTypeFromEvent (const lldb::SBEvent& event);
-
-    static lldb::SBBreakpoint
-    GetBreakpointFromEvent (const lldb::SBEvent& event);
-    
-    static lldb::SBBreakpointLocation
-    GetBreakpointLocationAtIndexFromEvent (const lldb::SBEvent& event, uint32_t loc_idx);
-    
-    static uint32_t
-    GetNumBreakpointLocationsFromEvent (const lldb::SBEvent &event_sp);
+  void SetCallback(BreakpointHitCallback callback, void *baton);
 
+  void SetScriptCallbackFunction(const char *callback_function_name);
+
+  void SetCommandLineCommands(SBStringList &commands);
+
+  bool GetCommandLineCommands(SBStringList &commands);
+
+  SBError SetScriptCallbackBody(const char *script_body_text);
+
+  bool AddName(const char *new_name);
+
+  void RemoveName(const char *name_to_remove);
+
+  bool MatchesName(const char *name);
+
+  void GetNames(SBStringList &names);
+
+  size_t GetNumResolvedLocations() const;
+
+  size_t GetNumLocations() const;
+
+  bool GetDescription(lldb::SBStream &description);
+
+  bool GetDescription(lldb::SBStream &description, bool include_locations);
+
+  static bool EventIsBreakpointEvent(const lldb::SBEvent &event);
+
+  static lldb::BreakpointEventType
+  GetBreakpointEventTypeFromEvent(const lldb::SBEvent &event);
+
+  static lldb::SBBreakpoint GetBreakpointFromEvent(const lldb::SBEvent &event);
+
+  static lldb::SBBreakpointLocation
+  GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event,
+                                        uint32_t loc_idx);
+
+  static uint32_t
+  GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event_sp);
 
 private:
-    friend class SBBreakpointLocation;
-    friend class SBTarget;
+  friend class SBBreakpointList;
+  friend class SBBreakpointLocation;
+  friend class SBTarget;
 
-    SBBreakpoint (const lldb::BreakpointSP &bp_sp);
+  SBBreakpoint(const lldb::BreakpointSP &bp_sp);
 
-    lldb_private::Breakpoint *
-    operator->() const;
+  lldb_private::Breakpoint *operator->() const;
 
-    lldb_private::Breakpoint *
-    get() const;
+  lldb_private::Breakpoint *get() const;
 
-    lldb::BreakpointSP &
-    operator *();
+  lldb::BreakpointSP &operator*();
 
-    const lldb::BreakpointSP &
-    operator *() const;
+  const lldb::BreakpointSP &operator*() const;
 
-    static bool
-    PrivateBreakpointHitCallback (void *baton, 
-                                  lldb_private::StoppointCallbackContext *context, 
-                                  lldb::user_id_t break_id, 
-                                  lldb::user_id_t break_loc_id);
-    
-    lldb::BreakpointSP m_opaque_sp;
+  static bool PrivateBreakpointHitCallback(
+      void *baton, lldb_private::StoppointCallbackContext *context,
+      lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
+
+  lldb::BreakpointSP m_opaque_sp;
+};
+
+class LLDB_API SBBreakpointList {
+public:
+  SBBreakpointList(SBTarget &target);
+
+  ~SBBreakpointList();
+
+  size_t GetSize() const;
+
+  SBBreakpoint GetBreakpointAtIndex(size_t idx);
+
+  SBBreakpoint FindBreakpointByID(lldb::break_id_t);
+
+  void Append(const SBBreakpoint &sb_file);
+
+  bool AppendIfUnique(const SBBreakpoint &sb_file);
+
+  void AppendByID(lldb::break_id_t id);
+
+  void Clear();
+
+protected:
+  friend class SBTarget;
+
+  void CopyToBreakpointIDList(lldb_private::BreakpointIDList &bp_id_list);
+
+private:
+  std::shared_ptr<SBBreakpointListImpl> m_opaque_sp;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBBreakpoint_h_
+#endif // LLDB_SBBreakpoint_h_
diff --git a/include/lldb/API/SBBreakpointLocation.h b/include/lldb/API/SBBreakpointLocation.h
index ab7049739c0b..344c39c7bfd3 100644
--- a/include/lldb/API/SBBreakpointLocation.h
+++ b/include/lldb/API/SBBreakpointLocation.h
@@ -10,105 +10,78 @@
 #ifndef LLDB_SBBreakpointLocation_h_
 #define LLDB_SBBreakpointLocation_h_
 
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBBreakpoint.h"
+#include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
-class LLDB_API SBBreakpointLocation
-{
+class LLDB_API SBBreakpointLocation {
 public:
+  SBBreakpointLocation();
 
-    SBBreakpointLocation ();
-
-    SBBreakpointLocation (const lldb::SBBreakpointLocation &rhs);
-
-    ~SBBreakpointLocation ();
-
-    const lldb::SBBreakpointLocation &
-    operator = (const lldb::SBBreakpointLocation &rhs);
-
-    break_id_t
-    GetID ();
-    
-    bool
-    IsValid() const;
-
-    lldb::SBAddress
-    GetAddress ();
-    
-    lldb::addr_t
-    GetLoadAddress ();
-
-    void
-    SetEnabled(bool enabled);
-
-    bool
-    IsEnabled ();
-
-    uint32_t
-    GetIgnoreCount ();
-
-    void
-    SetIgnoreCount (uint32_t n);
-
-    void 
-    SetCondition (const char *condition);
-    
-    const char *
-    GetCondition ();
-
-    void
-    SetScriptCallbackFunction (const char *callback_function_name);
-
-    SBError
-    SetScriptCallbackBody (const char *script_body_text);
-    
-    void
-    SetThreadID (lldb::tid_t sb_thread_id);
-
-    lldb::tid_t
-    GetThreadID ();
-    
-    void
-    SetThreadIndex (uint32_t index);
-    
-    uint32_t
-    GetThreadIndex() const;
-    
-    void
-    SetThreadName (const char *thread_name);
-    
-    const char *
-    GetThreadName () const;
-    
-    void 
-    SetQueueName (const char *queue_name);
-    
-    const char *
-    GetQueueName () const;
-
-    bool
-    IsResolved ();
-
-    bool
-    GetDescription (lldb::SBStream &description, DescriptionLevel level);
-
-    SBBreakpoint
-    GetBreakpoint ();
-
-    SBBreakpointLocation (const lldb::BreakpointLocationSP &break_loc_sp);
+  SBBreakpointLocation(const lldb::SBBreakpointLocation &rhs);
 
-private:
-    friend class SBBreakpoint;
+  ~SBBreakpointLocation();
+
+  const lldb::SBBreakpointLocation &
+  operator=(const lldb::SBBreakpointLocation &rhs);
+
+  break_id_t GetID();
+
+  bool IsValid() const;
+
+  lldb::SBAddress GetAddress();
+
+  lldb::addr_t GetLoadAddress();
+
+  void SetEnabled(bool enabled);
+
+  bool IsEnabled();
+
+  uint32_t GetIgnoreCount();
+
+  void SetIgnoreCount(uint32_t n);
+
+  void SetCondition(const char *condition);
+
+  const char *GetCondition();
+
+  void SetScriptCallbackFunction(const char *callback_function_name);
 
-    void
-    SetLocation (const lldb::BreakpointLocationSP &break_loc_sp);
+  SBError SetScriptCallbackBody(const char *script_body_text);
+
+  void SetThreadID(lldb::tid_t sb_thread_id);
+
+  lldb::tid_t GetThreadID();
+
+  void SetThreadIndex(uint32_t index);
+
+  uint32_t GetThreadIndex() const;
+
+  void SetThreadName(const char *thread_name);
+
+  const char *GetThreadName() const;
+
+  void SetQueueName(const char *queue_name);
+
+  const char *GetQueueName() const;
+
+  bool IsResolved();
+
+  bool GetDescription(lldb::SBStream &description, DescriptionLevel level);
+
+  SBBreakpoint GetBreakpoint();
+
+  SBBreakpointLocation(const lldb::BreakpointLocationSP &break_loc_sp);
+
+private:
+  friend class SBBreakpoint;
 
-    lldb::BreakpointLocationSP m_opaque_sp;
+  void SetLocation(const lldb::BreakpointLocationSP &break_loc_sp);
 
+  lldb::BreakpointLocationSP m_opaque_sp;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBBreakpointLocation_h_
+#endif // LLDB_SBBreakpointLocation_h_
diff --git a/include/lldb/API/SBBroadcaster.h b/include/lldb/API/SBBroadcaster.h
index 28b6686b79b3..3fc47af65513 100644
--- a/include/lldb/API/SBBroadcaster.h
+++ b/include/lldb/API/SBBroadcaster.h
@@ -14,84 +14,70 @@
 
 namespace lldb {
 
-class LLDB_API SBBroadcaster
-{
+class LLDB_API SBBroadcaster {
 public:
-    SBBroadcaster ();
+  SBBroadcaster();
 
-    SBBroadcaster (const char *name);
+  SBBroadcaster(const char *name);
 
-    SBBroadcaster (const SBBroadcaster &rhs);
-    
-    const SBBroadcaster &
-    operator = (const SBBroadcaster &rhs);
+  SBBroadcaster(const SBBroadcaster &rhs);
 
-    ~SBBroadcaster();
+  const SBBroadcaster &operator=(const SBBroadcaster &rhs);
 
-    bool
-    IsValid () const;
+  ~SBBroadcaster();
 
-    void
-    Clear ();
+  bool IsValid() const;
 
-    void
-    BroadcastEventByType (uint32_t event_type, bool unique = false);
+  void Clear();
 
-    void
-    BroadcastEvent (const lldb::SBEvent &event, bool unique = false);
+  void BroadcastEventByType(uint32_t event_type, bool unique = false);
 
-    void
-    AddInitialEventsToListener (const lldb::SBListener &listener, uint32_t requested_events);
+  void BroadcastEvent(const lldb::SBEvent &event, bool unique = false);
 
-    uint32_t
-    AddListener (const lldb::SBListener &listener, uint32_t event_mask);
+  void AddInitialEventsToListener(const lldb::SBListener &listener,
+                                  uint32_t requested_events);
 
-    const char *
-    GetName () const;
+  uint32_t AddListener(const lldb::SBListener &listener, uint32_t event_mask);
 
-    bool
-    EventTypeHasListeners (uint32_t event_type);
+  const char *GetName() const;
 
-    bool
-    RemoveListener (const lldb::SBListener &listener, uint32_t event_mask = UINT32_MAX);
+  bool EventTypeHasListeners(uint32_t event_type);
 
-    // This comparison is checking if the internal opaque pointer value
-    // is equal to that in "rhs".
-    bool
-    operator == (const lldb::SBBroadcaster &rhs) const;
+  bool RemoveListener(const lldb::SBListener &listener,
+                      uint32_t event_mask = UINT32_MAX);
 
-    // This comparison is checking if the internal opaque pointer value
-    // is not equal to that in "rhs".
-    bool
-    operator != (const lldb::SBBroadcaster &rhs) const;
+  // This comparison is checking if the internal opaque pointer value
+  // is equal to that in "rhs".
+  bool operator==(const lldb::SBBroadcaster &rhs) const;
 
-    // This comparison is checking if the internal opaque pointer value
-    // is less than that in "rhs" so SBBroadcaster objects can be contained
-    // in ordered containers.
-    bool
-    operator < (const lldb::SBBroadcaster &rhs) const;
+  // This comparison is checking if the internal opaque pointer value
+  // is not equal to that in "rhs".
+  bool operator!=(const lldb::SBBroadcaster &rhs) const;
+
+  // This comparison is checking if the internal opaque pointer value
+  // is less than that in "rhs" so SBBroadcaster objects can be contained
+  // in ordered containers.
+  bool operator<(const lldb::SBBroadcaster &rhs) const;
 
 protected:
-    friend class SBCommandInterpreter;
-    friend class SBCommunication;
-    friend class SBEvent;
-    friend class SBListener;
-    friend class SBProcess;
-    friend class SBTarget;
+  friend class SBCommandInterpreter;
+  friend class SBCommunication;
+  friend class SBEvent;
+  friend class SBListener;
+  friend class SBProcess;
+  friend class SBTarget;
 
-    SBBroadcaster (lldb_private::Broadcaster *broadcaster, bool owns);
+  SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns);
 
-    lldb_private::Broadcaster *
-    get () const;
+  lldb_private::Broadcaster *get() const;
 
-    void
-    reset (lldb_private::Broadcaster *broadcaster, bool owns);
+  void reset(lldb_private::Broadcaster *broadcaster, bool owns);
 
 private:
-    lldb::BroadcasterSP m_opaque_sp;
-    lldb_private::Broadcaster *m_opaque_ptr;
+  lldb::BroadcasterSP m_opaque_sp;
+  lldb_private::Broadcaster *m_opaque_ptr;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBBroadcaster_h_
+#endif // LLDB_SBBroadcaster_h_
diff --git a/include/lldb/API/SBCommandInterpreter.h b/include/lldb/API/SBCommandInterpreter.h
index a8e9bf7ed769..f684071740e3 100644
--- a/include/lldb/API/SBCommandInterpreter.h
+++ b/include/lldb/API/SBCommandInterpreter.h
@@ -16,305 +16,267 @@
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBDebugger.h"
+#include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
-class LLDB_API SBCommandInterpreterRunOptions
-{
-friend class SBDebugger;
-friend class SBCommandInterpreter;
+class LLDB_API SBCommandInterpreterRunOptions {
+  friend class SBDebugger;
+  friend class SBCommandInterpreter;
 
 public:
-    SBCommandInterpreterRunOptions();
-    ~SBCommandInterpreterRunOptions();
+  SBCommandInterpreterRunOptions();
+  ~SBCommandInterpreterRunOptions();
 
-    bool
-    GetStopOnContinue () const;
+  bool GetStopOnContinue() const;
 
-    void
-    SetStopOnContinue (bool);
+  void SetStopOnContinue(bool);
 
-    bool
-    GetStopOnError () const;
+  bool GetStopOnError() const;
 
-    void
-    SetStopOnError (bool);
+  void SetStopOnError(bool);
 
-    bool
-    GetStopOnCrash () const;
+  bool GetStopOnCrash() const;
 
-    void
-    SetStopOnCrash (bool);
+  void SetStopOnCrash(bool);
 
-    bool
-    GetEchoCommands () const;
+  bool GetEchoCommands() const;
 
-    void
-    SetEchoCommands (bool);
+  void SetEchoCommands(bool);
 
-    bool
-    GetPrintResults () const;
+  bool GetPrintResults() const;
 
-    void
-    SetPrintResults (bool);
+  void SetPrintResults(bool);
 
-    bool
-    GetAddToHistory () const;
+  bool GetAddToHistory() const;
 
-    void
-    SetAddToHistory (bool);
+  void SetAddToHistory(bool);
 
 private:
-    lldb_private::CommandInterpreterRunOptions *
-    get () const;
+  lldb_private::CommandInterpreterRunOptions *get() const;
 
-    lldb_private::CommandInterpreterRunOptions &
-    ref () const;
+  lldb_private::CommandInterpreterRunOptions &ref() const;
 
-    // This is set in the constructor and will always be valid.
-    mutable std::unique_ptr<lldb_private::CommandInterpreterRunOptions> m_opaque_up;
+  // This is set in the constructor and will always be valid.
+  mutable std::unique_ptr<lldb_private::CommandInterpreterRunOptions>
+      m_opaque_up;
 };
 
-class SBCommandInterpreter
-{
+class SBCommandInterpreter {
 public:
-    enum
-    {
-        eBroadcastBitThreadShouldExit       = (1 << 0),
-        eBroadcastBitResetPrompt            = (1 << 1),
-        eBroadcastBitQuitCommandReceived    = (1 << 2),           // User entered quit 
-        eBroadcastBitAsynchronousOutputData = (1 << 3),
-        eBroadcastBitAsynchronousErrorData  = (1 << 4)
-    };
-
-    SBCommandInterpreter (const lldb::SBCommandInterpreter &rhs);
-    
-    ~SBCommandInterpreter ();
-
-    const lldb::SBCommandInterpreter &
-    operator = (const lldb::SBCommandInterpreter &rhs);
-
-    static const char * 
-    GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type);
-    
-    static const char *
-    GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type);
-
-    static bool
-    EventIsCommandInterpreterEvent (const lldb::SBEvent &event);
-    
-    bool
-    IsValid() const;
-
-    bool
-    CommandExists (const char *cmd);
-
-    bool
-    AliasExists (const char *cmd);
-
-    lldb::SBBroadcaster
-    GetBroadcaster ();
-    
-    static const char *
-    GetBroadcasterClass ();
-
-    bool
-    HasCommands ();
-
-    bool
-    HasAliases ();
-
-    bool
-    HasAliasOptions ();
-
-    lldb::SBProcess
-    GetProcess ();
-    
-    lldb::SBDebugger
-    GetDebugger ();
-    
-    lldb::SBCommand
-    AddMultiwordCommand (const char* name, const char* help);
-    
-    lldb::SBCommand
-    AddCommand (const char* name, lldb::SBCommandPluginInterface *impl, const char* help);
-
-    void
-    SourceInitFileInHomeDirectory (lldb::SBCommandReturnObject &result);
-
-    void
-    SourceInitFileInCurrentWorkingDirectory (lldb::SBCommandReturnObject &result);
-
-    lldb::ReturnStatus
-    HandleCommand (const char *command_line, lldb::SBCommandReturnObject &result, bool add_to_history = false);
-
-    lldb::ReturnStatus
-    HandleCommand (const char *command_line, SBExecutionContext &exe_ctx, SBCommandReturnObject &result, bool add_to_history = false);
-
-    void
-    HandleCommandsFromFile (lldb::SBFileSpec &file,
-                            lldb::SBExecutionContext &override_context,
-                            lldb::SBCommandInterpreterRunOptions &options,
-                            lldb::SBCommandReturnObject result);
-
-    // The pointer based interface is not useful in SWIG, since the cursor & last_char arguments are string pointers INTO current_line
-    // and you can't do that in a scripting language interface in general...
-    
-    // In either case, the way this works is that the you give it a line and cursor position in the line.  The function
-    // will return the number of completions.  The matches list will contain number_of_completions + 1 elements.  The first
-    // element is the common substring after the cursor position for all the matches.  The rest of the elements are the
-    // matches.  The first element is useful if you are emulating the common shell behavior where the tab completes
-    // to the string that is common among all the matches, then you should first check if the first element is non-empty,
-    // and if so just insert it and move the cursor to the end of the insertion.  The next tab will return an empty
-    // common substring, and a list of choices (if any), at which point you should display the choices and let the user
-    // type further to disambiguate.
-    
-    int
-    HandleCompletion (const char *current_line,
-                      const char *cursor,
-                      const char *last_char,
-                      int match_start_point,
-                      int max_return_elements,
-                      lldb::SBStringList &matches);
-
-    int
-    HandleCompletion (const char *current_line,
-                      uint32_t cursor_pos,
-                      int match_start_point,
-                      int max_return_elements,
-                      lldb::SBStringList &matches);
-
-    // Catch commands before they execute by registering a callback that will
-    // get called when the command gets executed. This allows GUI or command
-    // line interfaces to intercept a command and stop it from happening
-    bool
-    SetCommandOverrideCallback (const char *command_name,
-                                lldb::CommandOverrideCallback callback,
-                                void *baton);
-    
-    SBCommandInterpreter(lldb_private::CommandInterpreter *interpreter_ptr = nullptr);   // Access using SBDebugger::GetCommandInterpreter();
-    
-    //----------------------------------------------------------------------
-    /// Return true if the command interpreter is the active IO handler.
-    ///
-    /// This indicates that any input coming into the debugger handles will
-    /// go to the command interpreter and will result in LLDB command line
-    /// commands being executed.
-    //----------------------------------------------------------------------
-    bool
-    IsActive ();
-    
-    //----------------------------------------------------------------------
-    /// Get the string that needs to be written to the debugger stdin file
-    /// handle when a control character is typed.
-    ///
-    /// Some GUI programs will intercept "control + char" sequences and want
-    /// to have them do what normally would happen when using a real
-    /// terminal, so this function allows GUI programs to emulate this
-    /// functionality.
-    ///
-    /// @param[in] ch
-    ///     The character that was typed along with the control key
-    ///
-    /// @return
-    ///     The string that should be written into the file handle that is
-    ///     feeding the input stream for the debugger, or nullptr if there is
-    ///     no string for this control key.
-    //----------------------------------------------------------------------
-    const char *
-    GetIOHandlerControlSequence(char ch);
-
-    bool
-    GetPromptOnQuit();
-
-    void
-    SetPromptOnQuit(bool b);
-
-    //----------------------------------------------------------------------
-    /// Resolve the command just as HandleCommand would, expanding abbreviations
-    /// and aliases.  If successful, result->GetOutput has the full expansion.
-    //----------------------------------------------------------------------
-    void
-    ResolveCommand(const char *command_line, SBCommandReturnObject &result);
+  enum {
+    eBroadcastBitThreadShouldExit = (1 << 0),
+    eBroadcastBitResetPrompt = (1 << 1),
+    eBroadcastBitQuitCommandReceived = (1 << 2), // User entered quit
+    eBroadcastBitAsynchronousOutputData = (1 << 3),
+    eBroadcastBitAsynchronousErrorData = (1 << 4)
+  };
+
+  SBCommandInterpreter(const lldb::SBCommandInterpreter &rhs);
+
+  ~SBCommandInterpreter();
+
+  const lldb::SBCommandInterpreter &
+  operator=(const lldb::SBCommandInterpreter &rhs);
+
+  static const char *
+  GetArgumentTypeAsCString(const lldb::CommandArgumentType arg_type);
+
+  static const char *
+  GetArgumentDescriptionAsCString(const lldb::CommandArgumentType arg_type);
+
+  static bool EventIsCommandInterpreterEvent(const lldb::SBEvent &event);
+
+  bool IsValid() const;
+
+  bool CommandExists(const char *cmd);
+
+  bool AliasExists(const char *cmd);
+
+  lldb::SBBroadcaster GetBroadcaster();
+
+  static const char *GetBroadcasterClass();
+
+  bool HasCommands();
+
+  bool HasAliases();
+
+  bool HasAliasOptions();
+
+  lldb::SBProcess GetProcess();
+
+  lldb::SBDebugger GetDebugger();
+
+  lldb::SBCommand AddMultiwordCommand(const char *name, const char *help);
+
+  lldb::SBCommand AddCommand(const char *name,
+                             lldb::SBCommandPluginInterface *impl,
+                             const char *help);
+
+  lldb::SBCommand AddCommand(const char *name,
+                             lldb::SBCommandPluginInterface *impl,
+                             const char *help, const char *syntax);
+
+  void SourceInitFileInHomeDirectory(lldb::SBCommandReturnObject &result);
+
+  void
+  SourceInitFileInCurrentWorkingDirectory(lldb::SBCommandReturnObject &result);
+
+  lldb::ReturnStatus HandleCommand(const char *command_line,
+                                   lldb::SBCommandReturnObject &result,
+                                   bool add_to_history = false);
+
+  lldb::ReturnStatus HandleCommand(const char *command_line,
+                                   SBExecutionContext &exe_ctx,
+                                   SBCommandReturnObject &result,
+                                   bool add_to_history = false);
+
+  void HandleCommandsFromFile(lldb::SBFileSpec &file,
+                              lldb::SBExecutionContext &override_context,
+                              lldb::SBCommandInterpreterRunOptions &options,
+                              lldb::SBCommandReturnObject result);
+
+  // The pointer based interface is not useful in SWIG, since the cursor &
+  // last_char arguments are string pointers INTO current_line
+  // and you can't do that in a scripting language interface in general...
+
+  // In either case, the way this works is that the you give it a line and
+  // cursor position in the line.  The function
+  // will return the number of completions.  The matches list will contain
+  // number_of_completions + 1 elements.  The first
+  // element is the common substring after the cursor position for all the
+  // matches.  The rest of the elements are the
+  // matches.  The first element is useful if you are emulating the common shell
+  // behavior where the tab completes
+  // to the string that is common among all the matches, then you should first
+  // check if the first element is non-empty,
+  // and if so just insert it and move the cursor to the end of the insertion.
+  // The next tab will return an empty
+  // common substring, and a list of choices (if any), at which point you should
+  // display the choices and let the user
+  // type further to disambiguate.
+
+  int HandleCompletion(const char *current_line, const char *cursor,
+                       const char *last_char, int match_start_point,
+                       int max_return_elements, lldb::SBStringList &matches);
+
+  int HandleCompletion(const char *current_line, uint32_t cursor_pos,
+                       int match_start_point, int max_return_elements,
+                       lldb::SBStringList &matches);
+
+  // Catch commands before they execute by registering a callback that will
+  // get called when the command gets executed. This allows GUI or command
+  // line interfaces to intercept a command and stop it from happening
+  bool SetCommandOverrideCallback(const char *command_name,
+                                  lldb::CommandOverrideCallback callback,
+                                  void *baton);
+
+  SBCommandInterpreter(
+      lldb_private::CommandInterpreter *interpreter_ptr =
+          nullptr); // Access using SBDebugger::GetCommandInterpreter();
+
+  //----------------------------------------------------------------------
+  /// Return true if the command interpreter is the active IO handler.
+  ///
+  /// This indicates that any input coming into the debugger handles will
+  /// go to the command interpreter and will result in LLDB command line
+  /// commands being executed.
+  //----------------------------------------------------------------------
+  bool IsActive();
+
+  //----------------------------------------------------------------------
+  /// Get the string that needs to be written to the debugger stdin file
+  /// handle when a control character is typed.
+  ///
+  /// Some GUI programs will intercept "control + char" sequences and want
+  /// to have them do what normally would happen when using a real
+  /// terminal, so this function allows GUI programs to emulate this
+  /// functionality.
+  ///
+  /// @param[in] ch
+  ///     The character that was typed along with the control key
+  ///
+  /// @return
+  ///     The string that should be written into the file handle that is
+  ///     feeding the input stream for the debugger, or nullptr if there is
+  ///     no string for this control key.
+  //----------------------------------------------------------------------
+  const char *GetIOHandlerControlSequence(char ch);
+
+  bool GetPromptOnQuit();
+
+  void SetPromptOnQuit(bool b);
+
+  //----------------------------------------------------------------------
+  /// Resolve the command just as HandleCommand would, expanding abbreviations
+  /// and aliases.  If successful, result->GetOutput has the full expansion.
+  //----------------------------------------------------------------------
+  void ResolveCommand(const char *command_line, SBCommandReturnObject &result);
 
 protected:
-    lldb_private::CommandInterpreter &
-    ref ();
+  lldb_private::CommandInterpreter &ref();
 
-    lldb_private::CommandInterpreter *
-    get ();
+  lldb_private::CommandInterpreter *get();
 
-    void
-    reset (lldb_private::CommandInterpreter *);
+  void reset(lldb_private::CommandInterpreter *);
 
 private:
-    friend class SBDebugger;
+  friend class SBDebugger;
 
-    static void
-    InitializeSWIG ();
+  static void InitializeSWIG();
 
-    lldb_private::CommandInterpreter *m_opaque_ptr;
+  lldb_private::CommandInterpreter *m_opaque_ptr;
 };
 
-class SBCommandPluginInterface
-{
+class SBCommandPluginInterface {
 public:
-    virtual
-    ~SBCommandPluginInterface() = default;
-
-    virtual bool
-    DoExecute (lldb::SBDebugger /*debugger*/,
-               char** /*command*/,
-               lldb::SBCommandReturnObject & /*result*/)
-    {
-        return false;
-    }
+  virtual ~SBCommandPluginInterface() = default;
+
+  virtual bool DoExecute(lldb::SBDebugger /*debugger*/, char ** /*command*/,
+                         lldb::SBCommandReturnObject & /*result*/) {
+    return false;
+  }
 };
-    
-class SBCommand
-{
+
+class SBCommand {
 public:
-    SBCommand ();
-    
-    bool
-    IsValid ();
-    
-    const char*
-    GetName ();
-    
-    const char*
-    GetHelp ();
-    
-    const char*
-    GetHelpLong ();
-    
-    void
-    SetHelp (const char*);
-    
-    void
-    SetHelpLong (const char*);
-    
-    uint32_t
-    GetFlags ();
-    
-    void
-    SetFlags (uint32_t flags);
-    
-    lldb::SBCommand
-    AddMultiwordCommand(const char* name, const char* help = nullptr);
-    
-    lldb::SBCommand
-    AddCommand(const char* name, lldb::SBCommandPluginInterface* impl, const char* help = nullptr);
-    
+  SBCommand();
+
+  bool IsValid();
+
+  const char *GetName();
+
+  const char *GetHelp();
+
+  const char *GetHelpLong();
+
+  void SetHelp(const char *);
+
+  void SetHelpLong(const char *);
+
+  uint32_t GetFlags();
+
+  void SetFlags(uint32_t flags);
+
+  lldb::SBCommand AddMultiwordCommand(const char *name,
+                                      const char *help = nullptr);
+
+  lldb::SBCommand AddCommand(const char *name,
+                             lldb::SBCommandPluginInterface *impl,
+                             const char *help = nullptr);
+
+  lldb::SBCommand AddCommand(const char *name,
+                             lldb::SBCommandPluginInterface *impl,
+                             const char *help, const char *syntax);
+
 private:
-    friend class SBDebugger;
-    friend class SBCommandInterpreter;
-    
-    SBCommand (lldb::CommandObjectSP cmd_sp);
-    
-    lldb::CommandObjectSP m_opaque_sp;
+  friend class SBDebugger;
+  friend class SBCommandInterpreter;
+
+  SBCommand(lldb::CommandObjectSP cmd_sp);
+
+  lldb::CommandObjectSP m_opaque_sp;
 };
 
 } // namespace lldb
diff --git a/include/lldb/API/SBCommandReturnObject.h b/include/lldb/API/SBCommandReturnObject.h
index 2b7cce5ded59..c73e3f7cf1f2 100644
--- a/include/lldb/API/SBCommandReturnObject.h
+++ b/include/lldb/API/SBCommandReturnObject.h
@@ -22,122 +22,90 @@
 
 namespace lldb {
 
-class LLDB_API SBCommandReturnObject
-{
+class LLDB_API SBCommandReturnObject {
 public:
-    SBCommandReturnObject ();
-
-    SBCommandReturnObject (const lldb::SBCommandReturnObject &rhs);
-
-    ~SBCommandReturnObject ();
-
-    const lldb::SBCommandReturnObject &
-    operator = (const lldb::SBCommandReturnObject &rhs);
-
-    SBCommandReturnObject (lldb_private::CommandReturnObject *ptr);
-    
-    lldb_private::CommandReturnObject *
-    Release ();
-
-    bool
-    IsValid() const;
-
-    const char *
-    GetOutput ();
-
-    const char *
-    GetError ();
-
-    size_t
-    PutOutput (FILE *fh);
-
-    size_t
-    GetOutputSize ();
-
-    size_t
-    GetErrorSize ();
-
-    size_t
-    PutError (FILE *fh);
-
-    void
-    Clear();
-
-    lldb::ReturnStatus
-    GetStatus();
-    
-    void
-    SetStatus (lldb::ReturnStatus status);
-
-    bool
-    Succeeded ();
-
-    bool
-    HasResult ();
-
-    void
-    AppendMessage (const char *message);
-
-    void
-    AppendWarning (const char *message);
-    
-    bool
-    GetDescription (lldb::SBStream &description);
-   
-    // deprecated, these two functions do not take
-    // ownership of file handle
-    void
-    SetImmediateOutputFile (FILE *fh);
-    
-    void
-    SetImmediateErrorFile (FILE *fh);
-    
-    void
-    SetImmediateOutputFile (FILE *fh, bool transfer_ownership);
-    
-    void
-    SetImmediateErrorFile (FILE *fh, bool transfer_ownership);
-    
-    void
-    PutCString(const char* string, int len = -1);
-    
-    size_t
-    Printf(const char* format, ...)  __attribute__ ((format (printf, 2, 3)));
-    
-    const char *
-    GetOutput (bool only_if_no_immediate);
-    
-    const char *
-    GetError (bool only_if_no_immediate);
-    
-    void
-    SetError(lldb::SBError &error,
-             const char *fallback_error_cstr = nullptr);
-    
-    void
-    SetError (const char* error_cstr);
-    
+  SBCommandReturnObject();
+
+  SBCommandReturnObject(const lldb::SBCommandReturnObject &rhs);
+
+  ~SBCommandReturnObject();
+
+  const lldb::SBCommandReturnObject &
+  operator=(const lldb::SBCommandReturnObject &rhs);
+
+  SBCommandReturnObject(lldb_private::CommandReturnObject *ptr);
+
+  lldb_private::CommandReturnObject *Release();
+
+  bool IsValid() const;
+
+  const char *GetOutput();
+
+  const char *GetError();
+
+  size_t PutOutput(FILE *fh);
+
+  size_t GetOutputSize();
+
+  size_t GetErrorSize();
+
+  size_t PutError(FILE *fh);
+
+  void Clear();
+
+  lldb::ReturnStatus GetStatus();
+
+  void SetStatus(lldb::ReturnStatus status);
+
+  bool Succeeded();
+
+  bool HasResult();
+
+  void AppendMessage(const char *message);
+
+  void AppendWarning(const char *message);
+
+  bool GetDescription(lldb::SBStream &description);
+
+  // deprecated, these two functions do not take
+  // ownership of file handle
+  void SetImmediateOutputFile(FILE *fh);
+
+  void SetImmediateErrorFile(FILE *fh);
+
+  void SetImmediateOutputFile(FILE *fh, bool transfer_ownership);
+
+  void SetImmediateErrorFile(FILE *fh, bool transfer_ownership);
+
+  void PutCString(const char *string, int len = -1);
+
+  size_t Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
+
+  const char *GetOutput(bool only_if_no_immediate);
+
+  const char *GetError(bool only_if_no_immediate);
+
+  void SetError(lldb::SBError &error,
+                const char *fallback_error_cstr = nullptr);
+
+  void SetError(const char *error_cstr);
+
 protected:
-    friend class SBCommandInterpreter;
-    friend class SBOptions;
+  friend class SBCommandInterpreter;
+  friend class SBOptions;
 
-    lldb_private::CommandReturnObject *
-    operator->() const;
+  lldb_private::CommandReturnObject *operator->() const;
 
-    lldb_private::CommandReturnObject *
-    get() const;
+  lldb_private::CommandReturnObject *get() const;
 
-    lldb_private::CommandReturnObject &
-    operator*() const;
+  lldb_private::CommandReturnObject &operator*() const;
 
-    lldb_private::CommandReturnObject &
-    ref() const;
+  lldb_private::CommandReturnObject &ref() const;
 
-    void
-    SetLLDBObjectPtr (lldb_private::CommandReturnObject *ptr);
+  void SetLLDBObjectPtr(lldb_private::CommandReturnObject *ptr);
 
 private:
-    std::unique_ptr<lldb_private::CommandReturnObject> m_opaque_ap;
+  std::unique_ptr<lldb_private::CommandReturnObject> m_opaque_ap;
 };
 
 } // namespace lldb
diff --git a/include/lldb/API/SBCommunication.h b/include/lldb/API/SBCommunication.h
index c4b2709de8ab..f0016275b634 100644
--- a/include/lldb/API/SBCommunication.h
+++ b/include/lldb/API/SBCommunication.h
@@ -15,86 +15,68 @@
 
 namespace lldb {
 
-class LLDB_API SBCommunication
-{
+class LLDB_API SBCommunication {
 public:
-    FLAGS_ANONYMOUS_ENUM()
-    {
-        eBroadcastBitDisconnected           = (1 << 0), ///< Sent when the communications connection is lost.
-        eBroadcastBitReadThreadGotBytes     = (1 << 1), ///< Sent by the read thread when bytes become available.
-        eBroadcastBitReadThreadDidExit      = (1 << 2), ///< Sent by the read thread when it exits to inform clients.
-        eBroadcastBitReadThreadShouldExit   = (1 << 3), ///< Sent by clients that need to cancel the read thread.
-        eBroadcastBitPacketAvailable        = (1 << 4), ///< Sent when data received makes a complete packet.
-        eAllEventBits                       = 0xffffffff
-    };
+  FLAGS_ANONYMOUS_ENUM(){
+      eBroadcastBitDisconnected =
+          (1 << 0), ///< Sent when the communications connection is lost.
+      eBroadcastBitReadThreadGotBytes =
+          (1 << 1), ///< Sent by the read thread when bytes become available.
+      eBroadcastBitReadThreadDidExit =
+          (1
+           << 2), ///< Sent by the read thread when it exits to inform clients.
+      eBroadcastBitReadThreadShouldExit =
+          (1 << 3), ///< Sent by clients that need to cancel the read thread.
+      eBroadcastBitPacketAvailable =
+          (1 << 4), ///< Sent when data received makes a complete packet.
+      eAllEventBits = 0xffffffff};
 
-    typedef void (*ReadThreadBytesReceived) (void *baton, const void *src, size_t src_len);
+  typedef void (*ReadThreadBytesReceived)(void *baton, const void *src,
+                                          size_t src_len);
 
-    SBCommunication ();
-    SBCommunication (const char * broadcaster_name);
-   ~SBCommunication ();
+  SBCommunication();
+  SBCommunication(const char *broadcaster_name);
+  ~SBCommunication();
 
+  bool IsValid() const;
 
-    bool
-    IsValid () const;
+  lldb::SBBroadcaster GetBroadcaster();
 
-    lldb::SBBroadcaster
-    GetBroadcaster ();
-    
-    static const char *GetBroadcasterClass();
+  static const char *GetBroadcasterClass();
 
-    lldb::ConnectionStatus
-    AdoptFileDesriptor (int fd, bool owns_fd);
+  lldb::ConnectionStatus AdoptFileDesriptor(int fd, bool owns_fd);
 
-    lldb::ConnectionStatus
-    Connect (const char *url);
+  lldb::ConnectionStatus Connect(const char *url);
 
-    lldb::ConnectionStatus
-    Disconnect ();
+  lldb::ConnectionStatus Disconnect();
 
-    bool
-    IsConnected () const;
+  bool IsConnected() const;
 
-    bool
-    GetCloseOnEOF ();
+  bool GetCloseOnEOF();
 
-    void
-    SetCloseOnEOF (bool b);
+  void SetCloseOnEOF(bool b);
 
-    size_t
-    Read (void *dst,
-          size_t dst_len,
-          uint32_t timeout_usec,
-          lldb::ConnectionStatus &status);
+  size_t Read(void *dst, size_t dst_len, uint32_t timeout_usec,
+              lldb::ConnectionStatus &status);
 
-    size_t
-    Write (const void *src,
-           size_t src_len,
-           lldb::ConnectionStatus &status);
+  size_t Write(const void *src, size_t src_len, lldb::ConnectionStatus &status);
 
-    bool
-    ReadThreadStart ();
+  bool ReadThreadStart();
 
-    bool
-    ReadThreadStop ();
+  bool ReadThreadStop();
 
-    bool
-    ReadThreadIsRunning ();
-
-    bool
-    SetReadThreadBytesReceivedCallback (ReadThreadBytesReceived callback,
-                                        void *callback_baton);
+  bool ReadThreadIsRunning();
 
+  bool SetReadThreadBytesReceivedCallback(ReadThreadBytesReceived callback,
+                                          void *callback_baton);
 
 private:
+  DISALLOW_COPY_AND_ASSIGN(SBCommunication);
 
-    DISALLOW_COPY_AND_ASSIGN (SBCommunication);
-
-    lldb_private::Communication *m_opaque;
-    bool m_opaque_owned;
+  lldb_private::Communication *m_opaque;
+  bool m_opaque_owned;
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBCommunication_h_
diff --git a/include/lldb/API/SBCompileUnit.h b/include/lldb/API/SBCompileUnit.h
index a53d556679c4..4d5f9f36f246 100644
--- a/include/lldb/API/SBCompileUnit.h
+++ b/include/lldb/API/SBCompileUnit.h
@@ -15,104 +15,81 @@
 
 namespace lldb {
 
-class LLDB_API SBCompileUnit
-{
+class LLDB_API SBCompileUnit {
 public:
+  SBCompileUnit();
 
-    SBCompileUnit ();
-
-    SBCompileUnit (const lldb::SBCompileUnit &rhs);
-
-    ~SBCompileUnit ();
-
-    const lldb::SBCompileUnit &
-    operator = (const lldb::SBCompileUnit &rhs);
-
-    bool
-    IsValid () const;
-
-    lldb::SBFileSpec
-    GetFileSpec () const;
-
-    uint32_t
-    GetNumLineEntries () const;
-
-    lldb::SBLineEntry
-    GetLineEntryAtIndex (uint32_t idx) const;
-
-    uint32_t
-    FindLineEntryIndex (uint32_t start_idx,
-                        uint32_t line,
-                        lldb::SBFileSpec *inline_file_spec) const;
-
-    uint32_t
-    FindLineEntryIndex (uint32_t start_idx,
-                        uint32_t line,
-                        lldb::SBFileSpec *inline_file_spec,
-                        bool exact) const;
-
-    SBFileSpec
-    GetSupportFileAtIndex (uint32_t idx) const;
-
-    uint32_t
-    GetNumSupportFiles () const;
-
-    uint32_t
-    FindSupportFileIndex (uint32_t start_idx, const SBFileSpec &sb_file, bool full);
-    
-    //------------------------------------------------------------------
-    /// Get all types matching \a type_mask from debug info in this
-    /// compile unit.
-    ///
-    /// @param[in] type_mask
-    ///    A bitfield that consists of one or more bits logically OR'ed
-    ///    together from the lldb::TypeClass enumeration. This allows
-    ///    you to request only structure types, or only class, struct
-    ///    and union types. Passing in lldb::eTypeClassAny will return
-    ///    all types found in the debug information for this compile
-    ///    unit.
-    ///
-    /// @return
-    ///    A list of types in this compile unit that match \a type_mask
-    //------------------------------------------------------------------
-    lldb::SBTypeList
-    GetTypes (uint32_t type_mask = lldb::eTypeClassAny);
-
-    lldb::LanguageType
-    GetLanguage ();
-    
-    bool
-    operator == (const lldb::SBCompileUnit &rhs) const;
-
-    bool
-    operator != (const lldb::SBCompileUnit &rhs) const;
-
-    bool
-    GetDescription (lldb::SBStream &description);
+  SBCompileUnit(const lldb::SBCompileUnit &rhs);
+
+  ~SBCompileUnit();
+
+  const lldb::SBCompileUnit &operator=(const lldb::SBCompileUnit &rhs);
+
+  bool IsValid() const;
+
+  lldb::SBFileSpec GetFileSpec() const;
+
+  uint32_t GetNumLineEntries() const;
+
+  lldb::SBLineEntry GetLineEntryAtIndex(uint32_t idx) const;
+
+  uint32_t FindLineEntryIndex(uint32_t start_idx, uint32_t line,
+                              lldb::SBFileSpec *inline_file_spec) const;
+
+  uint32_t FindLineEntryIndex(uint32_t start_idx, uint32_t line,
+                              lldb::SBFileSpec *inline_file_spec,
+                              bool exact) const;
+
+  SBFileSpec GetSupportFileAtIndex(uint32_t idx) const;
+
+  uint32_t GetNumSupportFiles() const;
+
+  uint32_t FindSupportFileIndex(uint32_t start_idx, const SBFileSpec &sb_file,
+                                bool full);
+
+  //------------------------------------------------------------------
+  /// Get all types matching \a type_mask from debug info in this
+  /// compile unit.
+  ///
+  /// @param[in] type_mask
+  ///    A bitfield that consists of one or more bits logically OR'ed
+  ///    together from the lldb::TypeClass enumeration. This allows
+  ///    you to request only structure types, or only class, struct
+  ///    and union types. Passing in lldb::eTypeClassAny will return
+  ///    all types found in the debug information for this compile
+  ///    unit.
+  ///
+  /// @return
+  ///    A list of types in this compile unit that match \a type_mask
+  //------------------------------------------------------------------
+  lldb::SBTypeList GetTypes(uint32_t type_mask = lldb::eTypeClassAny);
+
+  lldb::LanguageType GetLanguage();
+
+  bool operator==(const lldb::SBCompileUnit &rhs) const;
+
+  bool operator!=(const lldb::SBCompileUnit &rhs) const;
+
+  bool GetDescription(lldb::SBStream &description);
 
 private:
-    friend class SBAddress;
-    friend class SBFrame;
-    friend class SBSymbolContext;
-    friend class SBModule;
-
-    SBCompileUnit (lldb_private::CompileUnit *lldb_object_ptr);
-
-    const lldb_private::CompileUnit *
-    operator->() const;
-
-    const lldb_private::CompileUnit &
-    operator*() const;
-    
-    lldb_private::CompileUnit *
-    get ();
-    
-    void
-    reset (lldb_private::CompileUnit *lldb_object_ptr);
-
-    lldb_private::CompileUnit *m_opaque_ptr;
-};
+  friend class SBAddress;
+  friend class SBFrame;
+  friend class SBSymbolContext;
+  friend class SBModule;
+
+  SBCompileUnit(lldb_private::CompileUnit *lldb_object_ptr);
 
+  const lldb_private::CompileUnit *operator->() const;
+
+  const lldb_private::CompileUnit &operator*() const;
+
+  lldb_private::CompileUnit *get();
+
+  void reset(lldb_private::CompileUnit *lldb_object_ptr);
+
+  lldb_private::CompileUnit *m_opaque_ptr;
+};
 
 } // namespace lldb
 
diff --git a/include/lldb/API/SBData.h b/include/lldb/API/SBData.h
index a2bd72fad570..7aa4ea0ff8d0 100644
--- a/include/lldb/API/SBData.h
+++ b/include/lldb/API/SBData.h
@@ -14,168 +14,143 @@
 
 namespace lldb {
 
-class LLDB_API SBData
-{
+class LLDB_API SBData {
 public:
+  SBData();
+
+  SBData(const SBData &rhs);
+
+  const SBData &operator=(const SBData &rhs);
+
+  ~SBData();
+
+  uint8_t GetAddressByteSize();
+
+  void SetAddressByteSize(uint8_t addr_byte_size);
+
+  void Clear();
+
+  bool IsValid();
+
+  size_t GetByteSize();
+
+  lldb::ByteOrder GetByteOrder();
+
+  void SetByteOrder(lldb::ByteOrder endian);
+
+  float GetFloat(lldb::SBError &error, lldb::offset_t offset);
+
+  double GetDouble(lldb::SBError &error, lldb::offset_t offset);
+
+  long double GetLongDouble(lldb::SBError &error, lldb::offset_t offset);
+
+  lldb::addr_t GetAddress(lldb::SBError &error, lldb::offset_t offset);
+
+  uint8_t GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset);
+
+  uint16_t GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset);
+
+  uint32_t GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset);
+
+  uint64_t GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset);
+
+  int8_t GetSignedInt8(lldb::SBError &error, lldb::offset_t offset);
+
+  int16_t GetSignedInt16(lldb::SBError &error, lldb::offset_t offset);
+
+  int32_t GetSignedInt32(lldb::SBError &error, lldb::offset_t offset);
+
+  int64_t GetSignedInt64(lldb::SBError &error, lldb::offset_t offset);
+
+  const char *GetString(lldb::SBError &error, lldb::offset_t offset);
+
+  size_t ReadRawData(lldb::SBError &error, lldb::offset_t offset, void *buf,
+                     size_t size);
+
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::addr_t base_addr = LLDB_INVALID_ADDRESS);
+
+  // it would be nice to have SetData(SBError, const void*, size_t) when
+  // endianness and address size can be
+  // inferred from the existing DataExtractor, but having two SetData()
+  // signatures triggers a SWIG bug where
+  // the typemap isn't applied before resolving the overload, and thus the right
+  // function never gets called
+  void SetData(lldb::SBError &error, const void *buf, size_t size,
+               lldb::ByteOrder endian, uint8_t addr_size);
+
+  // see SetData() for why we don't have Append(const void* buf, size_t size)
+  bool Append(const SBData &rhs);
+
+  static lldb::SBData CreateDataFromCString(lldb::ByteOrder endian,
+                                            uint32_t addr_byte_size,
+                                            const char *data);
+
+  // in the following CreateData*() and SetData*() prototypes, the two
+  // parameters array and array_len
+  // should not be renamed or rearranged, because doing so will break the SWIG
+  // typemap
+  static lldb::SBData CreateDataFromUInt64Array(lldb::ByteOrder endian,
+                                                uint32_t addr_byte_size,
+                                                uint64_t *array,
+                                                size_t array_len);
+
+  static lldb::SBData CreateDataFromUInt32Array(lldb::ByteOrder endian,
+                                                uint32_t addr_byte_size,
+                                                uint32_t *array,
+                                                size_t array_len);
+
+  static lldb::SBData CreateDataFromSInt64Array(lldb::ByteOrder endian,
+                                                uint32_t addr_byte_size,
+                                                int64_t *array,
+                                                size_t array_len);
+
+  static lldb::SBData CreateDataFromSInt32Array(lldb::ByteOrder endian,
+                                                uint32_t addr_byte_size,
+                                                int32_t *array,
+                                                size_t array_len);
+
+  static lldb::SBData CreateDataFromDoubleArray(lldb::ByteOrder endian,
+                                                uint32_t addr_byte_size,
+                                                double *array,
+                                                size_t array_len);
+
+  bool SetDataFromCString(const char *data);
+
+  bool SetDataFromUInt64Array(uint64_t *array, size_t array_len);
+
+  bool SetDataFromUInt32Array(uint32_t *array, size_t array_len);
+
+  bool SetDataFromSInt64Array(int64_t *array, size_t array_len);
+
+  bool SetDataFromSInt32Array(int32_t *array, size_t array_len);
+
+  bool SetDataFromDoubleArray(double *array, size_t array_len);
 
-    SBData ();
-
-    SBData (const SBData &rhs);
-    
-    const SBData &
-    operator = (const SBData &rhs);
-
-    ~SBData ();
-    
-    uint8_t
-    GetAddressByteSize ();
-    
-    void
-    SetAddressByteSize (uint8_t addr_byte_size);
-    
-    void
-    Clear ();
-    
-    bool
-    IsValid();
-    
-    size_t
-    GetByteSize ();
-    
-    lldb::ByteOrder
-    GetByteOrder();
-    
-    void
-    SetByteOrder (lldb::ByteOrder endian);
-    
-    float
-    GetFloat (lldb::SBError& error, lldb::offset_t offset);
-    
-    double
-    GetDouble (lldb::SBError& error, lldb::offset_t offset);
-
-    long double
-    GetLongDouble (lldb::SBError& error, lldb::offset_t offset);
-    
-    lldb::addr_t
-    GetAddress (lldb::SBError& error, lldb::offset_t offset);
-    
-    uint8_t
-    GetUnsignedInt8 (lldb::SBError& error, lldb::offset_t offset);
-
-    uint16_t
-    GetUnsignedInt16 (lldb::SBError& error, lldb::offset_t offset);
-
-    uint32_t
-    GetUnsignedInt32 (lldb::SBError& error, lldb::offset_t offset);
-
-    uint64_t
-    GetUnsignedInt64 (lldb::SBError& error, lldb::offset_t offset);
-    
-    int8_t
-    GetSignedInt8 (lldb::SBError& error, lldb::offset_t offset);
-    
-    int16_t
-    GetSignedInt16 (lldb::SBError& error, lldb::offset_t offset);
-    
-    int32_t
-    GetSignedInt32 (lldb::SBError& error, lldb::offset_t offset);
-    
-    int64_t
-    GetSignedInt64 (lldb::SBError& error, lldb::offset_t offset);
-    
-    const char*
-    GetString (lldb::SBError& error, lldb::offset_t offset);
-    
-    size_t
-    ReadRawData (lldb::SBError& error,
-                 lldb::offset_t offset,
-                 void *buf,
-                 size_t size);
-    
-    bool
-    GetDescription (lldb::SBStream &description, lldb::addr_t base_addr = LLDB_INVALID_ADDRESS);
-    
-    // it would be nice to have SetData(SBError, const void*, size_t) when endianness and address size can be
-    // inferred from the existing DataExtractor, but having two SetData() signatures triggers a SWIG bug where
-    // the typemap isn't applied before resolving the overload, and thus the right function never gets called
-    void
-    SetData (lldb::SBError& error, const void *buf, size_t size, lldb::ByteOrder endian, uint8_t addr_size);
-    
-    // see SetData() for why we don't have Append(const void* buf, size_t size)
-    bool
-    Append (const SBData& rhs);
-    
-    static lldb::SBData
-    CreateDataFromCString (lldb::ByteOrder endian, uint32_t addr_byte_size, const char* data);
-    
-    // in the following CreateData*() and SetData*() prototypes, the two parameters array and array_len
-    // should not be renamed or rearranged, because doing so will break the SWIG typemap
-    static lldb::SBData
-    CreateDataFromUInt64Array (lldb::ByteOrder endian, uint32_t addr_byte_size, uint64_t* array, size_t array_len);
-    
-    static lldb::SBData
-    CreateDataFromUInt32Array (lldb::ByteOrder endian, uint32_t addr_byte_size, uint32_t* array, size_t array_len);
-    
-    static lldb::SBData
-    CreateDataFromSInt64Array (lldb::ByteOrder endian, uint32_t addr_byte_size, int64_t* array, size_t array_len);
-    
-    static lldb::SBData
-    CreateDataFromSInt32Array (lldb::ByteOrder endian, uint32_t addr_byte_size, int32_t* array, size_t array_len);
-    
-    static lldb::SBData
-    CreateDataFromDoubleArray (lldb::ByteOrder endian, uint32_t addr_byte_size, double* array, size_t array_len);
-    
-    bool
-    SetDataFromCString (const char* data);
-    
-    bool
-    SetDataFromUInt64Array (uint64_t* array, size_t array_len);
-    
-    bool
-    SetDataFromUInt32Array (uint32_t* array, size_t array_len);
-    
-    bool
-    SetDataFromSInt64Array (int64_t* array, size_t array_len);
-    
-    bool
-    SetDataFromSInt32Array (int32_t* array, size_t array_len);
-    
-    bool
-    SetDataFromDoubleArray (double* array, size_t array_len);
-
-    
 protected:
-    
-    // Mimic shared pointer...
-    lldb_private::DataExtractor *
-    get() const;
-    
-    lldb_private::DataExtractor *
-    operator->() const;
-    
-    lldb::DataExtractorSP &
-    operator*();
-    
-    const lldb::DataExtractorSP &
-    operator*() const;
-
-    SBData (const lldb::DataExtractorSP &data_sp);
-
-    void
-    SetOpaque (const lldb::DataExtractorSP &data_sp);
+  // Mimic shared pointer...
+  lldb_private::DataExtractor *get() const;
+
+  lldb_private::DataExtractor *operator->() const;
+
+  lldb::DataExtractorSP &operator*();
+
+  const lldb::DataExtractorSP &operator*() const;
+
+  SBData(const lldb::DataExtractorSP &data_sp);
+
+  void SetOpaque(const lldb::DataExtractorSP &data_sp);
 
 private:
-    friend class SBInstruction;
-    friend class SBProcess;
-    friend class SBSection;
-    friend class SBTarget;
-    friend class SBValue;
+  friend class SBInstruction;
+  friend class SBProcess;
+  friend class SBSection;
+  friend class SBTarget;
+  friend class SBValue;
 
-    lldb::DataExtractorSP  m_opaque_sp;
+  lldb::DataExtractorSP m_opaque_sp;
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBData_h_
diff --git a/include/lldb/API/SBDebugger.h b/include/lldb/API/SBDebugger.h
index 7588cfc9ec42..9084943b9131 100644
--- a/include/lldb/API/SBDebugger.h
+++ b/include/lldb/API/SBDebugger.h
@@ -16,349 +16,255 @@
 #include "lldb/API/SBPlatform.h"
 
 namespace lldb {
-    
-class LLDB_API SBInputReader
-{
-public:
-    SBInputReader() = default;
-    ~SBInputReader() = default;
 
-    SBError Initialize(lldb::SBDebugger&, unsigned long (*)(void*, lldb::SBInputReader*, lldb::InputReaderAction, char const*, unsigned long), void*, lldb::InputReaderGranularity, char const*, char const*, bool);
-    void SetIsDone(bool);
-    bool IsActive() const;
+class LLDB_API SBInputReader {
+public:
+  SBInputReader() = default;
+  ~SBInputReader() = default;
+
+  SBError Initialize(lldb::SBDebugger &,
+                     unsigned long (*)(void *, lldb::SBInputReader *,
+                                       lldb::InputReaderAction, char const *,
+                                       unsigned long),
+                     void *, lldb::InputReaderGranularity, char const *,
+                     char const *, bool);
+  void SetIsDone(bool);
+  bool IsActive() const;
 };
 
-class LLDB_API SBDebugger
-{
+class LLDB_API SBDebugger {
 public:
-    SBDebugger();
+  SBDebugger();
+
+  SBDebugger(const lldb::SBDebugger &rhs);
+
+  SBDebugger(const lldb::DebuggerSP &debugger_sp);
+
+  ~SBDebugger();
+
+  lldb::SBDebugger &operator=(const lldb::SBDebugger &rhs);
+
+  static void Initialize();
+
+  static void Terminate();
+
+  // Deprecated, use the one that takes a source_init_files bool.
+  static lldb::SBDebugger Create();
+
+  static lldb::SBDebugger Create(bool source_init_files);
+
+  static lldb::SBDebugger Create(bool source_init_files,
+                                 lldb::LogOutputCallback log_callback,
+                                 void *baton);
+
+  static void Destroy(lldb::SBDebugger &debugger);
+
+  static void MemoryPressureDetected();
+
+  bool IsValid() const;
+
+  void Clear();
+
+  void SetAsync(bool b);
+
+  bool GetAsync();
+
+  void SkipLLDBInitFiles(bool b);
+
+  void SkipAppInitFiles(bool b);
+
+  void SetInputFileHandle(FILE *f, bool transfer_ownership);
+
+  void SetOutputFileHandle(FILE *f, bool transfer_ownership);
+
+  void SetErrorFileHandle(FILE *f, bool transfer_ownership);
+
+  FILE *GetInputFileHandle();
+
+  FILE *GetOutputFileHandle();
+
+  FILE *GetErrorFileHandle();
+
+  void SaveInputTerminalState();
+
+  void RestoreInputTerminalState();
+
+  lldb::SBCommandInterpreter GetCommandInterpreter();
+
+  void HandleCommand(const char *command);
+
+  lldb::SBListener GetListener();
 
-    SBDebugger(const lldb::SBDebugger &rhs);
+  void HandleProcessEvent(const lldb::SBProcess &process,
+                          const lldb::SBEvent &event, FILE *out, FILE *err);
 
-    SBDebugger(const lldb::DebuggerSP &debugger_sp);
+  lldb::SBTarget CreateTarget(const char *filename, const char *target_triple,
+                              const char *platform_name,
+                              bool add_dependent_modules, lldb::SBError &error);
 
-    ~SBDebugger();
+  lldb::SBTarget CreateTargetWithFileAndTargetTriple(const char *filename,
+                                                     const char *target_triple);
 
-    lldb::SBDebugger &
-    operator = (const lldb::SBDebugger &rhs);
+  lldb::SBTarget CreateTargetWithFileAndArch(const char *filename,
+                                             const char *archname);
 
-    static void
-    Initialize();
-    
-    static void
-    Terminate();
-    
-    // Deprecated, use the one that takes a source_init_files bool.
-    static lldb::SBDebugger
-    Create();
+  lldb::SBTarget CreateTarget(const char *filename);
 
-    static lldb::SBDebugger
-    Create(bool source_init_files);
+  // Return true if target is deleted from the target list of the debugger.
+  bool DeleteTarget(lldb::SBTarget &target);
 
-    static lldb::SBDebugger
-    Create(bool source_init_files, lldb::LogOutputCallback log_callback, void *baton);
+  lldb::SBTarget GetTargetAtIndex(uint32_t idx);
 
-    static void
-    Destroy (lldb::SBDebugger &debugger);
+  uint32_t GetIndexOfTarget(lldb::SBTarget target);
 
-    static void
-    MemoryPressureDetected ();
+  lldb::SBTarget FindTargetWithProcessID(pid_t pid);
 
-    bool
-    IsValid() const;
+  lldb::SBTarget FindTargetWithFileAndArch(const char *filename,
+                                           const char *arch);
 
-    void
-    Clear ();
+  uint32_t GetNumTargets();
 
-    void
-    SetAsync (bool b);
-    
-    bool 
-    GetAsync ();
+  lldb::SBTarget GetSelectedTarget();
 
-    void
-    SkipLLDBInitFiles (bool b);
+  void SetSelectedTarget(SBTarget &target);
 
-    void
-    SkipAppInitFiles (bool b);
+  lldb::SBPlatform GetSelectedPlatform();
 
-    void
-    SetInputFileHandle (FILE *f, bool transfer_ownership);
+  void SetSelectedPlatform(lldb::SBPlatform &platform);
 
-    void
-    SetOutputFileHandle (FILE *f, bool transfer_ownership);
+  lldb::SBSourceManager GetSourceManager();
 
-    void
-    SetErrorFileHandle (FILE *f, bool transfer_ownership);
-    
-    FILE *
-    GetInputFileHandle ();
+  // REMOVE: just for a quick fix, need to expose platforms through
+  // SBPlatform from this class.
+  lldb::SBError SetCurrentPlatform(const char *platform_name);
 
-    FILE *
-    GetOutputFileHandle ();
+  bool SetCurrentPlatformSDKRoot(const char *sysroot);
 
-    FILE *
-    GetErrorFileHandle ();
+  // FIXME: Once we get the set show stuff in place, the driver won't need
+  // an interface to the Set/Get UseExternalEditor.
+  bool SetUseExternalEditor(bool input);
 
-    void
-    SaveInputTerminalState();
-    
-    void
-    RestoreInputTerminalState();
+  bool GetUseExternalEditor();
 
-    lldb::SBCommandInterpreter
-    GetCommandInterpreter ();
+  bool SetUseColor(bool use_color);
 
-    void
-    HandleCommand (const char *command);
+  bool GetUseColor() const;
 
-    lldb::SBListener
-    GetListener ();
+  static bool GetDefaultArchitecture(char *arch_name, size_t arch_name_len);
 
-    void
-    HandleProcessEvent (const lldb::SBProcess &process,
-                        const lldb::SBEvent &event,
-                        FILE *out,
-                        FILE *err);
+  static bool SetDefaultArchitecture(const char *arch_name);
 
-    lldb::SBTarget
-    CreateTarget (const char *filename,
-                  const char *target_triple,
-                  const char *platform_name,
-                  bool add_dependent_modules,
-                  lldb::SBError& error);
+  lldb::ScriptLanguage GetScriptingLanguage(const char *script_language_name);
 
-    lldb::SBTarget
-    CreateTargetWithFileAndTargetTriple (const char *filename,
-                                         const char *target_triple);
+  static const char *GetVersionString();
 
-    lldb::SBTarget
-    CreateTargetWithFileAndArch (const char *filename,
-                                 const char *archname);
+  static const char *StateAsCString(lldb::StateType state);
 
-    lldb::SBTarget
-    CreateTarget (const char *filename);
-
-    // Return true if target is deleted from the target list of the debugger.
-    bool
-    DeleteTarget (lldb::SBTarget &target);
-
-    lldb::SBTarget
-    GetTargetAtIndex (uint32_t idx);
-    
-    uint32_t
-    GetIndexOfTarget (lldb::SBTarget target);
+  static bool StateIsRunningState(lldb::StateType state);
 
-    lldb::SBTarget
-    FindTargetWithProcessID (pid_t pid);
+  static bool StateIsStoppedState(lldb::StateType state);
 
-    lldb::SBTarget
-    FindTargetWithFileAndArch (const char *filename,
-                               const char *arch);
+  bool EnableLog(const char *channel, const char **categories);
 
-    uint32_t
-    GetNumTargets ();
+  void SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton);
 
-    lldb::SBTarget
-    GetSelectedTarget ();
+  // DEPRECATED
+  void DispatchInput(void *baton, const void *data, size_t data_len);
 
-    void
-    SetSelectedTarget (SBTarget& target);
+  void DispatchInput(const void *data, size_t data_len);
 
-    lldb::SBPlatform
-    GetSelectedPlatform();
+  void DispatchInputInterrupt();
 
-    void
-    SetSelectedPlatform(lldb::SBPlatform &platform);
-
-    lldb::SBSourceManager
-    GetSourceManager ();
+  void DispatchInputEndOfFile();
 
-    // REMOVE: just for a quick fix, need to expose platforms through
-    // SBPlatform from this class.
-    lldb::SBError
-    SetCurrentPlatform (const char *platform_name);
-    
-    bool
-    SetCurrentPlatformSDKRoot (const char *sysroot);
-
-    // FIXME: Once we get the set show stuff in place, the driver won't need
-    // an interface to the Set/Get UseExternalEditor.
-    bool
-    SetUseExternalEditor (bool input);
-    
-    bool 
-    GetUseExternalEditor ();
-
-    bool
-    SetUseColor (bool use_color);
-
-    bool
-    GetUseColor () const;
-
-    static bool
-    GetDefaultArchitecture (char *arch_name, size_t arch_name_len);
-
-    static bool
-    SetDefaultArchitecture (const char *arch_name);
-
-    lldb::ScriptLanguage
-    GetScriptingLanguage (const char *script_language_name);
-
-    static const char *
-    GetVersionString ();
-
-    static const char *
-    StateAsCString (lldb::StateType state);
-
-    static bool
-    StateIsRunningState (lldb::StateType state);
-
-    static bool
-    StateIsStoppedState (lldb::StateType state);
-    
-    bool
-    EnableLog (const char *channel, const char **categories);
-
-    void
-    SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton);
-    
-    // DEPRECATED
-    void
-    DispatchInput (void* baton,
-                   const void* data,
-                   size_t data_len);
-    
-    void
-    DispatchInput (const void *data, size_t data_len);
-
-    void
-    DispatchInputInterrupt ();
-
-    void
-    DispatchInputEndOfFile ();
-    
-    void
-    PushInputReader (lldb::SBInputReader &reader);
-
-    const char *
-    GetInstanceName  ();
-
-    static SBDebugger
-    FindDebuggerWithID (int id);
-
-    static lldb::SBError
-    SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name);
-
-    static lldb::SBStringList
-    GetInternalVariableValue (const char *var_name, const char *debugger_instance_name);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    uint32_t
-    GetTerminalWidth () const;
-
-    void
-    SetTerminalWidth (uint32_t term_width);
-
-    lldb::user_id_t
-    GetID ();
-    
-    const char *
-    GetPrompt() const;
-
-    void
-    SetPrompt (const char *prompt);
-        
-    lldb::ScriptLanguage 
-    GetScriptLanguage() const;
-
-    void
-    SetScriptLanguage (lldb::ScriptLanguage script_lang);
-
-    bool
-    GetCloseInputOnEOF () const;
-    
-    void
-    SetCloseInputOnEOF (bool b);
-
-    SBTypeCategory
-    GetCategory (const char* category_name);
-
-    SBTypeCategory
-    GetCategory (lldb::LanguageType lang_type);
-    
-    SBTypeCategory
-    CreateCategory (const char* category_name);
-    
-    bool
-    DeleteCategory (const char* category_name);
-    
-    uint32_t
-    GetNumCategories ();
-    
-    SBTypeCategory
-    GetCategoryAtIndex (uint32_t);
-    
-    SBTypeCategory
-    GetDefaultCategory();
-    
-    SBTypeFormat
-    GetFormatForType (SBTypeNameSpecifier);
+  void PushInputReader(lldb::SBInputReader &reader);
+
+  const char *GetInstanceName();
+
+  static SBDebugger FindDebuggerWithID(int id);
+
+  static lldb::SBError SetInternalVariable(const char *var_name,
+                                           const char *value,
+                                           const char *debugger_instance_name);
+
+  static lldb::SBStringList
+  GetInternalVariableValue(const char *var_name,
+                           const char *debugger_instance_name);
+
+  bool GetDescription(lldb::SBStream &description);
+
+  uint32_t GetTerminalWidth() const;
+
+  void SetTerminalWidth(uint32_t term_width);
+
+  lldb::user_id_t GetID();
+
+  const char *GetPrompt() const;
+
+  void SetPrompt(const char *prompt);
+
+  lldb::ScriptLanguage GetScriptLanguage() const;
+
+  void SetScriptLanguage(lldb::ScriptLanguage script_lang);
+
+  bool GetCloseInputOnEOF() const;
+
+  void SetCloseInputOnEOF(bool b);
+
+  SBTypeCategory GetCategory(const char *category_name);
+
+  SBTypeCategory GetCategory(lldb::LanguageType lang_type);
+
+  SBTypeCategory CreateCategory(const char *category_name);
+
+  bool DeleteCategory(const char *category_name);
+
+  uint32_t GetNumCategories();
+
+  SBTypeCategory GetCategoryAtIndex(uint32_t);
+
+  SBTypeCategory GetDefaultCategory();
+
+  SBTypeFormat GetFormatForType(SBTypeNameSpecifier);
 
 #ifndef LLDB_DISABLE_PYTHON
-    SBTypeSummary
-    GetSummaryForType (SBTypeNameSpecifier);
+  SBTypeSummary GetSummaryForType(SBTypeNameSpecifier);
 #endif
 
-    SBTypeFilter
-    GetFilterForType (SBTypeNameSpecifier);
+  SBTypeFilter GetFilterForType(SBTypeNameSpecifier);
 
 #ifndef LLDB_DISABLE_PYTHON
-    SBTypeSynthetic
-    GetSyntheticForType (SBTypeNameSpecifier);
+  SBTypeSynthetic GetSyntheticForType(SBTypeNameSpecifier);
 #endif
 
-    void
-    RunCommandInterpreter (bool auto_handle_events,
-                           bool spawn_thread);
-
-    void
-    RunCommandInterpreter (bool auto_handle_events,
-                           bool spawn_thread,
-                           SBCommandInterpreterRunOptions &options,
-                           int  &num_errors,
-                           bool &quit_requested,
-                           bool &stopped_for_crash);
-    
-    SBError
-    RunREPL (lldb::LanguageType language, const char *repl_options);
+  void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread);
+
+  void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread,
+                             SBCommandInterpreterRunOptions &options,
+                             int &num_errors, bool &quit_requested,
+                             bool &stopped_for_crash);
+
+  SBError RunREPL(lldb::LanguageType language, const char *repl_options);
 
 private:
-    friend class SBCommandInterpreter;
-    friend class SBInputReader;
-    friend class SBListener;
-    friend class SBProcess;
-    friend class SBSourceManager;
-    friend class SBTarget;
-    
-    lldb::SBTarget
-    FindTargetWithLLDBProcess (const lldb::ProcessSP &processSP);
-
-    void
-    reset (const lldb::DebuggerSP &debugger_sp);
-
-    lldb_private::Debugger *
-    get () const;
-
-    lldb_private::Debugger &
-    ref () const;
-
-    const lldb::DebuggerSP &
-    get_sp () const;
-    
-    lldb::DebuggerSP m_opaque_sp;
+  friend class SBCommandInterpreter;
+  friend class SBInputReader;
+  friend class SBListener;
+  friend class SBProcess;
+  friend class SBSourceManager;
+  friend class SBTarget;
+
+  lldb::SBTarget FindTargetWithLLDBProcess(const lldb::ProcessSP &processSP);
+
+  void reset(const lldb::DebuggerSP &debugger_sp);
+
+  lldb_private::Debugger *get() const;
+
+  lldb_private::Debugger &ref() const;
+
+  const lldb::DebuggerSP &get_sp() const;
+
+  lldb::DebuggerSP m_opaque_sp;
 
 }; // class SBDebugger
 
diff --git a/include/lldb/API/SBDeclaration.h b/include/lldb/API/SBDeclaration.h
index 5461a1f15c2e..42cf76963847 100644
--- a/include/lldb/API/SBDeclaration.h
+++ b/include/lldb/API/SBDeclaration.h
@@ -1,4 +1,5 @@
-//===-- SBDeclaration.h -------------------------------------------*- C++ -*-===//
+//===-- SBDeclaration.h -------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -14,76 +15,56 @@
 #include "lldb/API/SBFileSpec.h"
 
 namespace lldb {
-    
-    class LLDB_API SBDeclaration
-    {
-    public:
-        
-        SBDeclaration ();
-        
-        SBDeclaration (const lldb::SBDeclaration &rhs);
-        
-        ~SBDeclaration ();
-        
-        const lldb::SBDeclaration &
-        operator = (const lldb::SBDeclaration &rhs);
-        
-        bool
-        IsValid () const;
-        
-        lldb::SBFileSpec
-        GetFileSpec () const;
-        
-        uint32_t
-        GetLine () const;
-        
-        uint32_t
-        GetColumn () const;
-        
-        void
-        SetFileSpec (lldb::SBFileSpec filespec);
-        
-        void
-        SetLine (uint32_t line);
-        
-        void
-        SetColumn (uint32_t column);
-        
-        bool
-        operator == (const lldb::SBDeclaration &rhs) const;
-        
-        bool
-        operator != (const lldb::SBDeclaration &rhs) const;
-        
-        bool
-        GetDescription (lldb::SBStream &description);
-        
-    protected:
-        
-        lldb_private::Declaration *
-        get ();
-        
-    private:
-        friend class SBValue;
-        
-        const lldb_private::Declaration *
-        operator->() const;
-        
-        lldb_private::Declaration &
-        ref();
-        
-        const lldb_private::Declaration &
-        ref() const;
-        
-        SBDeclaration (const lldb_private::Declaration *lldb_object_ptr);
-        
-        void
-        SetDeclaration (const lldb_private::Declaration &lldb_object_ref);
-        
-        std::unique_ptr<lldb_private::Declaration> m_opaque_ap;
-    };
-    
-    
+
+class LLDB_API SBDeclaration {
+public:
+  SBDeclaration();
+
+  SBDeclaration(const lldb::SBDeclaration &rhs);
+
+  ~SBDeclaration();
+
+  const lldb::SBDeclaration &operator=(const lldb::SBDeclaration &rhs);
+
+  bool IsValid() const;
+
+  lldb::SBFileSpec GetFileSpec() const;
+
+  uint32_t GetLine() const;
+
+  uint32_t GetColumn() const;
+
+  void SetFileSpec(lldb::SBFileSpec filespec);
+
+  void SetLine(uint32_t line);
+
+  void SetColumn(uint32_t column);
+
+  bool operator==(const lldb::SBDeclaration &rhs) const;
+
+  bool operator!=(const lldb::SBDeclaration &rhs) const;
+
+  bool GetDescription(lldb::SBStream &description);
+
+protected:
+  lldb_private::Declaration *get();
+
+private:
+  friend class SBValue;
+
+  const lldb_private::Declaration *operator->() const;
+
+  lldb_private::Declaration &ref();
+
+  const lldb_private::Declaration &ref() const;
+
+  SBDeclaration(const lldb_private::Declaration *lldb_object_ptr);
+
+  void SetDeclaration(const lldb_private::Declaration &lldb_object_ref);
+
+  std::unique_ptr<lldb_private::Declaration> m_opaque_ap;
+};
+
 } // namespace lldb
 
 #endif // LLDB_SBDeclaration_h_
diff --git a/include/lldb/API/SBDefines.h b/include/lldb/API/SBDefines.h
index 4a95903ec92c..25443c4761af 100644
--- a/include/lldb/API/SBDefines.h
+++ b/include/lldb/API/SBDefines.h
@@ -71,6 +71,7 @@ class LLDB_API SBSection;
 class LLDB_API SBSourceManager;
 class LLDB_API SBStream;
 class LLDB_API SBStringList;
+class LLDB_API SBStructuredData;
 class LLDB_API SBSymbol;
 class LLDB_API SBSymbolContext;
 class LLDB_API SBSymbolContextList;
@@ -95,7 +96,6 @@ class LLDB_API SBValueList;
 class LLDB_API SBVariablesOptions;
 class LLDB_API SBWatchpoint;
 class LLDB_API SBUnixSignals;
-
 }
 
-#endif  // LLDB_SBDefines_h_
+#endif // LLDB_SBDefines_h_
diff --git a/include/lldb/API/SBError.h b/include/lldb/API/SBError.h
index afdec0d3826d..7f2f3a6cc5ec 100644
--- a/include/lldb/API/SBError.h
+++ b/include/lldb/API/SBError.h
@@ -16,93 +16,73 @@ namespace lldb {
 
 class LLDB_API SBError {
 public:
-    SBError ();
+  SBError();
 
-    SBError (const lldb::SBError &rhs);
+  SBError(const lldb::SBError &rhs);
 
-    ~SBError();
+  ~SBError();
 
-    const SBError &
-    operator =(const lldb::SBError &rhs);
+  const SBError &operator=(const lldb::SBError &rhs);
 
-    const char *
-    GetCString () const;
+  const char *GetCString() const;
 
-    void
-    Clear ();
+  void Clear();
 
-    bool
-    Fail () const;
+  bool Fail() const;
 
-    bool
-    Success () const;
+  bool Success() const;
 
-    uint32_t
-    GetError () const;
+  uint32_t GetError() const;
 
-    lldb::ErrorType
-    GetType () const;
+  lldb::ErrorType GetType() const;
 
-    void
-    SetError (uint32_t err, lldb::ErrorType type);
+  void SetError(uint32_t err, lldb::ErrorType type);
 
-    void
-    SetErrorToErrno ();
+  void SetErrorToErrno();
 
-    void
-    SetErrorToGenericError ();
+  void SetErrorToGenericError();
 
-    void
-    SetErrorString (const char *err_str);
+  void SetErrorString(const char *err_str);
 
-    int
-    SetErrorStringWithFormat (const char *format, ...) __attribute__ ((format (printf, 2, 3)));
+  int SetErrorStringWithFormat(const char *format, ...)
+      __attribute__((format(printf, 2, 3)));
 
-    bool
-    IsValid () const;
+  bool IsValid() const;
 
-    bool
-    GetDescription (lldb::SBStream &description);
+  bool GetDescription(lldb::SBStream &description);
 
 protected:
+  friend class SBCommandReturnObject;
+  friend class SBData;
+  friend class SBDebugger;
+  friend class SBCommunication;
+  friend class SBHostOS;
+  friend class SBPlatform;
+  friend class SBProcess;
+  friend class SBStructuredData;
+  friend class SBThread;
+  friend class SBTarget;
+  friend class SBValue;
+  friend class SBWatchpoint;
+  friend class SBBreakpoint;
+  friend class SBBreakpointLocation;
 
-    friend class SBCommandReturnObject;
-    friend class SBData;
-    friend class SBDebugger;
-    friend class SBCommunication;
-    friend class SBHostOS;
-    friend class SBPlatform;
-    friend class SBProcess;
-    friend class SBThread;
-    friend class SBTarget;
-    friend class SBValue;
-    friend class SBWatchpoint;
-    friend class SBBreakpoint;
-    friend class SBBreakpointLocation;
+  lldb_private::Error *get();
 
-    lldb_private::Error *
-    get();
+  lldb_private::Error *operator->();
 
-    lldb_private::Error *
-    operator->();
+  const lldb_private::Error &operator*() const;
 
-    const lldb_private::Error &
-    operator*() const;
+  lldb_private::Error &ref();
 
-    lldb_private::Error &
-    ref();
-
-    void
-    SetError (const lldb_private::Error &lldb_error);
+  void SetError(const lldb_private::Error &lldb_error);
 
 private:
-    std::unique_ptr<lldb_private::Error> m_opaque_ap;
+  std::unique_ptr<lldb_private::Error> m_opaque_ap;
 
-    void
-    CreateIfNeeded ();
+  void CreateIfNeeded();
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBError_h_
diff --git a/include/lldb/API/SBEvent.h b/include/lldb/API/SBEvent.h
index 975c365f5916..ff15716d853e 100644
--- a/include/lldb/API/SBEvent.h
+++ b/include/lldb/API/SBEvent.h
@@ -15,91 +15,72 @@
 #include <stdio.h>
 #include <vector>
 
-
 namespace lldb {
 
 class SBBroadcaster;
 
-class LLDB_API SBEvent
-{
+class LLDB_API SBEvent {
 public:
-    SBEvent();
+  SBEvent();
+
+  SBEvent(const lldb::SBEvent &rhs);
 
-    SBEvent (const lldb::SBEvent &rhs);
-    
-    // Make an event that contains a C string.
-    SBEvent (uint32_t event, const char *cstr, uint32_t cstr_len);
+  // Make an event that contains a C string.
+  SBEvent(uint32_t event, const char *cstr, uint32_t cstr_len);
 
-    SBEvent (lldb::EventSP &event_sp);
+  SBEvent(lldb::EventSP &event_sp);
 
-    SBEvent (lldb_private::Event *event_sp);
+  SBEvent(lldb_private::Event *event_sp);
 
-    ~SBEvent();
+  ~SBEvent();
 
-    const SBEvent &
-    operator = (const lldb::SBEvent &rhs);
+  const SBEvent &operator=(const lldb::SBEvent &rhs);
 
-    bool
-    IsValid() const;
+  bool IsValid() const;
 
-    const char *
-    GetDataFlavor ();
+  const char *GetDataFlavor();
 
-    uint32_t
-    GetType () const;
+  uint32_t GetType() const;
 
-    lldb::SBBroadcaster
-    GetBroadcaster () const;
+  lldb::SBBroadcaster GetBroadcaster() const;
 
-    const char *
-    GetBroadcasterClass () const;
+  const char *GetBroadcasterClass() const;
 
-    bool
-    BroadcasterMatchesPtr (const lldb::SBBroadcaster *broadcaster);
+  bool BroadcasterMatchesPtr(const lldb::SBBroadcaster *broadcaster);
 
-    bool
-    BroadcasterMatchesRef (const lldb::SBBroadcaster &broadcaster);
+  bool BroadcasterMatchesRef(const lldb::SBBroadcaster &broadcaster);
 
-    void
-    Clear();
+  void Clear();
 
-    static const char *
-    GetCStringFromEvent (const lldb::SBEvent &event);
+  static const char *GetCStringFromEvent(const lldb::SBEvent &event);
 
-    bool
-    GetDescription (lldb::SBStream &description);
+  bool GetDescription(lldb::SBStream &description);
 
-    bool
-    GetDescription (lldb::SBStream &description) const;
+  bool GetDescription(lldb::SBStream &description) const;
 
 protected:
-    friend class SBListener;
-    friend class SBBroadcaster;
-    friend class SBBreakpoint;
-    friend class SBDebugger;
-    friend class SBProcess;
-    friend class SBTarget;
-    friend class SBThread;
-    friend class SBWatchpoint;
+  friend class SBListener;
+  friend class SBBroadcaster;
+  friend class SBBreakpoint;
+  friend class SBDebugger;
+  friend class SBProcess;
+  friend class SBTarget;
+  friend class SBThread;
+  friend class SBWatchpoint;
 
-    lldb::EventSP &
-    GetSP () const;
+  lldb::EventSP &GetSP() const;
 
-    void
-    reset (lldb::EventSP &event_sp);
+  void reset(lldb::EventSP &event_sp);
 
-    void
-    reset (lldb_private::Event* event);
+  void reset(lldb_private::Event *event);
 
-    lldb_private::Event *
-    get () const;
+  lldb_private::Event *get() const;
 
 private:
-
-    mutable lldb::EventSP m_event_sp;
-    mutable lldb_private::Event *m_opaque_ptr;
+  mutable lldb::EventSP m_event_sp;
+  mutable lldb_private::Event *m_opaque_ptr;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBEvent_h_
+#endif // LLDB_SBEvent_h_
diff --git a/include/lldb/API/SBExecutionContext.h b/include/lldb/API/SBExecutionContext.h
index 1d64497ae867..c19d539bc80a 100644
--- a/include/lldb/API/SBExecutionContext.h
+++ b/include/lldb/API/SBExecutionContext.h
@@ -1,4 +1,5 @@
-//===-- SBExecutionContext.h -----------------------------------------*- C++ -*-===//
+//===-- SBExecutionContext.h -----------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -15,60 +16,51 @@
 #include <stdio.h>
 #include <vector>
 
-
 namespace lldb {
-    
-class LLDB_API SBExecutionContext
-{
-friend class SBCommandInterpreter;
+
+class LLDB_API SBExecutionContext {
+  friend class SBCommandInterpreter;
 
 public:
-    SBExecutionContext();
-    
-    SBExecutionContext (const lldb::SBExecutionContext &rhs);
-    
-    SBExecutionContext (lldb::ExecutionContextRefSP exe_ctx_ref_sp);
-    
-    SBExecutionContext (const lldb::SBTarget &target);
-    
-    SBExecutionContext (const lldb::SBProcess &process);
-    
-    SBExecutionContext (lldb::SBThread thread); // can't be a const& because SBThread::get() isn't itself a const function
-    
-    SBExecutionContext (const lldb::SBFrame &frame);
-    
-    ~SBExecutionContext();
-    
-    const SBExecutionContext &
-    operator = (const lldb::SBExecutionContext &rhs);
-    
-    SBTarget
-    GetTarget () const;
-    
-    SBProcess
-    GetProcess () const;
-
-    SBThread
-    GetThread () const;
-
-    SBFrame
-    GetFrame () const;
-    
+  SBExecutionContext();
+
+  SBExecutionContext(const lldb::SBExecutionContext &rhs);
+
+  SBExecutionContext(lldb::ExecutionContextRefSP exe_ctx_ref_sp);
+
+  SBExecutionContext(const lldb::SBTarget &target);
+
+  SBExecutionContext(const lldb::SBProcess &process);
+
+  SBExecutionContext(lldb::SBThread thread); // can't be a const& because
+                                             // SBThread::get() isn't itself a
+                                             // const function
+
+  SBExecutionContext(const lldb::SBFrame &frame);
+
+  ~SBExecutionContext();
+
+  const SBExecutionContext &operator=(const lldb::SBExecutionContext &rhs);
+
+  SBTarget GetTarget() const;
+
+  SBProcess GetProcess() const;
+
+  SBThread GetThread() const;
+
+  SBFrame GetFrame() const;
+
 protected:
-    ExecutionContextRefSP &
-    GetSP () const;
-    
-    void
-    reset (lldb::ExecutionContextRefSP &event_sp);
-    
-    lldb_private::ExecutionContextRef *
-    get () const;
-    
+  ExecutionContextRefSP &GetSP() const;
+
+  void reset(lldb::ExecutionContextRefSP &event_sp);
+
+  lldb_private::ExecutionContextRef *get() const;
+
 private:
-    
-    mutable lldb::ExecutionContextRefSP m_exe_ctx_sp;
+  mutable lldb::ExecutionContextRefSP m_exe_ctx_sp;
 };
-    
+
 } // namespace lldb
 
-#endif  // LLDB_SBExecutionContext_h_
+#endif // LLDB_SBExecutionContext_h_
diff --git a/include/lldb/API/SBExpressionOptions.h b/include/lldb/API/SBExpressionOptions.h
index 051ed7220ac8..370811d0c355 100644
--- a/include/lldb/API/SBExpressionOptions.h
+++ b/include/lldb/API/SBExpressionOptions.h
@@ -16,133 +16,100 @@
 
 namespace lldb {
 
-
-class LLDB_API SBExpressionOptions
-{
+class LLDB_API SBExpressionOptions {
 public:
-    SBExpressionOptions();
-
-    SBExpressionOptions (const lldb::SBExpressionOptions &rhs);
-    
-    ~SBExpressionOptions();
-
-    const SBExpressionOptions &
-    operator = (const lldb::SBExpressionOptions &rhs);
-
-    bool
-    GetCoerceResultToId () const;
-    
-    void
-    SetCoerceResultToId (bool coerce = true);
-    
-    bool
-    GetUnwindOnError () const;
-    
-    void
-    SetUnwindOnError (bool unwind = true);
-    
-    bool
-    GetIgnoreBreakpoints () const;
-    
-    void
-    SetIgnoreBreakpoints (bool ignore = true);
-    
-    lldb::DynamicValueType
-    GetFetchDynamicValue () const;
-    
-    void
-    SetFetchDynamicValue (lldb::DynamicValueType dynamic = lldb::eDynamicCanRunTarget);
-    
-    uint32_t
-    GetTimeoutInMicroSeconds () const;
-    
-    // Set the timeout for the expression, 0 means wait forever.
-    void
-    SetTimeoutInMicroSeconds (uint32_t timeout = 0);
-    
-    uint32_t
-    GetOneThreadTimeoutInMicroSeconds () const;
-    
-    // Set the timeout for running on one thread, 0 means use the default behavior.
-    // If you set this higher than the overall timeout, you'll get an error when you
-    // try to run the expression.
-    void
-    SetOneThreadTimeoutInMicroSeconds (uint32_t timeout = 0);
-    
-    bool
-    GetTryAllThreads () const;
-    
-    void
-    SetTryAllThreads (bool run_others = true);
-    
-    bool
-    GetStopOthers() const;
-    
-    void
-    SetStopOthers(bool stop_others = true);
-
-    bool
-    GetTrapExceptions () const;
-    
-    void
-    SetTrapExceptions (bool trap_exceptions = true);
-    
-    void
-    SetLanguage (lldb::LanguageType language);
-
-    void
-    SetCancelCallback (lldb::ExpressionCancelCallback callback, void *baton);
-
-    bool
-    GetGenerateDebugInfo ();
-    
-    void
-    SetGenerateDebugInfo (bool b = true);
-    
-    bool
-    GetSuppressPersistentResult ();
-    
-    void
-    SetSuppressPersistentResult (bool b = false);
-
-    const char *
-    GetPrefix () const;
-
-    void
-    SetPrefix (const char *prefix);
-    
-    void
-    SetAutoApplyFixIts(bool b = true);
-    
-    bool
-    GetAutoApplyFixIts();
-    
-    bool
-    GetTopLevel ();
-
-    void
-    SetTopLevel (bool b = true);
+  SBExpressionOptions();
 
+  SBExpressionOptions(const lldb::SBExpressionOptions &rhs);
 
-protected:
+  ~SBExpressionOptions();
+
+  const SBExpressionOptions &operator=(const lldb::SBExpressionOptions &rhs);
+
+  bool GetCoerceResultToId() const;
+
+  void SetCoerceResultToId(bool coerce = true);
+
+  bool GetUnwindOnError() const;
+
+  void SetUnwindOnError(bool unwind = true);
+
+  bool GetIgnoreBreakpoints() const;
+
+  void SetIgnoreBreakpoints(bool ignore = true);
+
+  lldb::DynamicValueType GetFetchDynamicValue() const;
+
+  void SetFetchDynamicValue(
+      lldb::DynamicValueType dynamic = lldb::eDynamicCanRunTarget);
+
+  uint32_t GetTimeoutInMicroSeconds() const;
+
+  // Set the timeout for the expression, 0 means wait forever.
+  void SetTimeoutInMicroSeconds(uint32_t timeout = 0);
+
+  uint32_t GetOneThreadTimeoutInMicroSeconds() const;
+
+  // Set the timeout for running on one thread, 0 means use the default
+  // behavior.
+  // If you set this higher than the overall timeout, you'll get an error when
+  // you
+  // try to run the expression.
+  void SetOneThreadTimeoutInMicroSeconds(uint32_t timeout = 0);
+
+  bool GetTryAllThreads() const;
+
+  void SetTryAllThreads(bool run_others = true);
 
-    SBExpressionOptions (lldb_private::EvaluateExpressionOptions &expression_options);
+  bool GetStopOthers() const;
+
+  void SetStopOthers(bool stop_others = true);
+
+  bool GetTrapExceptions() const;
+
+  void SetTrapExceptions(bool trap_exceptions = true);
+
+  void SetLanguage(lldb::LanguageType language);
+
+  void SetCancelCallback(lldb::ExpressionCancelCallback callback, void *baton);
+
+  bool GetGenerateDebugInfo();
+
+  void SetGenerateDebugInfo(bool b = true);
+
+  bool GetSuppressPersistentResult();
+
+  void SetSuppressPersistentResult(bool b = false);
+
+  const char *GetPrefix() const;
+
+  void SetPrefix(const char *prefix);
+
+  void SetAutoApplyFixIts(bool b = true);
+
+  bool GetAutoApplyFixIts();
+
+  bool GetTopLevel();
+
+  void SetTopLevel(bool b = true);
+
+protected:
+  SBExpressionOptions(
+      lldb_private::EvaluateExpressionOptions &expression_options);
 
-    lldb_private::EvaluateExpressionOptions *
-    get () const;
+  lldb_private::EvaluateExpressionOptions *get() const;
 
-    lldb_private::EvaluateExpressionOptions &
-    ref () const;
+  lldb_private::EvaluateExpressionOptions &ref() const;
 
-    friend class SBFrame;
-    friend class SBValue;
-    friend class SBTarget;
+  friend class SBFrame;
+  friend class SBValue;
+  friend class SBTarget;
 
 private:
-    // This auto_pointer is made in the constructor and is always valid.
-    mutable std::unique_ptr<lldb_private::EvaluateExpressionOptions> m_opaque_ap;
+  // This auto_pointer is made in the constructor and is always valid.
+  mutable std::unique_ptr<lldb_private::EvaluateExpressionOptions> m_opaque_ap;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBExpressionOptions_h_
+#endif // LLDB_SBExpressionOptions_h_
diff --git a/include/lldb/API/SBFileSpec.h b/include/lldb/API/SBFileSpec.h
index 2f9d6bab89f3..a31d95abb493 100644
--- a/include/lldb/API/SBFileSpec.h
+++ b/include/lldb/API/SBFileSpec.h
@@ -14,93 +14,75 @@
 
 namespace lldb {
 
-class LLDB_API SBFileSpec
-{
+class LLDB_API SBFileSpec {
 public:
-    SBFileSpec ();
+  SBFileSpec();
 
-    SBFileSpec (const lldb::SBFileSpec &rhs);
+  SBFileSpec(const lldb::SBFileSpec &rhs);
 
-    SBFileSpec (const char *path);// Deprecated, use SBFileSpec (const char *path, bool resolve)
+  SBFileSpec(const char *path); // Deprecated, use SBFileSpec (const char *path,
+                                // bool resolve)
 
-    SBFileSpec (const char *path, bool resolve);
+  SBFileSpec(const char *path, bool resolve);
 
-    ~SBFileSpec ();
+  ~SBFileSpec();
 
-    const SBFileSpec &
-    operator = (const lldb::SBFileSpec &rhs);
+  const SBFileSpec &operator=(const lldb::SBFileSpec &rhs);
 
-    bool
-    IsValid() const;
+  bool IsValid() const;
 
-    bool
-    Exists () const;
+  bool Exists() const;
 
-    bool
-    ResolveExecutableLocation ();
+  bool ResolveExecutableLocation();
 
-    const char *
-    GetFilename() const;
+  const char *GetFilename() const;
 
-    const char *
-    GetDirectory() const;
+  const char *GetDirectory() const;
 
-    void
-    SetFilename(const char *filename);
-    
-    void
-    SetDirectory(const char *directory);
+  void SetFilename(const char *filename);
 
-    uint32_t
-    GetPath (char *dst_path, size_t dst_len) const;
+  void SetDirectory(const char *directory);
 
-    static int
-    ResolvePath (const char *src_path, char *dst_path, size_t dst_len);
+  uint32_t GetPath(char *dst_path, size_t dst_len) const;
 
-    bool
-    GetDescription (lldb::SBStream &description) const;
+  static int ResolvePath(const char *src_path, char *dst_path, size_t dst_len);
 
-    void
-    AppendPathComponent (const char *file_or_directory);
+  bool GetDescription(lldb::SBStream &description) const;
+
+  void AppendPathComponent(const char *file_or_directory);
 
 private:
-    friend class SBAttachInfo;
-    friend class SBBlock;
-    friend class SBCommandInterpreter;
-    friend class SBCompileUnit;
-    friend class SBDeclaration;
-    friend class SBFileSpecList;
-    friend class SBHostOS;
-    friend class SBLaunchInfo;
-    friend class SBLineEntry;
-    friend class SBModule;
-    friend class SBModuleSpec;
-    friend class SBPlatform;
-    friend class SBProcess;
-    friend class SBSourceManager;
-    friend class SBThread;
-    friend class SBTarget;
-
-    SBFileSpec (const lldb_private::FileSpec& fspec);
-
-    void
-    SetFileSpec (const lldb_private::FileSpec& fspec);
-
-    const lldb_private::FileSpec *
-    operator->() const;
-
-    const lldb_private::FileSpec *
-    get() const;
-
-    const lldb_private::FileSpec &
-    operator*() const;
-
-    const lldb_private::FileSpec &
-    ref() const;
-
-    std::unique_ptr<lldb_private::FileSpec> m_opaque_ap;
-};
+  friend class SBAttachInfo;
+  friend class SBBlock;
+  friend class SBCommandInterpreter;
+  friend class SBCompileUnit;
+  friend class SBDeclaration;
+  friend class SBFileSpecList;
+  friend class SBHostOS;
+  friend class SBLaunchInfo;
+  friend class SBLineEntry;
+  friend class SBModule;
+  friend class SBModuleSpec;
+  friend class SBPlatform;
+  friend class SBProcess;
+  friend class SBSourceManager;
+  friend class SBThread;
+  friend class SBTarget;
+
+  SBFileSpec(const lldb_private::FileSpec &fspec);
+
+  void SetFileSpec(const lldb_private::FileSpec &fspec);
+
+  const lldb_private::FileSpec *operator->() const;
 
+  const lldb_private::FileSpec *get() const;
+
+  const lldb_private::FileSpec &operator*() const;
+
+  const lldb_private::FileSpec &ref() const;
+
+  std::unique_ptr<lldb_private::FileSpec> m_opaque_ap;
+};
 
 } // namespace lldb
 
diff --git a/include/lldb/API/SBFileSpecList.h b/include/lldb/API/SBFileSpecList.h
index ff429a1815be..97f843adbb5f 100644
--- a/include/lldb/API/SBFileSpecList.h
+++ b/include/lldb/API/SBFileSpecList.h
@@ -1,4 +1,5 @@
-//===-- SBFileSpecList.h --------------------------------------------*- C++ -*-===//
+//===-- SBFileSpecList.h --------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -14,58 +15,43 @@
 
 namespace lldb {
 
-class LLDB_API SBFileSpecList
-{
+class LLDB_API SBFileSpecList {
 public:
-    SBFileSpecList ();
-
-    SBFileSpecList (const lldb::SBFileSpecList &rhs);
-
-    ~SBFileSpecList ();
-
-    const SBFileSpecList &
-    operator = (const lldb::SBFileSpecList &rhs);
-
-    uint32_t
-    GetSize () const;
-
-    bool
-    GetDescription (SBStream &description) const;
-    
-    void
-    Append (const SBFileSpec &sb_file);
-    
-    bool
-    AppendIfUnique (const SBFileSpec &sb_file);
-    
-    void
-    Clear();
-    
-    uint32_t
-    FindFileIndex (uint32_t idx, const SBFileSpec &sb_file, bool full);
-    
-    const SBFileSpec
-    GetFileSpecAtIndex (uint32_t idx) const;
+  SBFileSpecList();
 
-private:
+  SBFileSpecList(const lldb::SBFileSpecList &rhs);
 
-friend class SBTarget;
+  ~SBFileSpecList();
 
-    const lldb_private::FileSpecList *
-    operator->() const;
+  const SBFileSpecList &operator=(const lldb::SBFileSpecList &rhs);
 
-    const lldb_private::FileSpecList *
-    get() const;
+  uint32_t GetSize() const;
 
-    const lldb_private::FileSpecList &
-    operator*() const;
+  bool GetDescription(SBStream &description) const;
 
-    const lldb_private::FileSpecList &
-    ref() const;
+  void Append(const SBFileSpec &sb_file);
 
-    std::unique_ptr<lldb_private::FileSpecList> m_opaque_ap;
-};
+  bool AppendIfUnique(const SBFileSpec &sb_file);
+
+  void Clear();
+
+  uint32_t FindFileIndex(uint32_t idx, const SBFileSpec &sb_file, bool full);
+
+  const SBFileSpec GetFileSpecAtIndex(uint32_t idx) const;
+
+private:
+  friend class SBTarget;
+
+  const lldb_private::FileSpecList *operator->() const;
+
+  const lldb_private::FileSpecList *get() const;
 
+  const lldb_private::FileSpecList &operator*() const;
+
+  const lldb_private::FileSpecList &ref() const;
+
+  std::unique_ptr<lldb_private::FileSpecList> m_opaque_ap;
+};
 
 } // namespace lldb
 
diff --git a/include/lldb/API/SBFrame.h b/include/lldb/API/SBFrame.h
index 3177b0cc5a69..be5c0920aee5 100644
--- a/include/lldb/API/SBFrame.h
+++ b/include/lldb/API/SBFrame.h
@@ -15,227 +15,182 @@
 
 namespace lldb {
 
-class LLDB_API SBFrame
-{
+class LLDB_API SBFrame {
 public:
-    SBFrame ();
-
-    SBFrame (const lldb::SBFrame &rhs);
-    
-    const lldb::SBFrame &
-    operator =(const lldb::SBFrame &rhs);
-
-    ~SBFrame();
-
-    bool
-    IsEqual (const lldb::SBFrame &that) const;
-
-    bool
-    IsValid() const;
-
-    uint32_t
-    GetFrameID () const;
-
-    lldb::addr_t
-    GetCFA () const;
-
-    lldb::addr_t
-    GetPC () const;
-
-    bool
-    SetPC (lldb::addr_t new_pc);
-
-    lldb::addr_t
-    GetSP () const;
-
-    lldb::addr_t
-    GetFP () const;
-
-    lldb::SBAddress
-    GetPCAddress () const;
-
-    lldb::SBSymbolContext
-    GetSymbolContext (uint32_t resolve_scope) const;
-
-    lldb::SBModule
-    GetModule () const;
-
-    lldb::SBCompileUnit
-    GetCompileUnit () const;
-
-    lldb::SBFunction
-    GetFunction () const;
-
-    lldb::SBSymbol
-    GetSymbol () const;
-
-    /// Gets the deepest block that contains the frame PC.
-    ///
-    /// See also GetFrameBlock().
-    lldb::SBBlock
-    GetBlock () const;
-
-    /// Get the appropriate function name for this frame. Inlined functions in
-    /// LLDB are represented by Blocks that have inlined function information, so
-    /// just looking at the SBFunction or SBSymbol for a frame isn't enough.
-    /// This function will return the appropriate function, symbol or inlined
-    /// function name for the frame.
-    ///
-    /// This function returns:
-    /// - the name of the inlined function (if there is one)
-    /// - the name of the concrete function (if there is one)
-    /// - the name of the symbol (if there is one)
-    /// - NULL
-    ///
-    /// See also IsInlined().
-    const char *
-    GetFunctionName();
-    
-    // Get an appropriate function name for this frame that is suitable for display to a user
-    const char *
-    GetDisplayFunctionName ();
-
-    const char *
-    GetFunctionName() const;
-
-    /// Return true if this frame represents an inlined function.
-    ///
-    /// See also GetFunctionName().
-    bool
-    IsInlined();
-
-    bool
-    IsInlined() const;
-
-    /// The version that doesn't supply a 'use_dynamic' value will use the
-    /// target's default.
-    lldb::SBValue
-    EvaluateExpression (const char *expr);    
-
-    lldb::SBValue
-    EvaluateExpression (const char *expr, lldb::DynamicValueType use_dynamic);
-
-    lldb::SBValue
-    EvaluateExpression (const char *expr, lldb::DynamicValueType use_dynamic, bool unwind_on_error);
-    
-    lldb::SBValue
-    EvaluateExpression (const char *expr, const SBExpressionOptions &options);
-
-    /// Gets the lexical block that defines the stack frame. Another way to think
-    /// of this is it will return the block that contains all of the variables
-    /// for a stack frame. Inlined functions are represented as SBBlock objects
-    /// that have inlined function information: the name of the inlined function,
-    /// where it was called from. The block that is returned will be the first 
-    /// block at or above the block for the PC (SBFrame::GetBlock()) that defines
-    /// the scope of the frame. When a function contains no inlined functions,
-    /// this will be the top most lexical block that defines the function. 
-    /// When a function has inlined functions and the PC is currently
-    /// in one of those inlined functions, this method will return the inlined
-    /// block that defines this frame. If the PC isn't currently in an inlined
-    /// function, the lexical block that defines the function is returned.
-    lldb::SBBlock
-    GetFrameBlock () const;
-
-    lldb::SBLineEntry
-    GetLineEntry () const;
-
-    lldb::SBThread
-    GetThread () const;
-
-    const char *
-    Disassemble () const;
-
-    void
-    Clear();
-
-    bool
-    operator == (const lldb::SBFrame &rhs) const;
-
-    bool
-    operator != (const lldb::SBFrame &rhs) const;
-
-    /// The version that doesn't supply a 'use_dynamic' value will use the
-    /// target's default.
-    lldb::SBValueList
-    GetVariables (bool arguments,
-                  bool locals,
-                  bool statics,
-                  bool in_scope_only);
-
-    lldb::SBValueList
-    GetVariables (bool arguments,
-                  bool locals,
-                  bool statics,
-                  bool in_scope_only,
-                  lldb::DynamicValueType  use_dynamic);
-
-    lldb::SBValueList
-    GetVariables (const lldb::SBVariablesOptions& options);
-    
-    lldb::SBValueList
-    GetRegisters ();
-
-    lldb::SBValue
-    FindRegister (const char *name);
-
-    /// The version that doesn't supply a 'use_dynamic' value will use the
-    /// target's default.
-    lldb::SBValue
-    FindVariable (const char *var_name);
-
-    lldb::SBValue
-    FindVariable (const char *var_name, lldb::DynamicValueType use_dynamic);
-
-    // Find a value for a variable expression path like "rect.origin.x" or
-    // "pt_ptr->x", "*self", "*this->obj_ptr". The returned value is _not_
-    // and expression result and is not a constant object like 
-    // SBFrame::EvaluateExpression(...) returns, but a child object of 
-    // the variable value.
-    lldb::SBValue
-    GetValueForVariablePath (const char *var_expr_cstr, 
-                             DynamicValueType use_dynamic);
-
-    /// The version that doesn't supply a 'use_dynamic' value will use the
-    /// target's default.
-    lldb::SBValue
-    GetValueForVariablePath (const char *var_path);
-
-    /// Find variables, register sets, registers, or persistent variables using
-    /// the frame as the scope.
-    ///
-    /// NB. This function does not look up ivars in the function object pointer.
-    /// To do that use GetValueForVariablePath.
-    ///
-    /// The version that doesn't supply a 'use_dynamic' value will use the
-    /// target's default.
-    lldb::SBValue
-    FindValue (const char *name, ValueType value_type);
-
-    lldb::SBValue
-    FindValue (const char *name, ValueType value_type, lldb::DynamicValueType use_dynamic);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    SBFrame (const lldb::StackFrameSP &lldb_object_sp);
+  SBFrame();
 
-protected:
+  SBFrame(const lldb::SBFrame &rhs);
+
+  const lldb::SBFrame &operator=(const lldb::SBFrame &rhs);
+
+  ~SBFrame();
+
+  bool IsEqual(const lldb::SBFrame &that) const;
+
+  bool IsValid() const;
+
+  uint32_t GetFrameID() const;
+
+  lldb::addr_t GetCFA() const;
+
+  lldb::addr_t GetPC() const;
+
+  bool SetPC(lldb::addr_t new_pc);
+
+  lldb::addr_t GetSP() const;
+
+  lldb::addr_t GetFP() const;
+
+  lldb::SBAddress GetPCAddress() const;
+
+  lldb::SBSymbolContext GetSymbolContext(uint32_t resolve_scope) const;
+
+  lldb::SBModule GetModule() const;
+
+  lldb::SBCompileUnit GetCompileUnit() const;
+
+  lldb::SBFunction GetFunction() const;
+
+  lldb::SBSymbol GetSymbol() const;
+
+  /// Gets the deepest block that contains the frame PC.
+  ///
+  /// See also GetFrameBlock().
+  lldb::SBBlock GetBlock() const;
+
+  /// Get the appropriate function name for this frame. Inlined functions in
+  /// LLDB are represented by Blocks that have inlined function information, so
+  /// just looking at the SBFunction or SBSymbol for a frame isn't enough.
+  /// This function will return the appropriate function, symbol or inlined
+  /// function name for the frame.
+  ///
+  /// This function returns:
+  /// - the name of the inlined function (if there is one)
+  /// - the name of the concrete function (if there is one)
+  /// - the name of the symbol (if there is one)
+  /// - NULL
+  ///
+  /// See also IsInlined().
+  const char *GetFunctionName();
+
+  // Get an appropriate function name for this frame that is suitable for
+  // display to a user
+  const char *GetDisplayFunctionName();
+
+  const char *GetFunctionName() const;
+
+  /// Return true if this frame represents an inlined function.
+  ///
+  /// See also GetFunctionName().
+  bool IsInlined();
+
+  bool IsInlined() const;
+
+  /// The version that doesn't supply a 'use_dynamic' value will use the
+  /// target's default.
+  lldb::SBValue EvaluateExpression(const char *expr);
 
-    friend class SBBlock;
-    friend class SBExecutionContext;
-    friend class SBInstruction;
-    friend class SBThread;
-    friend class SBValue;
+  lldb::SBValue EvaluateExpression(const char *expr,
+                                   lldb::DynamicValueType use_dynamic);
+
+  lldb::SBValue EvaluateExpression(const char *expr,
+                                   lldb::DynamicValueType use_dynamic,
+                                   bool unwind_on_error);
+
+  lldb::SBValue EvaluateExpression(const char *expr,
+                                   const SBExpressionOptions &options);
+
+  /// Gets the lexical block that defines the stack frame. Another way to think
+  /// of this is it will return the block that contains all of the variables
+  /// for a stack frame. Inlined functions are represented as SBBlock objects
+  /// that have inlined function information: the name of the inlined function,
+  /// where it was called from. The block that is returned will be the first
+  /// block at or above the block for the PC (SBFrame::GetBlock()) that defines
+  /// the scope of the frame. When a function contains no inlined functions,
+  /// this will be the top most lexical block that defines the function.
+  /// When a function has inlined functions and the PC is currently
+  /// in one of those inlined functions, this method will return the inlined
+  /// block that defines this frame. If the PC isn't currently in an inlined
+  /// function, the lexical block that defines the function is returned.
+  lldb::SBBlock GetFrameBlock() const;
+
+  lldb::SBLineEntry GetLineEntry() const;
+
+  lldb::SBThread GetThread() const;
+
+  const char *Disassemble() const;
+
+  void Clear();
+
+  bool operator==(const lldb::SBFrame &rhs) const;
+
+  bool operator!=(const lldb::SBFrame &rhs) const;
+
+  /// The version that doesn't supply a 'use_dynamic' value will use the
+  /// target's default.
+  lldb::SBValueList GetVariables(bool arguments, bool locals, bool statics,
+                                 bool in_scope_only);
+
+  lldb::SBValueList GetVariables(bool arguments, bool locals, bool statics,
+                                 bool in_scope_only,
+                                 lldb::DynamicValueType use_dynamic);
+
+  lldb::SBValueList GetVariables(const lldb::SBVariablesOptions &options);
+
+  lldb::SBValueList GetRegisters();
+
+  lldb::SBValue FindRegister(const char *name);
+
+  /// The version that doesn't supply a 'use_dynamic' value will use the
+  /// target's default.
+  lldb::SBValue FindVariable(const char *var_name);
+
+  lldb::SBValue FindVariable(const char *var_name,
+                             lldb::DynamicValueType use_dynamic);
+
+  // Find a value for a variable expression path like "rect.origin.x" or
+  // "pt_ptr->x", "*self", "*this->obj_ptr". The returned value is _not_
+  // and expression result and is not a constant object like
+  // SBFrame::EvaluateExpression(...) returns, but a child object of
+  // the variable value.
+  lldb::SBValue GetValueForVariablePath(const char *var_expr_cstr,
+                                        DynamicValueType use_dynamic);
+
+  /// The version that doesn't supply a 'use_dynamic' value will use the
+  /// target's default.
+  lldb::SBValue GetValueForVariablePath(const char *var_path);
+
+  /// Find variables, register sets, registers, or persistent variables using
+  /// the frame as the scope.
+  ///
+  /// NB. This function does not look up ivars in the function object pointer.
+  /// To do that use GetValueForVariablePath.
+  ///
+  /// The version that doesn't supply a 'use_dynamic' value will use the
+  /// target's default.
+  lldb::SBValue FindValue(const char *name, ValueType value_type);
+
+  lldb::SBValue FindValue(const char *name, ValueType value_type,
+                          lldb::DynamicValueType use_dynamic);
+
+  bool GetDescription(lldb::SBStream &description);
+
+  SBFrame(const lldb::StackFrameSP &lldb_object_sp);
+
+protected:
+  friend class SBBlock;
+  friend class SBExecutionContext;
+  friend class SBInstruction;
+  friend class SBThread;
+  friend class SBValue;
 
-    lldb::StackFrameSP
-    GetFrameSP() const;
+  lldb::StackFrameSP GetFrameSP() const;
 
-    void
-    SetFrameSP (const lldb::StackFrameSP &lldb_object_sp);
+  void SetFrameSP(const lldb::StackFrameSP &lldb_object_sp);
 
-    lldb::ExecutionContextRefSP m_opaque_sp;
+  lldb::ExecutionContextRefSP m_opaque_sp;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBFrame_h_
+#endif // LLDB_SBFrame_h_
diff --git a/include/lldb/API/SBFunction.h b/include/lldb/API/SBFunction.h
index f76c77c44e3f..23da02102cfb 100644
--- a/include/lldb/API/SBFunction.h
+++ b/include/lldb/API/SBFunction.h
@@ -10,96 +10,72 @@
 #ifndef LLDB_SBFunction_h_
 #define LLDB_SBFunction_h_
 
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBAddress.h"
+#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBInstructionList.h"
 
 namespace lldb {
 
-class LLDB_API SBFunction
-{
+class LLDB_API SBFunction {
 public:
+  SBFunction();
 
-    SBFunction ();
+  SBFunction(const lldb::SBFunction &rhs);
 
-    SBFunction (const lldb::SBFunction &rhs);
+  const lldb::SBFunction &operator=(const lldb::SBFunction &rhs);
 
-    const lldb::SBFunction &
-    operator = (const lldb::SBFunction &rhs);
+  ~SBFunction();
 
-    ~SBFunction ();
+  bool IsValid() const;
 
-    bool
-    IsValid () const;
+  const char *GetName() const;
 
-    const char *
-    GetName() const;
+  const char *GetDisplayName() const;
 
-    const char *
-    GetDisplayName() const;
-    
-    const char *
-    GetMangledName () const;
+  const char *GetMangledName() const;
 
-    lldb::SBInstructionList
-    GetInstructions (lldb::SBTarget target);
+  lldb::SBInstructionList GetInstructions(lldb::SBTarget target);
 
-    lldb::SBInstructionList
-    GetInstructions (lldb::SBTarget target, const char *flavor);
+  lldb::SBInstructionList GetInstructions(lldb::SBTarget target,
+                                          const char *flavor);
 
-    lldb::SBAddress
-    GetStartAddress ();
+  lldb::SBAddress GetStartAddress();
 
-    lldb::SBAddress
-    GetEndAddress ();
+  lldb::SBAddress GetEndAddress();
 
-    const char *
-    GetArgumentName (uint32_t arg_idx);
+  const char *GetArgumentName(uint32_t arg_idx);
 
-    uint32_t
-    GetPrologueByteSize ();
+  uint32_t GetPrologueByteSize();
 
-    lldb::SBType
-    GetType ();
+  lldb::SBType GetType();
 
-    lldb::SBBlock
-    GetBlock ();
-    
-    lldb::LanguageType
-    GetLanguage ();
+  lldb::SBBlock GetBlock();
 
-    bool
-    GetIsOptimized ();
+  lldb::LanguageType GetLanguage();
 
-    bool
-    operator == (const lldb::SBFunction &rhs) const;
+  bool GetIsOptimized();
 
-    bool
-    operator != (const lldb::SBFunction &rhs) const;
+  bool operator==(const lldb::SBFunction &rhs) const;
 
-    bool
-    GetDescription (lldb::SBStream &description);
+  bool operator!=(const lldb::SBFunction &rhs) const;
 
-protected:
+  bool GetDescription(lldb::SBStream &description);
 
-    lldb_private::Function *
-    get ();
+protected:
+  lldb_private::Function *get();
 
-    void
-    reset (lldb_private::Function *lldb_object_ptr);
+  void reset(lldb_private::Function *lldb_object_ptr);
 
 private:
-    friend class SBAddress;
-    friend class SBFrame;
-    friend class SBSymbolContext;
-
-    SBFunction (lldb_private::Function *lldb_object_ptr);
+  friend class SBAddress;
+  friend class SBFrame;
+  friend class SBSymbolContext;
 
+  SBFunction(lldb_private::Function *lldb_object_ptr);
 
-    lldb_private::Function *m_opaque_ptr;
+  lldb_private::Function *m_opaque_ptr;
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBFunction_h_
diff --git a/include/lldb/API/SBHostOS.h b/include/lldb/API/SBHostOS.h
index a3675856a136..1671917f865c 100644
--- a/include/lldb/API/SBHostOS.h
+++ b/include/lldb/API/SBHostOS.h
@@ -15,49 +15,31 @@
 
 namespace lldb {
 
-class LLDB_API SBHostOS
-{
+class LLDB_API SBHostOS {
 public:
+  static lldb::SBFileSpec GetProgramFileSpec();
 
-    static lldb::SBFileSpec
-    GetProgramFileSpec ();
-    
-    static lldb::SBFileSpec
-    GetLLDBPythonPath ();
+  static lldb::SBFileSpec GetLLDBPythonPath();
 
-    static lldb::SBFileSpec
-    GetLLDBPath (lldb::PathType path_type);
+  static lldb::SBFileSpec GetLLDBPath(lldb::PathType path_type);
 
-    static lldb::SBFileSpec
-    GetUserHomeDirectory ();
+  static lldb::SBFileSpec GetUserHomeDirectory();
 
-    static void
-    ThreadCreated (const char *name);
+  static void ThreadCreated(const char *name);
 
-    static lldb::thread_t
-    ThreadCreate (const char *name,
-                  lldb::thread_func_t thread_function,
-                  void *thread_arg,
-                  lldb::SBError *err);
+  static lldb::thread_t ThreadCreate(const char *name,
+                                     lldb::thread_func_t thread_function,
+                                     void *thread_arg, lldb::SBError *err);
 
-    static bool
-    ThreadCancel (lldb::thread_t thread,
-                  lldb::SBError *err);
-
-    static bool
-    ThreadDetach (lldb::thread_t thread,
-                  lldb::SBError *err);
-    static bool
-    ThreadJoin (lldb::thread_t thread,
-                lldb::thread_result_t *result,
-                lldb::SBError *err);
+  static bool ThreadCancel(lldb::thread_t thread, lldb::SBError *err);
 
+  static bool ThreadDetach(lldb::thread_t thread, lldb::SBError *err);
+  static bool ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result,
+                         lldb::SBError *err);
 
 private:
-
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBHostOS_h_
diff --git a/include/lldb/API/SBInstruction.h b/include/lldb/API/SBInstruction.h
index cb0b2a32a829..0fc12eb61cba 100644
--- a/include/lldb/API/SBInstruction.h
+++ b/include/lldb/API/SBInstruction.h
@@ -10,93 +10,76 @@
 #ifndef LLDB_SBInstruction_h_
 #define LLDB_SBInstruction_h_
 
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBData.h"
+#include "lldb/API/SBDefines.h"
 
 #include <stdio.h>
 
-// There's a lot to be fixed here, but need to wait for underlying insn implementation
+// There's a lot to be fixed here, but need to wait for underlying insn
+// implementation
 // to be revised & settle down first.
 
 class InstructionImpl;
 
 namespace lldb {
 
-class LLDB_API SBInstruction
-{
+class LLDB_API SBInstruction {
 public:
+  SBInstruction();
+
+  SBInstruction(const SBInstruction &rhs);
+
+  const SBInstruction &operator=(const SBInstruction &rhs);
 
-    SBInstruction ();
+  ~SBInstruction();
 
-    SBInstruction (const SBInstruction &rhs);
-    
-    const SBInstruction &
-    operator = (const SBInstruction &rhs);
+  bool IsValid();
 
-    ~SBInstruction ();
+  SBAddress GetAddress();
 
-    bool
-    IsValid();
+  lldb::AddressClass GetAddressClass();
 
-    SBAddress
-    GetAddress();
-    
-    lldb::AddressClass
-    GetAddressClass ();
-    
-    const char *
-    GetMnemonic (lldb::SBTarget target);
+  const char *GetMnemonic(lldb::SBTarget target);
 
-    const char *
-    GetOperands (lldb::SBTarget target);
-    
-    const char *
-    GetComment (lldb::SBTarget target);
+  const char *GetOperands(lldb::SBTarget target);
 
-    lldb::SBData
-    GetData (lldb::SBTarget target);
+  const char *GetComment(lldb::SBTarget target);
 
-    size_t
-    GetByteSize ();
+  lldb::SBData GetData(lldb::SBTarget target);
 
-    bool
-    DoesBranch ();
+  size_t GetByteSize();
 
-    bool
-    HasDelaySlot ();
+  bool DoesBranch();
 
-    void
-    Print (FILE *out);
+  bool HasDelaySlot();
 
-    bool
-    GetDescription (lldb::SBStream &description);
+  void Print(FILE *out);
 
-    bool
-    EmulateWithFrame (lldb::SBFrame &frame, uint32_t evaluate_options);
+  bool GetDescription(lldb::SBStream &description);
 
-    bool
-    DumpEmulation (const char * triple); // triple is to specify the architecture, e.g. 'armv6' or 'armv7-apple-ios'
-    
-    bool
-    TestEmulation (lldb::SBStream &output_stream, const char *test_file);
+  bool EmulateWithFrame(lldb::SBFrame &frame, uint32_t evaluate_options);
+
+  bool DumpEmulation(const char *triple); // triple is to specify the
+                                          // architecture, e.g. 'armv6' or
+                                          // 'armv7-apple-ios'
+
+  bool TestEmulation(lldb::SBStream &output_stream, const char *test_file);
 
 protected:
-    friend class SBInstructionList;
+  friend class SBInstructionList;
 
-    SBInstruction(const lldb::DisassemblerSP &disasm_sp, const lldb::InstructionSP &inst_sp);
+  SBInstruction(const lldb::DisassemblerSP &disasm_sp,
+                const lldb::InstructionSP &inst_sp);
 
-    void
-    SetOpaque(const lldb::DisassemblerSP &disasm_sp, const lldb::InstructionSP& inst_sp);
+  void SetOpaque(const lldb::DisassemblerSP &disasm_sp,
+                 const lldb::InstructionSP &inst_sp);
 
-    lldb::InstructionSP
-    GetOpaque();
+  lldb::InstructionSP GetOpaque();
 
 private:
-
-    std::shared_ptr<InstructionImpl> m_opaque_sp;
+  std::shared_ptr<InstructionImpl> m_opaque_sp;
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBInstruction_h_
diff --git a/include/lldb/API/SBInstructionList.h b/include/lldb/API/SBInstructionList.h
index 8ef163796629..29baef5790eb 100644
--- a/include/lldb/API/SBInstructionList.h
+++ b/include/lldb/API/SBInstructionList.h
@@ -16,55 +16,42 @@
 
 namespace lldb {
 
-class LLDB_API SBInstructionList
-{
+class LLDB_API SBInstructionList {
 public:
+  SBInstructionList();
 
-    SBInstructionList ();
+  SBInstructionList(const SBInstructionList &rhs);
 
-    SBInstructionList (const SBInstructionList &rhs);
-    
-    const SBInstructionList &
-    operator = (const SBInstructionList &rhs);
+  const SBInstructionList &operator=(const SBInstructionList &rhs);
 
-    ~SBInstructionList ();
+  ~SBInstructionList();
 
-    bool
-    IsValid () const;
+  bool IsValid() const;
 
-    size_t
-    GetSize ();
+  size_t GetSize();
 
-    lldb::SBInstruction
-    GetInstructionAtIndex (uint32_t idx);
+  lldb::SBInstruction GetInstructionAtIndex(uint32_t idx);
 
-    void
-    Clear ();
+  void Clear();
 
-    void
-    AppendInstruction (lldb::SBInstruction inst);
+  void AppendInstruction(lldb::SBInstruction inst);
 
-    void
-    Print (FILE *out);
+  void Print(FILE *out);
 
-    bool
-    GetDescription (lldb::SBStream &description);
-    
-    bool
-    DumpEmulationForAllInstructions (const char *triple);
+  bool GetDescription(lldb::SBStream &description);
+
+  bool DumpEmulationForAllInstructions(const char *triple);
 
 protected:
-    friend class SBFunction;
-    friend class SBSymbol;
-    friend class SBTarget;
-    
-    void
-    SetDisassembler (const lldb::DisassemblerSP &opaque_sp);
-
-private:    
-    lldb::DisassemblerSP m_opaque_sp;
-};
+  friend class SBFunction;
+  friend class SBSymbol;
+  friend class SBTarget;
 
+  void SetDisassembler(const lldb::DisassemblerSP &opaque_sp);
+
+private:
+  lldb::DisassemblerSP m_opaque_sp;
+};
 
 } // namespace lldb
 
diff --git a/include/lldb/API/SBLanguageRuntime.h b/include/lldb/API/SBLanguageRuntime.h
index 898604c496fa..3912f352491b 100644
--- a/include/lldb/API/SBLanguageRuntime.h
+++ b/include/lldb/API/SBLanguageRuntime.h
@@ -14,14 +14,11 @@
 
 namespace lldb {
 
-class SBLanguageRuntime
-{
+class SBLanguageRuntime {
 public:
-    static lldb::LanguageType
-    GetLanguageTypeFromString (const char *string);
-    
-    static const char *
-    GetNameForLanguageType (lldb::LanguageType language);
+  static lldb::LanguageType GetLanguageTypeFromString(const char *string);
+
+  static const char *GetNameForLanguageType(lldb::LanguageType language);
 };
 
 } // namespace lldb
diff --git a/include/lldb/API/SBLaunchInfo.h b/include/lldb/API/SBLaunchInfo.h
index 38d598aec456..1cece235127f 100644
--- a/include/lldb/API/SBLaunchInfo.h
+++ b/include/lldb/API/SBLaunchInfo.h
@@ -17,179 +17,137 @@ namespace lldb {
 class SBPlatform;
 class SBTarget;
 
-class LLDB_API SBLaunchInfo
-{
+class LLDB_API SBLaunchInfo {
 public:
-    SBLaunchInfo (const char **argv);
-
-    ~SBLaunchInfo();
-
-    lldb::pid_t
-    GetProcessID();
-
-    uint32_t
-    GetUserID();
-
-    uint32_t
-    GetGroupID();
-
-    bool
-    UserIDIsValid ();
-
-    bool
-    GroupIDIsValid ();
-
-    void
-    SetUserID (uint32_t uid);
-
-    void
-    SetGroupID (uint32_t gid);
-
-    SBFileSpec
-    GetExecutableFile ();
-
-    //----------------------------------------------------------------------
-    /// Set the executable file that will be used to launch the process and
-    /// optionally set it as the first argument in the argument vector.
-    ///
-    /// This only needs to be specified if clients wish to carefully control
-    /// the exact path will be used to launch a binary. If you create a
-    /// target with a symlink, that symlink will get resolved in the target
-    /// and the resolved path will get used to launch the process. Calling
-    /// this function can help you still launch your process using the
-    /// path of your choice.
-    ///
-    /// If this function is not called prior to launching with
-    /// SBTarget::Launch(...), the target will use the resolved executable
-    /// path that was used to create the target.
-    ///
-    /// @param[in] exe_file
-    ///     The override path to use when launching the executable.
-    ///
-    /// @param[in] add_as_first_arg
-    ///     If true, then the path will be inserted into the argument vector
-    ///     prior to launching. Otherwise the argument vector will be left
-    ///     alone.
-    //----------------------------------------------------------------------
-    void
-    SetExecutableFile (SBFileSpec exe_file, bool add_as_first_arg);
-
-
-    //----------------------------------------------------------------------
-    /// Get the listener that will be used to receive process events.
-    ///
-    /// If no listener has been set via a call to
-    /// SBLaunchInfo::SetListener(), then an invalid SBListener will be
-    /// returned (SBListener::IsValid() will return false). If a listener
-    /// has been set, then the valid listener object will be returned.
-    //----------------------------------------------------------------------
-    SBListener
-    GetListener ();
-
-    //----------------------------------------------------------------------
-    /// Set the listener that will be used to receive process events.
-    ///
-    /// By default the SBDebugger, which has a listener, that the SBTarget
-    /// belongs to will listen for the process events. Calling this function
-    /// allows a different listener to be used to listen for process events.
-    //----------------------------------------------------------------------
-    void
-    SetListener (SBListener &listener);
-
-    uint32_t
-    GetNumArguments ();
-
-    const char *
-    GetArgumentAtIndex (uint32_t idx);
-
-    void
-    SetArguments (const char **argv, bool append);
-
-    uint32_t
-    GetNumEnvironmentEntries ();
-
-    const char *
-    GetEnvironmentEntryAtIndex (uint32_t idx);
-
-    void
-    SetEnvironmentEntries (const char **envp, bool append);
-
-    void
-    Clear ();
-
-    const char *
-    GetWorkingDirectory () const;
-
-    void
-    SetWorkingDirectory (const char *working_dir);
-
-    uint32_t
-    GetLaunchFlags ();
-
-    void
-    SetLaunchFlags (uint32_t flags);
-
-    const char *
-    GetProcessPluginName ();
-
-    void
-    SetProcessPluginName (const char *plugin_name);
-
-    const char *
-    GetShell ();
-
-    void
-    SetShell (const char * path);
-    
-    bool
-    GetShellExpandArguments ();
-    
-    void
-    SetShellExpandArguments (bool expand);
-    
-    uint32_t
-    GetResumeCount ();
-
-    void
-    SetResumeCount (uint32_t c);
-
-    bool
-    AddCloseFileAction (int fd);
-
-    bool
-    AddDuplicateFileAction (int fd, int dup_fd);
-
-    bool
-    AddOpenFileAction (int fd, const char *path, bool read, bool write);
-
-    bool
-    AddSuppressFileAction (int fd, bool read, bool write);
+  SBLaunchInfo(const char **argv);
 
-    void
-    SetLaunchEventData (const char *data);
+  ~SBLaunchInfo();
 
-    const char *
-    GetLaunchEventData () const;
+  lldb::pid_t GetProcessID();
 
-    bool
-    GetDetachOnError() const;
+  uint32_t GetUserID();
 
-    void
-    SetDetachOnError(bool enable);
+  uint32_t GetGroupID();
+
+  bool UserIDIsValid();
+
+  bool GroupIDIsValid();
+
+  void SetUserID(uint32_t uid);
+
+  void SetGroupID(uint32_t gid);
+
+  SBFileSpec GetExecutableFile();
+
+  //----------------------------------------------------------------------
+  /// Set the executable file that will be used to launch the process and
+  /// optionally set it as the first argument in the argument vector.
+  ///
+  /// This only needs to be specified if clients wish to carefully control
+  /// the exact path will be used to launch a binary. If you create a
+  /// target with a symlink, that symlink will get resolved in the target
+  /// and the resolved path will get used to launch the process. Calling
+  /// this function can help you still launch your process using the
+  /// path of your choice.
+  ///
+  /// If this function is not called prior to launching with
+  /// SBTarget::Launch(...), the target will use the resolved executable
+  /// path that was used to create the target.
+  ///
+  /// @param[in] exe_file
+  ///     The override path to use when launching the executable.
+  ///
+  /// @param[in] add_as_first_arg
+  ///     If true, then the path will be inserted into the argument vector
+  ///     prior to launching. Otherwise the argument vector will be left
+  ///     alone.
+  //----------------------------------------------------------------------
+  void SetExecutableFile(SBFileSpec exe_file, bool add_as_first_arg);
+
+  //----------------------------------------------------------------------
+  /// Get the listener that will be used to receive process events.
+  ///
+  /// If no listener has been set via a call to
+  /// SBLaunchInfo::SetListener(), then an invalid SBListener will be
+  /// returned (SBListener::IsValid() will return false). If a listener
+  /// has been set, then the valid listener object will be returned.
+  //----------------------------------------------------------------------
+  SBListener GetListener();
+
+  //----------------------------------------------------------------------
+  /// Set the listener that will be used to receive process events.
+  ///
+  /// By default the SBDebugger, which has a listener, that the SBTarget
+  /// belongs to will listen for the process events. Calling this function
+  /// allows a different listener to be used to listen for process events.
+  //----------------------------------------------------------------------
+  void SetListener(SBListener &listener);
+
+  uint32_t GetNumArguments();
+
+  const char *GetArgumentAtIndex(uint32_t idx);
+
+  void SetArguments(const char **argv, bool append);
+
+  uint32_t GetNumEnvironmentEntries();
+
+  const char *GetEnvironmentEntryAtIndex(uint32_t idx);
+
+  void SetEnvironmentEntries(const char **envp, bool append);
+
+  void Clear();
+
+  const char *GetWorkingDirectory() const;
+
+  void SetWorkingDirectory(const char *working_dir);
+
+  uint32_t GetLaunchFlags();
+
+  void SetLaunchFlags(uint32_t flags);
+
+  const char *GetProcessPluginName();
+
+  void SetProcessPluginName(const char *plugin_name);
+
+  const char *GetShell();
+
+  void SetShell(const char *path);
+
+  bool GetShellExpandArguments();
+
+  void SetShellExpandArguments(bool expand);
+
+  uint32_t GetResumeCount();
+
+  void SetResumeCount(uint32_t c);
+
+  bool AddCloseFileAction(int fd);
+
+  bool AddDuplicateFileAction(int fd, int dup_fd);
+
+  bool AddOpenFileAction(int fd, const char *path, bool read, bool write);
+
+  bool AddSuppressFileAction(int fd, bool read, bool write);
+
+  void SetLaunchEventData(const char *data);
+
+  const char *GetLaunchEventData() const;
+
+  bool GetDetachOnError() const;
+
+  void SetDetachOnError(bool enable);
 
 protected:
-    friend class SBPlatform;
-    friend class SBTarget;
+  friend class SBPlatform;
+  friend class SBTarget;
 
-    lldb_private::ProcessLaunchInfo &
-    ref ();
+  lldb_private::ProcessLaunchInfo &ref();
 
-    const lldb_private::ProcessLaunchInfo &
-    ref () const;
+  const lldb_private::ProcessLaunchInfo &ref() const;
 
-    ProcessLaunchInfoSP m_opaque_sp;
+  ProcessLaunchInfoSP m_opaque_sp;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBLaunchInfo_h_
+#endif // LLDB_SBLaunchInfo_h_
diff --git a/include/lldb/API/SBLineEntry.h b/include/lldb/API/SBLineEntry.h
index 8311bbbafc90..3d58ea8278ea 100644
--- a/include/lldb/API/SBLineEntry.h
+++ b/include/lldb/API/SBLineEntry.h
@@ -10,90 +10,68 @@
 #ifndef LLDB_SBLineEntry_h_
 #define LLDB_SBLineEntry_h_
 
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBAddress.h"
+#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBFileSpec.h"
 
 namespace lldb {
 
-class LLDB_API SBLineEntry
-{
+class LLDB_API SBLineEntry {
 public:
+  SBLineEntry();
 
-    SBLineEntry ();
+  SBLineEntry(const lldb::SBLineEntry &rhs);
 
-    SBLineEntry (const lldb::SBLineEntry &rhs);
+  ~SBLineEntry();
 
-    ~SBLineEntry ();
+  const lldb::SBLineEntry &operator=(const lldb::SBLineEntry &rhs);
 
-    const lldb::SBLineEntry &
-    operator = (const lldb::SBLineEntry &rhs);
+  lldb::SBAddress GetStartAddress() const;
 
-    lldb::SBAddress
-    GetStartAddress () const;
+  lldb::SBAddress GetEndAddress() const;
 
-    lldb::SBAddress
-    GetEndAddress () const;
+  bool IsValid() const;
 
-    bool
-    IsValid () const;
+  lldb::SBFileSpec GetFileSpec() const;
 
-    lldb::SBFileSpec
-    GetFileSpec () const;
+  uint32_t GetLine() const;
 
-    uint32_t
-    GetLine () const;
+  uint32_t GetColumn() const;
 
-    uint32_t
-    GetColumn () const;
+  void SetFileSpec(lldb::SBFileSpec filespec);
 
-    void
-    SetFileSpec (lldb::SBFileSpec filespec);
-    
-    void
-    SetLine (uint32_t line);
-    
-    void
-    SetColumn (uint32_t column);
+  void SetLine(uint32_t line);
 
-    bool
-    operator == (const lldb::SBLineEntry &rhs) const;
+  void SetColumn(uint32_t column);
 
-    bool
-    operator != (const lldb::SBLineEntry &rhs) const;
+  bool operator==(const lldb::SBLineEntry &rhs) const;
 
-    bool
-    GetDescription (lldb::SBStream &description);
+  bool operator!=(const lldb::SBLineEntry &rhs) const;
+
+  bool GetDescription(lldb::SBStream &description);
 
 protected:
+  lldb_private::LineEntry *get();
 
-    lldb_private::LineEntry *
-    get ();
-    
 private:
-    friend class SBAddress;
-    friend class SBCompileUnit;
-    friend class SBFrame;
-    friend class SBSymbolContext;
+  friend class SBAddress;
+  friend class SBCompileUnit;
+  friend class SBFrame;
+  friend class SBSymbolContext;
 
-    const lldb_private::LineEntry *
-    operator->() const;
+  const lldb_private::LineEntry *operator->() const;
 
-    lldb_private::LineEntry &
-    ref();
+  lldb_private::LineEntry &ref();
 
-    const lldb_private::LineEntry &
-    ref() const;
+  const lldb_private::LineEntry &ref() const;
 
-    SBLineEntry (const lldb_private::LineEntry *lldb_object_ptr);
+  SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr);
 
-    void
-    SetLineEntry (const lldb_private::LineEntry &lldb_object_ref);
+  void SetLineEntry(const lldb_private::LineEntry &lldb_object_ref);
 
-    std::unique_ptr<lldb_private::LineEntry> m_opaque_ap;
+  std::unique_ptr<lldb_private::LineEntry> m_opaque_ap;
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBLineEntry_h_
diff --git a/include/lldb/API/SBListener.h b/include/lldb/API/SBListener.h
index e74d318ea118..05282c215406 100644
--- a/include/lldb/API/SBListener.h
+++ b/include/lldb/API/SBListener.h
@@ -14,121 +14,94 @@
 
 namespace lldb {
 
-class LLDB_API SBListener
-{
+class LLDB_API SBListener {
 public:
-    SBListener ();
+  SBListener();
 
-    SBListener (const char *name);
+  SBListener(const char *name);
 
-    SBListener (const SBListener &rhs);
+  SBListener(const SBListener &rhs);
 
-    ~SBListener ();
+  ~SBListener();
 
-    const lldb::SBListener &
-    operator = (const lldb::SBListener &rhs);
+  const lldb::SBListener &operator=(const lldb::SBListener &rhs);
 
-    void
-    AddEvent (const lldb::SBEvent &event);
+  void AddEvent(const lldb::SBEvent &event);
 
-    void
-    Clear ();
+  void Clear();
 
-    bool
-    IsValid () const;
+  bool IsValid() const;
 
-    uint32_t
-    StartListeningForEventClass (SBDebugger &debugger,
-                                 const char *broadcaster_class, 
-                                 uint32_t event_mask);
-                                 
-    bool
-    StopListeningForEventClass (SBDebugger &debugger,
-                                const char *broadcaster_class,
-                                uint32_t event_mask);
-    
-    uint32_t
-    StartListeningForEvents (const lldb::SBBroadcaster& broadcaster,
-                             uint32_t event_mask);
+  uint32_t StartListeningForEventClass(SBDebugger &debugger,
+                                       const char *broadcaster_class,
+                                       uint32_t event_mask);
 
-    bool
-    StopListeningForEvents (const lldb::SBBroadcaster& broadcaster,
-                            uint32_t event_mask);
+  bool StopListeningForEventClass(SBDebugger &debugger,
+                                  const char *broadcaster_class,
+                                  uint32_t event_mask);
 
-    // Returns true if an event was received, false if we timed out.
-    bool
-    WaitForEvent (uint32_t num_seconds,
-                  lldb::SBEvent &event);
+  uint32_t StartListeningForEvents(const lldb::SBBroadcaster &broadcaster,
+                                   uint32_t event_mask);
 
-    bool
-    WaitForEventForBroadcaster (uint32_t num_seconds,
-                                const lldb::SBBroadcaster &broadcaster,
-                                lldb::SBEvent &sb_event);
+  bool StopListeningForEvents(const lldb::SBBroadcaster &broadcaster,
+                              uint32_t event_mask);
 
-    bool
-    WaitForEventForBroadcasterWithType (uint32_t num_seconds,
-                                        const lldb::SBBroadcaster &broadcaster,
-                                        uint32_t event_type_mask,
-                                        lldb::SBEvent &sb_event);
+  // Returns true if an event was received, false if we timed out.
+  bool WaitForEvent(uint32_t num_seconds, lldb::SBEvent &event);
 
-    bool
-    PeekAtNextEvent (lldb::SBEvent &sb_event);
+  bool WaitForEventForBroadcaster(uint32_t num_seconds,
+                                  const lldb::SBBroadcaster &broadcaster,
+                                  lldb::SBEvent &sb_event);
 
-    bool
-    PeekAtNextEventForBroadcaster (const lldb::SBBroadcaster &broadcaster,
-                                   lldb::SBEvent &sb_event);
+  bool WaitForEventForBroadcasterWithType(
+      uint32_t num_seconds, const lldb::SBBroadcaster &broadcaster,
+      uint32_t event_type_mask, lldb::SBEvent &sb_event);
 
-    bool
-    PeekAtNextEventForBroadcasterWithType (const lldb::SBBroadcaster &broadcaster,
-                                           uint32_t event_type_mask,
-                                           lldb::SBEvent &sb_event);
+  bool PeekAtNextEvent(lldb::SBEvent &sb_event);
 
-    bool
-    GetNextEvent (lldb::SBEvent &sb_event);
+  bool PeekAtNextEventForBroadcaster(const lldb::SBBroadcaster &broadcaster,
+                                     lldb::SBEvent &sb_event);
 
-    bool
-    GetNextEventForBroadcaster (const lldb::SBBroadcaster &broadcaster,
-                                lldb::SBEvent &sb_event);
-
-    bool
-    GetNextEventForBroadcasterWithType (const lldb::SBBroadcaster &broadcaster,
+  bool
+  PeekAtNextEventForBroadcasterWithType(const lldb::SBBroadcaster &broadcaster,
                                         uint32_t event_type_mask,
                                         lldb::SBEvent &sb_event);
 
-    bool
-    HandleBroadcastEvent (const lldb::SBEvent &event);
+  bool GetNextEvent(lldb::SBEvent &sb_event);
+
+  bool GetNextEventForBroadcaster(const lldb::SBBroadcaster &broadcaster,
+                                  lldb::SBEvent &sb_event);
+
+  bool
+  GetNextEventForBroadcasterWithType(const lldb::SBBroadcaster &broadcaster,
+                                     uint32_t event_type_mask,
+                                     lldb::SBEvent &sb_event);
+
+  bool HandleBroadcastEvent(const lldb::SBEvent &event);
 
 protected:
-    friend class SBAttachInfo;
-    friend class SBBroadcaster;
-    friend class SBCommandInterpreter;
-    friend class SBDebugger;
-    friend class SBLaunchInfo;
-    friend class SBTarget;
+  friend class SBAttachInfo;
+  friend class SBBroadcaster;
+  friend class SBCommandInterpreter;
+  friend class SBDebugger;
+  friend class SBLaunchInfo;
+  friend class SBTarget;
 
-    SBListener (const lldb::ListenerSP &listener_sp);
+  SBListener(const lldb::ListenerSP &listener_sp);
 
-    lldb::ListenerSP
-    GetSP ()
-    {
-        return m_opaque_sp;
-    }
+  lldb::ListenerSP GetSP() { return m_opaque_sp; }
 
 private:
+  lldb_private::Listener *operator->() const;
 
-    lldb_private::Listener *
-    operator->() const;
-
-    lldb_private::Listener *
-    get() const;
+  lldb_private::Listener *get() const;
 
-    void
-    reset(lldb::ListenerSP listener_sp);
+  void reset(lldb::ListenerSP listener_sp);
 
-    lldb::ListenerSP m_opaque_sp;
-    lldb_private::Listener *m_unused_ptr;
+  lldb::ListenerSP m_opaque_sp;
+  lldb_private::Listener *m_unused_ptr;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBListener_h_
+#endif // LLDB_SBListener_h_
diff --git a/include/lldb/API/SBMemoryRegionInfo.h b/include/lldb/API/SBMemoryRegionInfo.h
index fadd0760891b..297f877a6341 100644
--- a/include/lldb/API/SBMemoryRegionInfo.h
+++ b/include/lldb/API/SBMemoryRegionInfo.h
@@ -10,108 +10,103 @@
 #ifndef LLDB_SBMemoryRegionInfo_h_
 #define LLDB_SBMemoryRegionInfo_h_
 
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBData.h"
+#include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
-class LLDB_API SBMemoryRegionInfo
-{
+class LLDB_API SBMemoryRegionInfo {
 public:
-
-    SBMemoryRegionInfo ();
-
-    SBMemoryRegionInfo (const lldb::SBMemoryRegionInfo &rhs);
-
-    ~SBMemoryRegionInfo ();
-
-    const lldb::SBMemoryRegionInfo &
-    operator = (const lldb::SBMemoryRegionInfo &rhs);
-
-    void
-    Clear();
-
-    //------------------------------------------------------------------
-    /// Get the base address of this memory range.
-    ///
-    /// @return
-    ///     The base address of this memory range.
-    //------------------------------------------------------------------
-    lldb::addr_t
-    GetRegionBase ();
-
-    //------------------------------------------------------------------
-    /// Get the end address of this memory range.
-    ///
-    /// @return
-    ///     The base address of this memory range.
-    //------------------------------------------------------------------
-    lldb::addr_t
-    GetRegionEnd ();
-
-    //------------------------------------------------------------------
-    /// Check if this memory address is marked readable to the process.
-    ///
-    /// @return
-    ///     true if this memory address is marked readable
-    //------------------------------------------------------------------
-    bool
-    IsReadable ();
-
-    //------------------------------------------------------------------
-    /// Check if this memory address is marked writable to the process.
-    ///
-    /// @return
-    ///     true if this memory address is marked writable
-    //------------------------------------------------------------------
-    bool
-    IsWritable ();
-
-    //------------------------------------------------------------------
-    /// Check if this memory address is marked executable to the process.
-    ///
-    /// @return
-    ///     true if this memory address is marked executable
-    //------------------------------------------------------------------
-    bool
-    IsExecutable ();
-
-    //------------------------------------------------------------------
-    /// Check if this memory address is mapped into the process address
-    /// space.
-    ///
-    /// @return
-    ///     true if this memory address is in the process address space.
-    //------------------------------------------------------------------
-    bool
-    IsMapped ();
-
-    bool
-    operator == (const lldb::SBMemoryRegionInfo &rhs) const;
-
-    bool
-    operator != (const lldb::SBMemoryRegionInfo &rhs) const;
-
-    bool
-    GetDescription (lldb::SBStream &description);
+  SBMemoryRegionInfo();
+
+  SBMemoryRegionInfo(const lldb::SBMemoryRegionInfo &rhs);
+
+  ~SBMemoryRegionInfo();
+
+  const lldb::SBMemoryRegionInfo &
+  operator=(const lldb::SBMemoryRegionInfo &rhs);
+
+  void Clear();
+
+  //------------------------------------------------------------------
+  /// Get the base address of this memory range.
+  ///
+  /// @return
+  ///     The base address of this memory range.
+  //------------------------------------------------------------------
+  lldb::addr_t GetRegionBase();
+
+  //------------------------------------------------------------------
+  /// Get the end address of this memory range.
+  ///
+  /// @return
+  ///     The base address of this memory range.
+  //------------------------------------------------------------------
+  lldb::addr_t GetRegionEnd();
+
+  //------------------------------------------------------------------
+  /// Check if this memory address is marked readable to the process.
+  ///
+  /// @return
+  ///     true if this memory address is marked readable
+  //------------------------------------------------------------------
+  bool IsReadable();
+
+  //------------------------------------------------------------------
+  /// Check if this memory address is marked writable to the process.
+  ///
+  /// @return
+  ///     true if this memory address is marked writable
+  //------------------------------------------------------------------
+  bool IsWritable();
+
+  //------------------------------------------------------------------
+  /// Check if this memory address is marked executable to the process.
+  ///
+  /// @return
+  ///     true if this memory address is marked executable
+  //------------------------------------------------------------------
+  bool IsExecutable();
+
+  //------------------------------------------------------------------
+  /// Check if this memory address is mapped into the process address
+  /// space.
+  ///
+  /// @return
+  ///     true if this memory address is in the process address space.
+  //------------------------------------------------------------------
+  bool IsMapped();
+
+  //------------------------------------------------------------------
+  /// Returns the name of the memory region mapped at the given
+  /// address.
+  ///
+  /// @return
+  ///     In case of memory mapped files it is the absolute path of
+  ///     the file otherwise it is a name associated with the memory
+  ///     region. If no name can be determined the returns nullptr.
+  //------------------------------------------------------------------
+  const char *GetName();
+
+  bool operator==(const lldb::SBMemoryRegionInfo &rhs) const;
+
+  bool operator!=(const lldb::SBMemoryRegionInfo &rhs) const;
+
+  bool GetDescription(lldb::SBStream &description);
 
 private:
+  friend class SBProcess;
+  friend class SBMemoryRegionInfoList;
 
-    friend class SBProcess;
-    friend class SBMemoryRegionInfoList;
+  lldb_private::MemoryRegionInfo &ref();
 
-    lldb_private::MemoryRegionInfo &
-    ref();
+  const lldb_private::MemoryRegionInfo &ref() const;
 
-    const lldb_private::MemoryRegionInfo &
-    ref() const;
+  SBMemoryRegionInfo(const lldb_private::MemoryRegionInfo *lldb_object_ptr);
 
-    SBMemoryRegionInfo (const lldb_private::MemoryRegionInfo *lldb_object_ptr);
-
-    lldb::MemoryRegionInfoUP m_opaque_ap;
+  lldb::MemoryRegionInfoUP m_opaque_ap;
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBMemoryRegionInfo_h_
diff --git a/include/lldb/API/SBMemoryRegionInfoList.h b/include/lldb/API/SBMemoryRegionInfoList.h
index 7723820897d8..883a2224c92d 100644
--- a/include/lldb/API/SBMemoryRegionInfoList.h
+++ b/include/lldb/API/SBMemoryRegionInfoList.h
@@ -16,46 +16,33 @@ class MemoryRegionInfoListImpl;
 
 namespace lldb {
 
-class LLDB_API SBMemoryRegionInfoList
-{
+class LLDB_API SBMemoryRegionInfoList {
 public:
+  SBMemoryRegionInfoList();
 
-    SBMemoryRegionInfoList ();
+  SBMemoryRegionInfoList(const lldb::SBMemoryRegionInfoList &rhs);
 
-    SBMemoryRegionInfoList (const lldb::SBMemoryRegionInfoList &rhs);
+  const SBMemoryRegionInfoList &operator=(const SBMemoryRegionInfoList &rhs);
 
-    const SBMemoryRegionInfoList &
-    operator = (const SBMemoryRegionInfoList &rhs);
+  ~SBMemoryRegionInfoList();
 
-    ~SBMemoryRegionInfoList ();
+  uint32_t GetSize() const;
 
-    uint32_t
-    GetSize () const;
+  bool GetMemoryRegionAtIndex(uint32_t idx, SBMemoryRegionInfo &region_info);
 
-    bool
-    GetMemoryRegionAtIndex (uint32_t idx, SBMemoryRegionInfo &region_info);
+  void Append(lldb::SBMemoryRegionInfo &region);
 
-    void
-    Append (lldb::SBMemoryRegionInfo &region);
+  void Append(lldb::SBMemoryRegionInfoList &region_list);
 
-    void
-    Append (lldb::SBMemoryRegionInfoList &region_list);
-
-    void
-    Clear ();
+  void Clear();
 
 protected:
+  const MemoryRegionInfoListImpl *operator->() const;
 
-    const MemoryRegionInfoListImpl *
-    operator->() const;
-
-    const MemoryRegionInfoListImpl &
-    operator*() const;
+  const MemoryRegionInfoListImpl &operator*() const;
 
 private:
-
-    std::unique_ptr<MemoryRegionInfoListImpl> m_opaque_ap;
-
+  std::unique_ptr<MemoryRegionInfoListImpl> m_opaque_ap;
 };
 
 } // namespace lldb
diff --git a/include/lldb/API/SBModule.h b/include/lldb/API/SBModule.h
index 4030d2b21797..bcc3997a275b 100644
--- a/include/lldb/API/SBModule.h
+++ b/include/lldb/API/SBModule.h
@@ -18,341 +18,298 @@
 
 namespace lldb {
 
-class LLDB_API SBModule
-{
+class LLDB_API SBModule {
 public:
+  SBModule();
+
+  SBModule(const SBModule &rhs);
+
+  SBModule(const SBModuleSpec &module_spec);
+
+  const SBModule &operator=(const SBModule &rhs);
+
+  SBModule(lldb::SBProcess &process, lldb::addr_t header_addr);
+
+  ~SBModule();
+
+  bool IsValid() const;
 
-    SBModule ();
-
-    SBModule (const SBModule &rhs);
-
-    SBModule (const SBModuleSpec &module_spec);
-
-    const SBModule &
-    operator = (const SBModule &rhs);
-
-    SBModule (lldb::SBProcess &process, 
-              lldb::addr_t header_addr);
-
-    ~SBModule ();
-
-    bool
-    IsValid () const;
-
-    void
-    Clear();
-
-    //------------------------------------------------------------------
-    /// Get const accessor for the module file specification.
-    ///
-    /// This function returns the file for the module on the host system
-    /// that is running LLDB. This can differ from the path on the 
-    /// platform since we might be doing remote debugging.
-    ///
-    /// @return
-    ///     A const reference to the file specification object.
-    //------------------------------------------------------------------
-    lldb::SBFileSpec
-    GetFileSpec () const;
-
-    //------------------------------------------------------------------
-    /// Get accessor for the module platform file specification.
-    ///
-    /// Platform file refers to the path of the module as it is known on
-    /// the remote system on which it is being debugged. For local 
-    /// debugging this is always the same as Module::GetFileSpec(). But
-    /// remote debugging might mention a file '/usr/lib/liba.dylib'
-    /// which might be locally downloaded and cached. In this case the
-    /// platform file could be something like:
-    /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
-    /// The file could also be cached in a local developer kit directory.
-    ///
-    /// @return
-    ///     A const reference to the file specification object.
-    //------------------------------------------------------------------
-    lldb::SBFileSpec
-    GetPlatformFileSpec () const;
-
-    bool
-    SetPlatformFileSpec (const lldb::SBFileSpec &platform_file);
-
-    //------------------------------------------------------------------
-    /// Get accessor for the remote install path for a module.
-    ///
-    /// When debugging to a remote platform by connecting to a remote
-    /// platform, the install path of the module can be set. If the
-    /// install path is set, every time the process is about to launch
-    /// the target will install this module on the remote platform prior
-    /// to launching.
-    ///
-    /// @return
-    ///     A file specification object.
-    //------------------------------------------------------------------
-    lldb::SBFileSpec
-    GetRemoteInstallFileSpec ();
-    
-    //------------------------------------------------------------------
-    /// Set accessor for the remote install path for a module.
-    ///
-    /// When debugging to a remote platform by connecting to a remote
-    /// platform, the install path of the module can be set. If the
-    /// install path is set, every time the process is about to launch
-    /// the target will install this module on the remote platform prior
-    /// to launching.
-    ///
-    /// If \a file specifies a full path to an install location, the
-    /// module will be installed to this path. If the path is relative
-    /// (no directory specified, or the path is partial like "usr/lib"
-    /// or "./usr/lib", then the install path will be resolved using
-    /// the platform's current working directory as the base path.
-    ///
-    /// @param[in] file
-    ///     A file specification object.
-    //------------------------------------------------------------------
-    bool
-    SetRemoteInstallFileSpec (lldb::SBFileSpec &file);
-    
-    lldb::ByteOrder
-    GetByteOrder ();
-    
-    uint32_t
-    GetAddressByteSize();
-    
-    const char *
-    GetTriple ();
-
-    const uint8_t *
-    GetUUIDBytes () const;
-
-    const char *
-    GetUUIDString () const;
-
-    bool
-    operator == (const lldb::SBModule &rhs) const;
-
-    bool
-    operator != (const lldb::SBModule &rhs) const;
-
-    lldb::SBSection
-    FindSection (const char *sect_name);
-
-    lldb::SBAddress
-    ResolveFileAddress (lldb::addr_t vm_addr);
-
-    lldb::SBSymbolContext
-    ResolveSymbolContextForAddress (const lldb::SBAddress& addr, 
-                                    uint32_t resolve_scope);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    uint32_t
-    GetNumCompileUnits();
-
-    lldb::SBCompileUnit
-    GetCompileUnitAtIndex (uint32_t);
-
-    size_t
-    GetNumSymbols ();
-    
-    lldb::SBSymbol
-    GetSymbolAtIndex (size_t idx);
-
-    lldb::SBSymbol
-    FindSymbol (const char *name,
-                lldb::SymbolType type = eSymbolTypeAny);
-
-    lldb::SBSymbolContextList
-    FindSymbols (const char *name,
-                 lldb::SymbolType type = eSymbolTypeAny);
-
-    size_t
-    GetNumSections ();
-    
-    lldb::SBSection
-    GetSectionAtIndex (size_t idx);
-    //------------------------------------------------------------------
-    /// Find functions by name.
-    ///
-    /// @param[in] name
-    ///     The name of the function we are looking for.
-    ///
-    /// @param[in] name_type_mask
-    ///     A logical OR of one or more FunctionNameType enum bits that
-    ///     indicate what kind of names should be used when doing the
-    ///     lookup. Bits include fully qualified names, base names,
-    ///     C++ methods, or ObjC selectors. 
-    ///     See FunctionNameType for more details.
-    ///
-    /// @return
-    ///     A lldb::SBSymbolContextList that gets filled in with all of 
-    ///     the symbol contexts for all the matches.
-    //------------------------------------------------------------------
-    lldb::SBSymbolContextList
-    FindFunctions (const char *name, 
-                   uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
-
-    //------------------------------------------------------------------
-    /// Find global and static variables by name.
-    ///
-    /// @param[in] target
-    ///     A valid SBTarget instance representing the debuggee.
-    ///
-    /// @param[in] name
-    ///     The name of the global or static variable we are looking
-    ///     for.
-    ///
-    /// @param[in] max_matches
-    ///     Allow the number of matches to be limited to \a max_matches.
-    ///
-    /// @return
-    ///     A list of matched variables in an SBValueList.
-    //------------------------------------------------------------------
-    lldb::SBValueList
-    FindGlobalVariables (lldb::SBTarget &target, 
-                         const char *name, 
-                         uint32_t max_matches);
-    
-    //------------------------------------------------------------------
-    /// Find the first global (or static) variable by name.
-    ///
-    /// @param[in] target
-    ///     A valid SBTarget instance representing the debuggee.
-    ///
-    /// @param[in] name
-    ///     The name of the global or static variable we are looking
-    ///     for.
-    ///
-    /// @return
-    ///     An SBValue that gets filled in with the found variable (if any).
-    //------------------------------------------------------------------
-    lldb::SBValue
-    FindFirstGlobalVariable (lldb::SBTarget &target, const char *name);
-    
-    lldb::SBType
-    FindFirstType (const char* name);
-    
-    lldb::SBTypeList
-    FindTypes (const char* type);
-    
-    //------------------------------------------------------------------
-    /// Get a type using its type ID.
-    ///
-    /// Each symbol file reader will assign different user IDs to their
-    /// types, but it is sometimes useful when debugging type issues to
-    /// be able to grab a type using its type ID.
-    ///
-    /// For DWARF debug info, the type ID is the DIE offset.
-    ///
-    /// @param[in] uid
-    ///     The type user ID.
-    ///
-    /// @return
-    ///     An SBType for the given type ID, or an empty SBType if the
-    ///     type was not found.
-    //------------------------------------------------------------------
-    lldb::SBType
-    GetTypeByID (lldb::user_id_t uid);
-
-    lldb::SBType
-    GetBasicType(lldb::BasicType type);
-
-    //------------------------------------------------------------------
-    /// Get all types matching \a type_mask from debug info in this
-    /// module.
-    ///
-    /// @param[in] type_mask
-    ///     A bitfield that consists of one or more bits logically OR'ed
-    ///     together from the lldb::TypeClass enumeration. This allows
-    ///     you to request only structure types, or only class, struct
-    ///     and union types. Passing in lldb::eTypeClassAny will return
-    ///     all types found in the debug information for this module.
-    ///
-    /// @return
-    ///     A list of types in this module that match \a type_mask
-    //------------------------------------------------------------------
-    lldb::SBTypeList
-    GetTypes (uint32_t type_mask = lldb::eTypeClassAny);
-
-    //------------------------------------------------------------------
-    /// Get the module version numbers.
-    ///
-    /// Many object files have a set of version numbers that describe
-    /// the version of the executable or shared library. Typically there
-    /// are major, minor and build, but there may be more. This function
-    /// will extract the versions from object files if they are available.
-    ///
-    /// If \a versions is NULL, or if \a num_versions is 0, the return
-    /// value will indicate how many version numbers are available in
-    /// this object file. Then a subsequent call can be made to this 
-    /// function with a value of \a versions and \a num_versions that
-    /// has enough storage to store some or all version numbers.
-    ///
-    /// @param[out] versions
-    ///     A pointer to an array of uint32_t types that is \a num_versions
-    ///     long. If this value is NULL, the return value will indicate
-    ///     how many version numbers are required for a subsequent call
-    ///     to this function so that all versions can be retrieved. If
-    ///     the value is non-NULL, then at most \a num_versions of the
-    ///     existing versions numbers will be filled into \a versions.
-    ///     If there is no version information available, \a versions
-    ///     will be filled with \a num_versions UINT32_MAX values
-    ///     and zero will be returned.
-    ///
-    /// @param[in] num_versions
-    ///     The maximum number of entries to fill into \a versions. If
-    ///     this value is zero, then the return value will indicate
-    ///     how many version numbers there are in total so another call
-    ///     to this function can be make with adequate storage in
-    ///     \a versions to get all of the version numbers. If \a
-    ///     num_versions is less than the actual number of version 
-    ///     numbers in this object file, only \a num_versions will be
-    ///     filled into \a versions (if \a versions is non-NULL).
-    ///
-    /// @return
-    ///     This function always returns the number of version numbers
-    ///     that this object file has regardless of the number of
-    ///     version numbers that were copied into \a versions. 
-    //------------------------------------------------------------------
-    uint32_t
-    GetVersion (uint32_t *versions, 
-                uint32_t num_versions);
-
-    //------------------------------------------------------------------
-    /// Get accessor for the symbol file specification.
-    ///
-    /// When debugging an object file an additional debug information can
-    /// be provided in separate file. Therefore if you debugging something
-    /// like '/usr/lib/liba.dylib' then debug information can be located
-    /// in folder like '/usr/lib/liba.dylib.dSYM/'.
-    ///
-    /// @return
-    ///     A const reference to the file specification object.
-    //------------------------------------------------------------------
-    lldb::SBFileSpec
-    GetSymbolFileSpec() const;
-
-    lldb::SBAddress
-    GetObjectFileHeaderAddress() const;
+  void Clear();
+
+  //------------------------------------------------------------------
+  /// Get const accessor for the module file specification.
+  ///
+  /// This function returns the file for the module on the host system
+  /// that is running LLDB. This can differ from the path on the
+  /// platform since we might be doing remote debugging.
+  ///
+  /// @return
+  ///     A const reference to the file specification object.
+  //------------------------------------------------------------------
+  lldb::SBFileSpec GetFileSpec() const;
+
+  //------------------------------------------------------------------
+  /// Get accessor for the module platform file specification.
+  ///
+  /// Platform file refers to the path of the module as it is known on
+  /// the remote system on which it is being debugged. For local
+  /// debugging this is always the same as Module::GetFileSpec(). But
+  /// remote debugging might mention a file '/usr/lib/liba.dylib'
+  /// which might be locally downloaded and cached. In this case the
+  /// platform file could be something like:
+  /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
+  /// The file could also be cached in a local developer kit directory.
+  ///
+  /// @return
+  ///     A const reference to the file specification object.
+  //------------------------------------------------------------------
+  lldb::SBFileSpec GetPlatformFileSpec() const;
+
+  bool SetPlatformFileSpec(const lldb::SBFileSpec &platform_file);
+
+  //------------------------------------------------------------------
+  /// Get accessor for the remote install path for a module.
+  ///
+  /// When debugging to a remote platform by connecting to a remote
+  /// platform, the install path of the module can be set. If the
+  /// install path is set, every time the process is about to launch
+  /// the target will install this module on the remote platform prior
+  /// to launching.
+  ///
+  /// @return
+  ///     A file specification object.
+  //------------------------------------------------------------------
+  lldb::SBFileSpec GetRemoteInstallFileSpec();
+
+  //------------------------------------------------------------------
+  /// Set accessor for the remote install path for a module.
+  ///
+  /// When debugging to a remote platform by connecting to a remote
+  /// platform, the install path of the module can be set. If the
+  /// install path is set, every time the process is about to launch
+  /// the target will install this module on the remote platform prior
+  /// to launching.
+  ///
+  /// If \a file specifies a full path to an install location, the
+  /// module will be installed to this path. If the path is relative
+  /// (no directory specified, or the path is partial like "usr/lib"
+  /// or "./usr/lib", then the install path will be resolved using
+  /// the platform's current working directory as the base path.
+  ///
+  /// @param[in] file
+  ///     A file specification object.
+  //------------------------------------------------------------------
+  bool SetRemoteInstallFileSpec(lldb::SBFileSpec &file);
+
+  lldb::ByteOrder GetByteOrder();
+
+  uint32_t GetAddressByteSize();
+
+  const char *GetTriple();
+
+  const uint8_t *GetUUIDBytes() const;
+
+  const char *GetUUIDString() const;
+
+  bool operator==(const lldb::SBModule &rhs) const;
+
+  bool operator!=(const lldb::SBModule &rhs) const;
+
+  lldb::SBSection FindSection(const char *sect_name);
+
+  lldb::SBAddress ResolveFileAddress(lldb::addr_t vm_addr);
+
+  lldb::SBSymbolContext
+  ResolveSymbolContextForAddress(const lldb::SBAddress &addr,
+                                 uint32_t resolve_scope);
+
+  bool GetDescription(lldb::SBStream &description);
+
+  uint32_t GetNumCompileUnits();
+
+  lldb::SBCompileUnit GetCompileUnitAtIndex(uint32_t);
+
+  size_t GetNumSymbols();
+
+  lldb::SBSymbol GetSymbolAtIndex(size_t idx);
+
+  lldb::SBSymbol FindSymbol(const char *name,
+                            lldb::SymbolType type = eSymbolTypeAny);
+
+  lldb::SBSymbolContextList FindSymbols(const char *name,
+                                        lldb::SymbolType type = eSymbolTypeAny);
+
+  size_t GetNumSections();
+
+  lldb::SBSection GetSectionAtIndex(size_t idx);
+  //------------------------------------------------------------------
+  /// Find functions by name.
+  ///
+  /// @param[in] name
+  ///     The name of the function we are looking for.
+  ///
+  /// @param[in] name_type_mask
+  ///     A logical OR of one or more FunctionNameType enum bits that
+  ///     indicate what kind of names should be used when doing the
+  ///     lookup. Bits include fully qualified names, base names,
+  ///     C++ methods, or ObjC selectors.
+  ///     See FunctionNameType for more details.
+  ///
+  /// @return
+  ///     A lldb::SBSymbolContextList that gets filled in with all of
+  ///     the symbol contexts for all the matches.
+  //------------------------------------------------------------------
+  lldb::SBSymbolContextList
+  FindFunctions(const char *name,
+                uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
+
+  //------------------------------------------------------------------
+  /// Find global and static variables by name.
+  ///
+  /// @param[in] target
+  ///     A valid SBTarget instance representing the debuggee.
+  ///
+  /// @param[in] name
+  ///     The name of the global or static variable we are looking
+  ///     for.
+  ///
+  /// @param[in] max_matches
+  ///     Allow the number of matches to be limited to \a max_matches.
+  ///
+  /// @return
+  ///     A list of matched variables in an SBValueList.
+  //------------------------------------------------------------------
+  lldb::SBValueList FindGlobalVariables(lldb::SBTarget &target,
+                                        const char *name, uint32_t max_matches);
+
+  //------------------------------------------------------------------
+  /// Find the first global (or static) variable by name.
+  ///
+  /// @param[in] target
+  ///     A valid SBTarget instance representing the debuggee.
+  ///
+  /// @param[in] name
+  ///     The name of the global or static variable we are looking
+  ///     for.
+  ///
+  /// @return
+  ///     An SBValue that gets filled in with the found variable (if any).
+  //------------------------------------------------------------------
+  lldb::SBValue FindFirstGlobalVariable(lldb::SBTarget &target,
+                                        const char *name);
+
+  lldb::SBType FindFirstType(const char *name);
+
+  lldb::SBTypeList FindTypes(const char *type);
+
+  //------------------------------------------------------------------
+  /// Get a type using its type ID.
+  ///
+  /// Each symbol file reader will assign different user IDs to their
+  /// types, but it is sometimes useful when debugging type issues to
+  /// be able to grab a type using its type ID.
+  ///
+  /// For DWARF debug info, the type ID is the DIE offset.
+  ///
+  /// @param[in] uid
+  ///     The type user ID.
+  ///
+  /// @return
+  ///     An SBType for the given type ID, or an empty SBType if the
+  ///     type was not found.
+  //------------------------------------------------------------------
+  lldb::SBType GetTypeByID(lldb::user_id_t uid);
+
+  lldb::SBType GetBasicType(lldb::BasicType type);
+
+  //------------------------------------------------------------------
+  /// Get all types matching \a type_mask from debug info in this
+  /// module.
+  ///
+  /// @param[in] type_mask
+  ///     A bitfield that consists of one or more bits logically OR'ed
+  ///     together from the lldb::TypeClass enumeration. This allows
+  ///     you to request only structure types, or only class, struct
+  ///     and union types. Passing in lldb::eTypeClassAny will return
+  ///     all types found in the debug information for this module.
+  ///
+  /// @return
+  ///     A list of types in this module that match \a type_mask
+  //------------------------------------------------------------------
+  lldb::SBTypeList GetTypes(uint32_t type_mask = lldb::eTypeClassAny);
+
+  //------------------------------------------------------------------
+  /// Get the module version numbers.
+  ///
+  /// Many object files have a set of version numbers that describe
+  /// the version of the executable or shared library. Typically there
+  /// are major, minor and build, but there may be more. This function
+  /// will extract the versions from object files if they are available.
+  ///
+  /// If \a versions is NULL, or if \a num_versions is 0, the return
+  /// value will indicate how many version numbers are available in
+  /// this object file. Then a subsequent call can be made to this
+  /// function with a value of \a versions and \a num_versions that
+  /// has enough storage to store some or all version numbers.
+  ///
+  /// @param[out] versions
+  ///     A pointer to an array of uint32_t types that is \a num_versions
+  ///     long. If this value is NULL, the return value will indicate
+  ///     how many version numbers are required for a subsequent call
+  ///     to this function so that all versions can be retrieved. If
+  ///     the value is non-NULL, then at most \a num_versions of the
+  ///     existing versions numbers will be filled into \a versions.
+  ///     If there is no version information available, \a versions
+  ///     will be filled with \a num_versions UINT32_MAX values
+  ///     and zero will be returned.
+  ///
+  /// @param[in] num_versions
+  ///     The maximum number of entries to fill into \a versions. If
+  ///     this value is zero, then the return value will indicate
+  ///     how many version numbers there are in total so another call
+  ///     to this function can be make with adequate storage in
+  ///     \a versions to get all of the version numbers. If \a
+  ///     num_versions is less than the actual number of version
+  ///     numbers in this object file, only \a num_versions will be
+  ///     filled into \a versions (if \a versions is non-NULL).
+  ///
+  /// @return
+  ///     This function always returns the number of version numbers
+  ///     that this object file has regardless of the number of
+  ///     version numbers that were copied into \a versions.
+  //------------------------------------------------------------------
+  uint32_t GetVersion(uint32_t *versions, uint32_t num_versions);
+
+  //------------------------------------------------------------------
+  /// Get accessor for the symbol file specification.
+  ///
+  /// When debugging an object file an additional debug information can
+  /// be provided in separate file. Therefore if you debugging something
+  /// like '/usr/lib/liba.dylib' then debug information can be located
+  /// in folder like '/usr/lib/liba.dylib.dSYM/'.
+  ///
+  /// @return
+  ///     A const reference to the file specification object.
+  //------------------------------------------------------------------
+  lldb::SBFileSpec GetSymbolFileSpec() const;
+
+  lldb::SBAddress GetObjectFileHeaderAddress() const;
 
 private:
-    friend class SBAddress;
-    friend class SBFrame;
-    friend class SBSection;
-    friend class SBSymbolContext;
-    friend class SBTarget;
+  friend class SBAddress;
+  friend class SBFrame;
+  friend class SBSection;
+  friend class SBSymbolContext;
+  friend class SBTarget;
 
-    explicit SBModule (const lldb::ModuleSP& module_sp);
+  explicit SBModule(const lldb::ModuleSP &module_sp);
 
-    ModuleSP
-    GetSP () const;
-    
-    void
-    SetSP (const ModuleSP &module_sp);
+  ModuleSP GetSP() const;
 
-    lldb::ModuleSP m_opaque_sp;
-};
+  void SetSP(const ModuleSP &module_sp);
 
+  lldb::ModuleSP m_opaque_sp;
+};
 
 } // namespace lldb
 
diff --git a/include/lldb/API/SBModuleSpec.h b/include/lldb/API/SBModuleSpec.h
index d533de3c7bce..1a862703a702 100644
--- a/include/lldb/API/SBModuleSpec.h
+++ b/include/lldb/API/SBModuleSpec.h
@@ -15,138 +15,109 @@
 
 namespace lldb {
 
-class LLDB_API SBModuleSpec
-{
+class LLDB_API SBModuleSpec {
 public:
+  SBModuleSpec();
+
+  SBModuleSpec(const SBModuleSpec &rhs);
+
+  ~SBModuleSpec();
+
+  const SBModuleSpec &operator=(const SBModuleSpec &rhs);
+
+  bool IsValid() const;
+
+  void Clear();
+
+  //------------------------------------------------------------------
+  /// Get const accessor for the module file.
+  ///
+  /// This function returns the file for the module on the host system
+  /// that is running LLDB. This can differ from the path on the
+  /// platform since we might be doing remote debugging.
+  ///
+  /// @return
+  ///     A const reference to the file specification object.
+  //------------------------------------------------------------------
+  lldb::SBFileSpec GetFileSpec();
+
+  void SetFileSpec(const lldb::SBFileSpec &fspec);
+
+  //------------------------------------------------------------------
+  /// Get accessor for the module platform file.
+  ///
+  /// Platform file refers to the path of the module as it is known on
+  /// the remote system on which it is being debugged. For local
+  /// debugging this is always the same as Module::GetFileSpec(). But
+  /// remote debugging might mention a file '/usr/lib/liba.dylib'
+  /// which might be locally downloaded and cached. In this case the
+  /// platform file could be something like:
+  /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
+  /// The file could also be cached in a local developer kit directory.
+  ///
+  /// @return
+  ///     A const reference to the file specification object.
+  //------------------------------------------------------------------
+  lldb::SBFileSpec GetPlatformFileSpec();
+
+  void SetPlatformFileSpec(const lldb::SBFileSpec &fspec);
+
+  lldb::SBFileSpec GetSymbolFileSpec();
+
+  void SetSymbolFileSpec(const lldb::SBFileSpec &fspec);
+
+  const char *GetObjectName();
+
+  void SetObjectName(const char *name);
+
+  const char *GetTriple();
+
+  void SetTriple(const char *triple);
+
+  const uint8_t *GetUUIDBytes();
+
+  size_t GetUUIDLength();
+
+  bool SetUUIDBytes(const uint8_t *uuid, size_t uuid_len);
+
+  bool GetDescription(lldb::SBStream &description);
 
-    SBModuleSpec ();
-
-    SBModuleSpec (const SBModuleSpec &rhs);
-
-    ~SBModuleSpec ();
-
-    const SBModuleSpec &
-    operator = (const SBModuleSpec &rhs);
-
-    bool
-    IsValid () const;
-
-    void
-    Clear();
-
-    //------------------------------------------------------------------
-    /// Get const accessor for the module file.
-    ///
-    /// This function returns the file for the module on the host system
-    /// that is running LLDB. This can differ from the path on the 
-    /// platform since we might be doing remote debugging.
-    ///
-    /// @return
-    ///     A const reference to the file specification object.
-    //------------------------------------------------------------------
-    lldb::SBFileSpec
-    GetFileSpec ();
-
-    void
-    SetFileSpec (const lldb::SBFileSpec &fspec);
-
-    //------------------------------------------------------------------
-    /// Get accessor for the module platform file.
-    ///
-    /// Platform file refers to the path of the module as it is known on
-    /// the remote system on which it is being debugged. For local 
-    /// debugging this is always the same as Module::GetFileSpec(). But
-    /// remote debugging might mention a file '/usr/lib/liba.dylib'
-    /// which might be locally downloaded and cached. In this case the
-    /// platform file could be something like:
-    /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
-    /// The file could also be cached in a local developer kit directory.
-    ///
-    /// @return
-    ///     A const reference to the file specification object.
-    //------------------------------------------------------------------
-    lldb::SBFileSpec
-    GetPlatformFileSpec ();
-
-    void
-    SetPlatformFileSpec (const lldb::SBFileSpec &fspec);
-
-    lldb::SBFileSpec
-    GetSymbolFileSpec ();
-    
-    void
-    SetSymbolFileSpec (const lldb::SBFileSpec &fspec);
-
-    const char *
-    GetObjectName ();
-    
-    void
-    SetObjectName (const char *name);
-
-    const char *
-    GetTriple ();
-
-    void
-    SetTriple (const char *triple);
-
-    const uint8_t *
-    GetUUIDBytes ();
-
-    size_t
-    GetUUIDLength ();
-
-    bool
-    SetUUIDBytes (const uint8_t *uuid, size_t uuid_len);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-    
 private:
-    friend class SBModuleSpecList;
-    friend class SBModule;
-    friend class SBTarget;
+  friend class SBModuleSpecList;
+  friend class SBModule;
+  friend class SBTarget;
 
-    std::unique_ptr<lldb_private::ModuleSpec> m_opaque_ap;
+  std::unique_ptr<lldb_private::ModuleSpec> m_opaque_ap;
 };
 
-class SBModuleSpecList
-{
+class SBModuleSpecList {
 public:
-    SBModuleSpecList();
-
-    SBModuleSpecList (const SBModuleSpecList &rhs);
-
-    ~SBModuleSpecList();
-
-    SBModuleSpecList &
-    operator = (const SBModuleSpecList &rhs);
-    
-    static SBModuleSpecList
-    GetModuleSpecifications (const char *path);
-    
-    void
-    Append (const SBModuleSpec &spec);
-    
-    void
-    Append (const SBModuleSpecList &spec_list);
-
-    SBModuleSpec
-    FindFirstMatchingSpec (const SBModuleSpec &match_spec);
-
-    SBModuleSpecList
-    FindMatchingSpecs (const SBModuleSpec &match_spec);
-
-    size_t
-    GetSize();
-    
-    SBModuleSpec
-    GetSpecAtIndex (size_t i);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-    
+  SBModuleSpecList();
+
+  SBModuleSpecList(const SBModuleSpecList &rhs);
+
+  ~SBModuleSpecList();
+
+  SBModuleSpecList &operator=(const SBModuleSpecList &rhs);
+
+  static SBModuleSpecList GetModuleSpecifications(const char *path);
+
+  void Append(const SBModuleSpec &spec);
+
+  void Append(const SBModuleSpecList &spec_list);
+
+  SBModuleSpec FindFirstMatchingSpec(const SBModuleSpec &match_spec);
+
+  SBModuleSpecList FindMatchingSpecs(const SBModuleSpec &match_spec);
+
+  size_t GetSize();
+
+  SBModuleSpec GetSpecAtIndex(size_t i);
+
+  bool GetDescription(lldb::SBStream &description);
+
 private:
-    std::unique_ptr<lldb_private::ModuleSpecList> m_opaque_ap;
+  std::unique_ptr<lldb_private::ModuleSpecList> m_opaque_ap;
 };
 
 } // namespace lldb
diff --git a/include/lldb/API/SBPlatform.h b/include/lldb/API/SBPlatform.h
index 80ad1c06e868..3f7e1acb74b5 100644
--- a/include/lldb/API/SBPlatform.h
+++ b/include/lldb/API/SBPlatform.h
@@ -19,195 +19,147 @@ struct PlatformShellCommand;
 
 namespace lldb {
 
-    class SBLaunchInfo;
-
-    class LLDB_API SBPlatformConnectOptions
-    {
-    public:
-        SBPlatformConnectOptions (const char *url);
-
-        SBPlatformConnectOptions (const SBPlatformConnectOptions &rhs);
-
-        ~SBPlatformConnectOptions ();
-        
-        void
-        operator=(const SBPlatformConnectOptions &rhs);
-
-        const char *
-        GetURL();
-        
-        void
-        SetURL(const char *url);
-        
-        bool
-        GetRsyncEnabled();
-        
-        void
-        EnableRsync (const char *options,
-                     const char *remote_path_prefix,
-                     bool omit_remote_hostname);
-                     
-        void
-        DisableRsync ();
-        
-        const char *
-        GetLocalCacheDirectory();
-
-        void
-        SetLocalCacheDirectory(const char *path);
-    protected:
-        PlatformConnectOptions *m_opaque_ptr;
-    };
-
-    class LLDB_API SBPlatformShellCommand
-    {
-    public:
-        SBPlatformShellCommand (const char *shell_command);
-        
-        SBPlatformShellCommand (const SBPlatformShellCommand &rhs);
-        
-        ~SBPlatformShellCommand();
-        
-        void
-        Clear();
-
-        const char *
-        GetCommand();
-
-        void
-        SetCommand(const char *shell_command);
-        
-        const char *
-        GetWorkingDirectory ();
-
-        void
-        SetWorkingDirectory (const char *path);
-
-        uint32_t
-        GetTimeoutSeconds ();
-        
-        void
-        SetTimeoutSeconds (uint32_t sec);
-        
-        int
-        GetSignal ();
-        
-        int
-        GetStatus ();
-        
-        const char *
-        GetOutput ();
-
-    protected:
-        friend class SBPlatform;
-
-        PlatformShellCommand *m_opaque_ptr;
-    };
-
-    class LLDB_API SBPlatform
-    {
-    public:
-        
-        SBPlatform ();
-        
-        SBPlatform (const char *platform_name);
-        
-        ~SBPlatform();
-        
-        bool
-        IsValid () const;
-        
-        void
-        Clear ();
-
-        const char *
-        GetWorkingDirectory();
-
-        bool
-        SetWorkingDirectory(const char *path);
-
-        const char *
-        GetName ();
-
-        SBError
-        ConnectRemote (SBPlatformConnectOptions &connect_options);
-
-        void
-        DisconnectRemote ();
-        
-        bool
-        IsConnected();
-
-        //----------------------------------------------------------------------
-        // The following functions will work if the platform is connected
-        //----------------------------------------------------------------------
-        const char *
-        GetTriple();
-
-        const char *
-        GetHostname ();
-        
-        const char *
-        GetOSBuild ();
-        
-        const char *
-        GetOSDescription ();
-
-        uint32_t
-        GetOSMajorVersion ();
-
-        uint32_t
-        GetOSMinorVersion ();
-
-        uint32_t
-        GetOSUpdateVersion ();
-
-        SBError
-        Put (SBFileSpec &src, SBFileSpec &dst);
-        
-        SBError
-        Get (SBFileSpec &src, SBFileSpec &dst);
-
-        SBError
-        Install (SBFileSpec& src, SBFileSpec& dst);
-
-        SBError
-        Run (SBPlatformShellCommand &shell_command);
-
-        SBError
-        Launch (SBLaunchInfo &launch_info);
-
-        SBError
-        Kill (const lldb::pid_t pid);
-
-        SBError
-        MakeDirectory (const char *path, uint32_t file_permissions = eFilePermissionsDirectoryDefault);
-
-        uint32_t
-        GetFilePermissions (const char *path);
-        
-        SBError
-        SetFilePermissions (const char *path, uint32_t file_permissions);
-
-        SBUnixSignals
-        GetUnixSignals() const;
-
-    protected:
-        
-        friend class SBDebugger;
-        friend class SBTarget;
-
-        lldb::PlatformSP
-        GetSP () const;
-        
-        void
-        SetSP (const lldb::PlatformSP& platform_sp);
-
-        SBError
-        ExecuteConnected (const std::function<lldb_private::Error(const lldb::PlatformSP&)>& func);
-
-        lldb::PlatformSP m_opaque_sp;
-    };
+class SBLaunchInfo;
+
+class LLDB_API SBPlatformConnectOptions {
+public:
+  SBPlatformConnectOptions(const char *url);
+
+  SBPlatformConnectOptions(const SBPlatformConnectOptions &rhs);
+
+  ~SBPlatformConnectOptions();
+
+  void operator=(const SBPlatformConnectOptions &rhs);
+
+  const char *GetURL();
+
+  void SetURL(const char *url);
+
+  bool GetRsyncEnabled();
+
+  void EnableRsync(const char *options, const char *remote_path_prefix,
+                   bool omit_remote_hostname);
+
+  void DisableRsync();
+
+  const char *GetLocalCacheDirectory();
+
+  void SetLocalCacheDirectory(const char *path);
+
+protected:
+  PlatformConnectOptions *m_opaque_ptr;
+};
+
+class LLDB_API SBPlatformShellCommand {
+public:
+  SBPlatformShellCommand(const char *shell_command);
+
+  SBPlatformShellCommand(const SBPlatformShellCommand &rhs);
+
+  ~SBPlatformShellCommand();
+
+  void Clear();
+
+  const char *GetCommand();
+
+  void SetCommand(const char *shell_command);
+
+  const char *GetWorkingDirectory();
+
+  void SetWorkingDirectory(const char *path);
+
+  uint32_t GetTimeoutSeconds();
+
+  void SetTimeoutSeconds(uint32_t sec);
+
+  int GetSignal();
+
+  int GetStatus();
+
+  const char *GetOutput();
+
+protected:
+  friend class SBPlatform;
+
+  PlatformShellCommand *m_opaque_ptr;
+};
+
+class LLDB_API SBPlatform {
+public:
+  SBPlatform();
+
+  SBPlatform(const char *platform_name);
+
+  ~SBPlatform();
+
+  bool IsValid() const;
+
+  void Clear();
+
+  const char *GetWorkingDirectory();
+
+  bool SetWorkingDirectory(const char *path);
+
+  const char *GetName();
+
+  SBError ConnectRemote(SBPlatformConnectOptions &connect_options);
+
+  void DisconnectRemote();
+
+  bool IsConnected();
+
+  //----------------------------------------------------------------------
+  // The following functions will work if the platform is connected
+  //----------------------------------------------------------------------
+  const char *GetTriple();
+
+  const char *GetHostname();
+
+  const char *GetOSBuild();
+
+  const char *GetOSDescription();
+
+  uint32_t GetOSMajorVersion();
+
+  uint32_t GetOSMinorVersion();
+
+  uint32_t GetOSUpdateVersion();
+
+  SBError Put(SBFileSpec &src, SBFileSpec &dst);
+
+  SBError Get(SBFileSpec &src, SBFileSpec &dst);
+
+  SBError Install(SBFileSpec &src, SBFileSpec &dst);
+
+  SBError Run(SBPlatformShellCommand &shell_command);
+
+  SBError Launch(SBLaunchInfo &launch_info);
+
+  SBError Kill(const lldb::pid_t pid);
+
+  SBError
+  MakeDirectory(const char *path,
+                uint32_t file_permissions = eFilePermissionsDirectoryDefault);
+
+  uint32_t GetFilePermissions(const char *path);
+
+  SBError SetFilePermissions(const char *path, uint32_t file_permissions);
+
+  SBUnixSignals GetUnixSignals() const;
+
+protected:
+  friend class SBDebugger;
+  friend class SBTarget;
+
+  lldb::PlatformSP GetSP() const;
+
+  void SetSP(const lldb::PlatformSP &platform_sp);
+
+  SBError ExecuteConnected(
+      const std::function<lldb_private::Error(const lldb::PlatformSP &)> &func);
+
+  lldb::PlatformSP m_opaque_sp;
+};
 
 } // namespace lldb
 
diff --git a/include/lldb/API/SBProcess.h b/include/lldb/API/SBProcess.h
index a8881ad898c0..fd95790c6686 100644
--- a/include/lldb/API/SBProcess.h
+++ b/include/lldb/API/SBProcess.h
@@ -12,438 +12,368 @@
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBError.h"
-#include "lldb/API/SBTarget.h"
 #include "lldb/API/SBQueue.h"
+#include "lldb/API/SBTarget.h"
 #include <stdio.h>
 
 namespace lldb {
 
 class SBEvent;
 
-class LLDB_API SBProcess
-{
+class LLDB_API SBProcess {
 public:
-    //------------------------------------------------------------------
-    /// Broadcaster event bits definitions.
-    //------------------------------------------------------------------
-    FLAGS_ANONYMOUS_ENUM()
-    {
-        eBroadcastBitStateChanged   = (1 << 0),
-        eBroadcastBitInterrupt      = (1 << 1),
-        eBroadcastBitSTDOUT         = (1 << 2),
-        eBroadcastBitSTDERR         = (1 << 3),
-        eBroadcastBitProfileData    = (1 << 4)
-    };
-
-    SBProcess ();
-
-    SBProcess (const lldb::SBProcess& rhs);
-
-    const lldb::SBProcess&
-    operator = (const lldb::SBProcess& rhs);
-
-    SBProcess (const lldb::ProcessSP &process_sp);
-    
-    ~SBProcess();
-
-    static const char *
-    GetBroadcasterClassName ();
-    
-    const char *
-    GetPluginName ();
-    
-    // DEPRECATED: use GetPluginName()
-    const char *
-    GetShortPluginName ();
-    
-    void
-    Clear ();
-
-    bool
-    IsValid() const;
-
-    lldb::SBTarget
-    GetTarget() const;
-
-    lldb::ByteOrder
-    GetByteOrder() const;
-
-    size_t
-    PutSTDIN (const char *src, size_t src_len);
-
-    size_t
-    GetSTDOUT (char *dst, size_t dst_len) const;
-
-    size_t
-    GetSTDERR (char *dst, size_t dst_len) const;
-
-    size_t
-    GetAsyncProfileData(char *dst, size_t dst_len) const;
-    
-    void
-    ReportEventState (const lldb::SBEvent &event, FILE *out) const;
-
-    void
-    AppendEventStateReport (const lldb::SBEvent &event, lldb::SBCommandReturnObject &result);
-
-    //------------------------------------------------------------------
-    /// Remote connection related functions. These will fail if the
-    /// process is not in eStateConnected. They are intended for use
-    /// when connecting to an externally managed debugserver instance.
-    //------------------------------------------------------------------
-    bool
-    RemoteAttachToProcessWithID (lldb::pid_t pid,
-                                 lldb::SBError& error);
-    
-    bool
-    RemoteLaunch (char const **argv,
-                  char const **envp,
-                  const char *stdin_path,
-                  const char *stdout_path,
-                  const char *stderr_path,
-                  const char *working_directory,
-                  uint32_t launch_flags,
-                  bool stop_at_entry,
-                  lldb::SBError& error);
-    
-    //------------------------------------------------------------------
-    // Thread related functions
-    //------------------------------------------------------------------
-    uint32_t
-    GetNumThreads ();
-
-    lldb::SBThread
-    GetThreadAtIndex (size_t index);
-
-    lldb::SBThread
-    GetThreadByID (lldb::tid_t sb_thread_id);
-
-    lldb::SBThread
-    GetThreadByIndexID (uint32_t index_id);
-
-    lldb::SBThread
-    GetSelectedThread () const;
-
-    //------------------------------------------------------------------
-    // Function for lazily creating a thread using the current OS
-    // plug-in. This function will be removed in the future when there
-    // are APIs to create SBThread objects through the interface and add
-    // them to the process through the SBProcess API.
-    //------------------------------------------------------------------
-    lldb::SBThread
-    CreateOSPluginThread (lldb::tid_t tid, lldb::addr_t context);
-
-    bool
-    SetSelectedThread (const lldb::SBThread &thread);
-
-    bool
-    SetSelectedThreadByID (lldb::tid_t tid);
-    
-    bool
-    SetSelectedThreadByIndexID (uint32_t index_id);
-
-    //------------------------------------------------------------------
-    // Queue related functions
-    //------------------------------------------------------------------
-    uint32_t
-    GetNumQueues ();
-
-    lldb::SBQueue
-    GetQueueAtIndex (size_t index);
-
-    //------------------------------------------------------------------
-    // Stepping related functions
-    //------------------------------------------------------------------
-
-    lldb::StateType
-    GetState ();
-
-    int
-    GetExitStatus ();
-
-    const char *
-    GetExitDescription ();
-
-    //------------------------------------------------------------------
-    /// Gets the process ID
-    ///
-    /// Returns the process identifier for the process as it is known
-    /// on the system on which the process is running. For unix systems
-    /// this is typically the same as if you called "getpid()" in the
-    /// process.
-    ///
-    /// @return
-    ///     Returns LLDB_INVALID_PROCESS_ID if this object does not
-    ///     contain a valid process object, or if the process has not
-    ///     been launched. Returns a valid process ID if the process is
-    ///     valid.
-    //------------------------------------------------------------------
-    lldb::pid_t
-    GetProcessID ();
-
-    //------------------------------------------------------------------
-    /// Gets the unique ID associated with this process object
-    ///
-    /// Unique IDs start at 1 and increment up with each new process
-    /// instance. Since starting a process on a system might always
-    /// create a process with the same process ID, there needs to be a
-    /// way to tell two process instances apart.
-    ///
-    /// @return
-    ///     Returns a non-zero integer ID if this object contains a
-    ///     valid process object, zero if this object does not contain
-    ///     a valid process object.
-    //------------------------------------------------------------------
-    uint32_t
-    GetUniqueID();
-
-    uint32_t
-    GetAddressByteSize() const;
-
-    lldb::SBError
-    Destroy ();
-
-    lldb::SBError
-    Continue ();
-
-    lldb::SBError
-    Stop ();
-
-    lldb::SBError
-    Kill ();
-
-    lldb::SBError
-    Detach ();
-
-    lldb::SBError
-    Detach (bool keep_stopped);
-
-    lldb::SBError
-    Signal (int signal);
-
-    lldb::SBUnixSignals
-    GetUnixSignals();
-
-    void
-    SendAsyncInterrupt();
-    
-    uint32_t
-    GetStopID(bool include_expression_stops = false);
-
-    //------------------------------------------------------------------
-    /// Gets the stop event corresponding to stop ID.
-    //
-    /// Note that it wasn't fully implemented and tracks only the stop
-    /// event for the last natural stop ID.
-    ///
-    /// @param [in] stop_id
-    ///   The ID of the stop event to return.
-    ///
-    /// @return
-    ///   The stop event corresponding to stop ID.
-    //------------------------------------------------------------------
-    lldb::SBEvent
-    GetStopEventForStopID(uint32_t stop_id);
-
-    size_t
-    ReadMemory (addr_t addr, void *buf, size_t size, lldb::SBError &error);
-
-    size_t
-    WriteMemory (addr_t addr, const void *buf, size_t size, lldb::SBError &error);
-
-    size_t
-    ReadCStringFromMemory (addr_t addr, void *buf, size_t size, lldb::SBError &error);
-
-    uint64_t
-    ReadUnsignedFromMemory (addr_t addr, uint32_t byte_size, lldb::SBError &error);
-
-    lldb::addr_t
-    ReadPointerFromMemory (addr_t addr, lldb::SBError &error);
-
-    // Events
-    static lldb::StateType
-    GetStateFromEvent (const lldb::SBEvent &event);
-
-    static bool
-    GetRestartedFromEvent (const lldb::SBEvent &event);
-    
-    static size_t
-    GetNumRestartedReasonsFromEvent (const lldb::SBEvent &event);
-    
-    static const char *
-    GetRestartedReasonAtIndexFromEvent (const lldb::SBEvent &event, size_t idx);
-
-    static lldb::SBProcess
-    GetProcessFromEvent (const lldb::SBEvent &event);
-
-    static bool
-    GetInterruptedFromEvent (const lldb::SBEvent &event);
-    
-    static bool
-    EventIsProcessEvent (const lldb::SBEvent &event);
-
-    lldb::SBBroadcaster
-    GetBroadcaster () const;
-
-    static const char *
-    GetBroadcasterClass ();
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    uint32_t
-    GetNumSupportedHardwareWatchpoints (lldb::SBError &error) const;
-
-    //------------------------------------------------------------------
-    /// Load a shared library into this process.
-    ///
-    /// @param[in] remote_image_spec
-    ///     The path for the shared library on the target what you want
-    ///     to load.
-    ///
-    /// @param[out] error
-    ///     An error object that gets filled in with any errors that
-    ///     might occur when trying to load the shared library.
-    ///
-    /// @return
-    ///     A token that represents the shared library that can be
-    ///     later used to unload the shared library. A value of
-    ///     LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
-    ///     library can't be opened.
-    //------------------------------------------------------------------
-    uint32_t
-    LoadImage (lldb::SBFileSpec &remote_image_spec, lldb::SBError &error);
-
-    //------------------------------------------------------------------
-    /// Load a shared library into this process.
-    ///
-    /// @param[in] local_image_spec
-    ///     The file spec that points to the shared library that you
-    ///     want to load if the library is located on the host. The
-    ///     library will be copied over to the location specified by
-    ///     remote_image_spec or into the current working directory with
-    ///     the same filename if the remote_image_spec isn't specified.
-    ///
-    /// @param[in] remote_image_spec
-    ///     If local_image_spec is specified then the location where the
-    ///     library should be copied over from the host. If
-    ///     local_image_spec isn't specified, then the path for the
-    ///     shared library on the target what you want to load.
-    ///
-    /// @param[out] error
-    ///     An error object that gets filled in with any errors that
-    ///     might occur when trying to load the shared library.
-    ///
-    /// @return
-    ///     A token that represents the shared library that can be
-    ///     later used to unload the shared library. A value of
-    ///     LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
-    ///     library can't be opened.
-    //------------------------------------------------------------------
-    uint32_t
-    LoadImage (const lldb::SBFileSpec &local_image_spec,
-               const lldb::SBFileSpec &remote_image_spec,
-               lldb::SBError &error);
-    
-    lldb::SBError
-    UnloadImage (uint32_t image_token);
-    
-    lldb::SBError
-    SendEventData (const char *data);
-    
-    //------------------------------------------------------------------
-    /// Return the number of different thread-origin extended backtraces
-    /// this process can support.
-    ///
-    /// When the process is stopped and you have an SBThread, lldb may be
-    /// able to show a backtrace of when that thread was originally created,
-    /// or the work item was enqueued to it (in the case of a libdispatch 
-    /// queue).
-    ///
-    /// @return
-    ///   The number of thread-origin extended backtrace types that may be
-    ///   available.
-    //------------------------------------------------------------------
-    uint32_t
-    GetNumExtendedBacktraceTypes ();
-
-    //------------------------------------------------------------------
-    /// Return the name of one of the thread-origin extended backtrace 
-    /// methods.
-    ///
-    /// @param [in] idx
-    ///   The index of the name to return.  They will be returned in
-    ///   the order that the user will most likely want to see them.
-    ///   e.g. if the type at index 0 is not available for a thread, 
-    ///   see if the type at index 1 provides an extended backtrace.
-    ///
-    /// @return
-    ///   The name at that index.
-    //------------------------------------------------------------------
-    const char *
-    GetExtendedBacktraceTypeAtIndex (uint32_t idx);
-    
-    lldb::SBThreadCollection
-    GetHistoryThreads (addr_t addr);
-    
-    bool
-    IsInstrumentationRuntimePresent(InstrumentationRuntimeType type);
-
-    // Save the state of the process in a core file (or mini dump on Windows).
-    lldb::SBError
-    SaveCore(const char *file_name);
-
-    //------------------------------------------------------------------
-    /// Query the address load_addr and store the details of the memory
-    /// region that contains it in the supplied SBMemoryRegionInfo object.
-    /// To iterate over all memory regions use GetMemoryRegionList.
-    ///
-    /// @param[in] load_addr
-    ///     The address to be queried.
-    ///
-    /// @param[out] region_info
-    ///     A reference to an SBMemoryRegionInfo object that will contain
-    ///     the details of the memory region containing load_addr.
-    ///
-    /// @return
-    ///     An error object describes any errors that occurred while
-    ///     querying load_addr.
-    //------------------------------------------------------------------
-    lldb::SBError
-    GetMemoryRegionInfo (lldb::addr_t load_addr, lldb::SBMemoryRegionInfo &region_info);
-
-    //------------------------------------------------------------------
-    /// Return the list of memory regions within the process.
-    ///
-    /// @return
-    ///     A list of all witin the process memory regions.
-    //------------------------------------------------------------------
-    lldb::SBMemoryRegionInfoList
-    GetMemoryRegions();
+  //------------------------------------------------------------------
+  /// Broadcaster event bits definitions.
+  //------------------------------------------------------------------
+  FLAGS_ANONYMOUS_ENUM(){eBroadcastBitStateChanged = (1 << 0),
+                         eBroadcastBitInterrupt = (1 << 1),
+                         eBroadcastBitSTDOUT = (1 << 2),
+                         eBroadcastBitSTDERR = (1 << 3),
+                         eBroadcastBitProfileData = (1 << 4),
+                         eBroadcastBitStructuredData = (1 << 5)};
+
+  SBProcess();
+
+  SBProcess(const lldb::SBProcess &rhs);
+
+  const lldb::SBProcess &operator=(const lldb::SBProcess &rhs);
+
+  SBProcess(const lldb::ProcessSP &process_sp);
+
+  ~SBProcess();
+
+  static const char *GetBroadcasterClassName();
+
+  const char *GetPluginName();
+
+  // DEPRECATED: use GetPluginName()
+  const char *GetShortPluginName();
+
+  void Clear();
+
+  bool IsValid() const;
+
+  lldb::SBTarget GetTarget() const;
+
+  lldb::ByteOrder GetByteOrder() const;
+
+  size_t PutSTDIN(const char *src, size_t src_len);
+
+  size_t GetSTDOUT(char *dst, size_t dst_len) const;
+
+  size_t GetSTDERR(char *dst, size_t dst_len) const;
+
+  size_t GetAsyncProfileData(char *dst, size_t dst_len) const;
+
+  void ReportEventState(const lldb::SBEvent &event, FILE *out) const;
+
+  void AppendEventStateReport(const lldb::SBEvent &event,
+                              lldb::SBCommandReturnObject &result);
+
+  //------------------------------------------------------------------
+  /// Remote connection related functions. These will fail if the
+  /// process is not in eStateConnected. They are intended for use
+  /// when connecting to an externally managed debugserver instance.
+  //------------------------------------------------------------------
+  bool RemoteAttachToProcessWithID(lldb::pid_t pid, lldb::SBError &error);
+
+  bool RemoteLaunch(char const **argv, char const **envp,
+                    const char *stdin_path, const char *stdout_path,
+                    const char *stderr_path, const char *working_directory,
+                    uint32_t launch_flags, bool stop_at_entry,
+                    lldb::SBError &error);
+
+  //------------------------------------------------------------------
+  // Thread related functions
+  //------------------------------------------------------------------
+  uint32_t GetNumThreads();
+
+  lldb::SBThread GetThreadAtIndex(size_t index);
+
+  lldb::SBThread GetThreadByID(lldb::tid_t sb_thread_id);
+
+  lldb::SBThread GetThreadByIndexID(uint32_t index_id);
+
+  lldb::SBThread GetSelectedThread() const;
+
+  //------------------------------------------------------------------
+  // Function for lazily creating a thread using the current OS
+  // plug-in. This function will be removed in the future when there
+  // are APIs to create SBThread objects through the interface and add
+  // them to the process through the SBProcess API.
+  //------------------------------------------------------------------
+  lldb::SBThread CreateOSPluginThread(lldb::tid_t tid, lldb::addr_t context);
+
+  bool SetSelectedThread(const lldb::SBThread &thread);
+
+  bool SetSelectedThreadByID(lldb::tid_t tid);
+
+  bool SetSelectedThreadByIndexID(uint32_t index_id);
+
+  //------------------------------------------------------------------
+  // Queue related functions
+  //------------------------------------------------------------------
+  uint32_t GetNumQueues();
+
+  lldb::SBQueue GetQueueAtIndex(size_t index);
+
+  //------------------------------------------------------------------
+  // Stepping related functions
+  //------------------------------------------------------------------
+
+  lldb::StateType GetState();
+
+  int GetExitStatus();
+
+  const char *GetExitDescription();
+
+  //------------------------------------------------------------------
+  /// Gets the process ID
+  ///
+  /// Returns the process identifier for the process as it is known
+  /// on the system on which the process is running. For unix systems
+  /// this is typically the same as if you called "getpid()" in the
+  /// process.
+  ///
+  /// @return
+  ///     Returns LLDB_INVALID_PROCESS_ID if this object does not
+  ///     contain a valid process object, or if the process has not
+  ///     been launched. Returns a valid process ID if the process is
+  ///     valid.
+  //------------------------------------------------------------------
+  lldb::pid_t GetProcessID();
+
+  //------------------------------------------------------------------
+  /// Gets the unique ID associated with this process object
+  ///
+  /// Unique IDs start at 1 and increment up with each new process
+  /// instance. Since starting a process on a system might always
+  /// create a process with the same process ID, there needs to be a
+  /// way to tell two process instances apart.
+  ///
+  /// @return
+  ///     Returns a non-zero integer ID if this object contains a
+  ///     valid process object, zero if this object does not contain
+  ///     a valid process object.
+  //------------------------------------------------------------------
+  uint32_t GetUniqueID();
+
+  uint32_t GetAddressByteSize() const;
+
+  lldb::SBError Destroy();
+
+  lldb::SBError Continue();
+
+  lldb::SBError Stop();
+
+  lldb::SBError Kill();
+
+  lldb::SBError Detach();
+
+  lldb::SBError Detach(bool keep_stopped);
+
+  lldb::SBError Signal(int signal);
+
+  lldb::SBUnixSignals GetUnixSignals();
+
+  void SendAsyncInterrupt();
+
+  uint32_t GetStopID(bool include_expression_stops = false);
+
+  //------------------------------------------------------------------
+  /// Gets the stop event corresponding to stop ID.
+  //
+  /// Note that it wasn't fully implemented and tracks only the stop
+  /// event for the last natural stop ID.
+  ///
+  /// @param [in] stop_id
+  ///   The ID of the stop event to return.
+  ///
+  /// @return
+  ///   The stop event corresponding to stop ID.
+  //------------------------------------------------------------------
+  lldb::SBEvent GetStopEventForStopID(uint32_t stop_id);
+
+  size_t ReadMemory(addr_t addr, void *buf, size_t size, lldb::SBError &error);
+
+  size_t WriteMemory(addr_t addr, const void *buf, size_t size,
+                     lldb::SBError &error);
+
+  size_t ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
+                               lldb::SBError &error);
+
+  uint64_t ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
+                                  lldb::SBError &error);
+
+  lldb::addr_t ReadPointerFromMemory(addr_t addr, lldb::SBError &error);
+
+  // Events
+  static lldb::StateType GetStateFromEvent(const lldb::SBEvent &event);
+
+  static bool GetRestartedFromEvent(const lldb::SBEvent &event);
+
+  static size_t GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event);
+
+  static const char *
+  GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event, size_t idx);
+
+  static lldb::SBProcess GetProcessFromEvent(const lldb::SBEvent &event);
+
+  static bool GetInterruptedFromEvent(const lldb::SBEvent &event);
+
+  static lldb::SBStructuredData
+  GetStructuredDataFromEvent(const lldb::SBEvent &event);
+
+  static bool EventIsProcessEvent(const lldb::SBEvent &event);
+
+  static bool EventIsStructuredDataEvent(const lldb::SBEvent &event);
+
+  lldb::SBBroadcaster GetBroadcaster() const;
+
+  static const char *GetBroadcasterClass();
+
+  bool GetDescription(lldb::SBStream &description);
+
+  uint32_t GetNumSupportedHardwareWatchpoints(lldb::SBError &error) const;
+
+  //------------------------------------------------------------------
+  /// Load a shared library into this process.
+  ///
+  /// @param[in] remote_image_spec
+  ///     The path for the shared library on the target what you want
+  ///     to load.
+  ///
+  /// @param[out] error
+  ///     An error object that gets filled in with any errors that
+  ///     might occur when trying to load the shared library.
+  ///
+  /// @return
+  ///     A token that represents the shared library that can be
+  ///     later used to unload the shared library. A value of
+  ///     LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
+  ///     library can't be opened.
+  //------------------------------------------------------------------
+  uint32_t LoadImage(lldb::SBFileSpec &remote_image_spec, lldb::SBError &error);
+
+  //------------------------------------------------------------------
+  /// Load a shared library into this process.
+  ///
+  /// @param[in] local_image_spec
+  ///     The file spec that points to the shared library that you
+  ///     want to load if the library is located on the host. The
+  ///     library will be copied over to the location specified by
+  ///     remote_image_spec or into the current working directory with
+  ///     the same filename if the remote_image_spec isn't specified.
+  ///
+  /// @param[in] remote_image_spec
+  ///     If local_image_spec is specified then the location where the
+  ///     library should be copied over from the host. If
+  ///     local_image_spec isn't specified, then the path for the
+  ///     shared library on the target what you want to load.
+  ///
+  /// @param[out] error
+  ///     An error object that gets filled in with any errors that
+  ///     might occur when trying to load the shared library.
+  ///
+  /// @return
+  ///     A token that represents the shared library that can be
+  ///     later used to unload the shared library. A value of
+  ///     LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
+  ///     library can't be opened.
+  //------------------------------------------------------------------
+  uint32_t LoadImage(const lldb::SBFileSpec &local_image_spec,
+                     const lldb::SBFileSpec &remote_image_spec,
+                     lldb::SBError &error);
+
+  lldb::SBError UnloadImage(uint32_t image_token);
+
+  lldb::SBError SendEventData(const char *data);
+
+  //------------------------------------------------------------------
+  /// Return the number of different thread-origin extended backtraces
+  /// this process can support.
+  ///
+  /// When the process is stopped and you have an SBThread, lldb may be
+  /// able to show a backtrace of when that thread was originally created,
+  /// or the work item was enqueued to it (in the case of a libdispatch
+  /// queue).
+  ///
+  /// @return
+  ///   The number of thread-origin extended backtrace types that may be
+  ///   available.
+  //------------------------------------------------------------------
+  uint32_t GetNumExtendedBacktraceTypes();
+
+  //------------------------------------------------------------------
+  /// Return the name of one of the thread-origin extended backtrace
+  /// methods.
+  ///
+  /// @param [in] idx
+  ///   The index of the name to return.  They will be returned in
+  ///   the order that the user will most likely want to see them.
+  ///   e.g. if the type at index 0 is not available for a thread,
+  ///   see if the type at index 1 provides an extended backtrace.
+  ///
+  /// @return
+  ///   The name at that index.
+  //------------------------------------------------------------------
+  const char *GetExtendedBacktraceTypeAtIndex(uint32_t idx);
+
+  lldb::SBThreadCollection GetHistoryThreads(addr_t addr);
+
+  bool IsInstrumentationRuntimePresent(InstrumentationRuntimeType type);
+
+  // Save the state of the process in a core file (or mini dump on Windows).
+  lldb::SBError SaveCore(const char *file_name);
+
+  //------------------------------------------------------------------
+  /// Query the address load_addr and store the details of the memory
+  /// region that contains it in the supplied SBMemoryRegionInfo object.
+  /// To iterate over all memory regions use GetMemoryRegionList.
+  ///
+  /// @param[in] load_addr
+  ///     The address to be queried.
+  ///
+  /// @param[out] region_info
+  ///     A reference to an SBMemoryRegionInfo object that will contain
+  ///     the details of the memory region containing load_addr.
+  ///
+  /// @return
+  ///     An error object describes any errors that occurred while
+  ///     querying load_addr.
+  //------------------------------------------------------------------
+  lldb::SBError GetMemoryRegionInfo(lldb::addr_t load_addr,
+                                    lldb::SBMemoryRegionInfo &region_info);
+
+  //------------------------------------------------------------------
+  /// Return the list of memory regions within the process.
+  ///
+  /// @return
+  ///     A list of all witin the process memory regions.
+  //------------------------------------------------------------------
+  lldb::SBMemoryRegionInfoList GetMemoryRegions();
 
 protected:
-    friend class SBAddress;
-    friend class SBBreakpoint;
-    friend class SBBreakpointLocation;
-    friend class SBCommandInterpreter;
-    friend class SBDebugger;
-    friend class SBExecutionContext;
-    friend class SBFunction;
-    friend class SBModule;
-    friend class SBTarget;
-    friend class SBThread;
-    friend class SBValue;
-    friend class lldb_private::QueueImpl;
-
-    lldb::ProcessSP
-    GetSP() const;
-    
-    void
-    SetSP (const lldb::ProcessSP &process_sp);
-
-    lldb::ProcessWP m_opaque_wp;
+  friend class SBAddress;
+  friend class SBBreakpoint;
+  friend class SBBreakpointLocation;
+  friend class SBCommandInterpreter;
+  friend class SBDebugger;
+  friend class SBExecutionContext;
+  friend class SBFunction;
+  friend class SBModule;
+  friend class SBTarget;
+  friend class SBThread;
+  friend class SBValue;
+  friend class lldb_private::QueueImpl;
+
+  lldb::ProcessSP GetSP() const;
+
+  void SetSP(const lldb::ProcessSP &process_sp);
+
+  lldb::ProcessWP m_opaque_wp;
 };
 
-}  // namespace lldb
+} // namespace lldb
 
-#endif  // LLDB_SBProcess_h_
+#endif // LLDB_SBProcess_h_
diff --git a/include/lldb/API/SBQueue.h b/include/lldb/API/SBQueue.h
index 2f453cddd5d1..53612c0a125f 100644
--- a/include/lldb/API/SBQueue.h
+++ b/include/lldb/API/SBQueue.h
@@ -12,78 +12,61 @@
 
 #include <vector>
 
-#include "lldb/lldb-forward.h"
 #include "lldb/API/SBDefines.h"
+#include "lldb/lldb-forward.h"
 
 namespace lldb {
 
-class LLDB_API SBQueue
-{
+class LLDB_API SBQueue {
 public:
-    SBQueue ();
+  SBQueue();
+
+  SBQueue(const QueueSP &queue_sp);
 
-    SBQueue (const QueueSP& queue_sp);
-    
-    SBQueue (const SBQueue& rhs);
+  SBQueue(const SBQueue &rhs);
 
-    const SBQueue &
-    operator= (const lldb::SBQueue& rhs);
+  const SBQueue &operator=(const lldb::SBQueue &rhs);
 
-   ~SBQueue();
+  ~SBQueue();
 
-    bool
-    IsValid() const;
+  bool IsValid() const;
 
-    void
-    Clear ();
+  void Clear();
 
-    lldb::SBProcess
-    GetProcess ();
+  lldb::SBProcess GetProcess();
 
-    lldb::queue_id_t
-    GetQueueID () const;
+  lldb::queue_id_t GetQueueID() const;
 
-    const char *
-    GetName () const;
+  const char *GetName() const;
 
-    uint32_t
-    GetIndexID () const;
+  uint32_t GetIndexID() const;
 
-    uint32_t
-    GetNumThreads ();
+  uint32_t GetNumThreads();
 
-    lldb::SBThread
-    GetThreadAtIndex (uint32_t);
+  lldb::SBThread GetThreadAtIndex(uint32_t);
 
-    uint32_t
-    GetNumPendingItems ();
+  uint32_t GetNumPendingItems();
 
-    lldb::SBQueueItem
-    GetPendingItemAtIndex (uint32_t);
+  lldb::SBQueueItem GetPendingItemAtIndex(uint32_t);
 
-    uint32_t
-    GetNumRunningItems ();
+  uint32_t GetNumRunningItems();
 
-    lldb::QueueKind
-    GetKind ();
+  lldb::QueueKind GetKind();
 
 protected:
-    friend class SBProcess;
-    friend class SBThread;
+  friend class SBProcess;
+  friend class SBThread;
 
-    void
-    SetQueue (const lldb::QueueSP& queue_sp);
+  void SetQueue(const lldb::QueueSP &queue_sp);
 
-    void
-    FetchThreads ();
+  void FetchThreads();
 
-    void
-    FetchItems ();
+  void FetchItems();
 
 private:
-    std::shared_ptr<lldb_private::QueueImpl> m_opaque_sp;
+  std::shared_ptr<lldb_private::QueueImpl> m_opaque_sp;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBQueue_h_
+#endif // LLDB_SBQueue_h_
diff --git a/include/lldb/API/SBQueueItem.h b/include/lldb/API/SBQueueItem.h
index 9426a53b2376..78ca3ba02db1 100644
--- a/include/lldb/API/SBQueueItem.h
+++ b/include/lldb/API/SBQueueItem.h
@@ -10,48 +10,39 @@
 #ifndef LLDB_SBQueueItem_h_
 #define LLDB_SBQueueItem_h_
 
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBAddress.h"
+#include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
-class LLDB_API SBQueueItem
-{
+class LLDB_API SBQueueItem {
 public:
-    SBQueueItem ();
+  SBQueueItem();
+
+  SBQueueItem(const lldb::QueueItemSP &queue_item_sp);
 
-    SBQueueItem (const lldb::QueueItemSP& queue_item_sp);
-    
-   ~SBQueueItem();
+  ~SBQueueItem();
 
-    bool
-    IsValid() const;
+  bool IsValid() const;
 
-    void
-    Clear ();
+  void Clear();
 
-    lldb::QueueItemKind
-    GetKind () const;
+  lldb::QueueItemKind GetKind() const;
 
-    void
-    SetKind (lldb::QueueItemKind kind);
+  void SetKind(lldb::QueueItemKind kind);
 
-    lldb::SBAddress
-    GetAddress () const;
+  lldb::SBAddress GetAddress() const;
 
-    void
-    SetAddress (lldb::SBAddress addr);
+  void SetAddress(lldb::SBAddress addr);
 
-    void
-    SetQueueItem (const lldb::QueueItemSP& queue_item_sp);
+  void SetQueueItem(const lldb::QueueItemSP &queue_item_sp);
 
-    SBThread
-    GetExtendedBacktraceThread (const char *type);
+  SBThread GetExtendedBacktraceThread(const char *type);
 
 private:
-    lldb::QueueItemSP           m_queue_item_sp;
+  lldb::QueueItemSP m_queue_item_sp;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBQueueItem_h_
+#endif // LLDB_SBQueueItem_h_
diff --git a/include/lldb/API/SBSection.h b/include/lldb/API/SBSection.h
index 0a22413b5b9c..ffd8bf7c979b 100644
--- a/include/lldb/API/SBSection.h
+++ b/include/lldb/API/SBSection.h
@@ -10,106 +10,94 @@
 #ifndef LLDB_SBSection_h_
 #define LLDB_SBSection_h_
 
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBData.h"
+#include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
-class LLDB_API SBSection
-{
+class LLDB_API SBSection {
 public:
+  SBSection();
+
+  SBSection(const lldb::SBSection &rhs);
+
+  ~SBSection();
+
+  const lldb::SBSection &operator=(const lldb::SBSection &rhs);
 
-    SBSection ();
+  bool IsValid() const;
 
-    SBSection (const lldb::SBSection &rhs);
+  const char *GetName();
 
-    ~SBSection ();
+  lldb::SBSection GetParent();
 
-    const lldb::SBSection &
-    operator = (const lldb::SBSection &rhs);
+  lldb::SBSection FindSubSection(const char *sect_name);
 
-    bool
-    IsValid () const;
+  size_t GetNumSubSections();
 
-    const char *
-    GetName ();
+  lldb::SBSection GetSubSectionAtIndex(size_t idx);
 
-    lldb::SBSection
-    GetParent();
+  lldb::addr_t GetFileAddress();
 
-    lldb::SBSection
-    FindSubSection (const char *sect_name);
+  lldb::addr_t GetLoadAddress(lldb::SBTarget &target);
 
-    size_t
-    GetNumSubSections ();
+  lldb::addr_t GetByteSize();
 
-    lldb::SBSection
-    GetSubSectionAtIndex (size_t idx);
+  uint64_t GetFileOffset();
 
-    lldb::addr_t
-    GetFileAddress ();
+  uint64_t GetFileByteSize();
 
-    lldb::addr_t
-    GetLoadAddress (lldb::SBTarget &target);
-    
-    lldb::addr_t
-    GetByteSize ();
+  lldb::SBData GetSectionData();
 
-    uint64_t
-    GetFileOffset ();
+  lldb::SBData GetSectionData(uint64_t offset, uint64_t size);
 
-    uint64_t
-    GetFileByteSize ();
-    
-    lldb::SBData
-    GetSectionData ();
+  SectionType GetSectionType();
 
-    lldb::SBData
-    GetSectionData (uint64_t offset,
-                    uint64_t size);
-    
-    SectionType
-    GetSectionType ();
+  //------------------------------------------------------------------
+  /// Gets the permissions (RWX) of the section of the object file
+  ///
+  /// Returns a mask of bits of enum lldb::Permissions for this section.
+  /// Sections for which permissions are not defined, 0 is returned for
+  /// them. The binary representation of this value corresponds to [XRW]
+  /// i.e. for a section having read and execute permissions, the value
+  /// returned is 6
+  ///
+  /// @return
+  ///     Returns an unsigned value for Permissions for the section.
+  //------------------------------------------------------------------
+  uint32_t
+  GetPermissions() const;
 
-    //------------------------------------------------------------------
-    /// Return the size of a target's byte represented by this section
-    /// in numbers of host bytes. Note that certain architectures have
-    /// varying minimum addressable unit (i.e. byte) size for their 
-    /// CODE or DATA buses.
-    ///
-    /// @return
-    ///     The number of host (8-bit) bytes needed to hold a target byte
-    //------------------------------------------------------------------
-    uint32_t
-    GetTargetByteSize ();
+  //------------------------------------------------------------------
+  /// Return the size of a target's byte represented by this section
+  /// in numbers of host bytes. Note that certain architectures have
+  /// varying minimum addressable unit (i.e. byte) size for their
+  /// CODE or DATA buses.
+  ///
+  /// @return
+  ///     The number of host (8-bit) bytes needed to hold a target byte
+  //------------------------------------------------------------------
+  uint32_t GetTargetByteSize();
 
-    bool
-    operator == (const lldb::SBSection &rhs);
+  bool operator==(const lldb::SBSection &rhs);
 
-    bool
-    operator != (const lldb::SBSection &rhs);
+  bool operator!=(const lldb::SBSection &rhs);
 
-    bool
-    GetDescription (lldb::SBStream &description);
-    
+  bool GetDescription(lldb::SBStream &description);
 
 private:
+  friend class SBAddress;
+  friend class SBModule;
+  friend class SBTarget;
 
-    friend class SBAddress;
-    friend class SBModule;
-    friend class SBTarget;
-    
-    SBSection (const lldb::SectionSP &section_sp);
-
-    lldb::SectionSP
-    GetSP() const;
-    
-    void
-    SetSP(const lldb::SectionSP &section_sp);
-    
-    lldb::SectionWP m_opaque_wp;
-};
+  SBSection(const lldb::SectionSP &section_sp);
+
+  lldb::SectionSP GetSP() const;
 
+  void SetSP(const lldb::SectionSP &section_sp);
+
+  lldb::SectionWP m_opaque_wp;
+};
 
 } // namespace lldb
 
diff --git a/include/lldb/API/SBSourceManager.h b/include/lldb/API/SBSourceManager.h
index 6e7358f16e77..6f1c49504d52 100644
--- a/include/lldb/API/SBSourceManager.h
+++ b/include/lldb/API/SBSourceManager.h
@@ -16,38 +16,35 @@
 
 namespace lldb {
 
-class LLDB_API SBSourceManager
-{
+class LLDB_API SBSourceManager {
 public:
-    SBSourceManager (const SBDebugger &debugger);
-    SBSourceManager (const SBTarget &target);
-    SBSourceManager (const SBSourceManager &rhs);
-    
-    ~SBSourceManager();
+  SBSourceManager(const SBDebugger &debugger);
+  SBSourceManager(const SBTarget &target);
+  SBSourceManager(const SBSourceManager &rhs);
 
-    const lldb::SBSourceManager &
-    operator = (const lldb::SBSourceManager &rhs);
+  ~SBSourceManager();
 
-    size_t
-    DisplaySourceLinesWithLineNumbers (const lldb::SBFileSpec &file,
-                                       uint32_t line,
-                                       uint32_t context_before,
-                                       uint32_t context_after,
-                                       const char* current_line_cstr,
-                                       lldb::SBStream &s);
+  const lldb::SBSourceManager &operator=(const lldb::SBSourceManager &rhs);
 
+  size_t DisplaySourceLinesWithLineNumbers(
+      const lldb::SBFileSpec &file, uint32_t line, uint32_t context_before,
+      uint32_t context_after, const char *current_line_cstr, lldb::SBStream &s);
+
+  size_t DisplaySourceLinesWithLineNumbersAndColumn(
+      const lldb::SBFileSpec &file, uint32_t line, uint32_t column,
+      uint32_t context_before, uint32_t context_after,
+      const char *current_line_cstr, lldb::SBStream &s);
 
 protected:
-    friend class SBCommandInterpreter;
-    friend class SBDebugger;
+  friend class SBCommandInterpreter;
+  friend class SBDebugger;
 
-    SBSourceManager(lldb_private::SourceManager *source_manager);
+  SBSourceManager(lldb_private::SourceManager *source_manager);
 
 private:
-
-    std::unique_ptr<lldb_private::SourceManagerImpl> m_opaque_ap;
+  std::unique_ptr<lldb_private::SourceManagerImpl> m_opaque_ap;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBSourceManager_h_
+#endif // LLDB_SBSourceManager_h_
diff --git a/include/lldb/API/SBStream.h b/include/lldb/API/SBStream.h
index 717979977d16..68fcae21c08e 100644
--- a/include/lldb/API/SBStream.h
+++ b/include/lldb/API/SBStream.h
@@ -16,100 +16,87 @@
 
 namespace lldb {
 
-class LLDB_API SBStream
-{
+class LLDB_API SBStream {
 public:
+  SBStream();
 
-    SBStream ();
+  SBStream(SBStream &&rhs);
 
-    SBStream (SBStream &&rhs);
+  ~SBStream();
 
-    ~SBStream ();
+  bool IsValid() const;
 
-    bool
-    IsValid() const;
+  // If this stream is not redirected to a file, it will maintain a local
+  // cache for the stream data which can be accessed using this accessor.
+  const char *GetData();
 
-    // If this stream is not redirected to a file, it will maintain a local
-    // cache for the stream data which can be accessed using this accessor.
-    const char *
-    GetData ();
+  // If this stream is not redirected to a file, it will maintain a local
+  // cache for the stream output whose length can be accessed using this
+  // accessor.
+  size_t GetSize();
 
-    // If this stream is not redirected to a file, it will maintain a local
-    // cache for the stream output whose length can be accessed using this 
-    // accessor.
-    size_t
-    GetSize();
+  void Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
 
-    void
-    Printf (const char *format, ...)  __attribute__ ((format (printf, 2, 3)));
+  void RedirectToFile(const char *path, bool append);
 
-    void
-    RedirectToFile (const char *path, bool append);
+  void RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership);
 
-    void
-    RedirectToFileHandle (FILE *fh, bool transfer_fh_ownership);
+  void RedirectToFileDescriptor(int fd, bool transfer_fh_ownership);
 
-    void
-    RedirectToFileDescriptor (int fd, bool transfer_fh_ownership);
-
-    // If the stream is redirected to a file, forget about the file and if
-    // ownership of the file was transferred to this object, close the file.
-    // If the stream is backed by a local cache, clear this cache.
-    void
-    Clear ();
+  // If the stream is redirected to a file, forget about the file and if
+  // ownership of the file was transferred to this object, close the file.
+  // If the stream is backed by a local cache, clear this cache.
+  void Clear();
 
 protected:
-    friend class SBAddress;
-    friend class SBBlock;
-    friend class SBBreakpoint;
-    friend class SBBreakpointLocation;
-    friend class SBCommandReturnObject;
-    friend class SBCompileUnit;
-    friend class SBData;
-    friend class SBDebugger;
-    friend class SBDeclaration;
-    friend class SBEvent;
-    friend class SBFileSpec;
-    friend class SBFileSpecList;
-    friend class SBFrame;
-    friend class SBFunction;
-    friend class SBInstruction;
-    friend class SBInstructionList;
-    friend class SBLineEntry;
-    friend class SBMemoryRegionInfo;
-    friend class SBModule;
-    friend class SBModuleSpec;
-    friend class SBModuleSpecList;
-    friend class SBProcess;
-    friend class SBSection;
-    friend class SBSourceManager;
-    friend class SBSymbol;
-    friend class SBSymbolContext;
-    friend class SBSymbolContextList;
-    friend class SBTarget;
-    friend class SBThread;
-    friend class SBThreadPlan;
-    friend class SBType;
-    friend class SBTypeEnumMember;
-    friend class SBTypeMemberFunction;
-    friend class SBTypeMember;
-    friend class SBValue;
-    friend class SBWatchpoint;
-
-    lldb_private::Stream *
-    operator->();
-
-    lldb_private::Stream *
-    get();
-
-    lldb_private::Stream &
-    ref();
+  friend class SBAddress;
+  friend class SBBlock;
+  friend class SBBreakpoint;
+  friend class SBBreakpointLocation;
+  friend class SBCommandReturnObject;
+  friend class SBCompileUnit;
+  friend class SBData;
+  friend class SBDebugger;
+  friend class SBDeclaration;
+  friend class SBEvent;
+  friend class SBFileSpec;
+  friend class SBFileSpecList;
+  friend class SBFrame;
+  friend class SBFunction;
+  friend class SBInstruction;
+  friend class SBInstructionList;
+  friend class SBLineEntry;
+  friend class SBMemoryRegionInfo;
+  friend class SBModule;
+  friend class SBModuleSpec;
+  friend class SBModuleSpecList;
+  friend class SBProcess;
+  friend class SBSection;
+  friend class SBSourceManager;
+  friend class SBStructuredData;
+  friend class SBSymbol;
+  friend class SBSymbolContext;
+  friend class SBSymbolContextList;
+  friend class SBTarget;
+  friend class SBThread;
+  friend class SBThreadPlan;
+  friend class SBType;
+  friend class SBTypeEnumMember;
+  friend class SBTypeMemberFunction;
+  friend class SBTypeMember;
+  friend class SBValue;
+  friend class SBWatchpoint;
+
+  lldb_private::Stream *operator->();
+
+  lldb_private::Stream *get();
+
+  lldb_private::Stream &ref();
 
 private:
-
-    DISALLOW_COPY_AND_ASSIGN (SBStream);
-    std::unique_ptr<lldb_private::Stream> m_opaque_ap;
-    bool m_is_file;
+  DISALLOW_COPY_AND_ASSIGN(SBStream);
+  std::unique_ptr<lldb_private::Stream> m_opaque_ap;
+  bool m_is_file;
 };
 
 } // namespace lldb
diff --git a/include/lldb/API/SBStringList.h b/include/lldb/API/SBStringList.h
index bc8ff935eda3..66b5172a0b3e 100644
--- a/include/lldb/API/SBStringList.h
+++ b/include/lldb/API/SBStringList.h
@@ -14,59 +14,47 @@
 
 namespace lldb {
 
-class LLDB_API SBStringList
-{
+class LLDB_API SBStringList {
 public:
+  SBStringList();
 
-    SBStringList ();
+  SBStringList(const lldb::SBStringList &rhs);
 
-    SBStringList (const lldb::SBStringList &rhs);
-    
-    const SBStringList &
-    operator = (const SBStringList &rhs);
+  const SBStringList &operator=(const SBStringList &rhs);
 
-    ~SBStringList ();
+  ~SBStringList();
 
-    bool
-    IsValid() const;
+  bool IsValid() const;
 
-    void
-    AppendString (const char *str);
+  void AppendString(const char *str);
 
-    void
-    AppendList (const char **strv, int strc);
+  void AppendList(const char **strv, int strc);
 
-    void
-    AppendList (const lldb::SBStringList &strings);
+  void AppendList(const lldb::SBStringList &strings);
 
-    uint32_t
-    GetSize () const;
+  uint32_t GetSize() const;
 
-    const char *
-    GetStringAtIndex (size_t idx);
+  const char *GetStringAtIndex(size_t idx);
 
-    const char *
-    GetStringAtIndex (size_t idx) const;
+  const char *GetStringAtIndex(size_t idx) const;
 
-    void
-    Clear ();
+  void Clear();
 
 protected:
-    friend class SBCommandInterpreter;
-    friend class SBDebugger;
+  friend class SBCommandInterpreter;
+  friend class SBDebugger;
+  friend class SBBreakpoint;
 
-    SBStringList (const lldb_private::StringList *lldb_strings);
+  SBStringList(const lldb_private::StringList *lldb_strings);
 
-    const lldb_private::StringList *
-    operator->() const;
+  void AppendList(const lldb_private::StringList &strings);
 
-    const lldb_private::StringList &
-    operator*() const;
+  const lldb_private::StringList *operator->() const;
 
-private:
-
-    std::unique_ptr<lldb_private::StringList> m_opaque_ap;
+  const lldb_private::StringList &operator*() const;
 
+private:
+  std::unique_ptr<lldb_private::StringList> m_opaque_ap;
 };
 
 } // namespace lldb
diff --git a/include/lldb/API/SBStructuredData.h b/include/lldb/API/SBStructuredData.h
new file mode 100644
index 000000000000..9f0203bb245a
--- /dev/null
+++ b/include/lldb/API/SBStructuredData.h
@@ -0,0 +1,45 @@
+//===-- SBStructuredData.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SBStructuredData_h
+#define SBStructuredData_h
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBModule.h"
+
+class StructuredDataImpl;
+
+namespace lldb {
+
+class SBStructuredData {
+public:
+  SBStructuredData();
+
+  SBStructuredData(const lldb::SBStructuredData &rhs);
+
+  SBStructuredData(const lldb::EventSP &event_sp);
+
+  ~SBStructuredData();
+
+  lldb::SBStructuredData &operator=(const lldb::SBStructuredData &rhs);
+
+  bool IsValid() const;
+
+  void Clear();
+
+  lldb::SBError GetAsJSON(lldb::SBStream &stream) const;
+
+  lldb::SBError GetDescription(lldb::SBStream &stream) const;
+
+private:
+  std::unique_ptr<StructuredDataImpl> m_impl_up;
+};
+}
+
+#endif /* SBStructuredData_h */
diff --git a/include/lldb/API/SBSymbol.h b/include/lldb/API/SBSymbol.h
index 5acebe975261..d17a4ccffe02 100644
--- a/include/lldb/API/SBSymbol.h
+++ b/include/lldb/API/SBSymbol.h
@@ -10,102 +10,79 @@
 #ifndef LLDB_SBSymbol_h_
 #define LLDB_SBSymbol_h_
 
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBAddress.h"
+#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBInstructionList.h"
 #include "lldb/API/SBTarget.h"
 
 namespace lldb {
 
-class LLDB_API SBSymbol
-{
+class LLDB_API SBSymbol {
 public:
+  SBSymbol();
+
+  ~SBSymbol();
 
-    SBSymbol ();
+  SBSymbol(const lldb::SBSymbol &rhs);
 
-    ~SBSymbol ();
+  const lldb::SBSymbol &operator=(const lldb::SBSymbol &rhs);
 
-    SBSymbol (const lldb::SBSymbol &rhs);
+  bool IsValid() const;
 
-    const lldb::SBSymbol &
-    operator = (const lldb::SBSymbol &rhs);
+  const char *GetName() const;
 
-    bool
-    IsValid () const;
+  const char *GetDisplayName() const;
 
+  const char *GetMangledName() const;
 
-    const char *
-    GetName() const;
+  lldb::SBInstructionList GetInstructions(lldb::SBTarget target);
 
-    const char *
-    GetDisplayName() const;
-    
-    const char *
-    GetMangledName () const;
+  lldb::SBInstructionList GetInstructions(lldb::SBTarget target,
+                                          const char *flavor_string);
 
-    lldb::SBInstructionList
-    GetInstructions (lldb::SBTarget target);
+  SBAddress GetStartAddress();
 
-    lldb::SBInstructionList
-    GetInstructions (lldb::SBTarget target, const char *flavor_string);
+  SBAddress GetEndAddress();
 
-    SBAddress
-    GetStartAddress ();
-    
-    SBAddress
-    GetEndAddress ();
-    
-    uint32_t
-    GetPrologueByteSize ();
+  uint32_t GetPrologueByteSize();
 
-    SymbolType
-    GetType ();
+  SymbolType GetType();
 
-    bool
-    operator == (const lldb::SBSymbol &rhs) const;
+  bool operator==(const lldb::SBSymbol &rhs) const;
 
-    bool
-    operator != (const lldb::SBSymbol &rhs) const;
+  bool operator!=(const lldb::SBSymbol &rhs) const;
 
-    bool
-    GetDescription (lldb::SBStream &description);
+  bool GetDescription(lldb::SBStream &description);
 
-    //----------------------------------------------------------------------
-    // Returns true if the symbol is externally visible in the module that
-    // it is defined in
-    //----------------------------------------------------------------------
-    bool
-    IsExternal();
+  //----------------------------------------------------------------------
+  // Returns true if the symbol is externally visible in the module that
+  // it is defined in
+  //----------------------------------------------------------------------
+  bool IsExternal();
 
-    //----------------------------------------------------------------------
-    // Returns true if the symbol was synthetically generated from something
-    // other than the actual symbol table itself in the object file.
-    //----------------------------------------------------------------------
-    bool
-    IsSynthetic();
+  //----------------------------------------------------------------------
+  // Returns true if the symbol was synthetically generated from something
+  // other than the actual symbol table itself in the object file.
+  //----------------------------------------------------------------------
+  bool IsSynthetic();
 
 protected:
+  lldb_private::Symbol *get();
 
-    lldb_private::Symbol *
-    get ();
+  void reset(lldb_private::Symbol *);
 
-    void
-    reset (lldb_private::Symbol *);
-    
 private:
-    friend class SBAddress;
-    friend class SBFrame;
-    friend class SBModule;
-    friend class SBSymbolContext;
+  friend class SBAddress;
+  friend class SBFrame;
+  friend class SBModule;
+  friend class SBSymbolContext;
 
-    SBSymbol (lldb_private::Symbol *lldb_object_ptr);
-    
-    void
-    SetSymbol (lldb_private::Symbol *lldb_object_ptr);
+  SBSymbol(lldb_private::Symbol *lldb_object_ptr);
 
-    lldb_private::Symbol *m_opaque_ptr;
-};
+  void SetSymbol(lldb_private::Symbol *lldb_object_ptr);
 
+  lldb_private::Symbol *m_opaque_ptr;
+};
 
 } // namespace lldb
 
diff --git a/include/lldb/API/SBSymbolContext.h b/include/lldb/API/SBSymbolContext.h
index 24c2ce9a1d6e..04ee15e8ecb1 100644
--- a/include/lldb/API/SBSymbolContext.h
+++ b/include/lldb/API/SBSymbolContext.h
@@ -10,9 +10,9 @@
 #ifndef LLDB_SBSymbolContext_h_
 #define LLDB_SBSymbolContext_h_
 
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBBlock.h"
 #include "lldb/API/SBCompileUnit.h"
+#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBFunction.h"
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBModule.h"
@@ -20,75 +20,63 @@
 
 namespace lldb {
 
-class LLDB_API SBSymbolContext
-{
+class LLDB_API SBSymbolContext {
 public:
-    SBSymbolContext ();
+  SBSymbolContext();
 
-    SBSymbolContext (const lldb::SBSymbolContext& rhs);
+  SBSymbolContext(const lldb::SBSymbolContext &rhs);
 
-    ~SBSymbolContext ();
+  ~SBSymbolContext();
 
-    bool
-    IsValid () const;
+  bool IsValid() const;
 
-    const lldb::SBSymbolContext &
-    operator = (const lldb::SBSymbolContext &rhs);
+  const lldb::SBSymbolContext &operator=(const lldb::SBSymbolContext &rhs);
 
-    lldb::SBModule        GetModule ();
-    lldb::SBCompileUnit   GetCompileUnit ();
-    lldb::SBFunction      GetFunction ();
-    lldb::SBBlock         GetBlock ();
-    lldb::SBLineEntry     GetLineEntry ();
-    lldb::SBSymbol        GetSymbol ();
+  lldb::SBModule GetModule();
+  lldb::SBCompileUnit GetCompileUnit();
+  lldb::SBFunction GetFunction();
+  lldb::SBBlock GetBlock();
+  lldb::SBLineEntry GetLineEntry();
+  lldb::SBSymbol GetSymbol();
 
-    void SetModule (lldb::SBModule module);
-    void SetCompileUnit (lldb::SBCompileUnit compile_unit);
-    void SetFunction (lldb::SBFunction function);
-    void SetBlock (lldb::SBBlock block);
-    void SetLineEntry (lldb::SBLineEntry line_entry);
-    void SetSymbol (lldb::SBSymbol symbol);
+  void SetModule(lldb::SBModule module);
+  void SetCompileUnit(lldb::SBCompileUnit compile_unit);
+  void SetFunction(lldb::SBFunction function);
+  void SetBlock(lldb::SBBlock block);
+  void SetLineEntry(lldb::SBLineEntry line_entry);
+  void SetSymbol(lldb::SBSymbol symbol);
 
-    SBSymbolContext
-    GetParentOfInlinedScope (const SBAddress &curr_frame_pc, 
-                             SBAddress &parent_frame_addr) const;
+  SBSymbolContext GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
+                                          SBAddress &parent_frame_addr) const;
 
-    bool
-    GetDescription (lldb::SBStream &description);
+  bool GetDescription(lldb::SBStream &description);
 
 protected:
-    friend class SBAddress;
-    friend class SBFrame;
-    friend class SBModule;
-    friend class SBThread;
-    friend class SBTarget;
-    friend class SBSymbolContextList;
+  friend class SBAddress;
+  friend class SBFrame;
+  friend class SBModule;
+  friend class SBThread;
+  friend class SBTarget;
+  friend class SBSymbolContextList;
 
-    lldb_private::SymbolContext*
-    operator->() const;
+  lldb_private::SymbolContext *operator->() const;
 
-    lldb_private::SymbolContext&
-    operator*();
+  lldb_private::SymbolContext &operator*();
 
-    lldb_private::SymbolContext&
-    ref();
+  lldb_private::SymbolContext &ref();
 
-    const lldb_private::SymbolContext&
-    operator*() const;
+  const lldb_private::SymbolContext &operator*() const;
 
-    lldb_private::SymbolContext *
-    get() const;
+  lldb_private::SymbolContext *get() const;
 
-    SBSymbolContext (const lldb_private::SymbolContext *sc_ptr);
+  SBSymbolContext(const lldb_private::SymbolContext *sc_ptr);
 
-    void
-    SetSymbolContext (const lldb_private::SymbolContext *sc_ptr);
+  void SetSymbolContext(const lldb_private::SymbolContext *sc_ptr);
 
 private:
-    std::unique_ptr<lldb_private::SymbolContext> m_opaque_ap;
+  std::unique_ptr<lldb_private::SymbolContext> m_opaque_ap;
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBSymbolContext_h_
diff --git a/include/lldb/API/SBSymbolContextList.h b/include/lldb/API/SBSymbolContextList.h
index 79dcccdcbf84..e7299dd5330c 100644
--- a/include/lldb/API/SBSymbolContextList.h
+++ b/include/lldb/API/SBSymbolContextList.h
@@ -15,55 +15,43 @@
 
 namespace lldb {
 
-class LLDB_API SBSymbolContextList
-{
+class LLDB_API SBSymbolContextList {
 public:
-    SBSymbolContextList ();
+  SBSymbolContextList();
 
-    SBSymbolContextList (const lldb::SBSymbolContextList& rhs);
+  SBSymbolContextList(const lldb::SBSymbolContextList &rhs);
 
-    ~SBSymbolContextList ();
+  ~SBSymbolContextList();
 
-    const lldb::SBSymbolContextList &
-    operator = (const lldb::SBSymbolContextList &rhs);
+  const lldb::SBSymbolContextList &
+  operator=(const lldb::SBSymbolContextList &rhs);
 
-    bool
-    IsValid () const;
+  bool IsValid() const;
 
-    uint32_t
-    GetSize() const;
+  uint32_t GetSize() const;
 
-    lldb::SBSymbolContext
-    GetContextAtIndex (uint32_t idx);
-    
-    bool
-    GetDescription (lldb::SBStream &description);
+  lldb::SBSymbolContext GetContextAtIndex(uint32_t idx);
 
-    void
-    Append (lldb::SBSymbolContext &sc);
-    
-    void
-    Append (lldb::SBSymbolContextList &sc_list);
-    
-    void
-    Clear();
+  bool GetDescription(lldb::SBStream &description);
 
-protected:
+  void Append(lldb::SBSymbolContext &sc);
+
+  void Append(lldb::SBSymbolContextList &sc_list);
 
-    friend class SBModule;
-    friend class SBTarget;
+  void Clear();
 
-    lldb_private::SymbolContextList*
-    operator->() const;
+protected:
+  friend class SBModule;
+  friend class SBTarget;
 
-    lldb_private::SymbolContextList&
-    operator*() const;
+  lldb_private::SymbolContextList *operator->() const;
+
+  lldb_private::SymbolContextList &operator*() const;
 
 private:
-    std::unique_ptr<lldb_private::SymbolContextList> m_opaque_ap;
+  std::unique_ptr<lldb_private::SymbolContextList> m_opaque_ap;
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBSymbolContextList_h_
diff --git a/include/lldb/API/SBTarget.h b/include/lldb/API/SBTarget.h
index 0bcabd043c9c..4e8db835ddc0 100644
--- a/include/lldb/API/SBTarget.h
+++ b/include/lldb/API/SBTarget.h
@@ -14,10 +14,11 @@
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBAttachInfo.h"
+#include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBBroadcaster.h"
+#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBLaunchInfo.h"
@@ -30,831 +31,817 @@ namespace lldb {
 
 class SBPlatform;
 
-class LLDB_API SBTarget
-{
+class LLDB_API SBTarget {
 public:
-    //------------------------------------------------------------------
-    // Broadcaster bits.
-    //------------------------------------------------------------------
-    enum
-    {
-        eBroadcastBitBreakpointChanged  = (1 << 0),
-        eBroadcastBitModulesLoaded      = (1 << 1),
-        eBroadcastBitModulesUnloaded    = (1 << 2),
-        eBroadcastBitWatchpointChanged  = (1 << 3),
-        eBroadcastBitSymbolsLoaded      = (1 << 4)
-    };
-
-    //------------------------------------------------------------------
-    // Constructors
-    //------------------------------------------------------------------
-    SBTarget ();
-
-    SBTarget (const lldb::SBTarget& rhs);
-
-    SBTarget (const lldb::TargetSP& target_sp);
-    
-    //------------------------------------------------------------------
-    // Destructor
-    //------------------------------------------------------------------
-    ~SBTarget();
-
-    const lldb::SBTarget&
-    operator = (const lldb::SBTarget& rhs);
-
-    bool
-    IsValid() const;
-
-    static bool
-    EventIsTargetEvent (const lldb::SBEvent &event);
-
-    static lldb::SBTarget
-    GetTargetFromEvent (const lldb::SBEvent &event);
-    
-    static uint32_t
-    GetNumModulesFromEvent (const lldb::SBEvent &event);
-
-    static lldb::SBModule
-    GetModuleAtIndexFromEvent (const uint32_t idx, const lldb::SBEvent &event);
-
-    static const char *
-    GetBroadcasterClassName ();
-
-    lldb::SBProcess
-    GetProcess ();
-
-    //------------------------------------------------------------------
-    /// Return the platform object associated with the target.
-    ///
-    /// After return, the platform object should be checked for
-    /// validity.
-    ///
-    /// @return
-    ///     A platform object.
-    //------------------------------------------------------------------
-    lldb::SBPlatform
-    GetPlatform ();
-
-    //------------------------------------------------------------------
-    /// Install any binaries that need to be installed.
-    ///
-    /// This function does nothing when debugging on the host system.
-    /// When connected to remote platforms, the target's main executable
-    /// and any modules that have their remote install path set will be
-    /// installed on the remote platform. If the main executable doesn't
-    /// have an install location set, it will be installed in the remote
-    /// platform's working directory.
-    ///
-    /// @return
-    ///     An error describing anything that went wrong during
-    ///     installation.
-    //------------------------------------------------------------------
-    SBError
-    Install();
-    
-    //------------------------------------------------------------------
-    /// Launch a new process.
-    ///
-    /// Launch a new process by spawning a new process using the
-    /// target object's executable module's file as the file to launch.
-    /// Arguments are given in \a argv, and the environment variables
-    /// are in \a envp. Standard input and output files can be
-    /// optionally re-directed to \a stdin_path, \a stdout_path, and
-    /// \a stderr_path.
-    ///
-    /// @param[in] listener
-    ///     An optional listener that will receive all process events.
-    ///     If \a listener is valid then \a listener will listen to all
-    ///     process events. If not valid, then this target's debugger
-    ///     (SBTarget::GetDebugger()) will listen to all process events. 
-    ///
-    /// @param[in] argv
-    ///     The argument array.
-    ///
-    /// @param[in] envp
-    ///     The environment array.
-    ///
-    /// @param[in] launch_flags
-    ///     Flags to modify the launch (@see lldb::LaunchFlags)
-    ///
-    /// @param[in] stdin_path
-    ///     The path to use when re-directing the STDIN of the new
-    ///     process. If all stdXX_path arguments are nullptr, a pseudo
-    ///     terminal will be used.
-    ///
-    /// @param[in] stdout_path
-    ///     The path to use when re-directing the STDOUT of the new
-    ///     process. If all stdXX_path arguments are nullptr, a pseudo
-    ///     terminal will be used.
-    ///
-    /// @param[in] stderr_path
-    ///     The path to use when re-directing the STDERR of the new
-    ///     process. If all stdXX_path arguments are nullptr, a pseudo
-    ///     terminal will be used.
-    ///
-    /// @param[in] working_directory
-    ///     The working directory to have the child process run in
-    ///
-    /// @param[in] launch_flags
-    ///     Some launch options specified by logical OR'ing 
-    ///     lldb::LaunchFlags enumeration values together.
-    ///
-    /// @param[in] stop_at_entry
-    ///     If false do not stop the inferior at the entry point.
-    ///
-    /// @param[out] error
-    ///     An error object. Contains the reason if there is some failure.
-    ///
-    /// @return
-    ///      A process object for the newly created process.
-    //------------------------------------------------------------------
-    lldb::SBProcess
-    Launch (SBListener &listener, 
-            char const **argv,
-            char const **envp,
-            const char *stdin_path,
-            const char *stdout_path,
-            const char *stderr_path,
-            const char *working_directory,
-            uint32_t launch_flags,   // See LaunchFlags
-            bool stop_at_entry,
-            lldb::SBError& error);
-
-    SBProcess
-    LoadCore (const char *core_file);
-
-    //------------------------------------------------------------------
-    /// Launch a new process with sensible defaults.
-    ///
-    /// @param[in] argv
-    ///     The argument array.
-    ///
-    /// @param[in] envp
-    ///     The environment array.
-    ///
-    /// @param[in] working_directory
-    ///     The working directory to have the child process run in
-    ///
-    /// Default: listener
-    ///     Set to the target's debugger (SBTarget::GetDebugger())
-    ///
-    /// Default: launch_flags
-    ///     Empty launch flags
-    ///
-    /// Default: stdin_path
-    /// Default: stdout_path
-    /// Default: stderr_path
-    ///     A pseudo terminal will be used.
-    ///
-    /// @return
-    ///      A process object for the newly created process.
-    //------------------------------------------------------------------
-    SBProcess
-    LaunchSimple (const char **argv, 
-                  const char **envp,
-                  const char *working_directory);
-    
-    SBProcess
-    Launch (SBLaunchInfo &launch_info, SBError& error);
-    
-    SBProcess
-    Attach (SBAttachInfo &attach_info, SBError& error);
-
-    //------------------------------------------------------------------
-    /// Attach to process with pid.
-    ///
-    /// @param[in] listener
-    ///     An optional listener that will receive all process events.
-    ///     If \a listener is valid then \a listener will listen to all
-    ///     process events. If not valid, then this target's debugger
-    ///     (SBTarget::GetDebugger()) will listen to all process events.
-    ///
-    /// @param[in] pid
-    ///     The process ID to attach to.
-    ///
-    /// @param[out] error
-    ///     An error explaining what went wrong if attach fails.
-    ///
-    /// @return
-    ///      A process object for the attached process.
-    //------------------------------------------------------------------
-    lldb::SBProcess
-    AttachToProcessWithID (SBListener &listener,
-                           lldb::pid_t pid,
-                           lldb::SBError& error);
+  //------------------------------------------------------------------
+  // Broadcaster bits.
+  //------------------------------------------------------------------
+  enum {
+    eBroadcastBitBreakpointChanged = (1 << 0),
+    eBroadcastBitModulesLoaded = (1 << 1),
+    eBroadcastBitModulesUnloaded = (1 << 2),
+    eBroadcastBitWatchpointChanged = (1 << 3),
+    eBroadcastBitSymbolsLoaded = (1 << 4)
+  };
+
+  //------------------------------------------------------------------
+  // Constructors
+  //------------------------------------------------------------------
+  SBTarget();
+
+  SBTarget(const lldb::SBTarget &rhs);
+
+  SBTarget(const lldb::TargetSP &target_sp);
+
+  //------------------------------------------------------------------
+  // Destructor
+  //------------------------------------------------------------------
+  ~SBTarget();
+
+  const lldb::SBTarget &operator=(const lldb::SBTarget &rhs);
+
+  bool IsValid() const;
+
+  static bool EventIsTargetEvent(const lldb::SBEvent &event);
+
+  static lldb::SBTarget GetTargetFromEvent(const lldb::SBEvent &event);
+
+  static uint32_t GetNumModulesFromEvent(const lldb::SBEvent &event);
+
+  static lldb::SBModule GetModuleAtIndexFromEvent(const uint32_t idx,
+                                                  const lldb::SBEvent &event);
+
+  static const char *GetBroadcasterClassName();
+
+  lldb::SBProcess GetProcess();
+
+  //------------------------------------------------------------------
+  /// Return the platform object associated with the target.
+  ///
+  /// After return, the platform object should be checked for
+  /// validity.
+  ///
+  /// @return
+  ///     A platform object.
+  //------------------------------------------------------------------
+  lldb::SBPlatform GetPlatform();
+
+  //------------------------------------------------------------------
+  /// Install any binaries that need to be installed.
+  ///
+  /// This function does nothing when debugging on the host system.
+  /// When connected to remote platforms, the target's main executable
+  /// and any modules that have their remote install path set will be
+  /// installed on the remote platform. If the main executable doesn't
+  /// have an install location set, it will be installed in the remote
+  /// platform's working directory.
+  ///
+  /// @return
+  ///     An error describing anything that went wrong during
+  ///     installation.
+  //------------------------------------------------------------------
+  SBError Install();
+
+  //------------------------------------------------------------------
+  /// Launch a new process.
+  ///
+  /// Launch a new process by spawning a new process using the
+  /// target object's executable module's file as the file to launch.
+  /// Arguments are given in \a argv, and the environment variables
+  /// are in \a envp. Standard input and output files can be
+  /// optionally re-directed to \a stdin_path, \a stdout_path, and
+  /// \a stderr_path.
+  ///
+  /// @param[in] listener
+  ///     An optional listener that will receive all process events.
+  ///     If \a listener is valid then \a listener will listen to all
+  ///     process events. If not valid, then this target's debugger
+  ///     (SBTarget::GetDebugger()) will listen to all process events.
+  ///
+  /// @param[in] argv
+  ///     The argument array.
+  ///
+  /// @param[in] envp
+  ///     The environment array.
+  ///
+  /// @param[in] launch_flags
+  ///     Flags to modify the launch (@see lldb::LaunchFlags)
+  ///
+  /// @param[in] stdin_path
+  ///     The path to use when re-directing the STDIN of the new
+  ///     process. If all stdXX_path arguments are nullptr, a pseudo
+  ///     terminal will be used.
+  ///
+  /// @param[in] stdout_path
+  ///     The path to use when re-directing the STDOUT of the new
+  ///     process. If all stdXX_path arguments are nullptr, a pseudo
+  ///     terminal will be used.
+  ///
+  /// @param[in] stderr_path
+  ///     The path to use when re-directing the STDERR of the new
+  ///     process. If all stdXX_path arguments are nullptr, a pseudo
+  ///     terminal will be used.
+  ///
+  /// @param[in] working_directory
+  ///     The working directory to have the child process run in
+  ///
+  /// @param[in] launch_flags
+  ///     Some launch options specified by logical OR'ing
+  ///     lldb::LaunchFlags enumeration values together.
+  ///
+  /// @param[in] stop_at_entry
+  ///     If false do not stop the inferior at the entry point.
+  ///
+  /// @param[out] error
+  ///     An error object. Contains the reason if there is some failure.
+  ///
+  /// @return
+  ///      A process object for the newly created process.
+  //------------------------------------------------------------------
+  lldb::SBProcess Launch(SBListener &listener, char const **argv,
+                         char const **envp, const char *stdin_path,
+                         const char *stdout_path, const char *stderr_path,
+                         const char *working_directory,
+                         uint32_t launch_flags, // See LaunchFlags
+                         bool stop_at_entry, lldb::SBError &error);
+
+  SBProcess LoadCore(const char *core_file);
+
+  //------------------------------------------------------------------
+  /// Launch a new process with sensible defaults.
+  ///
+  /// @param[in] argv
+  ///     The argument array.
+  ///
+  /// @param[in] envp
+  ///     The environment array.
+  ///
+  /// @param[in] working_directory
+  ///     The working directory to have the child process run in
+  ///
+  /// Default: listener
+  ///     Set to the target's debugger (SBTarget::GetDebugger())
+  ///
+  /// Default: launch_flags
+  ///     Empty launch flags
+  ///
+  /// Default: stdin_path
+  /// Default: stdout_path
+  /// Default: stderr_path
+  ///     A pseudo terminal will be used.
+  ///
+  /// @return
+  ///      A process object for the newly created process.
+  //------------------------------------------------------------------
+  SBProcess LaunchSimple(const char **argv, const char **envp,
+                         const char *working_directory);
+
+  SBProcess Launch(SBLaunchInfo &launch_info, SBError &error);
+
+  SBProcess Attach(SBAttachInfo &attach_info, SBError &error);
+
+  //------------------------------------------------------------------
+  /// Attach to process with pid.
+  ///
+  /// @param[in] listener
+  ///     An optional listener that will receive all process events.
+  ///     If \a listener is valid then \a listener will listen to all
+  ///     process events. If not valid, then this target's debugger
+  ///     (SBTarget::GetDebugger()) will listen to all process events.
+  ///
+  /// @param[in] pid
+  ///     The process ID to attach to.
+  ///
+  /// @param[out] error
+  ///     An error explaining what went wrong if attach fails.
+  ///
+  /// @return
+  ///      A process object for the attached process.
+  //------------------------------------------------------------------
+  lldb::SBProcess AttachToProcessWithID(SBListener &listener, lldb::pid_t pid,
+                                        lldb::SBError &error);
 
 #if defined(__APPLE__)
-    // We need to keep this around for a build or two since Xcode links
-    // to the 32 bit version of this function. We will take it out soon.
-    lldb::SBProcess
-    AttachToProcessWithID (SBListener &listener,
-                           ::pid_t pid,           // 32 bit int process ID
-                           lldb::SBError& error); // DEPRECATED 
+  // We need to keep this around for a build or two since Xcode links
+  // to the 32 bit version of this function. We will take it out soon.
+  lldb::SBProcess AttachToProcessWithID(SBListener &listener,
+                                        ::pid_t pid, // 32 bit int process ID
+                                        lldb::SBError &error); // DEPRECATED
 #endif
 
-    //------------------------------------------------------------------
-    /// Attach to process with name.
-    ///
-    /// @param[in] listener
-    ///     An optional listener that will receive all process events.
-    ///     If \a listener is valid then \a listener will listen to all
-    ///     process events. If not valid, then this target's debugger
-    ///     (SBTarget::GetDebugger()) will listen to all process events.
-    ///
-    /// @param[in] name
-    ///     Basename of process to attach to.
-    ///
-    /// @param[in] wait_for
-    ///     If true wait for a new instance of 'name' to be launched.
-    ///
-    /// @param[out] error
-    ///     An error explaining what went wrong if attach fails.
-    ///
-    /// @return
-    ///      A process object for the attached process.
-    //------------------------------------------------------------------
-    lldb::SBProcess
-    AttachToProcessWithName (SBListener &listener,
-                             const char *name,
-                             bool wait_for,
-                             lldb::SBError& error);
-
-    //------------------------------------------------------------------
-    /// Connect to a remote debug server with url.
-    ///
-    /// @param[in] listener
-    ///     An optional listener that will receive all process events.
-    ///     If \a listener is valid then \a listener will listen to all
-    ///     process events. If not valid, then this target's debugger
-    ///     (SBTarget::GetDebugger()) will listen to all process events.
-    ///
-    /// @param[in] url
-    ///     The url to connect to, e.g., 'connect://localhost:12345'.
-    ///
-    /// @param[in] plugin_name
-    ///     The plugin name to be used; can be nullptr.
-    ///
-    /// @param[out] error
-    ///     An error explaining what went wrong if the connect fails.
-    ///
-    /// @return
-    ///      A process object for the connected process.
-    //------------------------------------------------------------------
-    lldb::SBProcess
-    ConnectRemote (SBListener &listener,
-                   const char *url,
-                   const char *plugin_name,
-                   SBError& error);
-    
-    lldb::SBFileSpec
-    GetExecutable ();
-
-    bool
-    AddModule (lldb::SBModule &module);
-
-    lldb::SBModule
-    AddModule (const char *path,
-               const char *triple,
-               const char *uuid);
-
-    lldb::SBModule
-    AddModule (const char *path,
-               const char *triple,
-               const char *uuid_cstr,
-               const char *symfile);
-    
-    lldb::SBModule
-    AddModule (const SBModuleSpec &module_spec);
-
-    uint32_t
-    GetNumModules () const;
-
-    lldb::SBModule
-    GetModuleAtIndex (uint32_t idx);
-
-    bool
-    RemoveModule (lldb::SBModule module);
-
-    lldb::SBDebugger
-    GetDebugger() const;
-
-    lldb::SBModule
-    FindModule (const lldb::SBFileSpec &file_spec);
-
-    lldb::ByteOrder
-    GetByteOrder ();
-
-    uint32_t
-    GetAddressByteSize();
-
-    const char *
-    GetTriple ();
-
-    //------------------------------------------------------------------
-    /// Architecture data byte width accessor
-    ///
-    /// @return
-    /// The size in 8-bit (host) bytes of a minimum addressable
-    /// unit from the Architecture's data bus
-    //------------------------------------------------------------------
-    uint32_t
-    GetDataByteSize ();
-
-    //------------------------------------------------------------------
-    /// Architecture code byte width accessor
-    ///
-    /// @return
-    /// The size in 8-bit (host) bytes of a minimum addressable
-    /// unit from the Architecture's code bus
-    //------------------------------------------------------------------
-    uint32_t
-    GetCodeByteSize ();
-
-    //------------------------------------------------------------------
-    /// Set the base load address for a module section.
-    ///
-    /// @param[in] section
-    ///     The section whose base load address will be set within this
-    ///     target.
-    ///
-    /// @param[in] section_base_addr
-    ///     The base address for the section.
-    ///
-    /// @return
-    ///      An error to indicate success, fail, and any reason for 
-    ///     failure.
-    //------------------------------------------------------------------
-    lldb::SBError
-    SetSectionLoadAddress (lldb::SBSection section,
-                           lldb::addr_t section_base_addr);
-    
-    //------------------------------------------------------------------
-    /// Clear the base load address for a module section.
-    ///
-    /// @param[in] section
-    ///     The section whose base load address will be cleared within
-    ///     this target.
-    ///
-    /// @return
-    ///      An error to indicate success, fail, and any reason for 
-    ///     failure.
-    //------------------------------------------------------------------
-    lldb::SBError
-    ClearSectionLoadAddress (lldb::SBSection section);
-    
-    //------------------------------------------------------------------
-    /// Slide all file addresses for all module sections so that \a module
-    /// appears to loaded at these slide addresses.
-    /// 
-    /// When you need all sections within a module to be loaded at a 
-    /// rigid slide from the addresses found in the module object file,
-    /// this function will allow you to easily and quickly slide all
-    /// module sections.
-    ///
-    /// @param[in] module
-    ///     The module to load.
-    ///
-    /// @param[in] sections_offset
-    ///     An offset that will be applied to all section file addresses
-    ///     (the virtual addresses found in the object file itself).
-    ///
-    /// @return
-    ///     An error to indicate success, fail, and any reason for 
-    ///     failure.
-    //------------------------------------------------------------------
-    lldb::SBError
-    SetModuleLoadAddress (lldb::SBModule module,
-                          int64_t sections_offset);
-
-    //------------------------------------------------------------------
-    /// Clear the section base load addresses for all sections in a module.
-    /// 
-    /// @param[in] module
-    ///     The module to unload.
-    ///
-    /// @return
-    ///     An error to indicate success, fail, and any reason for 
-    ///     failure.
-    //------------------------------------------------------------------
-    lldb::SBError
-    ClearModuleLoadAddress (lldb::SBModule module);
-
-    //------------------------------------------------------------------
-    /// Find functions by name.
-    ///
-    /// @param[in] name
-    ///     The name of the function we are looking for.
-    ///
-    /// @param[in] name_type_mask
-    ///     A logical OR of one or more FunctionNameType enum bits that
-    ///     indicate what kind of names should be used when doing the
-    ///     lookup. Bits include fully qualified names, base names,
-    ///     C++ methods, or ObjC selectors. 
-    ///     See FunctionNameType for more details.
-    ///
-    /// @return
-    ///     A lldb::SBSymbolContextList that gets filled in with all of 
-    ///     the symbol contexts for all the matches.
-    //------------------------------------------------------------------
-    lldb::SBSymbolContextList
-    FindFunctions (const char *name, 
-                   uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
-
-    //------------------------------------------------------------------
-    /// Find global and static variables by name.
-    ///
-    /// @param[in] name
-    ///     The name of the global or static variable we are looking
-    ///     for.
-    ///
-    /// @param[in] max_matches
-    ///     Allow the number of matches to be limited to \a max_matches.
-    ///
-    /// @return
-    ///     A list of matched variables in an SBValueList.
-    //------------------------------------------------------------------
-    lldb::SBValueList
-    FindGlobalVariables (const char *name, 
-                         uint32_t max_matches);
-
-    //------------------------------------------------------------------
-    /// Find the first global (or static) variable by name.
-    ///
-    /// @param[in] name
-    ///     The name of the global or static variable we are looking
-    ///     for.
-    ///
-    /// @return
-    ///     An SBValue that gets filled in with the found variable (if any).
-    //------------------------------------------------------------------
-    lldb::SBValue
-    FindFirstGlobalVariable (const char* name);
-
-    //------------------------------------------------------------------
-    /// Find global and static variables by pattern.
-    ///
-    /// @param[in] name
-    ///     The pattern to search for global or static variables
-    ///
-    /// @param[in] max_matches
-    ///     Allow the number of matches to be limited to \a max_matches.
-    /// 
-    /// @param[in] matchtype
-    ///     The match type to use.    
-    ///
-    /// @return
-    ///     A list of matched variables in an SBValueList.
-    //------------------------------------------------------------------
-    lldb::SBValueList
-        FindGlobalVariables(const char *name,
-                            uint32_t max_matches,
-                            MatchType matchtype);
-    
-    //------------------------------------------------------------------
-    /// Find global functions by their name with pattern matching.
-    ///
-    /// @param[in] name
-    ///     The pattern to search for global or static variables
-    ///
-    /// @param[in] max_matches
-    ///     Allow the number of matches to be limited to \a max_matches.
-    /// 
-    /// @param[in] matchtype
-    ///     The match type to use.    
-    ///
-    /// @return
-    ///     A list of matched variables in an SBValueList.
-    //------------------------------------------------------------------
-    lldb::SBSymbolContextList
-        FindGlobalFunctions(const char *name,
-                           uint32_t max_matches,
-                           MatchType matchtype);
-
-    void
-    Clear ();
-
-    //------------------------------------------------------------------
-    /// Resolve a current file address into a section offset address.
-    ///
-    /// @param[in] file_addr
-    ///
-    /// @return
-    ///     An SBAddress which will be valid if...
-    //------------------------------------------------------------------
-    lldb::SBAddress
-    ResolveFileAddress (lldb::addr_t file_addr);
-
-    //------------------------------------------------------------------
-    /// Resolve a current load address into a section offset address.
-    ///
-    /// @param[in] vm_addr
-    ///     A virtual address from the current process state that is to
-    ///     be translated into a section offset address.
-    ///
-    /// @return
-    ///     An SBAddress which will be valid if \a vm_addr was
-    ///     successfully resolved into a section offset address, or an
-    ///     invalid SBAddress if \a vm_addr doesn't resolve to a section
-    ///     in a module.
-    //------------------------------------------------------------------
-    lldb::SBAddress
-    ResolveLoadAddress (lldb::addr_t vm_addr);
-
-    //------------------------------------------------------------------
-    /// Resolve a current load address into a section offset address
-    /// using the process stop ID to identify a time in the past.
-    ///
-    /// @param[in] stop_id
-    ///     Each time a process stops, the process stop ID integer gets
-    ///     incremented. These stop IDs are used to identify past times
-    ///     and can be used in history objects as a cheap way to store
-    ///     the time at which the sample was taken. Specifying
-    ///     UINT32_MAX will always resolve the address using the
-    ///     currently loaded sections.
-    ///
-    /// @param[in] vm_addr
-    ///     A virtual address from the current process state that is to
-    ///     be translated into a section offset address.
-    ///
-    /// @return
-    ///     An SBAddress which will be valid if \a vm_addr was
-    ///     successfully resolved into a section offset address, or an
-    ///     invalid SBAddress if \a vm_addr doesn't resolve to a section
-    ///     in a module.
-    //------------------------------------------------------------------
-    lldb::SBAddress
-    ResolvePastLoadAddress (uint32_t stop_id, lldb::addr_t vm_addr);
-
-    SBSymbolContext
-    ResolveSymbolContextForAddress (const SBAddress& addr, 
-                                    uint32_t resolve_scope);
-
-    //------------------------------------------------------------------
-    /// Read target memory. If a target process is running then memory  
-    /// is read from here. Otherwise the memory is read from the object
-    /// files. For a target whose bytes are sized as a multiple of host
-    /// bytes, the data read back will preserve the target's byte order.
-    ///
-    /// @param[in] addr
-    ///     A target address to read from. 
-    ///
-    /// @param[out] buf
-    ///     The buffer to read memory into. 
-    ///
-    /// @param[in] size
-    ///     The maximum number of host bytes to read in the buffer passed
-    ///     into this call
-    ///
-    /// @param[out] error
-    ///     Error information is written here if the memory read fails.
-    ///
-    /// @return
-    ///     The amount of data read in host bytes.
-    //------------------------------------------------------------------
-    size_t
-    ReadMemory (const SBAddress addr, void *buf, size_t size, lldb::SBError &error);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByLocation (const char *file, uint32_t line);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line, lldb::addr_t offset);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByName(const char *symbol_name, const char *module_name = nullptr);
-
-    // This version uses name_type_mask = eFunctionNameTypeAuto
-    lldb::SBBreakpoint
-    BreakpointCreateByName (const char *symbol_name, 
-                            const SBFileSpecList &module_list, 
-                            const SBFileSpecList &comp_unit_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByName (const char *symbol_name,
-                            uint32_t name_type_mask,           // Logical OR one or more FunctionNameType enum bits
-                            const SBFileSpecList &module_list, 
-                            const SBFileSpecList &comp_unit_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByName (const char *symbol_name,
-                            uint32_t name_type_mask,           // Logical OR one or more FunctionNameType enum bits
-                            lldb::LanguageType symbol_language,
-                            const SBFileSpecList &module_list, 
-                            const SBFileSpecList &comp_unit_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByNames (const char *symbol_name[],
-                             uint32_t num_names,
-                             uint32_t name_type_mask,           // Logical OR one or more FunctionNameType enum bits
-                             const SBFileSpecList &module_list,
-                             const SBFileSpecList &comp_unit_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByNames (const char *symbol_name[],
-                             uint32_t num_names,
-                             uint32_t name_type_mask,           // Logical OR one or more FunctionNameType enum bits
-                             lldb::LanguageType symbol_language,
-                             const SBFileSpecList &module_list,
-                             const SBFileSpecList &comp_unit_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByNames (const char *symbol_name[],
-                             uint32_t num_names,
-                             uint32_t name_type_mask,           // Logical OR one or more FunctionNameType enum bits
-                             lldb::LanguageType symbol_language,
-                             lldb::addr_t offset,
-                             const SBFileSpecList &module_list,
-                             const SBFileSpecList &comp_unit_list);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByRegex (const char *symbol_name_regex, const char *module_name = nullptr);
-    
-    lldb::SBBreakpoint
-    BreakpointCreateByRegex (const char *symbol_name_regex, 
-                             const SBFileSpecList &module_list, 
-                             const SBFileSpecList &comp_unit_list);
-    
-    lldb::SBBreakpoint
-    BreakpointCreateByRegex (const char *symbol_name_regex,
-                             lldb::LanguageType symbol_language,
-                             const SBFileSpecList &module_list, 
-                             const SBFileSpecList &comp_unit_list);
-    
-    lldb::SBBreakpoint
-    BreakpointCreateBySourceRegex(const char *source_regex,
-                                  const SBFileSpec &source_file,
-                                  const char *module_name = nullptr);
-
-    lldb::SBBreakpoint
-    BreakpointCreateBySourceRegex (const char *source_regex,
-                                   const SBFileSpecList &module_list,
-                                   const SBFileSpecList &source_file);
-    
-    lldb::SBBreakpoint
-    BreakpointCreateBySourceRegex (const char *source_regex,
-                                   const SBFileSpecList &module_list,
-                                   const SBFileSpecList &source_file,
-                                   const SBStringList  &func_names);
-    
-    lldb::SBBreakpoint
-    BreakpointCreateForException  (lldb::LanguageType language,
-                                   bool catch_bp,
-                                   bool throw_bp);
-
-    lldb::SBBreakpoint
-    BreakpointCreateByAddress (addr_t address);
-
-    lldb::SBBreakpoint
-    BreakpointCreateBySBAddress (SBAddress &address);
-
-    uint32_t
-    GetNumBreakpoints () const;
-
-    lldb::SBBreakpoint
-    GetBreakpointAtIndex (uint32_t idx) const;
-
-    bool
-    BreakpointDelete (break_id_t break_id);
-
-    lldb::SBBreakpoint
-    FindBreakpointByID (break_id_t break_id);
-
-    bool
-    EnableAllBreakpoints ();
-
-    bool
-    DisableAllBreakpoints ();
-
-    bool
-    DeleteAllBreakpoints ();
-
-    uint32_t
-    GetNumWatchpoints () const;
-
-    lldb::SBWatchpoint
-    GetWatchpointAtIndex (uint32_t idx) const;
-
-    bool
-    DeleteWatchpoint (lldb::watch_id_t watch_id);
-
-    lldb::SBWatchpoint
-    FindWatchpointByID (lldb::watch_id_t watch_id);
-
-    lldb::SBWatchpoint
-    WatchAddress (lldb::addr_t addr, size_t size, bool read, bool write, SBError& error);
-
-    bool
-    EnableAllWatchpoints ();
-
-    bool
-    DisableAllWatchpoints ();
-
-    bool
-    DeleteAllWatchpoints ();
-
-    lldb::SBBroadcaster
-    GetBroadcaster () const;
-    
-    lldb::SBType
-    FindFirstType (const char* type);
-    
-    lldb::SBTypeList
-    FindTypes (const char* type);
-    
-    lldb::SBType
-    GetBasicType(lldb::BasicType type);
-    
-    lldb::SBValue
-    CreateValueFromAddress (const char *name, lldb::SBAddress addr, lldb::SBType type);
-
-    lldb::SBValue
-    CreateValueFromData (const char *name, lldb::SBData data, lldb::SBType type);
-
-    lldb::SBValue
-    CreateValueFromExpression (const char *name, const char* expr);
-    
-    SBSourceManager
-    GetSourceManager();
-    
-    lldb::SBInstructionList
-    ReadInstructions (lldb::SBAddress base_addr, uint32_t count);
-
-    lldb::SBInstructionList
-    ReadInstructions (lldb::SBAddress base_addr, uint32_t count, const char *flavor_string);
-
-    lldb::SBInstructionList
-    GetInstructions (lldb::SBAddress base_addr, const void *buf, size_t size);
-    
-    // The "WithFlavor" is necessary to keep SWIG from getting confused about overloaded arguments when
-    // using the buf + size -> Python Object magic.
-    
-    lldb::SBInstructionList
-    GetInstructionsWithFlavor (lldb::SBAddress base_addr,  const char *flavor_string, const void *buf, size_t size);
-    
-    lldb::SBInstructionList
-    GetInstructions (lldb::addr_t base_addr, const void *buf, size_t size);
-
-    lldb::SBInstructionList
-    GetInstructionsWithFlavor (lldb::addr_t base_addr, const char *flavor_string, const void *buf, size_t size);
+  //------------------------------------------------------------------
+  /// Attach to process with name.
+  ///
+  /// @param[in] listener
+  ///     An optional listener that will receive all process events.
+  ///     If \a listener is valid then \a listener will listen to all
+  ///     process events. If not valid, then this target's debugger
+  ///     (SBTarget::GetDebugger()) will listen to all process events.
+  ///
+  /// @param[in] name
+  ///     Basename of process to attach to.
+  ///
+  /// @param[in] wait_for
+  ///     If true wait for a new instance of 'name' to be launched.
+  ///
+  /// @param[out] error
+  ///     An error explaining what went wrong if attach fails.
+  ///
+  /// @return
+  ///      A process object for the attached process.
+  //------------------------------------------------------------------
+  lldb::SBProcess AttachToProcessWithName(SBListener &listener,
+                                          const char *name, bool wait_for,
+                                          lldb::SBError &error);
+
+  //------------------------------------------------------------------
+  /// Connect to a remote debug server with url.
+  ///
+  /// @param[in] listener
+  ///     An optional listener that will receive all process events.
+  ///     If \a listener is valid then \a listener will listen to all
+  ///     process events. If not valid, then this target's debugger
+  ///     (SBTarget::GetDebugger()) will listen to all process events.
+  ///
+  /// @param[in] url
+  ///     The url to connect to, e.g., 'connect://localhost:12345'.
+  ///
+  /// @param[in] plugin_name
+  ///     The plugin name to be used; can be nullptr.
+  ///
+  /// @param[out] error
+  ///     An error explaining what went wrong if the connect fails.
+  ///
+  /// @return
+  ///      A process object for the connected process.
+  //------------------------------------------------------------------
+  lldb::SBProcess ConnectRemote(SBListener &listener, const char *url,
+                                const char *plugin_name, SBError &error);
+
+  lldb::SBFileSpec GetExecutable();
+
+  bool AddModule(lldb::SBModule &module);
+
+  lldb::SBModule AddModule(const char *path, const char *triple,
+                           const char *uuid);
+
+  lldb::SBModule AddModule(const char *path, const char *triple,
+                           const char *uuid_cstr, const char *symfile);
+
+  lldb::SBModule AddModule(const SBModuleSpec &module_spec);
+
+  uint32_t GetNumModules() const;
+
+  lldb::SBModule GetModuleAtIndex(uint32_t idx);
+
+  bool RemoveModule(lldb::SBModule module);
+
+  lldb::SBDebugger GetDebugger() const;
+
+  lldb::SBModule FindModule(const lldb::SBFileSpec &file_spec);
+
+  lldb::ByteOrder GetByteOrder();
+
+  uint32_t GetAddressByteSize();
+
+  const char *GetTriple();
+
+  //------------------------------------------------------------------
+  /// Architecture data byte width accessor
+  ///
+  /// @return
+  /// The size in 8-bit (host) bytes of a minimum addressable
+  /// unit from the Architecture's data bus
+  //------------------------------------------------------------------
+  uint32_t GetDataByteSize();
+
+  //------------------------------------------------------------------
+  /// Architecture code byte width accessor
+  ///
+  /// @return
+  /// The size in 8-bit (host) bytes of a minimum addressable
+  /// unit from the Architecture's code bus
+  //------------------------------------------------------------------
+  uint32_t GetCodeByteSize();
+
+  //------------------------------------------------------------------
+  /// Set the base load address for a module section.
+  ///
+  /// @param[in] section
+  ///     The section whose base load address will be set within this
+  ///     target.
+  ///
+  /// @param[in] section_base_addr
+  ///     The base address for the section.
+  ///
+  /// @return
+  ///      An error to indicate success, fail, and any reason for
+  ///     failure.
+  //------------------------------------------------------------------
+  lldb::SBError SetSectionLoadAddress(lldb::SBSection section,
+                                      lldb::addr_t section_base_addr);
+
+  //------------------------------------------------------------------
+  /// Clear the base load address for a module section.
+  ///
+  /// @param[in] section
+  ///     The section whose base load address will be cleared within
+  ///     this target.
+  ///
+  /// @return
+  ///      An error to indicate success, fail, and any reason for
+  ///     failure.
+  //------------------------------------------------------------------
+  lldb::SBError ClearSectionLoadAddress(lldb::SBSection section);
+
+  //------------------------------------------------------------------
+  /// Slide all file addresses for all module sections so that \a module
+  /// appears to loaded at these slide addresses.
+  ///
+  /// When you need all sections within a module to be loaded at a
+  /// rigid slide from the addresses found in the module object file,
+  /// this function will allow you to easily and quickly slide all
+  /// module sections.
+  ///
+  /// @param[in] module
+  ///     The module to load.
+  ///
+  /// @param[in] sections_offset
+  ///     An offset that will be applied to all section file addresses
+  ///     (the virtual addresses found in the object file itself).
+  ///
+  /// @return
+  ///     An error to indicate success, fail, and any reason for
+  ///     failure.
+  //------------------------------------------------------------------
+  lldb::SBError SetModuleLoadAddress(lldb::SBModule module,
+                                     int64_t sections_offset);
+
+  //------------------------------------------------------------------
+  /// Clear the section base load addresses for all sections in a module.
+  ///
+  /// @param[in] module
+  ///     The module to unload.
+  ///
+  /// @return
+  ///     An error to indicate success, fail, and any reason for
+  ///     failure.
+  //------------------------------------------------------------------
+  lldb::SBError ClearModuleLoadAddress(lldb::SBModule module);
+
+  //------------------------------------------------------------------
+  /// Find functions by name.
+  ///
+  /// @param[in] name
+  ///     The name of the function we are looking for.
+  ///
+  /// @param[in] name_type_mask
+  ///     A logical OR of one or more FunctionNameType enum bits that
+  ///     indicate what kind of names should be used when doing the
+  ///     lookup. Bits include fully qualified names, base names,
+  ///     C++ methods, or ObjC selectors.
+  ///     See FunctionNameType for more details.
+  ///
+  /// @return
+  ///     A lldb::SBSymbolContextList that gets filled in with all of
+  ///     the symbol contexts for all the matches.
+  //------------------------------------------------------------------
+  lldb::SBSymbolContextList
+  FindFunctions(const char *name,
+                uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
+
+  //------------------------------------------------------------------
+  /// Find global and static variables by name.
+  ///
+  /// @param[in] name
+  ///     The name of the global or static variable we are looking
+  ///     for.
+  ///
+  /// @param[in] max_matches
+  ///     Allow the number of matches to be limited to \a max_matches.
+  ///
+  /// @return
+  ///     A list of matched variables in an SBValueList.
+  //------------------------------------------------------------------
+  lldb::SBValueList FindGlobalVariables(const char *name, uint32_t max_matches);
+
+  //------------------------------------------------------------------
+  /// Find the first global (or static) variable by name.
+  ///
+  /// @param[in] name
+  ///     The name of the global or static variable we are looking
+  ///     for.
+  ///
+  /// @return
+  ///     An SBValue that gets filled in with the found variable (if any).
+  //------------------------------------------------------------------
+  lldb::SBValue FindFirstGlobalVariable(const char *name);
+
+  //------------------------------------------------------------------
+  /// Find global and static variables by pattern.
+  ///
+  /// @param[in] name
+  ///     The pattern to search for global or static variables
+  ///
+  /// @param[in] max_matches
+  ///     Allow the number of matches to be limited to \a max_matches.
+  ///
+  /// @param[in] matchtype
+  ///     The match type to use.
+  ///
+  /// @return
+  ///     A list of matched variables in an SBValueList.
+  //------------------------------------------------------------------
+  lldb::SBValueList FindGlobalVariables(const char *name, uint32_t max_matches,
+                                        MatchType matchtype);
+
+  //------------------------------------------------------------------
+  /// Find global functions by their name with pattern matching.
+  ///
+  /// @param[in] name
+  ///     The pattern to search for global or static variables
+  ///
+  /// @param[in] max_matches
+  ///     Allow the number of matches to be limited to \a max_matches.
+  ///
+  /// @param[in] matchtype
+  ///     The match type to use.
+  ///
+  /// @return
+  ///     A list of matched variables in an SBValueList.
+  //------------------------------------------------------------------
+  lldb::SBSymbolContextList FindGlobalFunctions(const char *name,
+                                                uint32_t max_matches,
+                                                MatchType matchtype);
+
+  void Clear();
+
+  //------------------------------------------------------------------
+  /// Resolve a current file address into a section offset address.
+  ///
+  /// @param[in] file_addr
+  ///
+  /// @return
+  ///     An SBAddress which will be valid if...
+  //------------------------------------------------------------------
+  lldb::SBAddress ResolveFileAddress(lldb::addr_t file_addr);
+
+  //------------------------------------------------------------------
+  /// Resolve a current load address into a section offset address.
+  ///
+  /// @param[in] vm_addr
+  ///     A virtual address from the current process state that is to
+  ///     be translated into a section offset address.
+  ///
+  /// @return
+  ///     An SBAddress which will be valid if \a vm_addr was
+  ///     successfully resolved into a section offset address, or an
+  ///     invalid SBAddress if \a vm_addr doesn't resolve to a section
+  ///     in a module.
+  //------------------------------------------------------------------
+  lldb::SBAddress ResolveLoadAddress(lldb::addr_t vm_addr);
+
+  //------------------------------------------------------------------
+  /// Resolve a current load address into a section offset address
+  /// using the process stop ID to identify a time in the past.
+  ///
+  /// @param[in] stop_id
+  ///     Each time a process stops, the process stop ID integer gets
+  ///     incremented. These stop IDs are used to identify past times
+  ///     and can be used in history objects as a cheap way to store
+  ///     the time at which the sample was taken. Specifying
+  ///     UINT32_MAX will always resolve the address using the
+  ///     currently loaded sections.
+  ///
+  /// @param[in] vm_addr
+  ///     A virtual address from the current process state that is to
+  ///     be translated into a section offset address.
+  ///
+  /// @return
+  ///     An SBAddress which will be valid if \a vm_addr was
+  ///     successfully resolved into a section offset address, or an
+  ///     invalid SBAddress if \a vm_addr doesn't resolve to a section
+  ///     in a module.
+  //------------------------------------------------------------------
+  lldb::SBAddress ResolvePastLoadAddress(uint32_t stop_id,
+                                         lldb::addr_t vm_addr);
+
+  SBSymbolContext ResolveSymbolContextForAddress(const SBAddress &addr,
+                                                 uint32_t resolve_scope);
+
+  //------------------------------------------------------------------
+  /// Read target memory. If a target process is running then memory
+  /// is read from here. Otherwise the memory is read from the object
+  /// files. For a target whose bytes are sized as a multiple of host
+  /// bytes, the data read back will preserve the target's byte order.
+  ///
+  /// @param[in] addr
+  ///     A target address to read from.
+  ///
+  /// @param[out] buf
+  ///     The buffer to read memory into.
+  ///
+  /// @param[in] size
+  ///     The maximum number of host bytes to read in the buffer passed
+  ///     into this call
+  ///
+  /// @param[out] error
+  ///     Error information is written here if the memory read fails.
+  ///
+  /// @return
+  ///     The amount of data read in host bytes.
+  //------------------------------------------------------------------
+  size_t ReadMemory(const SBAddress addr, void *buf, size_t size,
+                    lldb::SBError &error);
+
+  lldb::SBBreakpoint BreakpointCreateByLocation(const char *file,
+                                                uint32_t line);
+
+  lldb::SBBreakpoint
+  BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line);
+
+  lldb::SBBreakpoint
+  BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line,
+                             lldb::addr_t offset);
+
+  lldb::SBBreakpoint
+  BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line,
+                             lldb::addr_t offset, SBFileSpecList &module_list);
+
+  lldb::SBBreakpoint BreakpointCreateByName(const char *symbol_name,
+                                            const char *module_name = nullptr);
+
+  // This version uses name_type_mask = eFunctionNameTypeAuto
+  lldb::SBBreakpoint
+  BreakpointCreateByName(const char *symbol_name,
+                         const SBFileSpecList &module_list,
+                         const SBFileSpecList &comp_unit_list);
+
+  lldb::SBBreakpoint BreakpointCreateByName(
+      const char *symbol_name,
+      uint32_t
+          name_type_mask, // Logical OR one or more FunctionNameType enum bits
+      const SBFileSpecList &module_list,
+      const SBFileSpecList &comp_unit_list);
+
+  lldb::SBBreakpoint BreakpointCreateByName(
+      const char *symbol_name,
+      uint32_t
+          name_type_mask, // Logical OR one or more FunctionNameType enum bits
+      lldb::LanguageType symbol_language,
+      const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list);
+
+  lldb::SBBreakpoint BreakpointCreateByNames(
+      const char *symbol_name[], uint32_t num_names,
+      uint32_t
+          name_type_mask, // Logical OR one or more FunctionNameType enum bits
+      const SBFileSpecList &module_list,
+      const SBFileSpecList &comp_unit_list);
+
+  lldb::SBBreakpoint BreakpointCreateByNames(
+      const char *symbol_name[], uint32_t num_names,
+      uint32_t
+          name_type_mask, // Logical OR one or more FunctionNameType enum bits
+      lldb::LanguageType symbol_language,
+      const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list);
+
+  lldb::SBBreakpoint BreakpointCreateByNames(
+      const char *symbol_name[], uint32_t num_names,
+      uint32_t
+          name_type_mask, // Logical OR one or more FunctionNameType enum bits
+      lldb::LanguageType symbol_language,
+      lldb::addr_t offset, const SBFileSpecList &module_list,
+      const SBFileSpecList &comp_unit_list);
+
+  lldb::SBBreakpoint BreakpointCreateByRegex(const char *symbol_name_regex,
+                                             const char *module_name = nullptr);
+
+  lldb::SBBreakpoint
+  BreakpointCreateByRegex(const char *symbol_name_regex,
+                          const SBFileSpecList &module_list,
+                          const SBFileSpecList &comp_unit_list);
+
+  lldb::SBBreakpoint BreakpointCreateByRegex(
+      const char *symbol_name_regex, lldb::LanguageType symbol_language,
+      const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list);
+
+  lldb::SBBreakpoint
+  BreakpointCreateBySourceRegex(const char *source_regex,
+                                const SBFileSpec &source_file,
+                                const char *module_name = nullptr);
+
+  lldb::SBBreakpoint
+  BreakpointCreateBySourceRegex(const char *source_regex,
+                                const SBFileSpecList &module_list,
+                                const SBFileSpecList &source_file);
+
+  lldb::SBBreakpoint BreakpointCreateBySourceRegex(
+      const char *source_regex, const SBFileSpecList &module_list,
+      const SBFileSpecList &source_file, const SBStringList &func_names);
+
+  lldb::SBBreakpoint BreakpointCreateForException(lldb::LanguageType language,
+                                                  bool catch_bp, bool throw_bp);
+
+  lldb::SBBreakpoint BreakpointCreateByAddress(addr_t address);
+
+  lldb::SBBreakpoint BreakpointCreateBySBAddress(SBAddress &address);
+
+  //------------------------------------------------------------------
+  /// Read breakpoints from source_file and return the newly created
+  /// breakpoints in bkpt_list.
+  ///
+  /// @param[in] source_file
+  ///    The file from which to read the breakpoints.
+  ///
+  /// @param[out] bkpt_list
+  ///    A list of the newly created breakpoints.
+  ///
+  /// @return
+  ///     An SBError detailing any errors in reading in the breakpoints.
+  //------------------------------------------------------------------
+  lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
+                                          SBBreakpointList &new_bps);
+
+  //------------------------------------------------------------------
+  /// Read breakpoints from source_file and return the newly created
+  /// breakpoints in bkpt_list.
+  ///
+  /// @param[in] source_file
+  ///    The file from which to read the breakpoints.
+  ///
+  /// @param[in] matching_names
+  ///    Only read in breakpoints whose names match one of the names in this
+  ///    list.
+  ///
+  /// @param[out] bkpt_list
+  ///    A list of the newly created breakpoints.
+  ///
+  /// @return
+  ///     An SBError detailing any errors in reading in the breakpoints.
+  //------------------------------------------------------------------
+  lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
+                                          SBStringList &matching_names,
+                                          SBBreakpointList &new_bps);
+
+  //------------------------------------------------------------------
+  /// Write breakpoints to dest_file.
+  ///
+  /// @param[in] dest_file
+  ///    The file to which to write the breakpoints.
+  ///
+  /// @return
+  ///     An SBError detailing any errors in writing in the breakpoints.
+  //------------------------------------------------------------------
+  lldb::SBError BreakpointsWriteToFile(SBFileSpec &dest_file);
+
+  //------------------------------------------------------------------
+  /// Write breakpoints listed in bkpt_list to dest_file.
+  ///
+  /// @param[in] dest_file
+  ///    The file to which to write the breakpoints.
+  ///
+  /// @param[in] bkpt_list
+  ///    Only write breakpoints from this list.
+  ///
+  /// @param[in] append
+  ///    If \btrue, append the breakpoints in bkpt_list to the others
+  ///    serialized in dest_file.  If dest_file doesn't exist, then a new
+  ///    file will be created and the breakpoints in bkpt_list written to it.
+  ///
+  /// @return
+  ///     An SBError detailing any errors in writing in the breakpoints.
+  //------------------------------------------------------------------
+  lldb::SBError BreakpointsWriteToFile(SBFileSpec &dest_file,
+                                       SBBreakpointList &bkpt_list,
+                                       bool append = false);
+
+  uint32_t GetNumBreakpoints() const;
+
+  lldb::SBBreakpoint GetBreakpointAtIndex(uint32_t idx) const;
+
+  bool BreakpointDelete(break_id_t break_id);
+
+  lldb::SBBreakpoint FindBreakpointByID(break_id_t break_id);
+
+  // Finds all breakpoints by name, returning the list in bkpt_list.  Returns
+  // false if the name is not a valid breakpoint name, true otherwise.
+  bool FindBreakpointsByName(const char *name, SBBreakpointList &bkpt_list);
+
+  bool EnableAllBreakpoints();
+
+  bool DisableAllBreakpoints();
+
+  bool DeleteAllBreakpoints();
+
+  uint32_t GetNumWatchpoints() const;
+
+  lldb::SBWatchpoint GetWatchpointAtIndex(uint32_t idx) const;
+
+  bool DeleteWatchpoint(lldb::watch_id_t watch_id);
+
+  lldb::SBWatchpoint FindWatchpointByID(lldb::watch_id_t watch_id);
+
+  lldb::SBWatchpoint WatchAddress(lldb::addr_t addr, size_t size, bool read,
+                                  bool write, SBError &error);
+
+  bool EnableAllWatchpoints();
+
+  bool DisableAllWatchpoints();
+
+  bool DeleteAllWatchpoints();
+
+  lldb::SBBroadcaster GetBroadcaster() const;
+
+  lldb::SBType FindFirstType(const char *type);
+
+  lldb::SBTypeList FindTypes(const char *type);
+
+  lldb::SBType GetBasicType(lldb::BasicType type);
+
+  lldb::SBValue CreateValueFromAddress(const char *name, lldb::SBAddress addr,
+                                       lldb::SBType type);
+
+  lldb::SBValue CreateValueFromData(const char *name, lldb::SBData data,
+                                    lldb::SBType type);
+
+  lldb::SBValue CreateValueFromExpression(const char *name, const char *expr);
+
+  SBSourceManager GetSourceManager();
+
+  lldb::SBInstructionList ReadInstructions(lldb::SBAddress base_addr,
+                                           uint32_t count);
+
+  lldb::SBInstructionList ReadInstructions(lldb::SBAddress base_addr,
+                                           uint32_t count,
+                                           const char *flavor_string);
+
+  lldb::SBInstructionList GetInstructions(lldb::SBAddress base_addr,
+                                          const void *buf, size_t size);
+
+  // The "WithFlavor" is necessary to keep SWIG from getting confused about
+  // overloaded arguments when
+  // using the buf + size -> Python Object magic.
+
+  lldb::SBInstructionList GetInstructionsWithFlavor(lldb::SBAddress base_addr,
+                                                    const char *flavor_string,
+                                                    const void *buf,
+                                                    size_t size);
+
+  lldb::SBInstructionList GetInstructions(lldb::addr_t base_addr,
+                                          const void *buf, size_t size);
+
+  lldb::SBInstructionList GetInstructionsWithFlavor(lldb::addr_t base_addr,
+                                                    const char *flavor_string,
+                                                    const void *buf,
+                                                    size_t size);
+
+  lldb::SBSymbolContextList FindSymbols(const char *name,
+                                        lldb::SymbolType type = eSymbolTypeAny);
+
+  bool operator==(const lldb::SBTarget &rhs) const;
 
-    lldb::SBSymbolContextList
-    FindSymbols (const char *name,
-                 lldb::SymbolType type = eSymbolTypeAny);
+  bool operator!=(const lldb::SBTarget &rhs) const;
 
-    bool
-    operator == (const lldb::SBTarget &rhs) const;
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::DescriptionLevel description_level);
 
-    bool
-    operator != (const lldb::SBTarget &rhs) const;
+  lldb::SBValue EvaluateExpression(const char *expr);
 
-    bool
-    GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level);
+  lldb::SBValue EvaluateExpression(const char *expr,
+                                   const SBExpressionOptions &options);
 
-    lldb::SBValue
-    EvaluateExpression (const char *expr);
+  lldb::addr_t GetStackRedZoneSize();
 
-    lldb::SBValue
-    EvaluateExpression (const char *expr, const SBExpressionOptions &options);
+  lldb::SBLaunchInfo GetLaunchInfo() const;
 
-    lldb::addr_t
-    GetStackRedZoneSize();
+  void SetLaunchInfo(const lldb::SBLaunchInfo &launch_info);
 
-    lldb::SBLaunchInfo
-    GetLaunchInfo () const;
-
-    void
-    SetLaunchInfo (const lldb::SBLaunchInfo &launch_info);
-    
 protected:
-    friend class SBAddress;
-    friend class SBBlock;
-    friend class SBDebugger;
-    friend class SBExecutionContext;
-    friend class SBFunction;
-    friend class SBInstruction;
-    friend class SBModule;
-    friend class SBProcess;
-    friend class SBSection;
-    friend class SBSourceManager;
-    friend class SBSymbol;
-    friend class SBValue;
-
-    //------------------------------------------------------------------
-    // Constructors are private, use static Target::Create function to
-    // create an instance of this class.
-    //------------------------------------------------------------------
-
-    lldb::TargetSP
-    GetSP () const;
-
-    void
-    SetSP (const lldb::TargetSP& target_sp);
+  friend class SBAddress;
+  friend class SBBlock;
+  friend class SBBreakpointList;
+  friend class SBDebugger;
+  friend class SBExecutionContext;
+  friend class SBFunction;
+  friend class SBInstruction;
+  friend class SBModule;
+  friend class SBProcess;
+  friend class SBSection;
+  friend class SBSourceManager;
+  friend class SBSymbol;
+  friend class SBValue;
+
+  //------------------------------------------------------------------
+  // Constructors are private, use static Target::Create function to
+  // create an instance of this class.
+  //------------------------------------------------------------------
+
+  lldb::TargetSP GetSP() const;
+
+  void SetSP(const lldb::TargetSP &target_sp);
 
 private:
-    lldb::TargetSP m_opaque_sp;
+  lldb::TargetSP m_opaque_sp;
 };
 
 } // namespace lldb
diff --git a/include/lldb/API/SBThread.h b/include/lldb/API/SBThread.h
index c1ce216f9be6..502e5c973ef5 100644
--- a/include/lldb/API/SBThread.h
+++ b/include/lldb/API/SBThread.h
@@ -18,254 +18,203 @@ namespace lldb {
 
 class SBFrame;
 
-class LLDB_API SBThread
-{
+class LLDB_API SBThread {
 public:
-    enum
-    {
-        eBroadcastBitStackChanged           = (1 << 0),
-        eBroadcastBitThreadSuspended        = (1 << 1),
-        eBroadcastBitThreadResumed          = (1 << 2),
-        eBroadcastBitSelectedFrameChanged   = (1 << 3),
-        eBroadcastBitThreadSelected         = (1 << 4)
-    };
-
-    static const char *
-    GetBroadcasterClassName ();
-    
-    SBThread ();
-
-    SBThread (const lldb::SBThread &thread);
-    
-    SBThread (const lldb::ThreadSP& lldb_object_sp);
-
-   ~SBThread();
-
-    lldb::SBQueue
-    GetQueue () const;
-
-    bool
-    IsValid() const;
-
-    void
-    Clear ();
-
-    lldb::StopReason
-    GetStopReason();
-
-    /// Get the number of words associated with the stop reason.
-    /// See also GetStopReasonDataAtIndex().
-    size_t
-    GetStopReasonDataCount();
-
-    //--------------------------------------------------------------------------
-    /// Get information associated with a stop reason.
-    ///
-    /// Breakpoint stop reasons will have data that consists of pairs of 
-    /// breakpoint IDs followed by the breakpoint location IDs (they always come
-    /// in pairs).
-    ///
-    /// Stop Reason              Count Data Type
-    /// ======================== ===== =========================================
-    /// eStopReasonNone          0
-    /// eStopReasonTrace         0
-    /// eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
-    /// eStopReasonWatchpoint    1     watchpoint id
-    /// eStopReasonSignal        1     unix signal number
-    /// eStopReasonException     N     exception data
-    /// eStopReasonExec          0
-    /// eStopReasonPlanComplete  0
-    //--------------------------------------------------------------------------
-    uint64_t
-    GetStopReasonDataAtIndex(uint32_t idx);
-    
-    bool
-    GetStopReasonExtendedInfoAsJSON (lldb::SBStream &stream);
-    
-    SBThreadCollection
-    GetStopReasonExtendedBacktraces (InstrumentationRuntimeType type);
-    
-    size_t
-    GetStopDescription (char *dst, size_t dst_len);
-    
-    SBValue
-    GetStopReturnValue ();
-
-    lldb::tid_t
-    GetThreadID () const;
-
-    uint32_t
-    GetIndexID () const;
-
-    const char *
-    GetName () const;
-
-    const char *
-    GetQueueName() const;
-
-    lldb::queue_id_t
-    GetQueueID() const;
-
-    bool
-    GetInfoItemByPathAsString ( const char *path, SBStream &strm);
-
-    void
-    StepOver (lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
-
-    void
-    StepInto (lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
-
-    void
-    StepInto (const char *target_name, lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
-    
-    void
-    StepInto (const char *target_name,
-              uint32_t end_line,
-              SBError &error,
-              lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
-    
-    void
-    StepOut ();
-
-    void
-    StepOutOfFrame (lldb::SBFrame &frame);
-
-    void
-    StepInstruction(bool step_over);
-
-    SBError
-    StepOverUntil (lldb::SBFrame &frame, 
-                   lldb::SBFileSpec &file_spec, 
-                   uint32_t line);
-
-    SBError
-    StepUsingScriptedThreadPlan (const char *script_class_name);
-
-    SBError
-    JumpToLine (lldb::SBFileSpec &file_spec, uint32_t line);
-
-    void
-    RunToAddress (lldb::addr_t addr);
-    
-    SBError
-    ReturnFromFrame (SBFrame &frame, SBValue &return_value);
-
-    SBError
-    UnwindInnermostExpression();
-
-    //--------------------------------------------------------------------------
-    /// LLDB currently supports process centric debugging which means when any
-    /// thread in a process stops, all other threads are stopped. The Suspend()
-    /// call here tells our process to suspend a thread and not let it run when
-    /// the other threads in a process are allowed to run. So when 
-    /// SBProcess::Continue() is called, any threads that aren't suspended will
-    /// be allowed to run. If any of the SBThread functions for stepping are 
-    /// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddress), the
-    /// thread will not be allowed to run and these functions will simply return.
-    ///
-    /// Eventually we plan to add support for thread centric debugging where
-    /// each thread is controlled individually and each thread would broadcast
-    /// its state, but we haven't implemented this yet.
-    /// 
-    /// Likewise the SBThread::Resume() call will again allow the thread to run
-    /// when the process is continued.
-    ///
-    /// Suspend() and Resume() functions are not currently reference counted, if
-    /// anyone has the need for them to be reference counted, please let us
-    /// know.
-    //--------------------------------------------------------------------------
-    bool
-    Suspend();
-    
-    bool
-    Resume ();
-    
-    bool
-    IsSuspended();
-
-    bool
-    IsStopped();
-
-    uint32_t
-    GetNumFrames ();
-
-    lldb::SBFrame
-    GetFrameAtIndex (uint32_t idx);
-
-    lldb::SBFrame
-    GetSelectedFrame ();
-
-    lldb::SBFrame
-    SetSelectedFrame (uint32_t frame_idx);
-    
-    static bool
-    EventIsThreadEvent (const SBEvent &event);
-    
-    static SBFrame
-    GetStackFrameFromEvent (const SBEvent &event);
-    
-    static SBThread
-    GetThreadFromEvent (const SBEvent &event);
-
-    lldb::SBProcess
-    GetProcess ();
-
-    const lldb::SBThread &
-    operator = (const lldb::SBThread &rhs);
-
-    bool
-    operator == (const lldb::SBThread &rhs) const;
-
-    bool
-    operator != (const lldb::SBThread &rhs) const;
-
-    bool
-    GetDescription (lldb::SBStream &description) const;
-    
-    bool
-    GetStatus (lldb::SBStream &status) const;
-
-    SBThread
-    GetExtendedBacktraceThread (const char *type);
-
-    uint32_t
-    GetExtendedBacktraceOriginatingIndexID ();
-
-    bool
-    SafeToCallFunctions ();
+  enum {
+    eBroadcastBitStackChanged = (1 << 0),
+    eBroadcastBitThreadSuspended = (1 << 1),
+    eBroadcastBitThreadResumed = (1 << 2),
+    eBroadcastBitSelectedFrameChanged = (1 << 3),
+    eBroadcastBitThreadSelected = (1 << 4)
+  };
+
+  static const char *GetBroadcasterClassName();
+
+  SBThread();
+
+  SBThread(const lldb::SBThread &thread);
+
+  SBThread(const lldb::ThreadSP &lldb_object_sp);
+
+  ~SBThread();
+
+  lldb::SBQueue GetQueue() const;
+
+  bool IsValid() const;
+
+  void Clear();
+
+  lldb::StopReason GetStopReason();
+
+  /// Get the number of words associated with the stop reason.
+  /// See also GetStopReasonDataAtIndex().
+  size_t GetStopReasonDataCount();
+
+  //--------------------------------------------------------------------------
+  /// Get information associated with a stop reason.
+  ///
+  /// Breakpoint stop reasons will have data that consists of pairs of
+  /// breakpoint IDs followed by the breakpoint location IDs (they always come
+  /// in pairs).
+  ///
+  /// Stop Reason              Count Data Type
+  /// ======================== ===== =========================================
+  /// eStopReasonNone          0
+  /// eStopReasonTrace         0
+  /// eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
+  /// eStopReasonWatchpoint    1     watchpoint id
+  /// eStopReasonSignal        1     unix signal number
+  /// eStopReasonException     N     exception data
+  /// eStopReasonExec          0
+  /// eStopReasonPlanComplete  0
+  //--------------------------------------------------------------------------
+  uint64_t GetStopReasonDataAtIndex(uint32_t idx);
+
+  bool GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream);
+
+  SBThreadCollection
+  GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type);
+
+  size_t GetStopDescription(char *dst, size_t dst_len);
+
+  SBValue GetStopReturnValue();
+
+  lldb::tid_t GetThreadID() const;
+
+  uint32_t GetIndexID() const;
+
+  const char *GetName() const;
+
+  const char *GetQueueName() const;
+
+  lldb::queue_id_t GetQueueID() const;
+
+  bool GetInfoItemByPathAsString(const char *path, SBStream &strm);
+
+  void StepOver(lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
+
+  void StepInto(lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
+
+  void StepInto(const char *target_name,
+                lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
+
+  void StepInto(const char *target_name, uint32_t end_line, SBError &error,
+                lldb::RunMode stop_other_threads = lldb::eOnlyDuringStepping);
+
+  void StepOut();
+
+  void StepOutOfFrame(lldb::SBFrame &frame);
+
+  void StepInstruction(bool step_over);
+
+  SBError StepOverUntil(lldb::SBFrame &frame, lldb::SBFileSpec &file_spec,
+                        uint32_t line);
+
+  SBError StepUsingScriptedThreadPlan(const char *script_class_name);
+
+  SBError StepUsingScriptedThreadPlan(const char *script_class_name,
+                                      bool resume_immediately);
+
+  SBError JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line);
+
+  void RunToAddress(lldb::addr_t addr);
+
+  SBError ReturnFromFrame(SBFrame &frame, SBValue &return_value);
+
+  SBError UnwindInnermostExpression();
+
+  //--------------------------------------------------------------------------
+  /// LLDB currently supports process centric debugging which means when any
+  /// thread in a process stops, all other threads are stopped. The Suspend()
+  /// call here tells our process to suspend a thread and not let it run when
+  /// the other threads in a process are allowed to run. So when
+  /// SBProcess::Continue() is called, any threads that aren't suspended will
+  /// be allowed to run. If any of the SBThread functions for stepping are
+  /// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddress), the
+  /// thread will not be allowed to run and these functions will simply return.
+  ///
+  /// Eventually we plan to add support for thread centric debugging where
+  /// each thread is controlled individually and each thread would broadcast
+  /// its state, but we haven't implemented this yet.
+  ///
+  /// Likewise the SBThread::Resume() call will again allow the thread to run
+  /// when the process is continued.
+  ///
+  /// Suspend() and Resume() functions are not currently reference counted, if
+  /// anyone has the need for them to be reference counted, please let us
+  /// know.
+  //--------------------------------------------------------------------------
+  bool Suspend();
+
+  bool Resume();
+
+  bool IsSuspended();
+
+  bool IsStopped();
+
+  uint32_t GetNumFrames();
+
+  lldb::SBFrame GetFrameAtIndex(uint32_t idx);
+
+  lldb::SBFrame GetSelectedFrame();
+
+  lldb::SBFrame SetSelectedFrame(uint32_t frame_idx);
+
+  static bool EventIsThreadEvent(const SBEvent &event);
+
+  static SBFrame GetStackFrameFromEvent(const SBEvent &event);
+
+  static SBThread GetThreadFromEvent(const SBEvent &event);
+
+  lldb::SBProcess GetProcess();
+
+  const lldb::SBThread &operator=(const lldb::SBThread &rhs);
+
+  bool operator==(const lldb::SBThread &rhs) const;
+
+  bool operator!=(const lldb::SBThread &rhs) const;
+
+  bool GetDescription(lldb::SBStream &description) const;
+
+  bool GetDescription(lldb::SBStream &description, bool stop_format) const;
+
+  bool GetStatus(lldb::SBStream &status) const;
+
+  SBThread GetExtendedBacktraceThread(const char *type);
+
+  uint32_t GetExtendedBacktraceOriginatingIndexID();
+
+  bool SafeToCallFunctions();
 
 #ifndef SWIG
-    lldb_private::Thread *
-    operator->();
+  lldb_private::Thread *operator->();
 
-    lldb_private::Thread *
-    get();
+  lldb_private::Thread *get();
 
 #endif
 
 protected:
-    friend class SBBreakpoint;
-    friend class SBBreakpointLocation;
-    friend class SBExecutionContext;
-    friend class SBFrame;
-    friend class SBProcess;
-    friend class SBDebugger;
-    friend class SBValue;
-    friend class lldb_private::QueueImpl;
-    friend class SBQueueItem;
-
-    void
-    SetThread (const lldb::ThreadSP& lldb_object_sp);
+  friend class SBBreakpoint;
+  friend class SBBreakpointLocation;
+  friend class SBExecutionContext;
+  friend class SBFrame;
+  friend class SBProcess;
+  friend class SBDebugger;
+  friend class SBValue;
+  friend class lldb_private::QueueImpl;
+  friend class SBQueueItem;
+
+  void SetThread(const lldb::ThreadSP &lldb_object_sp);
 
 #ifndef SWIG
-    SBError
-    ResumeNewPlan (lldb_private::ExecutionContext &exe_ctx, lldb_private::ThreadPlan *new_plan);
+  SBError ResumeNewPlan(lldb_private::ExecutionContext &exe_ctx,
+                        lldb_private::ThreadPlan *new_plan);
 #endif
 
 private:
-    lldb::ExecutionContextRefSP m_opaque_sp;
+  lldb::ExecutionContextRefSP m_opaque_sp;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBThread_h_
+#endif // LLDB_SBThread_h_
diff --git a/include/lldb/API/SBThreadCollection.h b/include/lldb/API/SBThreadCollection.h
index 79f977454497..715b0826b962 100644
--- a/include/lldb/API/SBThreadCollection.h
+++ b/include/lldb/API/SBThreadCollection.h
@@ -13,57 +13,44 @@
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
-    
-class LLDB_API SBThreadCollection
-{
+
+class LLDB_API SBThreadCollection {
 public:
-    
-    SBThreadCollection ();
-    
-    SBThreadCollection (const SBThreadCollection &rhs);
-    
-    const SBThreadCollection &
-    operator = (const SBThreadCollection &rhs);
-    
-    ~SBThreadCollection ();
-    
-    bool
-    IsValid () const;
-    
-    size_t
-    GetSize ();
-    
-    lldb::SBThread
-    GetThreadAtIndex (size_t idx);
-    
+  SBThreadCollection();
+
+  SBThreadCollection(const SBThreadCollection &rhs);
+
+  const SBThreadCollection &operator=(const SBThreadCollection &rhs);
+
+  ~SBThreadCollection();
+
+  bool IsValid() const;
+
+  size_t GetSize();
+
+  lldb::SBThread GetThreadAtIndex(size_t idx);
+
 protected:
-    
-    // Mimic shared pointer...
-    lldb_private::ThreadCollection *
-    get() const;
-    
-    lldb_private::ThreadCollection *
-    operator->() const;
-    
-    lldb::ThreadCollectionSP &
-    operator*();
-    
-    const lldb::ThreadCollectionSP &
-    operator*() const;
-    
-    SBThreadCollection (const lldb::ThreadCollectionSP &threads);
-
-    void
-    SetOpaque (const lldb::ThreadCollectionSP &threads);
-    
+  // Mimic shared pointer...
+  lldb_private::ThreadCollection *get() const;
+
+  lldb_private::ThreadCollection *operator->() const;
+
+  lldb::ThreadCollectionSP &operator*();
+
+  const lldb::ThreadCollectionSP &operator*() const;
+
+  SBThreadCollection(const lldb::ThreadCollectionSP &threads);
+
+  void SetOpaque(const lldb::ThreadCollectionSP &threads);
+
 private:
-    friend class SBProcess;
-    friend class SBThread;
-    
-    lldb::ThreadCollectionSP m_opaque_sp;
+  friend class SBProcess;
+  friend class SBThread;
+
+  lldb::ThreadCollectionSP m_opaque_sp;
 };
-    
-    
+
 } // namespace lldb
 
 #endif // LLDB_SBThreadCollection_h_
diff --git a/include/lldb/API/SBThreadPlan.h b/include/lldb/API/SBThreadPlan.h
index 9cc0d0b89bb5..abc14bf8fe4a 100644
--- a/include/lldb/API/SBThreadPlan.h
+++ b/include/lldb/API/SBThreadPlan.h
@@ -16,114 +16,100 @@
 
 namespace lldb {
 
-class LLDB_API SBThreadPlan
-{
+class LLDB_API SBThreadPlan {
 
-friend class lldb_private::ThreadPlan;
+  friend class lldb_private::ThreadPlan;
 
 public:
-    SBThreadPlan ();
+  SBThreadPlan();
 
-    SBThreadPlan (const lldb::SBThreadPlan &threadPlan);
-    
-    SBThreadPlan (const lldb::ThreadPlanSP& lldb_object_sp);
+  SBThreadPlan(const lldb::SBThreadPlan &threadPlan);
 
-    SBThreadPlan (lldb::SBThread &thread, const char *class_name);
+  SBThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);
 
-   ~SBThreadPlan ();
+  SBThreadPlan(lldb::SBThread &thread, const char *class_name);
 
-    bool
-    IsValid() const;
+  ~SBThreadPlan();
 
-    void
-    Clear ();
+  bool IsValid() const;
 
-    lldb::StopReason
-    GetStopReason();
+  void Clear();
 
-    /// Get the number of words associated with the stop reason.
-    /// See also GetStopReasonDataAtIndex().
-    size_t
-    GetStopReasonDataCount();
+  lldb::StopReason GetStopReason();
 
-    //--------------------------------------------------------------------------
-    /// Get information associated with a stop reason.
-    ///
-    /// Breakpoint stop reasons will have data that consists of pairs of 
-    /// breakpoint IDs followed by the breakpoint location IDs (they always come
-    /// in pairs).
-    ///
-    /// Stop Reason              Count Data Type
-    /// ======================== ===== =========================================
-    /// eStopReasonNone          0
-    /// eStopReasonTrace         0
-    /// eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
-    /// eStopReasonWatchpoint    1     watchpoint id
-    /// eStopReasonSignal        1     unix signal number
-    /// eStopReasonException     N     exception data
-    /// eStopReasonExec          0
-    /// eStopReasonPlanComplete  0
-    //--------------------------------------------------------------------------
-    uint64_t
-    GetStopReasonDataAtIndex(uint32_t idx);
+  /// Get the number of words associated with the stop reason.
+  /// See also GetStopReasonDataAtIndex().
+  size_t GetStopReasonDataCount();
 
-    SBThread
-    GetThread () const;
+  //--------------------------------------------------------------------------
+  /// Get information associated with a stop reason.
+  ///
+  /// Breakpoint stop reasons will have data that consists of pairs of
+  /// breakpoint IDs followed by the breakpoint location IDs (they always come
+  /// in pairs).
+  ///
+  /// Stop Reason              Count Data Type
+  /// ======================== ===== =========================================
+  /// eStopReasonNone          0
+  /// eStopReasonTrace         0
+  /// eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
+  /// eStopReasonWatchpoint    1     watchpoint id
+  /// eStopReasonSignal        1     unix signal number
+  /// eStopReasonException     N     exception data
+  /// eStopReasonExec          0
+  /// eStopReasonPlanComplete  0
+  //--------------------------------------------------------------------------
+  uint64_t GetStopReasonDataAtIndex(uint32_t idx);
 
-    const lldb::SBThreadPlan &
-    operator = (const lldb::SBThreadPlan &rhs);
+  SBThread GetThread() const;
 
-    bool
-    GetDescription (lldb::SBStream &description) const;
+  const lldb::SBThreadPlan &operator=(const lldb::SBThreadPlan &rhs);
 
-    void
-    SetPlanComplete (bool success);
+  bool GetDescription(lldb::SBStream &description) const;
 
-    bool
-    IsPlanComplete();
+  void SetPlanComplete(bool success);
 
-    bool
-    IsValid();
+  bool IsPlanComplete();
 
-    // This section allows an SBThreadPlan to push another of the common types of plans...
-    SBThreadPlan
-    QueueThreadPlanForStepOverRange (SBAddress &start_address,
-                                     lldb::addr_t range_size);
+  bool IsPlanStale();
 
-    SBThreadPlan
-    QueueThreadPlanForStepInRange (SBAddress &start_address,
-                                   lldb::addr_t range_size);
+  bool IsValid();
 
-    SBThreadPlan
-    QueueThreadPlanForStepOut (uint32_t frame_idx_to_step_to, bool first_insn = false);
+  // This section allows an SBThreadPlan to push another of the common types of
+  // plans...
+  SBThreadPlan QueueThreadPlanForStepOverRange(SBAddress &start_address,
+                                               lldb::addr_t range_size);
 
-    SBThreadPlan
-    QueueThreadPlanForRunToAddress (SBAddress address);
+  SBThreadPlan QueueThreadPlanForStepInRange(SBAddress &start_address,
+                                             lldb::addr_t range_size);
+
+  SBThreadPlan QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
+                                         bool first_insn = false);
+
+  SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address);
 
 #ifndef SWIG
-    lldb_private::ThreadPlan *
-    get();
+  lldb_private::ThreadPlan *get();
 #endif
 
 protected:
-    friend class SBBreakpoint;
-    friend class SBBreakpointLocation;
-    friend class SBFrame;
-    friend class SBProcess;
-    friend class SBDebugger;
-    friend class SBValue;
-    friend class lldb_private::QueueImpl;
-    friend class SBQueueItem;
+  friend class SBBreakpoint;
+  friend class SBBreakpointLocation;
+  friend class SBFrame;
+  friend class SBProcess;
+  friend class SBDebugger;
+  friend class SBValue;
+  friend class lldb_private::QueueImpl;
+  friend class SBQueueItem;
 
 #ifndef SWIG
-    void
-    SetThreadPlan (const lldb::ThreadPlanSP& lldb_object_sp);
+  void SetThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);
 #endif
 
 private:
-    lldb::ThreadPlanSP m_opaque_sp;
+  lldb::ThreadPlanSP m_opaque_sp;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBThreadPlan_h_
+#endif // LLDB_SBThreadPlan_h_
diff --git a/include/lldb/API/SBType.h b/include/lldb/API/SBType.h
index ed3c2ff23863..0dde0257909f 100644
--- a/include/lldb/API/SBType.h
+++ b/include/lldb/API/SBType.h
@@ -14,328 +14,241 @@
 
 namespace lldb {
 
-class SBTypeList;    
+class SBTypeList;
 
-class LLDB_API SBTypeMember
-{
+class LLDB_API SBTypeMember {
 public:
-    SBTypeMember ();
-    
-    SBTypeMember (const lldb::SBTypeMember& rhs);
-    
-    ~SBTypeMember();
-
-    lldb::SBTypeMember&
-    operator = (const lldb::SBTypeMember& rhs);
-
-    bool
-    IsValid() const;
-    
-    const char *
-    GetName ();
-    
-    lldb::SBType
-    GetType ();
-    
-    uint64_t
-    GetOffsetInBytes();
-    
-    uint64_t
-    GetOffsetInBits();
-
-    bool
-    IsBitfield();
-    
-    uint32_t
-    GetBitfieldSizeInBits();
-
-    bool
-    GetDescription (lldb::SBStream &description, 
-                    lldb::DescriptionLevel description_level);
-    
+  SBTypeMember();
+
+  SBTypeMember(const lldb::SBTypeMember &rhs);
+
+  ~SBTypeMember();
+
+  lldb::SBTypeMember &operator=(const lldb::SBTypeMember &rhs);
+
+  bool IsValid() const;
+
+  const char *GetName();
+
+  lldb::SBType GetType();
+
+  uint64_t GetOffsetInBytes();
+
+  uint64_t GetOffsetInBits();
+
+  bool IsBitfield();
+
+  uint32_t GetBitfieldSizeInBits();
+
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::DescriptionLevel description_level);
+
 protected:
-    friend class SBType;
+  friend class SBType;
 
-    void
-    reset (lldb_private::TypeMemberImpl *);
+  void reset(lldb_private::TypeMemberImpl *);
 
-    lldb_private::TypeMemberImpl &
-    ref ();
+  lldb_private::TypeMemberImpl &ref();
 
-    const lldb_private::TypeMemberImpl &
-    ref () const;
+  const lldb_private::TypeMemberImpl &ref() const;
 
-    std::unique_ptr<lldb_private::TypeMemberImpl> m_opaque_ap;
+  std::unique_ptr<lldb_private::TypeMemberImpl> m_opaque_ap;
 };
-    
-class SBTypeMemberFunction
-{
+
+class SBTypeMemberFunction {
 public:
-    SBTypeMemberFunction ();
-    
-    SBTypeMemberFunction (const lldb::SBTypeMemberFunction& rhs);
-    
-    ~SBTypeMemberFunction();
-    
-    lldb::SBTypeMemberFunction&
-    operator = (const lldb::SBTypeMemberFunction& rhs);
-    
-    bool
-    IsValid() const;
-    
-    const char *
-    GetName ();
-
-    const char *
-    GetDemangledName ();
-
-    const char *
-    GetMangledName ();
-
-    lldb::SBType
-    GetType ();
-    
-    lldb::SBType
-    GetReturnType ();
-    
-    uint32_t
-    GetNumberOfArguments ();
-    
-    lldb::SBType
-    GetArgumentTypeAtIndex (uint32_t);
-    
-    lldb::MemberFunctionKind
-    GetKind();
-    
-    bool
-    GetDescription (lldb::SBStream &description,
-                    lldb::DescriptionLevel description_level);
-    
+  SBTypeMemberFunction();
+
+  SBTypeMemberFunction(const lldb::SBTypeMemberFunction &rhs);
+
+  ~SBTypeMemberFunction();
+
+  lldb::SBTypeMemberFunction &operator=(const lldb::SBTypeMemberFunction &rhs);
+
+  bool IsValid() const;
+
+  const char *GetName();
+
+  const char *GetDemangledName();
+
+  const char *GetMangledName();
+
+  lldb::SBType GetType();
+
+  lldb::SBType GetReturnType();
+
+  uint32_t GetNumberOfArguments();
+
+  lldb::SBType GetArgumentTypeAtIndex(uint32_t);
+
+  lldb::MemberFunctionKind GetKind();
+
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::DescriptionLevel description_level);
+
 protected:
-    friend class SBType;
-    
-    void
-    reset (lldb_private::TypeMemberFunctionImpl *);
-    
-    lldb_private::TypeMemberFunctionImpl &
-    ref ();
-    
-    const lldb_private::TypeMemberFunctionImpl &
-    ref () const;
-    
-    lldb::TypeMemberFunctionImplSP m_opaque_sp;
-};
+  friend class SBType;
+
+  void reset(lldb_private::TypeMemberFunctionImpl *);
 
+  lldb_private::TypeMemberFunctionImpl &ref();
 
-class SBType
-{
+  const lldb_private::TypeMemberFunctionImpl &ref() const;
+
+  lldb::TypeMemberFunctionImplSP m_opaque_sp;
+};
+
+class SBType {
 public:
+  SBType();
+
+  SBType(const lldb::SBType &rhs);
+
+  ~SBType();
+
+  bool IsValid() const;
+
+  uint64_t GetByteSize();
+
+  bool IsPointerType();
+
+  bool IsReferenceType();
+
+  bool IsFunctionType();
+
+  bool IsPolymorphicClass();
+
+  bool IsArrayType();
+
+  bool IsVectorType();
+
+  bool IsTypedefType();
+
+  bool IsAnonymousType();
+
+  lldb::SBType GetPointerType();
+
+  lldb::SBType GetPointeeType();
+
+  lldb::SBType GetReferenceType();
+
+  lldb::SBType GetTypedefedType();
+
+  lldb::SBType GetDereferencedType();
+
+  lldb::SBType GetUnqualifiedType();
+
+  lldb::SBType GetArrayElementType();
+
+  lldb::SBType GetArrayType(uint64_t size);
+
+  lldb::SBType GetVectorElementType();
+
+  lldb::SBType GetCanonicalType();
+  // Get the "lldb::BasicType" enumeration for a type. If a type is not a basic
+  // type eBasicTypeInvalid will be returned
+  lldb::BasicType GetBasicType();
+
+  // The call below confusing and should really be renamed to "CreateBasicType"
+  lldb::SBType GetBasicType(lldb::BasicType type);
+
+  uint32_t GetNumberOfFields();
+
+  uint32_t GetNumberOfDirectBaseClasses();
+
+  uint32_t GetNumberOfVirtualBaseClasses();
+
+  lldb::SBTypeMember GetFieldAtIndex(uint32_t idx);
+
+  lldb::SBTypeMember GetDirectBaseClassAtIndex(uint32_t idx);
+
+  lldb::SBTypeMember GetVirtualBaseClassAtIndex(uint32_t idx);
+
+  lldb::SBTypeEnumMemberList GetEnumMembers();
+
+  uint32_t GetNumberOfTemplateArguments();
+
+  lldb::SBType GetTemplateArgumentType(uint32_t idx);
+
+  lldb::TemplateArgumentKind GetTemplateArgumentKind(uint32_t idx);
+
+  lldb::SBType GetFunctionReturnType();
+
+  lldb::SBTypeList GetFunctionArgumentTypes();
+
+  uint32_t GetNumberOfMemberFunctions();
+
+  lldb::SBTypeMemberFunction GetMemberFunctionAtIndex(uint32_t idx);
+
+  const char *GetName();
+
+  const char *GetDisplayTypeName();
+
+  lldb::TypeClass GetTypeClass();
+
+  bool IsTypeComplete();
+
+  uint32_t GetTypeFlags();
+
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::DescriptionLevel description_level);
+
+  lldb::SBType &operator=(const lldb::SBType &rhs);
+
+  bool operator==(lldb::SBType &rhs);
+
+  bool operator!=(lldb::SBType &rhs);
 
-    SBType();
-
-    SBType (const lldb::SBType &rhs);
-
-    ~SBType ();
-
-    bool
-    IsValid() const;
-    
-    uint64_t
-    GetByteSize();
-
-    bool
-    IsPointerType();
-    
-    bool
-    IsReferenceType();
-    
-    bool
-    IsFunctionType ();
-    
-    bool
-    IsPolymorphicClass ();
-    
-    bool
-    IsArrayType ();
-    
-    bool
-    IsVectorType ();
-    
-    bool
-    IsTypedefType ();
-    
-    bool
-    IsAnonymousType ();
-    
-    lldb::SBType
-    GetPointerType();
-    
-    lldb::SBType
-    GetPointeeType();
-    
-    lldb::SBType
-    GetReferenceType();
-    
-    lldb::SBType
-    GetTypedefedType();
-
-    lldb::SBType
-    GetDereferencedType();
-
-    lldb::SBType
-    GetUnqualifiedType();
-    
-    lldb::SBType
-    GetArrayElementType ();
-    
-    lldb::SBType
-    GetVectorElementType ();
-
-    lldb::SBType
-    GetCanonicalType();
-    // Get the "lldb::BasicType" enumeration for a type. If a type is not a basic
-    // type eBasicTypeInvalid will be returned
-    lldb::BasicType
-    GetBasicType();
-
-    // The call below confusing and should really be renamed to "CreateBasicType"
-    lldb::SBType
-    GetBasicType(lldb::BasicType type);
-    
-    uint32_t
-    GetNumberOfFields ();
-    
-    uint32_t
-    GetNumberOfDirectBaseClasses ();
-
-    uint32_t
-    GetNumberOfVirtualBaseClasses ();
-    
-    lldb::SBTypeMember
-    GetFieldAtIndex (uint32_t idx);
-    
-    lldb::SBTypeMember
-    GetDirectBaseClassAtIndex (uint32_t idx);
-
-    lldb::SBTypeMember
-    GetVirtualBaseClassAtIndex (uint32_t idx);
-
-    lldb::SBTypeEnumMemberList
-    GetEnumMembers();
-
-    uint32_t
-    GetNumberOfTemplateArguments ();
-    
-    lldb::SBType
-    GetTemplateArgumentType (uint32_t idx);
-
-    lldb::TemplateArgumentKind
-    GetTemplateArgumentKind (uint32_t idx);
-
-    lldb::SBType
-    GetFunctionReturnType ();
-
-    lldb::SBTypeList
-    GetFunctionArgumentTypes ();
-    
-    uint32_t
-    GetNumberOfMemberFunctions ();
-    
-    lldb::SBTypeMemberFunction
-    GetMemberFunctionAtIndex (uint32_t idx);
-
-    const char*
-    GetName();
-    
-    const char *
-    GetDisplayTypeName ();
-    
-    lldb::TypeClass
-    GetTypeClass ();
-    
-    bool
-    IsTypeComplete ();
-    
-    uint32_t
-    GetTypeFlags ();
-
-    bool
-    GetDescription (lldb::SBStream &description, 
-                    lldb::DescriptionLevel description_level);
-
-    lldb::SBType &
-    operator = (const lldb::SBType &rhs);
-    
-    bool
-    operator == (lldb::SBType &rhs);
-    
-    bool
-    operator != (lldb::SBType &rhs);
-    
 protected:
+  lldb_private::TypeImpl &ref();
+
+  const lldb_private::TypeImpl &ref() const;
+
+  lldb::TypeImplSP GetSP();
+
+  void SetSP(const lldb::TypeImplSP &type_impl_sp);
 
-    lldb_private::TypeImpl &
-    ref ();
-    
-    const lldb_private::TypeImpl &
-    ref () const;
-    
-    lldb::TypeImplSP
-    GetSP ();
-
-    void
-    SetSP (const lldb::TypeImplSP &type_impl_sp);    
-
-    lldb::TypeImplSP m_opaque_sp;
-    
-    friend class SBFunction;
-    friend class SBModule;
-    friend class SBTarget;
-    friend class SBTypeEnumMember;
-    friend class SBTypeEnumMemberList;
-    friend class SBTypeNameSpecifier;
-    friend class SBTypeMember;
-    friend class SBTypeMemberFunction;
-    friend class SBTypeList;
-    friend class SBValue;
-        
-    SBType (const lldb_private::CompilerType &);
-    SBType (const lldb::TypeSP &);
-    SBType (const lldb::TypeImplSP &);
-    
+  lldb::TypeImplSP m_opaque_sp;
+
+  friend class SBFunction;
+  friend class SBModule;
+  friend class SBTarget;
+  friend class SBTypeEnumMember;
+  friend class SBTypeEnumMemberList;
+  friend class SBTypeNameSpecifier;
+  friend class SBTypeMember;
+  friend class SBTypeMemberFunction;
+  friend class SBTypeList;
+  friend class SBValue;
+
+  SBType(const lldb_private::CompilerType &);
+  SBType(const lldb::TypeSP &);
+  SBType(const lldb::TypeImplSP &);
 };
-    
-class SBTypeList
-{
+
+class SBTypeList {
 public:
-    SBTypeList();
-    
-    SBTypeList(const lldb::SBTypeList& rhs);
-    
-    ~SBTypeList();
-
-    lldb::SBTypeList&
-    operator = (const lldb::SBTypeList& rhs);
-    
-    bool
-    IsValid();
-
-    void
-    Append (lldb::SBType type);
-    
-    lldb::SBType
-    GetTypeAtIndex (uint32_t index);
-    
-    uint32_t
-    GetSize();
-    
-    
+  SBTypeList();
+
+  SBTypeList(const lldb::SBTypeList &rhs);
+
+  ~SBTypeList();
+
+  lldb::SBTypeList &operator=(const lldb::SBTypeList &rhs);
+
+  bool IsValid();
+
+  void Append(lldb::SBType type);
+
+  lldb::SBType GetTypeAtIndex(uint32_t index);
+
+  uint32_t GetSize();
+
 private:
-    std::unique_ptr<lldb_private::TypeListImpl> m_opaque_ap;
-    friend class SBModule;
-    friend class SBCompileUnit;
+  std::unique_ptr<lldb_private::TypeListImpl> m_opaque_ap;
+  friend class SBModule;
+  friend class SBCompileUnit;
 };
-    
 
 } // namespace lldb
 
diff --git a/include/lldb/API/SBTypeCategory.h b/include/lldb/API/SBTypeCategory.h
index 997b3fc2f98d..f44dfc451e44 100644
--- a/include/lldb/API/SBTypeCategory.h
+++ b/include/lldb/API/SBTypeCategory.h
@@ -1,4 +1,5 @@
-//===-- SBTypeCategory.h --------------------------------------------*- C++ -*-===//
+//===-- SBTypeCategory.h --------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -13,165 +14,120 @@
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
-    
-    class LLDB_API SBTypeCategory
-    {
-    public:
-        
-        SBTypeCategory();
-        
-        SBTypeCategory (const lldb::SBTypeCategory &rhs);
-        
-        ~SBTypeCategory ();
-        
-        bool
-        IsValid() const;
-        
-        bool
-        GetEnabled ();
-        
-        void
-        SetEnabled (bool);
-        
-        const char*
-        GetName();
-        
-        lldb::LanguageType
-        GetLanguageAtIndex (uint32_t idx);
-        
-        uint32_t
-        GetNumLanguages ();
-        
-        void
-        AddLanguage (lldb::LanguageType language);
-        
-        bool
-        GetDescription (lldb::SBStream &description, 
-                        lldb::DescriptionLevel description_level);
-        
-        uint32_t
-        GetNumFormats ();
-        
-        uint32_t
-        GetNumSummaries ();
-        
-        uint32_t
-        GetNumFilters ();
-        
+
+class LLDB_API SBTypeCategory {
+public:
+  SBTypeCategory();
+
+  SBTypeCategory(const lldb::SBTypeCategory &rhs);
+
+  ~SBTypeCategory();
+
+  bool IsValid() const;
+
+  bool GetEnabled();
+
+  void SetEnabled(bool);
+
+  const char *GetName();
+
+  lldb::LanguageType GetLanguageAtIndex(uint32_t idx);
+
+  uint32_t GetNumLanguages();
+
+  void AddLanguage(lldb::LanguageType language);
+
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::DescriptionLevel description_level);
+
+  uint32_t GetNumFormats();
+
+  uint32_t GetNumSummaries();
+
+  uint32_t GetNumFilters();
+
 #ifndef LLDB_DISABLE_PYTHON
-        uint32_t
-        GetNumSynthetics ();
+  uint32_t GetNumSynthetics();
 #endif
-        
-        SBTypeNameSpecifier
-        GetTypeNameSpecifierForFilterAtIndex (uint32_t);
-        
-        SBTypeNameSpecifier
-        GetTypeNameSpecifierForFormatAtIndex (uint32_t);
-        
-        SBTypeNameSpecifier
-        GetTypeNameSpecifierForSummaryAtIndex (uint32_t);
+
+  SBTypeNameSpecifier GetTypeNameSpecifierForFilterAtIndex(uint32_t);
+
+  SBTypeNameSpecifier GetTypeNameSpecifierForFormatAtIndex(uint32_t);
+
+  SBTypeNameSpecifier GetTypeNameSpecifierForSummaryAtIndex(uint32_t);
 
 #ifndef LLDB_DISABLE_PYTHON
-        SBTypeNameSpecifier
-        GetTypeNameSpecifierForSyntheticAtIndex (uint32_t);
+  SBTypeNameSpecifier GetTypeNameSpecifierForSyntheticAtIndex(uint32_t);
 #endif
-        
-        SBTypeFilter
-        GetFilterForType (SBTypeNameSpecifier);
 
-        SBTypeFormat
-        GetFormatForType (SBTypeNameSpecifier);
-        
+  SBTypeFilter GetFilterForType(SBTypeNameSpecifier);
+
+  SBTypeFormat GetFormatForType(SBTypeNameSpecifier);
+
 #ifndef LLDB_DISABLE_PYTHON
-        SBTypeSummary
-        GetSummaryForType (SBTypeNameSpecifier);
+  SBTypeSummary GetSummaryForType(SBTypeNameSpecifier);
 #endif
 
 #ifndef LLDB_DISABLE_PYTHON
-        SBTypeSynthetic
-        GetSyntheticForType (SBTypeNameSpecifier);
+  SBTypeSynthetic GetSyntheticForType(SBTypeNameSpecifier);
 #endif
-        
+
 #ifndef LLDB_DISABLE_PYTHON
-        SBTypeFilter
-        GetFilterAtIndex (uint32_t);
+  SBTypeFilter GetFilterAtIndex(uint32_t);
 #endif
-        
-        SBTypeFormat
-        GetFormatAtIndex (uint32_t);
-        
+
+  SBTypeFormat GetFormatAtIndex(uint32_t);
+
 #ifndef LLDB_DISABLE_PYTHON
-        SBTypeSummary
-        GetSummaryAtIndex (uint32_t);
+  SBTypeSummary GetSummaryAtIndex(uint32_t);
 #endif
-        
+
 #ifndef LLDB_DISABLE_PYTHON
-        SBTypeSynthetic
-        GetSyntheticAtIndex (uint32_t);
+  SBTypeSynthetic GetSyntheticAtIndex(uint32_t);
 #endif
-        
-        bool
-        AddTypeFormat (SBTypeNameSpecifier,
-                       SBTypeFormat);
-        
-        bool
-        DeleteTypeFormat (SBTypeNameSpecifier);
-        
+
+  bool AddTypeFormat(SBTypeNameSpecifier, SBTypeFormat);
+
+  bool DeleteTypeFormat(SBTypeNameSpecifier);
+
 #ifndef LLDB_DISABLE_PYTHON
-        bool
-        AddTypeSummary (SBTypeNameSpecifier,
-                        SBTypeSummary);
+  bool AddTypeSummary(SBTypeNameSpecifier, SBTypeSummary);
 #endif
-        
-        bool
-        DeleteTypeSummary (SBTypeNameSpecifier);
-        
-        bool
-        AddTypeFilter (SBTypeNameSpecifier,
-                       SBTypeFilter);
-        
-        bool
-        DeleteTypeFilter (SBTypeNameSpecifier);
-        
+
+  bool DeleteTypeSummary(SBTypeNameSpecifier);
+
+  bool AddTypeFilter(SBTypeNameSpecifier, SBTypeFilter);
+
+  bool DeleteTypeFilter(SBTypeNameSpecifier);
+
 #ifndef LLDB_DISABLE_PYTHON
-        bool
-        AddTypeSynthetic (SBTypeNameSpecifier,
-                          SBTypeSynthetic);
-        
-        bool
-        DeleteTypeSynthetic (SBTypeNameSpecifier);
+  bool AddTypeSynthetic(SBTypeNameSpecifier, SBTypeSynthetic);
+
+  bool DeleteTypeSynthetic(SBTypeNameSpecifier);
 #endif
-        
-        lldb::SBTypeCategory &
-        operator = (const lldb::SBTypeCategory &rhs);
-        
-        bool
-        operator == (lldb::SBTypeCategory &rhs);
-        
-        bool
-        operator != (lldb::SBTypeCategory &rhs);
-        
-    protected:
-        friend class SBDebugger;
-        
-        lldb::TypeCategoryImplSP
-        GetSP ();
-        
-        void
-        SetSP (const lldb::TypeCategoryImplSP &typecategory_impl_sp);    
-        
-        TypeCategoryImplSP m_opaque_sp;
-        
-        SBTypeCategory (const lldb::TypeCategoryImplSP &);
-        
-        SBTypeCategory (const char*);
-        
-        bool
-        IsDefaultCategory();
-        
-    };
-    
+
+  lldb::SBTypeCategory &operator=(const lldb::SBTypeCategory &rhs);
+
+  bool operator==(lldb::SBTypeCategory &rhs);
+
+  bool operator!=(lldb::SBTypeCategory &rhs);
+
+protected:
+  friend class SBDebugger;
+
+  lldb::TypeCategoryImplSP GetSP();
+
+  void SetSP(const lldb::TypeCategoryImplSP &typecategory_impl_sp);
+
+  TypeCategoryImplSP m_opaque_sp;
+
+  SBTypeCategory(const lldb::TypeCategoryImplSP &);
+
+  SBTypeCategory(const char *);
+
+  bool IsDefaultCategory();
+};
+
 } // namespace lldb
 
 #endif // LLDB_SBTypeCategory_h_
diff --git a/include/lldb/API/SBTypeEnumMember.h b/include/lldb/API/SBTypeEnumMember.h
index b141ba0a6bb0..f45c234d2c77 100644
--- a/include/lldb/API/SBTypeEnumMember.h
+++ b/include/lldb/API/SBTypeEnumMember.h
@@ -15,82 +15,64 @@
 
 namespace lldb {
 
-class LLDB_API SBTypeEnumMember
-{
+class LLDB_API SBTypeEnumMember {
 public:
-    SBTypeEnumMember ();
+  SBTypeEnumMember();
 
-    SBTypeEnumMember (const SBTypeEnumMember& rhs);
+  SBTypeEnumMember(const SBTypeEnumMember &rhs);
 
-    ~SBTypeEnumMember();
+  ~SBTypeEnumMember();
 
-    SBTypeEnumMember&
-    operator = (const SBTypeEnumMember& rhs);
+  SBTypeEnumMember &operator=(const SBTypeEnumMember &rhs);
 
-    bool
-    IsValid() const;
+  bool IsValid() const;
 
-    int64_t
-    GetValueAsSigned();
+  int64_t GetValueAsSigned();
 
-    uint64_t
-    GetValueAsUnsigned();
+  uint64_t GetValueAsUnsigned();
 
-    const char *
-    GetName ();
+  const char *GetName();
 
-    lldb::SBType
-    GetType ();
+  lldb::SBType GetType();
 
-    bool
-    GetDescription (lldb::SBStream &description,
-                    lldb::DescriptionLevel description_level);
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::DescriptionLevel description_level);
 
 protected:
-    friend class SBType;
-    friend class SBTypeEnumMemberList;
+  friend class SBType;
+  friend class SBTypeEnumMemberList;
 
-    void
-    reset (lldb_private::TypeEnumMemberImpl *);
+  void reset(lldb_private::TypeEnumMemberImpl *);
 
-    lldb_private::TypeEnumMemberImpl &
-    ref ();
+  lldb_private::TypeEnumMemberImpl &ref();
 
-    const lldb_private::TypeEnumMemberImpl &
-    ref () const;
+  const lldb_private::TypeEnumMemberImpl &ref() const;
 
-    lldb::TypeEnumMemberImplSP m_opaque_sp;
+  lldb::TypeEnumMemberImplSP m_opaque_sp;
 
-    SBTypeEnumMember (const lldb::TypeEnumMemberImplSP &);
+  SBTypeEnumMember(const lldb::TypeEnumMemberImplSP &);
 };
 
-class SBTypeEnumMemberList
-{
+class SBTypeEnumMemberList {
 public:
-    SBTypeEnumMemberList();
+  SBTypeEnumMemberList();
 
-    SBTypeEnumMemberList(const SBTypeEnumMemberList& rhs);
+  SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs);
 
-    ~SBTypeEnumMemberList();
+  ~SBTypeEnumMemberList();
 
-    SBTypeEnumMemberList&
-    operator = (const SBTypeEnumMemberList& rhs);
+  SBTypeEnumMemberList &operator=(const SBTypeEnumMemberList &rhs);
 
-    bool
-    IsValid();
+  bool IsValid();
 
-    void
-    Append (SBTypeEnumMember entry);
+  void Append(SBTypeEnumMember entry);
 
-    SBTypeEnumMember
-    GetTypeEnumMemberAtIndex (uint32_t index);
-
-    uint32_t
-    GetSize();
+  SBTypeEnumMember GetTypeEnumMemberAtIndex(uint32_t index);
 
+  uint32_t GetSize();
 
 private:
-    std::unique_ptr<lldb_private::TypeEnumMemberListImpl> m_opaque_ap;
+  std::unique_ptr<lldb_private::TypeEnumMemberListImpl> m_opaque_ap;
 };
 
 } // namespace lldb
diff --git a/include/lldb/API/SBTypeFilter.h b/include/lldb/API/SBTypeFilter.h
index f030b6a99b60..19888ba7cfb6 100644
--- a/include/lldb/API/SBTypeFilter.h
+++ b/include/lldb/API/SBTypeFilter.h
@@ -1,4 +1,5 @@
-//===-- SBTypeFilter.h --------------------------------------------*- C++ -*-===//
+//===-- SBTypeFilter.h --------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -13,80 +14,60 @@
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
-    
-    class LLDB_API SBTypeFilter
-    {
-    public:
-        
-        SBTypeFilter();
-        
-        SBTypeFilter (uint32_t options); // see lldb::eTypeOption values
-        
-        SBTypeFilter (const lldb::SBTypeFilter &rhs);
-        
-        ~SBTypeFilter ();
-        
-        bool
-        IsValid() const;
-
-        uint32_t
-        GetNumberOfExpressionPaths ();
-        
-        const char*
-        GetExpressionPathAtIndex (uint32_t i);
-        
-        bool
-        ReplaceExpressionPathAtIndex (uint32_t i, const char* item);
-        
-        void
-        AppendExpressionPath (const char* item);
-        
-        void
-        Clear();
-                
-        uint32_t
-        GetOptions();
-        
-        void
-        SetOptions (uint32_t);
-        
-        bool
-        GetDescription (lldb::SBStream &description, 
-                        lldb::DescriptionLevel description_level);
-        
-        lldb::SBTypeFilter &
-        operator = (const lldb::SBTypeFilter &rhs);
-        
-        bool
-        IsEqualTo (lldb::SBTypeFilter &rhs);
-        
-        bool
-        operator == (lldb::SBTypeFilter &rhs);
-
-        bool
-        operator != (lldb::SBTypeFilter &rhs);
-        
-    protected:
-        friend class SBDebugger;
-        friend class SBTypeCategory;
-        friend class SBValue;
-        
-        lldb::TypeFilterImplSP
-        GetSP ();
-        
-        void
-        SetSP (const lldb::TypeFilterImplSP &typefilter_impl_sp);    
-        
-        lldb::TypeFilterImplSP m_opaque_sp;
-        
-        SBTypeFilter (const lldb::TypeFilterImplSP &);
-        
-        bool
-        CopyOnWrite_Impl();
-        
-    };
-    
-    
+
+class LLDB_API SBTypeFilter {
+public:
+  SBTypeFilter();
+
+  SBTypeFilter(uint32_t options); // see lldb::eTypeOption values
+
+  SBTypeFilter(const lldb::SBTypeFilter &rhs);
+
+  ~SBTypeFilter();
+
+  bool IsValid() const;
+
+  uint32_t GetNumberOfExpressionPaths();
+
+  const char *GetExpressionPathAtIndex(uint32_t i);
+
+  bool ReplaceExpressionPathAtIndex(uint32_t i, const char *item);
+
+  void AppendExpressionPath(const char *item);
+
+  void Clear();
+
+  uint32_t GetOptions();
+
+  void SetOptions(uint32_t);
+
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::DescriptionLevel description_level);
+
+  lldb::SBTypeFilter &operator=(const lldb::SBTypeFilter &rhs);
+
+  bool IsEqualTo(lldb::SBTypeFilter &rhs);
+
+  bool operator==(lldb::SBTypeFilter &rhs);
+
+  bool operator!=(lldb::SBTypeFilter &rhs);
+
+protected:
+  friend class SBDebugger;
+  friend class SBTypeCategory;
+  friend class SBValue;
+
+  lldb::TypeFilterImplSP GetSP();
+
+  void SetSP(const lldb::TypeFilterImplSP &typefilter_impl_sp);
+
+  lldb::TypeFilterImplSP m_opaque_sp;
+
+  SBTypeFilter(const lldb::TypeFilterImplSP &);
+
+  bool CopyOnWrite_Impl();
+};
+
 } // namespace lldb
 
 #endif // LLDB_SBTypeFilter_h_
diff --git a/include/lldb/API/SBTypeFormat.h b/include/lldb/API/SBTypeFormat.h
index c24641ac15f5..d0429e97ff9c 100644
--- a/include/lldb/API/SBTypeFormat.h
+++ b/include/lldb/API/SBTypeFormat.h
@@ -1,4 +1,5 @@
-//===-- SBTypeFormat.h --------------------------------------------*- C++ -*-===//
+//===-- SBTypeFormat.h --------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -14,87 +15,63 @@
 
 namespace lldb {
 
-class LLDB_API SBTypeFormat
-{
+class LLDB_API SBTypeFormat {
 public:
-    
-    SBTypeFormat();
-    
-    SBTypeFormat (lldb::Format format,
-                  uint32_t options = 0); // see lldb::eTypeOption values
-
-    SBTypeFormat (const char* type,
-                  uint32_t options = 0); // see lldb::eTypeOption values
-    
-    SBTypeFormat (const lldb::SBTypeFormat &rhs);
-    
-    ~SBTypeFormat ();
-    
-    bool
-    IsValid() const;
-    
-    lldb::Format
-    GetFormat ();
-    
-    const char*
-    GetTypeName ();
-    
-    uint32_t
-    GetOptions();
-    
-    void
-    SetFormat (lldb::Format);
-    
-    void
-    SetTypeName (const char*);
-    
-    void
-    SetOptions (uint32_t);
-    
-    bool
-    GetDescription (lldb::SBStream &description, 
-                    lldb::DescriptionLevel description_level);
-    
-    lldb::SBTypeFormat &
-    operator = (const lldb::SBTypeFormat &rhs);
-    
-    bool
-    IsEqualTo (lldb::SBTypeFormat &rhs);
-
-    bool
-    operator == (lldb::SBTypeFormat &rhs);
-    
-    bool
-    operator != (lldb::SBTypeFormat &rhs);
-    
+  SBTypeFormat();
+
+  SBTypeFormat(lldb::Format format,
+               uint32_t options = 0); // see lldb::eTypeOption values
+
+  SBTypeFormat(const char *type,
+               uint32_t options = 0); // see lldb::eTypeOption values
+
+  SBTypeFormat(const lldb::SBTypeFormat &rhs);
+
+  ~SBTypeFormat();
+
+  bool IsValid() const;
+
+  lldb::Format GetFormat();
+
+  const char *GetTypeName();
+
+  uint32_t GetOptions();
+
+  void SetFormat(lldb::Format);
+
+  void SetTypeName(const char *);
+
+  void SetOptions(uint32_t);
+
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::DescriptionLevel description_level);
+
+  lldb::SBTypeFormat &operator=(const lldb::SBTypeFormat &rhs);
+
+  bool IsEqualTo(lldb::SBTypeFormat &rhs);
+
+  bool operator==(lldb::SBTypeFormat &rhs);
+
+  bool operator!=(lldb::SBTypeFormat &rhs);
+
 protected:
-    friend class SBDebugger;
-    friend class SBTypeCategory;
-    friend class SBValue;
-    
-    lldb::TypeFormatImplSP
-    GetSP ();
-    
-    void
-    SetSP (const lldb::TypeFormatImplSP &typeformat_impl_sp);    
-    
-    lldb::TypeFormatImplSP m_opaque_sp;
-    
-    SBTypeFormat (const lldb::TypeFormatImplSP &);
-    
-    enum class Type
-    {
-        eTypeKeepSame,
-        eTypeFormat,
-        eTypeEnum
-    };
-    
-    bool
-    CopyOnWrite_Impl(Type);
-    
+  friend class SBDebugger;
+  friend class SBTypeCategory;
+  friend class SBValue;
+
+  lldb::TypeFormatImplSP GetSP();
+
+  void SetSP(const lldb::TypeFormatImplSP &typeformat_impl_sp);
+
+  lldb::TypeFormatImplSP m_opaque_sp;
+
+  SBTypeFormat(const lldb::TypeFormatImplSP &);
+
+  enum class Type { eTypeKeepSame, eTypeFormat, eTypeEnum };
+
+  bool CopyOnWrite_Impl(Type);
 };
 
-    
 } // namespace lldb
 
 #endif // LLDB_SBTypeFormat_h_
diff --git a/include/lldb/API/SBTypeNameSpecifier.h b/include/lldb/API/SBTypeNameSpecifier.h
index 71700a7123d5..2a4f09c2068b 100644
--- a/include/lldb/API/SBTypeNameSpecifier.h
+++ b/include/lldb/API/SBTypeNameSpecifier.h
@@ -1,4 +1,5 @@
-//===-- SBTypeNameSpecifier.h --------------------------------------*- C++ -*-===//
+//===-- SBTypeNameSpecifier.h --------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -13,65 +14,51 @@
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
-    
-    class LLDB_API SBTypeNameSpecifier
-    {
-    public:
-        
-        SBTypeNameSpecifier();
-        
-        SBTypeNameSpecifier (const char* name,
-                             bool is_regex = false);
-
-        SBTypeNameSpecifier (SBType type);
-        
-        SBTypeNameSpecifier (const lldb::SBTypeNameSpecifier &rhs);
-        
-        ~SBTypeNameSpecifier ();
-        
-        bool
-        IsValid() const;
-        
-        const char*
-        GetName();
-        
-        SBType
-        GetType ();
-        
-        bool
-        IsRegex();
-        
-        bool
-        GetDescription (lldb::SBStream &description, 
-                        lldb::DescriptionLevel description_level);
-        
-        lldb::SBTypeNameSpecifier &
-        operator = (const lldb::SBTypeNameSpecifier &rhs);
-        
-        bool
-        IsEqualTo (lldb::SBTypeNameSpecifier &rhs);
-
-        bool
-        operator == (lldb::SBTypeNameSpecifier &rhs);
-        
-        bool
-        operator != (lldb::SBTypeNameSpecifier &rhs);
-        
-    protected:
-        friend class SBDebugger;
-        friend class SBTypeCategory;
-        
-        lldb::TypeNameSpecifierImplSP
-        GetSP ();
-        
-        void
-        SetSP (const lldb::TypeNameSpecifierImplSP &type_namespec_sp);    
-        
-        lldb::TypeNameSpecifierImplSP m_opaque_sp;
-        
-        SBTypeNameSpecifier (const lldb::TypeNameSpecifierImplSP &);
-    };
-    
+
+class LLDB_API SBTypeNameSpecifier {
+public:
+  SBTypeNameSpecifier();
+
+  SBTypeNameSpecifier(const char *name, bool is_regex = false);
+
+  SBTypeNameSpecifier(SBType type);
+
+  SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs);
+
+  ~SBTypeNameSpecifier();
+
+  bool IsValid() const;
+
+  const char *GetName();
+
+  SBType GetType();
+
+  bool IsRegex();
+
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::DescriptionLevel description_level);
+
+  lldb::SBTypeNameSpecifier &operator=(const lldb::SBTypeNameSpecifier &rhs);
+
+  bool IsEqualTo(lldb::SBTypeNameSpecifier &rhs);
+
+  bool operator==(lldb::SBTypeNameSpecifier &rhs);
+
+  bool operator!=(lldb::SBTypeNameSpecifier &rhs);
+
+protected:
+  friend class SBDebugger;
+  friend class SBTypeCategory;
+
+  lldb::TypeNameSpecifierImplSP GetSP();
+
+  void SetSP(const lldb::TypeNameSpecifierImplSP &type_namespec_sp);
+
+  lldb::TypeNameSpecifierImplSP m_opaque_sp;
+
+  SBTypeNameSpecifier(const lldb::TypeNameSpecifierImplSP &);
+};
+
 } // namespace lldb
 
 #endif // LLDB_SBTypeNameSpecifier_h_
diff --git a/include/lldb/API/SBTypeSummary.h b/include/lldb/API/SBTypeSummary.h
index f4c666180085..c9ccdff834ce 100644
--- a/include/lldb/API/SBTypeSummary.h
+++ b/include/lldb/API/SBTypeSummary.h
@@ -1,4 +1,5 @@
-//===-- SBTypeSummary.h -------------------------------------------*- C++ -*-===//
+//===-- SBTypeSummary.h -------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -13,160 +14,123 @@
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
-    class LLDB_API SBTypeSummaryOptions
-    {
-    public:
-        SBTypeSummaryOptions();
-
-        SBTypeSummaryOptions (const lldb::SBTypeSummaryOptions &rhs);
-        
-        SBTypeSummaryOptions (const lldb_private::TypeSummaryOptions *lldb_object_ptr);
-        
-        ~SBTypeSummaryOptions ();
-        
-        bool
-        IsValid ();
-        
-        lldb::LanguageType
-        GetLanguage ();
-        
-        lldb::TypeSummaryCapping
-        GetCapping ();
-        
-        void
-        SetLanguage (lldb::LanguageType);
-        
-        void
-        SetCapping (lldb::TypeSummaryCapping);
-        
-    protected:
-        friend class SBValue;
-        
-        lldb_private::TypeSummaryOptions *
-        operator->();
-        
-        const lldb_private::TypeSummaryOptions *
-        operator->() const;
-        
-        lldb_private::TypeSummaryOptions *
-        get ();
-        
-        lldb_private::TypeSummaryOptions &
-        ref();
-        
-        const lldb_private::TypeSummaryOptions &
-        ref() const;
-        
-        void
-        SetOptions (const lldb_private::TypeSummaryOptions *lldb_object_ptr);
-        
-    private:
-        std::unique_ptr<lldb_private::TypeSummaryOptions> m_opaque_ap;
-    };
-    
-    class SBTypeSummary
-    {
-    public:
-        
-        SBTypeSummary();
-
-        // Native function summary formatter callback
-        typedef bool (*FormatCallback) (SBValue, SBTypeSummaryOptions, SBStream&);
-        
-        static SBTypeSummary
-        CreateWithSummaryString (const char* data,
-                                 uint32_t options = 0); // see lldb::eTypeOption values
-        
-        static SBTypeSummary
-        CreateWithFunctionName (const char* data,
-                                uint32_t options = 0); // see lldb::eTypeOption values
-        
-        static SBTypeSummary
-        CreateWithScriptCode (const char* data,
-                              uint32_t options = 0); // see lldb::eTypeOption values
-
-        static SBTypeSummary
-        CreateWithCallback (FormatCallback cb, 
-                            uint32_t options = 0,
-                            const char* description = nullptr);
-        
-        SBTypeSummary (const lldb::SBTypeSummary &rhs);
-        
-        ~SBTypeSummary ();
-        
-        bool
-        IsValid() const;
-        
-        bool
-        IsFunctionCode();
-        
-        bool
-        IsFunctionName();
-        
-        bool
-        IsSummaryString();
-        
-        const char*
-        GetData ();
-        
-        void
-        SetSummaryString (const char* data);
-        
-        void
-        SetFunctionName (const char* data);
-        
-        void
-        SetFunctionCode (const char* data);
-        
-        uint32_t
-        GetOptions ();
-        
-        void
-        SetOptions (uint32_t);
-        
-        bool
-        GetDescription (lldb::SBStream &description, 
-                        lldb::DescriptionLevel description_level);
-        
-        lldb::SBTypeSummary &
-        operator = (const lldb::SBTypeSummary &rhs);
-        
-        bool
-        DoesPrintValue (lldb::SBValue value);
-        
-        bool
-        IsEqualTo (lldb::SBTypeSummary &rhs);
-
-        bool
-        operator == (lldb::SBTypeSummary &rhs);
-        
-        bool
-        operator != (lldb::SBTypeSummary &rhs);
-        
-    protected:
-        friend class SBDebugger;
-        friend class SBTypeCategory;
-        friend class SBValue;
-        
-        lldb::TypeSummaryImplSP
-        GetSP ();
-        
-        void
-        SetSP (const lldb::TypeSummaryImplSP &typefilter_impl_sp);    
-        
-        lldb::TypeSummaryImplSP m_opaque_sp;
-        
-        SBTypeSummary (const lldb::TypeSummaryImplSP &);
-        
-        bool
-        CopyOnWrite_Impl();
-        
-        bool
-        ChangeSummaryType (bool want_script);
-        
-    };
-    
-    
+class LLDB_API SBTypeSummaryOptions {
+public:
+  SBTypeSummaryOptions();
+
+  SBTypeSummaryOptions(const lldb::SBTypeSummaryOptions &rhs);
+
+  SBTypeSummaryOptions(const lldb_private::TypeSummaryOptions *lldb_object_ptr);
+
+  ~SBTypeSummaryOptions();
+
+  bool IsValid();
+
+  lldb::LanguageType GetLanguage();
+
+  lldb::TypeSummaryCapping GetCapping();
+
+  void SetLanguage(lldb::LanguageType);
+
+  void SetCapping(lldb::TypeSummaryCapping);
+
+protected:
+  friend class SBValue;
+
+  lldb_private::TypeSummaryOptions *operator->();
+
+  const lldb_private::TypeSummaryOptions *operator->() const;
+
+  lldb_private::TypeSummaryOptions *get();
+
+  lldb_private::TypeSummaryOptions &ref();
+
+  const lldb_private::TypeSummaryOptions &ref() const;
+
+  void SetOptions(const lldb_private::TypeSummaryOptions *lldb_object_ptr);
+
+private:
+  std::unique_ptr<lldb_private::TypeSummaryOptions> m_opaque_ap;
+};
+
+class SBTypeSummary {
+public:
+  SBTypeSummary();
+
+  // Native function summary formatter callback
+  typedef bool (*FormatCallback)(SBValue, SBTypeSummaryOptions, SBStream &);
+
+  static SBTypeSummary
+  CreateWithSummaryString(const char *data,
+                          uint32_t options = 0); // see lldb::eTypeOption values
+
+  static SBTypeSummary
+  CreateWithFunctionName(const char *data,
+                         uint32_t options = 0); // see lldb::eTypeOption values
+
+  static SBTypeSummary
+  CreateWithScriptCode(const char *data,
+                       uint32_t options = 0); // see lldb::eTypeOption values
+
+  static SBTypeSummary CreateWithCallback(FormatCallback cb,
+                                          uint32_t options = 0,
+                                          const char *description = nullptr);
+
+  SBTypeSummary(const lldb::SBTypeSummary &rhs);
+
+  ~SBTypeSummary();
+
+  bool IsValid() const;
+
+  bool IsFunctionCode();
+
+  bool IsFunctionName();
+
+  bool IsSummaryString();
+
+  const char *GetData();
+
+  void SetSummaryString(const char *data);
+
+  void SetFunctionName(const char *data);
+
+  void SetFunctionCode(const char *data);
+
+  uint32_t GetOptions();
+
+  void SetOptions(uint32_t);
+
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::DescriptionLevel description_level);
+
+  lldb::SBTypeSummary &operator=(const lldb::SBTypeSummary &rhs);
+
+  bool DoesPrintValue(lldb::SBValue value);
+
+  bool IsEqualTo(lldb::SBTypeSummary &rhs);
+
+  bool operator==(lldb::SBTypeSummary &rhs);
+
+  bool operator!=(lldb::SBTypeSummary &rhs);
+
+protected:
+  friend class SBDebugger;
+  friend class SBTypeCategory;
+  friend class SBValue;
+
+  lldb::TypeSummaryImplSP GetSP();
+
+  void SetSP(const lldb::TypeSummaryImplSP &typefilter_impl_sp);
+
+  lldb::TypeSummaryImplSP m_opaque_sp;
+
+  SBTypeSummary(const lldb::TypeSummaryImplSP &);
+
+  bool CopyOnWrite_Impl();
+
+  bool ChangeSummaryType(bool want_script);
+};
+
 } // namespace lldb
 
 #endif // LLDB_SBTypeSummary_h_
diff --git a/include/lldb/API/SBTypeSynthetic.h b/include/lldb/API/SBTypeSynthetic.h
index 5dd11757ba40..2099df316194 100644
--- a/include/lldb/API/SBTypeSynthetic.h
+++ b/include/lldb/API/SBTypeSynthetic.h
@@ -1,4 +1,5 @@
-//===-- SBTypeSynthetic.h -----------------------------------------*- C++ -*-===//
+//===-- SBTypeSynthetic.h -----------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -15,86 +16,66 @@
 #ifndef LLDB_DISABLE_PYTHON
 
 namespace lldb {
-    
-    class LLDB_API SBTypeSynthetic
-    {
-    public:
-        
-        SBTypeSynthetic();
-        
-        static SBTypeSynthetic
-        CreateWithClassName (const char* data,
-                             uint32_t options = 0); // see lldb::eTypeOption values
-        
-        static SBTypeSynthetic
-        CreateWithScriptCode (const char* data,
-                              uint32_t options = 0); // see lldb::eTypeOption values
-        
-        SBTypeSynthetic (const lldb::SBTypeSynthetic &rhs);
-        
-        ~SBTypeSynthetic ();
-        
-        bool
-        IsValid() const;
-        
-        bool
-        IsClassCode();
-
-        bool
-        IsClassName();
-        
-        const char*
-        GetData ();
-        
-        void
-        SetClassName (const char* data);
-        
-        void
-        SetClassCode (const char* data);
-                
-        uint32_t
-        GetOptions ();
-        
-        void
-        SetOptions (uint32_t);
-        
-        bool
-        GetDescription (lldb::SBStream &description, 
-                        lldb::DescriptionLevel description_level);
-        
-        lldb::SBTypeSynthetic &
-        operator = (const lldb::SBTypeSynthetic &rhs);
-
-        bool
-        IsEqualTo (lldb::SBTypeSynthetic &rhs);
-        
-        bool
-        operator == (lldb::SBTypeSynthetic &rhs);
-        
-        bool
-        operator != (lldb::SBTypeSynthetic &rhs);
-        
-    protected:
-        friend class SBDebugger;
-        friend class SBTypeCategory;
-        friend class SBValue;
-        
-        lldb::ScriptedSyntheticChildrenSP
-        GetSP ();
-        
-        void
-        SetSP (const lldb::ScriptedSyntheticChildrenSP &typefilter_impl_sp);    
-        
-        lldb::ScriptedSyntheticChildrenSP m_opaque_sp;
-        
-        SBTypeSynthetic (const lldb::ScriptedSyntheticChildrenSP &);
-        
-        bool
-        CopyOnWrite_Impl();
-        
-    };
-    
-    
+
+class LLDB_API SBTypeSynthetic {
+public:
+  SBTypeSynthetic();
+
+  static SBTypeSynthetic
+  CreateWithClassName(const char *data,
+                      uint32_t options = 0); // see lldb::eTypeOption values
+
+  static SBTypeSynthetic
+  CreateWithScriptCode(const char *data,
+                       uint32_t options = 0); // see lldb::eTypeOption values
+
+  SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs);
+
+  ~SBTypeSynthetic();
+
+  bool IsValid() const;
+
+  bool IsClassCode();
+
+  bool IsClassName();
+
+  const char *GetData();
+
+  void SetClassName(const char *data);
+
+  void SetClassCode(const char *data);
+
+  uint32_t GetOptions();
+
+  void SetOptions(uint32_t);
+
+  bool GetDescription(lldb::SBStream &description,
+                      lldb::DescriptionLevel description_level);
+
+  lldb::SBTypeSynthetic &operator=(const lldb::SBTypeSynthetic &rhs);
+
+  bool IsEqualTo(lldb::SBTypeSynthetic &rhs);
+
+  bool operator==(lldb::SBTypeSynthetic &rhs);
+
+  bool operator!=(lldb::SBTypeSynthetic &rhs);
+
+protected:
+  friend class SBDebugger;
+  friend class SBTypeCategory;
+  friend class SBValue;
+
+  lldb::ScriptedSyntheticChildrenSP GetSP();
+
+  void SetSP(const lldb::ScriptedSyntheticChildrenSP &typefilter_impl_sp);
+
+  lldb::ScriptedSyntheticChildrenSP m_opaque_sp;
+
+  SBTypeSynthetic(const lldb::ScriptedSyntheticChildrenSP &);
+
+  bool CopyOnWrite_Impl();
+};
+
 } // namespace lldb
 
 #endif // LLDB_DISABLE_PYTHON
diff --git a/include/lldb/API/SBUnixSignals.h b/include/lldb/API/SBUnixSignals.h
index ae48b63e1a2f..d44a508fbb42 100644
--- a/include/lldb/API/SBUnixSignals.h
+++ b/include/lldb/API/SBUnixSignals.h
@@ -1,4 +1,5 @@
-//===-- SBUnixSignals.h -----------------------------------------------*- C++ -*-===//
+//===-- SBUnixSignals.h -----------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -16,72 +17,54 @@ namespace lldb {
 
 class LLDB_API SBUnixSignals {
 public:
-    SBUnixSignals ();
+  SBUnixSignals();
 
-    SBUnixSignals (const lldb::SBUnixSignals &rhs);
+  SBUnixSignals(const lldb::SBUnixSignals &rhs);
 
-    ~SBUnixSignals();
+  ~SBUnixSignals();
 
-    const SBUnixSignals &
-    operator =(const lldb::SBUnixSignals &rhs);
+  const SBUnixSignals &operator=(const lldb::SBUnixSignals &rhs);
 
-    void
-    Clear ();
+  void Clear();
 
-    bool
-    IsValid () const;
+  bool IsValid() const;
 
-    const char *
-    GetSignalAsCString (int32_t signo) const;
+  const char *GetSignalAsCString(int32_t signo) const;
 
-    int32_t
-    GetSignalNumberFromName (const char *name) const;
+  int32_t GetSignalNumberFromName(const char *name) const;
 
-    bool
-    GetShouldSuppress (int32_t signo) const;
+  bool GetShouldSuppress(int32_t signo) const;
 
-    bool
-    SetShouldSuppress (int32_t signo,
-                       bool value);
+  bool SetShouldSuppress(int32_t signo, bool value);
 
-    bool
-    GetShouldStop (int32_t signo) const;
+  bool GetShouldStop(int32_t signo) const;
 
-    bool
-    SetShouldStop (int32_t signo,
-                   bool value);
+  bool SetShouldStop(int32_t signo, bool value);
 
-    bool
-    GetShouldNotify (int32_t signo) const;
+  bool GetShouldNotify(int32_t signo) const;
 
-    bool
-    SetShouldNotify (int32_t signo, bool value);
+  bool SetShouldNotify(int32_t signo, bool value);
 
-    int32_t
-    GetNumSignals () const;
+  int32_t GetNumSignals() const;
 
-    int32_t
-    GetSignalAtIndex (int32_t index) const;
+  int32_t GetSignalAtIndex(int32_t index) const;
 
 protected:
-    friend class SBProcess;
-    friend class SBPlatform;
+  friend class SBProcess;
+  friend class SBPlatform;
 
-    SBUnixSignals(lldb::ProcessSP &process_sp);
+  SBUnixSignals(lldb::ProcessSP &process_sp);
 
-    SBUnixSignals(lldb::PlatformSP &platform_sp);
+  SBUnixSignals(lldb::PlatformSP &platform_sp);
 
-    lldb::UnixSignalsSP
-    GetSP() const;
+  lldb::UnixSignalsSP GetSP() const;
 
-    void
-    SetSP(const lldb::UnixSignalsSP &signals_sp);
+  void SetSP(const lldb::UnixSignalsSP &signals_sp);
 
 private:
-    lldb::UnixSignalsWP m_opaque_wp;
+  lldb::UnixSignalsWP m_opaque_wp;
 };
 
-
 } // namespace lldb
 
 #endif // LLDB_SBUnixSignals_h_
diff --git a/include/lldb/API/SBValue.h b/include/lldb/API/SBValue.h
index b9f1e6f5c93f..5ef8915b58f9 100644
--- a/include/lldb/API/SBValue.h
+++ b/include/lldb/API/SBValue.h
@@ -19,498 +19,428 @@ class ValueLocker;
 
 namespace lldb {
 
-class LLDB_API SBValue
-{
+class LLDB_API SBValue {
 public:
-    SBValue ();
-
-    SBValue (const lldb::SBValue &rhs);
-
-    lldb::SBValue &
-    operator =(const lldb::SBValue &rhs);
-    
-    ~SBValue ();
-
-    bool
-    IsValid();
-    
-    void
-    Clear();
-    
-    SBError
-    GetError();
-
-    lldb::user_id_t
-    GetID ();
-    
-    const char *
-    GetName();
-
-    const char *
-    GetTypeName ();
-    
-    const char *
-    GetDisplayTypeName ();
-
-    size_t
-    GetByteSize ();
-
-    bool
-    IsInScope ();
-
-    lldb::Format
-    GetFormat ();
-    
-    void
-    SetFormat (lldb::Format format);
-
-    const char *
-    GetValue ();
-
-    int64_t
-    GetValueAsSigned (lldb::SBError& error, int64_t fail_value=0);
-    
-    uint64_t
-    GetValueAsUnsigned (lldb::SBError& error, uint64_t fail_value=0);
-    
-    int64_t
-    GetValueAsSigned(int64_t fail_value=0);
-    
-    uint64_t
-    GetValueAsUnsigned(uint64_t fail_value=0);
-
-    ValueType
-    GetValueType ();
-
-    // If you call this on a newly created ValueObject, it will always return false.
-    bool
-    GetValueDidChange ();
-
-    const char *
-    GetSummary ();
-    
-    const char *
-    GetSummary (lldb::SBStream& stream,
-                lldb::SBTypeSummaryOptions& options);
-    
-    const char *
-    GetObjectDescription ();
-    
-    const char *
-    GetTypeValidatorResult ();
-    
-    lldb::SBValue
-    GetDynamicValue (lldb::DynamicValueType use_dynamic);
-    
-    lldb::SBValue
-    GetStaticValue ();
-    
-    lldb::SBValue
-    GetNonSyntheticValue ();
-    
-    lldb::DynamicValueType
-    GetPreferDynamicValue ();
-    
-    void
-    SetPreferDynamicValue (lldb::DynamicValueType use_dynamic);
-    
-    bool
-    GetPreferSyntheticValue ();
-    
-    void
-    SetPreferSyntheticValue (bool use_synthetic);
-    
-    bool
-    IsDynamic ();
-    
-    bool
-    IsSynthetic ();
-    
-    bool
-    IsSyntheticChildrenGenerated ();
-    
-    void
-    SetSyntheticChildrenGenerated (bool);
-
-    const char *
-    GetLocation ();
-
-    // Deprecated - use the one that takes SBError&
-    bool
-    SetValueFromCString (const char *value_str);
-
-    bool
-    SetValueFromCString (const char *value_str, lldb::SBError& error);
-    
-    lldb::SBTypeFormat
-    GetTypeFormat ();
-    
-    lldb::SBTypeSummary
-    GetTypeSummary ();
-
-    lldb::SBTypeFilter
-    GetTypeFilter ();
-    
+  SBValue();
+
+  SBValue(const lldb::SBValue &rhs);
+
+  lldb::SBValue &operator=(const lldb::SBValue &rhs);
+
+  ~SBValue();
+
+  bool IsValid();
+
+  void Clear();
+
+  SBError GetError();
+
+  lldb::user_id_t GetID();
+
+  const char *GetName();
+
+  const char *GetTypeName();
+
+  const char *GetDisplayTypeName();
+
+  size_t GetByteSize();
+
+  bool IsInScope();
+
+  lldb::Format GetFormat();
+
+  void SetFormat(lldb::Format format);
+
+  const char *GetValue();
+
+  int64_t GetValueAsSigned(lldb::SBError &error, int64_t fail_value = 0);
+
+  uint64_t GetValueAsUnsigned(lldb::SBError &error, uint64_t fail_value = 0);
+
+  int64_t GetValueAsSigned(int64_t fail_value = 0);
+
+  uint64_t GetValueAsUnsigned(uint64_t fail_value = 0);
+
+  ValueType GetValueType();
+
+  // If you call this on a newly created ValueObject, it will always return
+  // false.
+  bool GetValueDidChange();
+
+  const char *GetSummary();
+
+  const char *GetSummary(lldb::SBStream &stream,
+                         lldb::SBTypeSummaryOptions &options);
+
+  const char *GetObjectDescription();
+
+  const char *GetTypeValidatorResult();
+
+  lldb::SBValue GetDynamicValue(lldb::DynamicValueType use_dynamic);
+
+  lldb::SBValue GetStaticValue();
+
+  lldb::SBValue GetNonSyntheticValue();
+
+  lldb::DynamicValueType GetPreferDynamicValue();
+
+  void SetPreferDynamicValue(lldb::DynamicValueType use_dynamic);
+
+  bool GetPreferSyntheticValue();
+
+  void SetPreferSyntheticValue(bool use_synthetic);
+
+  bool IsDynamic();
+
+  bool IsSynthetic();
+
+  bool IsSyntheticChildrenGenerated();
+
+  void SetSyntheticChildrenGenerated(bool);
+
+  const char *GetLocation();
+
+  // Deprecated - use the one that takes SBError&
+  bool SetValueFromCString(const char *value_str);
+
+  bool SetValueFromCString(const char *value_str, lldb::SBError &error);
+
+  lldb::SBTypeFormat GetTypeFormat();
+
+  lldb::SBTypeSummary GetTypeSummary();
+
+  lldb::SBTypeFilter GetTypeFilter();
+
 #ifndef LLDB_DISABLE_PYTHON
-    lldb::SBTypeSynthetic
-    GetTypeSynthetic ();
+  lldb::SBTypeSynthetic GetTypeSynthetic();
 #endif
 
-    lldb::SBValue
-    GetChildAtIndex (uint32_t idx);
-    
-    lldb::SBValue
-    CreateChildAtOffset (const char *name, uint32_t offset, lldb::SBType type);
-    
-    // Deprecated - use the expression evaluator to perform type casting
-    lldb::SBValue
-    Cast (lldb::SBType type);
-    
-    lldb::SBValue
-    CreateValueFromExpression (const char *name, const char* expression);
-    
-    lldb::SBValue
-    CreateValueFromExpression (const char *name, const char* expression, SBExpressionOptions &options);
-    
-    lldb::SBValue
-    CreateValueFromAddress (const char* name, 
-                            lldb::addr_t address, 
-                            lldb::SBType type);
-    
-    // this has no address! GetAddress() and GetLoadAddress() as well as AddressOf()
-    // on the return of this call all return invalid
-    lldb::SBValue
-    CreateValueFromData (const char* name,
-                         lldb::SBData data,
-                         lldb::SBType type);
-
-    //------------------------------------------------------------------
-    /// Get a child value by index from a value.
-    ///
-    /// Structs, unions, classes, arrays and pointers have child
-    /// values that can be access by index. 
-    ///
-    /// Structs and unions access child members using a zero based index
-    /// for each child member. For
-    /// 
-    /// Classes reserve the first indexes for base classes that have 
-    /// members (empty base classes are omitted), and all members of the
-    /// current class will then follow the base classes. 
-    ///
-    /// Pointers differ depending on what they point to. If the pointer
-    /// points to a simple type, the child at index zero
-    /// is the only child value available, unless \a synthetic_allowed 
-    /// is \b true, in which case the pointer will be used as an array
-    /// and can create 'synthetic' child values using positive or 
-    /// negative indexes. If the pointer points to an aggregate type 
-    /// (an array, class, union, struct), then the pointee is 
-    /// transparently skipped and any children are going to be the indexes
-    /// of the child values within the aggregate type. For example if
-    /// we have a 'Point' type and we have a SBValue that contains a
-    /// pointer to a 'Point' type, then the child at index zero will be
-    /// the 'x' member, and the child at index 1 will be the 'y' member
-    /// (the child at index zero won't be a 'Point' instance).
-    ///
-    /// If you actually need an SBValue that represents the type pointed
-    /// to by a SBValue for which GetType().IsPointeeType() returns true,
-    /// regardless of the pointee type, you can do that with SBValue::Dereference.
-    ///
-    /// Arrays have a preset number of children that can be accessed by
-    /// index and will returns invalid child values for indexes that are
-    /// out of bounds unless the \a synthetic_allowed is \b true. In this
-    /// case the array can create 'synthetic' child values for indexes 
-    /// that aren't in the array bounds using positive or negative 
-    /// indexes.
-    ///
-    /// @param[in] idx
-    ///     The index of the child value to get
-    ///
-    /// @param[in] use_dynamic
-    ///     An enumeration that specifies whether to get dynamic values,
-    ///     and also if the target can be run to figure out the dynamic
-    ///     type of the child value.
-    ///
-    /// @param[in] can_create_synthetic
-    ///     If \b true, then allow child values to be created by index
-    ///     for pointers and arrays for indexes that normally wouldn't
-    ///     be allowed.
-    ///
-    /// @return
-    ///     A new SBValue object that represents the child member value.
-    //------------------------------------------------------------------
-    lldb::SBValue
-    GetChildAtIndex (uint32_t idx, 
-                     lldb::DynamicValueType use_dynamic,
-                     bool can_create_synthetic);
-
-    // Matches children of this object only and will match base classes and
-    // member names if this is a clang typed object.
-    uint32_t
-    GetIndexOfChildWithName (const char *name);
-
-    // Matches child members of this object and child members of any base
-    // classes.
-    lldb::SBValue
-    GetChildMemberWithName (const char *name);
-
-    // Matches child members of this object and child members of any base
-    // classes.
-    lldb::SBValue
-    GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic);
-    
-    // Expands nested expressions like .a->b[0].c[1]->d
-    lldb::SBValue
-    GetValueForExpressionPath(const char* expr_path);
-    
-    lldb::SBValue
-    AddressOf();
-    
-    lldb::addr_t
-    GetLoadAddress();
-    
-    lldb::SBAddress
-    GetAddress();
-
-    //------------------------------------------------------------------
-    /// Get an SBData wrapping what this SBValue points to.
-    ///
-    /// This method will dereference the current SBValue, if its
-    /// data type is a T* or T[], and extract item_count elements
-    /// of type T from it, copying their contents in an SBData. 
-    ///
-    /// @param[in] item_idx
-    ///     The index of the first item to retrieve. For an array
-    ///     this is equivalent to array[item_idx], for a pointer
-    ///     to *(pointer + item_idx). In either case, the measurement
-    ///     unit for item_idx is the sizeof(T) rather than the byte
-    ///
-    /// @param[in] item_count
-    ///     How many items should be copied into the output. By default
-    ///     only one item is copied, but more can be asked for.
-    ///
-    /// @return
-    ///     An SBData with the contents of the copied items, on success.
-    ///     An empty SBData otherwise.
-    //------------------------------------------------------------------
-    lldb::SBData
-    GetPointeeData (uint32_t item_idx = 0,
-                    uint32_t item_count = 1);
-    
-    //------------------------------------------------------------------
-    /// Get an SBData wrapping the contents of this SBValue.
-    ///
-    /// This method will read the contents of this object in memory
-    /// and copy them into an SBData for future use. 
-    ///
-    /// @return
-    ///     An SBData with the contents of this SBValue, on success.
-    ///     An empty SBData otherwise.
-    //------------------------------------------------------------------
-    lldb::SBData
-    GetData ();
-    
-    bool
-    SetData (lldb::SBData &data, lldb::SBError& error);
-    
-    lldb::SBDeclaration
-    GetDeclaration ();
-    
-    //------------------------------------------------------------------
-    /// Find out if a SBValue might have children.
-    ///
-    /// This call is much more efficient than GetNumChildren() as it
-    /// doesn't need to complete the underlying type. This is designed
-    /// to be used in a UI environment in order to detect if the
-    /// disclosure triangle should be displayed or not.
-    ///
-    /// This function returns true for class, union, structure,
-    /// pointers, references, arrays and more. Again, it does so without
-    /// doing any expensive type completion.
-    ///
-    /// @return
-    ///     Returns \b true if the SBValue might have children, or \b
-    ///     false otherwise.
-    //------------------------------------------------------------------
-    bool
-    MightHaveChildren ();
-    
-    bool
-    IsRuntimeSupportValue ();
-
-    uint32_t
-    GetNumChildren ();
-
-    uint32_t
-    GetNumChildren (uint32_t max);
-
-    void *
-    GetOpaqueType();
-
-    lldb::SBTarget
-    GetTarget();
-    
-    lldb::SBProcess
-    GetProcess();
-    
-    lldb::SBThread
-    GetThread();
-
-    lldb::SBFrame
-    GetFrame();
-    
-    lldb::SBValue
-    Dereference ();
-
-    // Deprecated - please use GetType().IsPointerType() instead.
-    bool
-    TypeIsPointerType ();
-    
-    lldb::SBType
-    GetType();
-    
-    lldb::SBValue
-    Persist ();
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    bool
-    GetExpressionPath (lldb::SBStream &description);
-    
-    bool
-    GetExpressionPath (lldb::SBStream &description, 
-                       bool qualify_cxx_base_classes);
-
-    SBValue (const lldb::ValueObjectSP &value_sp);
-
-    //------------------------------------------------------------------
-    /// Watch this value if it resides in memory.
-    ///
-    /// Sets a watchpoint on the value.
-    ///
-    /// @param[in] resolve_location
-    ///     Resolve the location of this value once and watch its address.
-    ///     This value must currently be set to \b true as watching all
-    ///     locations of a variable or a variable path is not yet supported,
-    ///     though we plan to support it in the future.
-    ///
-    /// @param[in] read
-    ///     Stop when this value is accessed.
-    ///
-    /// @param[in] write
-    ///     Stop when this value is modified
-    ///
-    /// @param[out] error
-    ///     An error object. Contains the reason if there is some failure.
-    ///
-    /// @return
-    ///     An SBWatchpoint object. This object might not be valid upon
-    ///     return due to a value not being contained in memory, too 
-    ///     large, or watchpoint resources are not available or all in
-    ///     use.
-    //------------------------------------------------------------------
-    lldb::SBWatchpoint
-    Watch (bool resolve_location, bool read, bool write, SBError &error);
-
-    // Backward compatibility fix in the interim.
-    lldb::SBWatchpoint
-    Watch (bool resolve_location, bool read, bool write);
-
-    //------------------------------------------------------------------
-    /// Watch this value that this value points to in memory
-    ///
-    /// Sets a watchpoint on the value.
-    ///
-    /// @param[in] resolve_location
-    ///     Resolve the location of this value once and watch its address.
-    ///     This value must currently be set to \b true as watching all
-    ///     locations of a variable or a variable path is not yet supported,
-    ///     though we plan to support it in the future.
-    ///
-    /// @param[in] read
-    ///     Stop when this value is accessed.
-    ///
-    /// @param[in] write
-    ///     Stop when this value is modified
-    ///
-    /// @param[out] error
-    ///     An error object. Contains the reason if there is some failure.
-    ///
-    /// @return
-    ///     An SBWatchpoint object. This object might not be valid upon
-    ///     return due to a value not being contained in memory, too 
-    ///     large, or watchpoint resources are not available or all in
-    ///     use.
-    //------------------------------------------------------------------
-    lldb::SBWatchpoint
-    WatchPointee (bool resolve_location, bool read, bool write, SBError &error);
-
-    //------------------------------------------------------------------
-    /// Same as the protected version of GetSP that takes a locker, except that we make the
-    /// locker locally in the function.  Since the Target API mutex is recursive, and the
-    /// StopLocker is a read lock, you can call this function even if you are already
-    /// holding the two above-mentioned locks.
-    ///
-    /// @return
-    ///     A ValueObjectSP of the best kind (static, dynamic or synthetic) we
-    ///     can cons up, in accordance with the SBValue's settings.
-    //------------------------------------------------------------------
-    lldb::ValueObjectSP
-    GetSP () const;
+  lldb::SBValue GetChildAtIndex(uint32_t idx);
+
+  lldb::SBValue CreateChildAtOffset(const char *name, uint32_t offset,
+                                    lldb::SBType type);
+
+  // Deprecated - use the expression evaluator to perform type casting
+  lldb::SBValue Cast(lldb::SBType type);
+
+  lldb::SBValue CreateValueFromExpression(const char *name,
+                                          const char *expression);
+
+  lldb::SBValue CreateValueFromExpression(const char *name,
+                                          const char *expression,
+                                          SBExpressionOptions &options);
+
+  lldb::SBValue CreateValueFromAddress(const char *name, lldb::addr_t address,
+                                       lldb::SBType type);
+
+  // this has no address! GetAddress() and GetLoadAddress() as well as
+  // AddressOf()
+  // on the return of this call all return invalid
+  lldb::SBValue CreateValueFromData(const char *name, lldb::SBData data,
+                                    lldb::SBType type);
+
+  //------------------------------------------------------------------
+  /// Get a child value by index from a value.
+  ///
+  /// Structs, unions, classes, arrays and pointers have child
+  /// values that can be access by index.
+  ///
+  /// Structs and unions access child members using a zero based index
+  /// for each child member. For
+  ///
+  /// Classes reserve the first indexes for base classes that have
+  /// members (empty base classes are omitted), and all members of the
+  /// current class will then follow the base classes.
+  ///
+  /// Pointers differ depending on what they point to. If the pointer
+  /// points to a simple type, the child at index zero
+  /// is the only child value available, unless \a synthetic_allowed
+  /// is \b true, in which case the pointer will be used as an array
+  /// and can create 'synthetic' child values using positive or
+  /// negative indexes. If the pointer points to an aggregate type
+  /// (an array, class, union, struct), then the pointee is
+  /// transparently skipped and any children are going to be the indexes
+  /// of the child values within the aggregate type. For example if
+  /// we have a 'Point' type and we have a SBValue that contains a
+  /// pointer to a 'Point' type, then the child at index zero will be
+  /// the 'x' member, and the child at index 1 will be the 'y' member
+  /// (the child at index zero won't be a 'Point' instance).
+  ///
+  /// If you actually need an SBValue that represents the type pointed
+  /// to by a SBValue for which GetType().IsPointeeType() returns true,
+  /// regardless of the pointee type, you can do that with SBValue::Dereference.
+  ///
+  /// Arrays have a preset number of children that can be accessed by
+  /// index and will returns invalid child values for indexes that are
+  /// out of bounds unless the \a synthetic_allowed is \b true. In this
+  /// case the array can create 'synthetic' child values for indexes
+  /// that aren't in the array bounds using positive or negative
+  /// indexes.
+  ///
+  /// @param[in] idx
+  ///     The index of the child value to get
+  ///
+  /// @param[in] use_dynamic
+  ///     An enumeration that specifies whether to get dynamic values,
+  ///     and also if the target can be run to figure out the dynamic
+  ///     type of the child value.
+  ///
+  /// @param[in] can_create_synthetic
+  ///     If \b true, then allow child values to be created by index
+  ///     for pointers and arrays for indexes that normally wouldn't
+  ///     be allowed.
+  ///
+  /// @return
+  ///     A new SBValue object that represents the child member value.
+  //------------------------------------------------------------------
+  lldb::SBValue GetChildAtIndex(uint32_t idx,
+                                lldb::DynamicValueType use_dynamic,
+                                bool can_create_synthetic);
+
+  // Matches children of this object only and will match base classes and
+  // member names if this is a clang typed object.
+  uint32_t GetIndexOfChildWithName(const char *name);
+
+  // Matches child members of this object and child members of any base
+  // classes.
+  lldb::SBValue GetChildMemberWithName(const char *name);
+
+  // Matches child members of this object and child members of any base
+  // classes.
+  lldb::SBValue GetChildMemberWithName(const char *name,
+                                       lldb::DynamicValueType use_dynamic);
+
+  // Expands nested expressions like .a->b[0].c[1]->d
+  lldb::SBValue GetValueForExpressionPath(const char *expr_path);
+
+  lldb::SBValue AddressOf();
+
+  lldb::addr_t GetLoadAddress();
+
+  lldb::SBAddress GetAddress();
+
+  //------------------------------------------------------------------
+  /// Get an SBData wrapping what this SBValue points to.
+  ///
+  /// This method will dereference the current SBValue, if its
+  /// data type is a T* or T[], and extract item_count elements
+  /// of type T from it, copying their contents in an SBData.
+  ///
+  /// @param[in] item_idx
+  ///     The index of the first item to retrieve. For an array
+  ///     this is equivalent to array[item_idx], for a pointer
+  ///     to *(pointer + item_idx). In either case, the measurement
+  ///     unit for item_idx is the sizeof(T) rather than the byte
+  ///
+  /// @param[in] item_count
+  ///     How many items should be copied into the output. By default
+  ///     only one item is copied, but more can be asked for.
+  ///
+  /// @return
+  ///     An SBData with the contents of the copied items, on success.
+  ///     An empty SBData otherwise.
+  //------------------------------------------------------------------
+  lldb::SBData GetPointeeData(uint32_t item_idx = 0, uint32_t item_count = 1);
+
+  //------------------------------------------------------------------
+  /// Get an SBData wrapping the contents of this SBValue.
+  ///
+  /// This method will read the contents of this object in memory
+  /// and copy them into an SBData for future use.
+  ///
+  /// @return
+  ///     An SBData with the contents of this SBValue, on success.
+  ///     An empty SBData otherwise.
+  //------------------------------------------------------------------
+  lldb::SBData GetData();
+
+  bool SetData(lldb::SBData &data, lldb::SBError &error);
+
+  lldb::SBDeclaration GetDeclaration();
+
+  //------------------------------------------------------------------
+  /// Find out if a SBValue might have children.
+  ///
+  /// This call is much more efficient than GetNumChildren() as it
+  /// doesn't need to complete the underlying type. This is designed
+  /// to be used in a UI environment in order to detect if the
+  /// disclosure triangle should be displayed or not.
+  ///
+  /// This function returns true for class, union, structure,
+  /// pointers, references, arrays and more. Again, it does so without
+  /// doing any expensive type completion.
+  ///
+  /// @return
+  ///     Returns \b true if the SBValue might have children, or \b
+  ///     false otherwise.
+  //------------------------------------------------------------------
+  bool MightHaveChildren();
+
+  bool IsRuntimeSupportValue();
+
+  uint32_t GetNumChildren();
+
+  uint32_t GetNumChildren(uint32_t max);
+
+  void *GetOpaqueType();
+
+  lldb::SBTarget GetTarget();
+
+  lldb::SBProcess GetProcess();
+
+  lldb::SBThread GetThread();
+
+  lldb::SBFrame GetFrame();
+
+  lldb::SBValue Dereference();
+
+  // Deprecated - please use GetType().IsPointerType() instead.
+  bool TypeIsPointerType();
+
+  lldb::SBType GetType();
+
+  lldb::SBValue Persist();
+
+  bool GetDescription(lldb::SBStream &description);
+
+  bool GetExpressionPath(lldb::SBStream &description);
+
+  bool GetExpressionPath(lldb::SBStream &description,
+                         bool qualify_cxx_base_classes);
+
+  SBValue(const lldb::ValueObjectSP &value_sp);
+
+  //------------------------------------------------------------------
+  /// Watch this value if it resides in memory.
+  ///
+  /// Sets a watchpoint on the value.
+  ///
+  /// @param[in] resolve_location
+  ///     Resolve the location of this value once and watch its address.
+  ///     This value must currently be set to \b true as watching all
+  ///     locations of a variable or a variable path is not yet supported,
+  ///     though we plan to support it in the future.
+  ///
+  /// @param[in] read
+  ///     Stop when this value is accessed.
+  ///
+  /// @param[in] write
+  ///     Stop when this value is modified
+  ///
+  /// @param[out] error
+  ///     An error object. Contains the reason if there is some failure.
+  ///
+  /// @return
+  ///     An SBWatchpoint object. This object might not be valid upon
+  ///     return due to a value not being contained in memory, too
+  ///     large, or watchpoint resources are not available or all in
+  ///     use.
+  //------------------------------------------------------------------
+  lldb::SBWatchpoint Watch(bool resolve_location, bool read, bool write,
+                           SBError &error);
+
+  // Backward compatibility fix in the interim.
+  lldb::SBWatchpoint Watch(bool resolve_location, bool read, bool write);
+
+  //------------------------------------------------------------------
+  /// Watch this value that this value points to in memory
+  ///
+  /// Sets a watchpoint on the value.
+  ///
+  /// @param[in] resolve_location
+  ///     Resolve the location of this value once and watch its address.
+  ///     This value must currently be set to \b true as watching all
+  ///     locations of a variable or a variable path is not yet supported,
+  ///     though we plan to support it in the future.
+  ///
+  /// @param[in] read
+  ///     Stop when this value is accessed.
+  ///
+  /// @param[in] write
+  ///     Stop when this value is modified
+  ///
+  /// @param[out] error
+  ///     An error object. Contains the reason if there is some failure.
+  ///
+  /// @return
+  ///     An SBWatchpoint object. This object might not be valid upon
+  ///     return due to a value not being contained in memory, too
+  ///     large, or watchpoint resources are not available or all in
+  ///     use.
+  //------------------------------------------------------------------
+  lldb::SBWatchpoint WatchPointee(bool resolve_location, bool read, bool write,
+                                  SBError &error);
+
+  //------------------------------------------------------------------
+  /// Same as the protected version of GetSP that takes a locker, except that we
+  /// make the
+  /// locker locally in the function.  Since the Target API mutex is recursive,
+  /// and the
+  /// StopLocker is a read lock, you can call this function even if you are
+  /// already
+  /// holding the two above-mentioned locks.
+  ///
+  /// @return
+  ///     A ValueObjectSP of the best kind (static, dynamic or synthetic) we
+  ///     can cons up, in accordance with the SBValue's settings.
+  //------------------------------------------------------------------
+  lldb::ValueObjectSP GetSP() const;
 
 protected:
-    friend class SBBlock;
-    friend class SBFrame;
-    friend class SBTarget;
-    friend class SBThread;
-    friend class SBValueList;
-
-    //------------------------------------------------------------------
-    /// Get the appropriate ValueObjectSP from this SBValue, consulting the
-    /// use_dynamic and use_synthetic options passed in to SetSP when the
-    /// SBValue's contents were set.  Since this often requires examining memory,
-    /// and maybe even running code, it needs to acquire the Target API and Process StopLock.
-    /// Those are held in an opaque class ValueLocker which is currently local to SBValue.cpp.
-    /// So you don't have to get these yourself just default construct a ValueLocker, and pass it into this.
-    /// If we need to make a ValueLocker and use it in some other .cpp file, we'll have to move it to
-    /// ValueObject.h/cpp or somewhere else convenient.  We haven't needed to so far.
-    ///
-    /// @param[in] value_locker
-    ///     An object that will hold the Target API, and Process RunLocks, and
-    ///     auto-destroy them when it goes out of scope.  Currently this is only useful in
-    ///     SBValue.cpp.
-    ///
-    /// @return
-    ///     A ValueObjectSP of the best kind (static, dynamic or synthetic) we
-    ///     can cons up, in accordance with the SBValue's settings.
-    //------------------------------------------------------------------
-    lldb::ValueObjectSP
-    GetSP (ValueLocker &value_locker) const;
-    
-    // these calls do the right thing WRT adjusting their settings according to the target's preferences
-    void
-    SetSP (const lldb::ValueObjectSP &sp);
-
-    void
-    SetSP (const lldb::ValueObjectSP &sp, bool use_synthetic);
-    
-    void
-    SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic);
-
-    void
-    SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic);
-    
-    void
-    SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic, const char *name);
-    
+  friend class SBBlock;
+  friend class SBFrame;
+  friend class SBTarget;
+  friend class SBThread;
+  friend class SBValueList;
+
+  //------------------------------------------------------------------
+  /// Get the appropriate ValueObjectSP from this SBValue, consulting the
+  /// use_dynamic and use_synthetic options passed in to SetSP when the
+  /// SBValue's contents were set.  Since this often requires examining memory,
+  /// and maybe even running code, it needs to acquire the Target API and
+  /// Process StopLock.
+  /// Those are held in an opaque class ValueLocker which is currently local to
+  /// SBValue.cpp.
+  /// So you don't have to get these yourself just default construct a
+  /// ValueLocker, and pass it into this.
+  /// If we need to make a ValueLocker and use it in some other .cpp file, we'll
+  /// have to move it to
+  /// ValueObject.h/cpp or somewhere else convenient.  We haven't needed to so
+  /// far.
+  ///
+  /// @param[in] value_locker
+  ///     An object that will hold the Target API, and Process RunLocks, and
+  ///     auto-destroy them when it goes out of scope.  Currently this is only
+  ///     useful in
+  ///     SBValue.cpp.
+  ///
+  /// @return
+  ///     A ValueObjectSP of the best kind (static, dynamic or synthetic) we
+  ///     can cons up, in accordance with the SBValue's settings.
+  //------------------------------------------------------------------
+  lldb::ValueObjectSP GetSP(ValueLocker &value_locker) const;
+
+  // these calls do the right thing WRT adjusting their settings according to
+  // the target's preferences
+  void SetSP(const lldb::ValueObjectSP &sp);
+
+  void SetSP(const lldb::ValueObjectSP &sp, bool use_synthetic);
+
+  void SetSP(const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic);
+
+  void SetSP(const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic,
+             bool use_synthetic);
+
+  void SetSP(const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic,
+             bool use_synthetic, const char *name);
+
 private:
-    typedef std::shared_ptr<ValueImpl> ValueImplSP;
-    ValueImplSP m_opaque_sp;
-    
-    void
-    SetSP (ValueImplSP impl_sp);
+  typedef std::shared_ptr<ValueImpl> ValueImplSP;
+  ValueImplSP m_opaque_sp;
+
+  void SetSP(ValueImplSP impl_sp);
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBValue_h_
+#endif // LLDB_SBValue_h_
diff --git a/include/lldb/API/SBValueList.h b/include/lldb/API/SBValueList.h
index 563ca3d7e1bf..495b0140cad0 100644
--- a/include/lldb/API/SBValueList.h
+++ b/include/lldb/API/SBValueList.h
@@ -16,81 +16,59 @@ class ValueListImpl;
 
 namespace lldb {
 
-class LLDB_API SBValueList
-{
+class LLDB_API SBValueList {
 public:
+  SBValueList();
 
-    SBValueList ();
+  SBValueList(const lldb::SBValueList &rhs);
 
-    SBValueList (const lldb::SBValueList &rhs);
+  ~SBValueList();
 
-    ~SBValueList();
+  bool IsValid() const;
 
-    bool
-    IsValid() const;
-    
-    void
-    Clear();
+  void Clear();
 
-    void
-    Append (const lldb::SBValue &val_obj);
+  void Append(const lldb::SBValue &val_obj);
 
-    void
-    Append (const lldb::SBValueList& value_list);
+  void Append(const lldb::SBValueList &value_list);
 
-    uint32_t
-    GetSize() const;
+  uint32_t GetSize() const;
 
-    lldb::SBValue
-    GetValueAtIndex (uint32_t idx) const;
-    
-    lldb::SBValue
-    GetFirstValueByName (const char* name) const;
+  lldb::SBValue GetValueAtIndex(uint32_t idx) const;
 
-    lldb::SBValue
-    FindValueObjectByUID (lldb::user_id_t uid);
+  lldb::SBValue GetFirstValueByName(const char *name) const;
 
-    const lldb::SBValueList &
-    operator = (const lldb::SBValueList &rhs);
+  lldb::SBValue FindValueObjectByUID(lldb::user_id_t uid);
+
+  const lldb::SBValueList &operator=(const lldb::SBValueList &rhs);
 
 protected:
-    
-    // only useful for visualizing the pointer or comparing two SBValueLists
-    // to see if they are backed by the same underlying Impl.
-    void *
-    opaque_ptr ();
+  // only useful for visualizing the pointer or comparing two SBValueLists
+  // to see if they are backed by the same underlying Impl.
+  void *opaque_ptr();
 
 private:
-    friend class SBFrame;
-    
-    SBValueList (const ValueListImpl *lldb_object_ptr);
-
-    void
-    Append (lldb::ValueObjectSP& val_obj_sp);
-
-    void
-    CreateIfNeeded ();
-
-    ValueListImpl *
-    operator -> ();
-    
-    ValueListImpl &
-    operator* ();
-    
-    const ValueListImpl *
-    operator -> () const;
-    
-    const ValueListImpl &
-    operator* () const;
-    
-    
-    ValueListImpl &
-    ref ();
-    
-    std::unique_ptr<ValueListImpl> m_opaque_ap;
-};
+  friend class SBFrame;
+
+  SBValueList(const ValueListImpl *lldb_object_ptr);
+
+  void Append(lldb::ValueObjectSP &val_obj_sp);
+
+  void CreateIfNeeded();
+
+  ValueListImpl *operator->();
 
+  ValueListImpl &operator*();
+
+  const ValueListImpl *operator->() const;
+
+  const ValueListImpl &operator*() const;
+
+  ValueListImpl &ref();
+
+  std::unique_ptr<ValueListImpl> m_opaque_ap;
+};
 
 } // namespace lldb
 
-#endif  // LLDB_SBValueList_h_
+#endif // LLDB_SBValueList_h_
diff --git a/include/lldb/API/SBVariablesOptions.h b/include/lldb/API/SBVariablesOptions.h
index 527310f5dfc7..756da6439e3b 100644
--- a/include/lldb/API/SBVariablesOptions.h
+++ b/include/lldb/API/SBVariablesOptions.h
@@ -1,4 +1,5 @@
-//===-- SBVariablesOptions.h ------------------------------------------*- C++ -*-===//
+//===-- SBVariablesOptions.h ------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -16,83 +17,61 @@ class VariablesOptionsImpl;
 
 namespace lldb {
 
-class LLDB_API SBVariablesOptions
-{
+class LLDB_API SBVariablesOptions {
 public:
-    SBVariablesOptions ();
-    
-    SBVariablesOptions (const SBVariablesOptions& options);
-    
-    SBVariablesOptions&
-    operator = (const SBVariablesOptions& options);
-    
-    ~SBVariablesOptions ();
-    
-    bool
-    IsValid () const;
-    
-    bool
-    GetIncludeArguments () const;
-    
-    void
-    SetIncludeArguments (bool);
-    
-    bool
-    GetIncludeLocals () const;
-    
-    void
-    SetIncludeLocals (bool);
-    
-    bool
-    GetIncludeStatics () const;
-    
-    void
-    SetIncludeStatics (bool);
-    
-    bool
-    GetInScopeOnly () const;
-    
-    void
-    SetInScopeOnly (bool);
-    
-    bool
-    GetIncludeRuntimeSupportValues () const;
-    
-    void
-    SetIncludeRuntimeSupportValues (bool);
-    
-    lldb::DynamicValueType
-    GetUseDynamic () const;
-    
-    void
-    SetUseDynamic (lldb::DynamicValueType);
-    
+  SBVariablesOptions();
+
+  SBVariablesOptions(const SBVariablesOptions &options);
+
+  SBVariablesOptions &operator=(const SBVariablesOptions &options);
+
+  ~SBVariablesOptions();
+
+  bool IsValid() const;
+
+  bool GetIncludeArguments() const;
+
+  void SetIncludeArguments(bool);
+
+  bool GetIncludeLocals() const;
+
+  void SetIncludeLocals(bool);
+
+  bool GetIncludeStatics() const;
+
+  void SetIncludeStatics(bool);
+
+  bool GetInScopeOnly() const;
+
+  void SetInScopeOnly(bool);
+
+  bool GetIncludeRuntimeSupportValues() const;
+
+  void SetIncludeRuntimeSupportValues(bool);
+
+  lldb::DynamicValueType GetUseDynamic() const;
+
+  void SetUseDynamic(lldb::DynamicValueType);
+
 protected:
-    VariablesOptionsImpl *
-    operator->();
-    
-    const VariablesOptionsImpl *
-    operator->() const;
-    
-    VariablesOptionsImpl *
-    get ();
-    
-    VariablesOptionsImpl &
-    ref();
-    
-    const VariablesOptionsImpl &
-    ref() const;
-    
-    SBVariablesOptions (VariablesOptionsImpl *lldb_object_ptr);
-    
-    void
-    SetOptions (VariablesOptionsImpl *lldb_object_ptr);
-    
+  VariablesOptionsImpl *operator->();
+
+  const VariablesOptionsImpl *operator->() const;
+
+  VariablesOptionsImpl *get();
+
+  VariablesOptionsImpl &ref();
+
+  const VariablesOptionsImpl &ref() const;
+
+  SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr);
+
+  void SetOptions(VariablesOptionsImpl *lldb_object_ptr);
+
 private:
-    
-    std::unique_ptr<VariablesOptionsImpl> m_opaque_ap;
+  std::unique_ptr<VariablesOptionsImpl> m_opaque_ap;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBValue_h_
+#endif // LLDB_SBValue_h_
diff --git a/include/lldb/API/SBWatchpoint.h b/include/lldb/API/SBWatchpoint.h
index 5d0d48ee12f2..284ec12392a3 100644
--- a/include/lldb/API/SBWatchpoint.h
+++ b/include/lldb/API/SBWatchpoint.h
@@ -14,91 +14,67 @@
 
 namespace lldb {
 
-class LLDB_API SBWatchpoint
-{
+class LLDB_API SBWatchpoint {
 public:
+  SBWatchpoint();
 
-    SBWatchpoint ();
+  SBWatchpoint(const lldb::SBWatchpoint &rhs);
 
-    SBWatchpoint (const lldb::SBWatchpoint &rhs);
+  SBWatchpoint(const lldb::WatchpointSP &wp_sp);
 
-    SBWatchpoint (const lldb::WatchpointSP &wp_sp);
+  ~SBWatchpoint();
 
-    ~SBWatchpoint ();
+  const lldb::SBWatchpoint &operator=(const lldb::SBWatchpoint &rhs);
 
-    const lldb::SBWatchpoint &
-    operator = (const lldb::SBWatchpoint &rhs);
+  bool IsValid() const;
 
-    bool
-    IsValid() const;
+  SBError GetError();
 
-    SBError
-    GetError();
+  watch_id_t GetID();
 
-    watch_id_t
-    GetID ();
+  /// With -1 representing an invalid hardware index.
+  int32_t GetHardwareIndex();
 
-    /// With -1 representing an invalid hardware index.
-    int32_t
-    GetHardwareIndex ();
+  lldb::addr_t GetWatchAddress();
 
-    lldb::addr_t
-    GetWatchAddress ();
+  size_t GetWatchSize();
 
-    size_t
-    GetWatchSize();
+  void SetEnabled(bool enabled);
 
-    void
-    SetEnabled(bool enabled);
+  bool IsEnabled();
 
-    bool
-    IsEnabled ();
+  uint32_t GetHitCount();
 
-    uint32_t
-    GetHitCount ();
+  uint32_t GetIgnoreCount();
 
-    uint32_t
-    GetIgnoreCount ();
+  void SetIgnoreCount(uint32_t n);
 
-    void
-    SetIgnoreCount (uint32_t n);
+  const char *GetCondition();
 
-    const char *
-    GetCondition ();
+  void SetCondition(const char *condition);
 
-    void 
-    SetCondition (const char *condition);
-    
-    bool
-    GetDescription (lldb::SBStream &description, DescriptionLevel level);
+  bool GetDescription(lldb::SBStream &description, DescriptionLevel level);
 
-    void
-    Clear ();
+  void Clear();
 
-    lldb::WatchpointSP
-    GetSP () const;
+  lldb::WatchpointSP GetSP() const;
 
-    void
-    SetSP (const lldb::WatchpointSP &sp);
+  void SetSP(const lldb::WatchpointSP &sp);
 
-    static bool
-    EventIsWatchpointEvent (const lldb::SBEvent &event);
-    
-    static lldb::WatchpointEventType
-    GetWatchpointEventTypeFromEvent (const lldb::SBEvent& event);
+  static bool EventIsWatchpointEvent(const lldb::SBEvent &event);
 
-    static lldb::SBWatchpoint
-    GetWatchpointFromEvent (const lldb::SBEvent& event);
+  static lldb::WatchpointEventType
+  GetWatchpointEventTypeFromEvent(const lldb::SBEvent &event);
 
-private:
-    friend class SBTarget;
-    friend class SBValue;
+  static lldb::SBWatchpoint GetWatchpointFromEvent(const lldb::SBEvent &event);
 
-    
-    lldb::WatchpointSP m_opaque_sp;
+private:
+  friend class SBTarget;
+  friend class SBValue;
 
+  lldb::WatchpointSP m_opaque_sp;
 };
 
 } // namespace lldb
 
-#endif  // LLDB_SBWatchpoint_h_
+#endif // LLDB_SBWatchpoint_h_
diff --git a/include/lldb/API/SystemInitializerFull.h b/include/lldb/API/SystemInitializerFull.h
index 9e37611a6598..9cfc6896da61 100644
--- a/include/lldb/API/SystemInitializerFull.h
+++ b/include/lldb/API/SystemInitializerFull.h
@@ -12,8 +12,7 @@
 
 #include "lldb/Initialization/SystemInitializerCommon.h"
 
-namespace lldb_private
-{
+namespace lldb_private {
 //------------------------------------------------------------------
 /// Initializes lldb.
 ///
@@ -22,17 +21,16 @@ namespace lldb_private
 /// not intended to be used externally, but is instead used
 /// internally by SBDebugger to initialize the system.
 //------------------------------------------------------------------
-class SystemInitializerFull : public SystemInitializerCommon
-{
-  public:
-    SystemInitializerFull();
-    ~SystemInitializerFull() override;
+class SystemInitializerFull : public SystemInitializerCommon {
+public:
+  SystemInitializerFull();
+  ~SystemInitializerFull() override;
 
-    void Initialize() override;
-    void Terminate() override;
+  void Initialize() override;
+  void Terminate() override;
 
-  private:
-    void InitializeSWIG();
+private:
+  void InitializeSWIG();
 };
 
 } // namespace lldb_private
diff --git a/include/lldb/Breakpoint/Breakpoint.h b/include/lldb/Breakpoint/Breakpoint.h
index 7fdf06da3936..9af6e586de39 100644
--- a/include/lldb/Breakpoint/Breakpoint.h
+++ b/include/lldb/Breakpoint/Breakpoint.h
@@ -20,13 +20,14 @@
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointID.h"
+#include "lldb/Breakpoint/BreakpointLocationCollection.h"
 #include "lldb/Breakpoint/BreakpointLocationList.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
-#include "lldb/Breakpoint/BreakpointLocationCollection.h"
 #include "lldb/Breakpoint/Stoppoint.h"
-#include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/Event.h"
+#include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/StringList.h"
+#include "lldb/Core/StructuredData.h"
 
 namespace lldb_private {
 
@@ -37,27 +38,35 @@ namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// General Outline:
-/// A breakpoint has four main parts, a filter, a resolver, the list of breakpoint
-/// locations that have been determined for the filter/resolver pair, and finally
+/// A breakpoint has four main parts, a filter, a resolver, the list of
+/// breakpoint
+/// locations that have been determined for the filter/resolver pair, and
+/// finally
 /// a set of options for the breakpoint.
 ///
 /// \b Filter:
 /// This is an object derived from SearchFilter.  It manages the search
-/// for breakpoint location matches through the symbols in the module list of the target
-/// that owns it.  It also filters out locations based on whatever logic it wants.
+/// for breakpoint location matches through the symbols in the module list of
+/// the target
+/// that owns it.  It also filters out locations based on whatever logic it
+/// wants.
 ///
 /// \b Resolver:
 /// This is an object derived from BreakpointResolver.  It provides a
-/// callback to the filter that will find breakpoint locations.  How it does this is
+/// callback to the filter that will find breakpoint locations.  How it does
+/// this is
 /// determined by what kind of resolver it is.
 ///
-/// The Breakpoint class also provides constructors for the common breakpoint cases
+/// The Breakpoint class also provides constructors for the common breakpoint
+/// cases
 /// which make the appropriate filter and resolver for you.
 ///
 /// \b Location List:
 /// This stores the breakpoint locations that have been determined
-/// to date.  For a given breakpoint, there will be only one location with a given
-/// address.  Adding a location at an already taken address will just return the location
+/// to date.  For a given breakpoint, there will be only one location with a
+/// given
+/// address.  Adding a location at an already taken address will just return the
+/// location
 /// already at that address.  Locations can be looked up by ID, or by address.
 ///
 /// \b Options:
@@ -66,734 +75,687 @@ namespace lldb_private {
 ///    \b Ignore Count
 ///    \b Callback
 ///    \b Condition
-/// Note, these options can be set on the breakpoint, and they can also be set on the
-/// individual locations.  The options set on the breakpoint take precedence over the
+/// Note, these options can be set on the breakpoint, and they can also be set
+/// on the
+/// individual locations.  The options set on the breakpoint take precedence
+/// over the
 /// options set on the individual location.
-/// So for instance disabling the breakpoint will cause NONE of the locations to get hit.
-/// But if the breakpoint is enabled, then the location's enabled state will be checked
+/// So for instance disabling the breakpoint will cause NONE of the locations to
+/// get hit.
+/// But if the breakpoint is enabled, then the location's enabled state will be
+/// checked
 /// to determine whether to insert that breakpoint location.
-/// Similarly, if the breakpoint condition says "stop", we won't check the location's condition.
-/// But if the breakpoint condition says "continue", then we will check the location for whether
+/// Similarly, if the breakpoint condition says "stop", we won't check the
+/// location's condition.
+/// But if the breakpoint condition says "continue", then we will check the
+/// location for whether
 /// to actually stop or not.
-/// One subtle point worth observing here is that you don't actually stop at a Breakpoint, you
-/// always stop at one of its locations.  So the "should stop" tests are done by the location,
+/// One subtle point worth observing here is that you don't actually stop at a
+/// Breakpoint, you
+/// always stop at one of its locations.  So the "should stop" tests are done by
+/// the location,
 /// not by the breakpoint.
 //----------------------------------------------------------------------
-class Breakpoint:
-    public std::enable_shared_from_this<Breakpoint>,
-    public Stoppoint
-{
+class Breakpoint : public std::enable_shared_from_this<Breakpoint>,
+                   public Stoppoint {
 public:
-    static const ConstString &
-    GetEventIdentifier ();
-
-    //------------------------------------------------------------------
-    /// An enum specifying the match style for breakpoint settings.  At
-    /// present only used for function name style breakpoints.
-    //------------------------------------------------------------------
-    typedef enum
-    {
-        Exact,
-        Regexp,
-        Glob
-    } MatchType;
-
-    class BreakpointEventData :
-        public EventData
-    {
-    public:
-        BreakpointEventData (lldb::BreakpointEventType sub_type,
-                             const lldb::BreakpointSP &new_breakpoint_sp);
-
-        ~BreakpointEventData() override;
-
-        static const ConstString &
-        GetFlavorString ();
-
-        const ConstString &
-        GetFlavor() const override;
-
-        lldb::BreakpointEventType
-        GetBreakpointEventType () const;
-
-        lldb::BreakpointSP &
-        GetBreakpoint ();
-        
-        BreakpointLocationCollection &
-        GetBreakpointLocationCollection()
-        {
-            return m_locations;
-        }
-
-        void
-        Dump(Stream *s) const override;
-
-        static lldb::BreakpointEventType
-        GetBreakpointEventTypeFromEvent (const lldb::EventSP &event_sp);
-
-        static lldb::BreakpointSP
-        GetBreakpointFromEvent (const lldb::EventSP &event_sp);
-
-        static lldb::BreakpointLocationSP
-        GetBreakpointLocationAtIndexFromEvent (const lldb::EventSP &event_sp, uint32_t loc_idx);
-        
-        static size_t
-        GetNumBreakpointLocationsFromEvent (const lldb::EventSP &event_sp);
-
-        static const BreakpointEventData *
-        GetEventDataFromEvent (const Event *event_sp);
-
-    private:
-        lldb::BreakpointEventType m_breakpoint_event;
-        lldb::BreakpointSP m_new_breakpoint_sp;
-        BreakpointLocationCollection m_locations;
-
-        DISALLOW_COPY_AND_ASSIGN (BreakpointEventData);
-    };
-
-    class BreakpointPrecondition
-    {
-    public:
-        virtual ~BreakpointPrecondition() = default;
-
-        virtual bool
-        EvaluatePrecondition(StoppointCallbackContext &context);
-
-        virtual Error
-        ConfigurePrecondition(Args &options);
-
-        virtual void
-        GetDescription(Stream &stream, lldb::DescriptionLevel level);
-    };
-
-    typedef std::shared_ptr<BreakpointPrecondition> BreakpointPreconditionSP;
-
-    //------------------------------------------------------------------
-    /// Destructor.
-    ///
-    /// The destructor is not virtual since there should be no reason to subclass
-    /// breakpoints.  The varieties of breakpoints are specified instead by
-    /// providing different resolvers & filters.
-    //------------------------------------------------------------------
-    ~Breakpoint() override;
-
-    //------------------------------------------------------------------
-    // Methods
-    //------------------------------------------------------------------
-
-    //------------------------------------------------------------------
-    /// Tell whether this breakpoint is an "internal" breakpoint.
-    /// @return
-    ///     Returns \b true if this is an internal breakpoint, \b false otherwise.
-    //------------------------------------------------------------------
-    bool
-    IsInternal () const;
-
-    //------------------------------------------------------------------
-    /// Standard "Dump" method.  At present it does nothing.
-    //------------------------------------------------------------------
-    void
-    Dump(Stream *s) override;
-
-    //------------------------------------------------------------------
-    // The next set of methods provide ways to tell the breakpoint to update
-    // it's location list - usually done when modules appear or disappear.
-    //------------------------------------------------------------------
-
-    //------------------------------------------------------------------
-    /// Tell this breakpoint to clear all its breakpoint sites.  Done
-    /// when the process holding the breakpoint sites is destroyed.
-    //------------------------------------------------------------------
-    void
-    ClearAllBreakpointSites ();
-
-    //------------------------------------------------------------------
-    /// Tell this breakpoint to scan it's target's module list and resolve any
-    /// new locations that match the breakpoint's specifications.
-    //------------------------------------------------------------------
-    void
-    ResolveBreakpoint ();
-
-    //------------------------------------------------------------------
-    /// Tell this breakpoint to scan a given module list and resolve any
-    /// new locations that match the breakpoint's specifications.
-    ///
-    /// @param[in] module_list
-    ///    The list of modules to look in for new locations.
-    ///
-    /// @param[in]  send_event
-    ///     If \b true, send a breakpoint location added event for non-internal breakpoints.
-    //------------------------------------------------------------------
-    void
-    ResolveBreakpointInModules (ModuleList &module_list, bool send_event = true);
-
-    //------------------------------------------------------------------
-    /// Tell this breakpoint to scan a given module list and resolve any
-    /// new locations that match the breakpoint's specifications.
-    ///
-    /// @param[in] changed_modules
-    ///    The list of modules to look in for new locations.
-    ///
-    /// @param[in]  new_locations
-    ///     Fills new_locations with the new locations that were made.
-    //------------------------------------------------------------------
-    void
-    ResolveBreakpointInModules (ModuleList &module_list, BreakpointLocationCollection &new_locations);
-    
-    //------------------------------------------------------------------
-    /// Like ResolveBreakpointInModules, but allows for "unload" events, in
-    /// which case we will remove any locations that are in modules that got
-    /// unloaded.
-    ///
-    /// @param[in] changedModules
-    ///    The list of modules to look in for new locations.
-    /// @param[in] load_event
-    ///    If \b true then the modules were loaded, if \b false, unloaded.
-    /// @param[in] delete_locations
-    ///    If \b true then the modules were unloaded delete any locations in the changed modules.
-    //------------------------------------------------------------------
-    void
-    ModulesChanged (ModuleList &changed_modules,
-                    bool load_event,
-                    bool delete_locations = false);
-
-    //------------------------------------------------------------------
-    /// Tells the breakpoint the old module \a old_module_sp has been
-    /// replaced by new_module_sp (usually because the underlying file has been
-    /// rebuilt, and the old version is gone.)
-    ///
-    /// @param[in] old_module_sp
-    ///    The old module that is going away.
-    /// @param[in] new_module_sp
-    ///    The new module that is replacing it.
-    //------------------------------------------------------------------
-    void
-    ModuleReplaced (lldb::ModuleSP old_module_sp, lldb::ModuleSP new_module_sp);
-    
-    //------------------------------------------------------------------
-    // The next set of methods provide access to the breakpoint locations
-    // for this breakpoint.
-    //------------------------------------------------------------------
-
-    //------------------------------------------------------------------
-    /// Add a location to the breakpoint's location list.  This is only meant
-    /// to be called by the breakpoint's resolver.  FIXME: how do I ensure that?
-    ///
-    /// @param[in] addr
-    ///    The Address specifying the new location.
-    /// @param[out] new_location
-    ///    Set to \b true if a new location was created, to \b false if there
-    ///    already was a location at this Address.
-    /// @return
-    ///    Returns a pointer to the new location.
-    //------------------------------------------------------------------
-    lldb::BreakpointLocationSP
-    AddLocation(const Address &addr,
-                bool *new_location = nullptr);
-
-    //------------------------------------------------------------------
-    /// Find a breakpoint location by Address.
-    ///
-    /// @param[in] addr
-    ///    The Address specifying the location.
-    /// @return
-    ///    Returns a shared pointer to the location at \a addr.  The pointer
-    ///    in the shared