LLDB AddressSanitizer break on error and report data extraction

[kubamracek]

Summary

This patch gives LLDB some ability to interact with AddressSanitizer runtime library, on top of what we already have (historical memory stack traces provided by ASan). Namely, that's the ability to stop on an error caught by ASan, and access the report information that are associated with it. The report information is also exposed into SB API.

More precisely this patch...

1. adds a new plugin type, InstrumentationRuntime, which should serve as a generic superclass for other instrumentation runtime libraries, these plugins get notified when modules are loaded, so they get a chance to "activate" when a specific dynamic library is loaded
2. an instance of this plugin type, AddressSanitizerRuntime, which activates itself when it sees the ASan dynamic library or founds ASan statically linked in the executable
3. adds a collection of these plugins into the Process class
4. AddressSanitizerRuntime sets an internal breakpoint on __asan::AsanDie(), and when this breakpoint gets hit, it retrieves the report information from ASan
5. this breakpoint is then exposed as a new StopReason, eStopReasonInstrumentation, with a new StopInfo subclass, InstrumentationRuntimeStopInfo
6. the StopInfo superclass is extended with a m_extended_info field (it's a StructuredData::ObjectSP), that can hold arbitrary JSON-like data, which is the way the new plugin provides the report data
7. the "thread info" command now accepts a "-s" flag that prints out the JSON data of a stop reason (same way the "-j" flag works now)
8. SBThread has a new API, GetStopReasonExtendedInfoAsJSON, which dumps the JSON string into a SBStream
9. adds a test case for all of this

I plan to also get rid of the original ASan plugin (memory history stack traces) and use an instance of AddressSanitizerRuntime for that purpose.

[kubamracek]

On the other, I'm not sure about the new stop reason enum value (eStopReasonInstrumentation), maybe I should just reuse eStopReasonException. At least for AddressSanitizer, these stops practically *are* exceptions.

[jingham]

eStopReasonException is a Mach exception. When you hit a breakpoint the Mach Exception with type EXC_BREAKPOINT is the actual stop reason, but this gets translated to eStopReasonBreakpoint if it the stop address is one of our breakpoints. Similarly on Linux, you'd get an eStopReasonSignal/SIGTRAP, which would get translated to eStopReasonBreakpoint if the address was at one of our breakpoints. The eStopReasonInstrumentation is analogous. You stop for some system specific reason, which you then identify as an instrumentation stop, so you convert the stop reason from a general one to one specific to the event that occurred.

Jim

[jasonmolenda]

Looks good to me. It's not critical but AddressSanitizerRuntime::RetrieveReportData() is more expensive than it needs to be because it's compiling your expression every time. If this is going to be executed frequently, you'd want to use a ClangFunction - along the lines with how the SystemRuntimeMacOSX calls into libBacktraceRecording (although I did it poorly and I don't think I get the return type from the ClangFunction - I just extract it from memory, probably unnecessarily, I need to go back and look at that again.)

I don't think this code path will be hot enough to be performance sensitive, but that's the only comment I have. I would commit this patch and if you want to look at switching to a ClangFunction, do that after.

[kubamracek]

Landed in r219546!

include/lldb/API/SBThread.h

     /// 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);
+    
     size_t
     GetStopDescription (char *dst, size_t dst_len);
     
     SBValue
     GetStopReturnValue ();
 
     lldb::tid_t
     GetThreadID () const;

include/lldb/Core/PluginManager.h

     
     static MemoryHistoryCreateInstance
     GetMemoryHistoryCreateCallbackAtIndex (uint32_t idx);
     
     static MemoryHistoryCreateInstance
     GetMemoryHistoryCreateCallbackForPluginName (const ConstString &name);
 
     //------------------------------------------------------------------
+    // InstrumentationRuntime
+    //------------------------------------------------------------------
+    static bool
+    RegisterPlugin (const ConstString &name,
+                    const char *description,
+                    InstrumentationRuntimeCreateInstance create_callback,
+                    InstrumentationRuntimeGetType get_type_callback);
+    
+    static bool
+    UnregisterPlugin (InstrumentationRuntimeCreateInstance create_callback);
+
+    static InstrumentationRuntimeGetType
+    GetInstrumentationRuntimeGetTypeCallbackAtIndex (uint32_t idx);
+    
+    static InstrumentationRuntimeCreateInstance
+    GetInstrumentationRuntimeCreateCallbackAtIndex (uint32_t idx);
+    
+    static InstrumentationRuntimeCreateInstance
+    GetInstrumentationRuntimeCreateCallbackForPluginName (const ConstString &name);
+
+    
+    //------------------------------------------------------------------
     // Some plug-ins might register a DebuggerInitializeCallback
     // callback when registering the plug-in. After a new Debugger
     // instance is created, this DebuggerInitialize function will get
     // called. This allows plug-ins to install Properties and do any
     // other initialization that requires a debugger instance.
     //------------------------------------------------------------------
     static void
     DebuggerInitialize (Debugger &debugger);

include/lldb/Target/InstrumentationRuntime.h

+//===-- InstrumentationRuntime.h --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_InstrumentationRuntime_h_
+#define liblldb_InstrumentationRuntime_h_
+
+// C Includes
+// C++ Includes
+#include <vector>
+#include <map>
+
+// Other libraries and framework includes
+// Project includes
+#include "lldb/lldb-private.h"
+#include "lldb/lldb-types.h"
+#include "lldb/Core/PluginInterface.h"
+
+namespace lldb_private {
+    
+typedef std::map<lldb::InstrumentationRuntimeType, lldb::InstrumentationRuntimeSP> InstrumentationRuntimeCollection;
+    
+class InstrumentationRuntime :
+    public std::enable_shared_from_this<InstrumentationRuntime>,
+    public PluginInterface
+{
+public:
+    
+    static void
+    ModulesDidLoad(lldb_private::ModuleList &module_list, Process *process, InstrumentationRuntimeCollection &runtimes);
+    
+    virtual void
+    ModulesDidLoad(lldb_private::ModuleList &module_list);
+    
+    virtual bool
+    IsActive();
+    
+};
+    
+} // namespace lldb_private
+
+#endif  // liblldb_InstrumentationRuntime_h_

include/lldb/Target/InstrumentationRuntimeStopInfo.h

+//===-- InstrumentationRuntimeStopInfo.h ------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_InstrumentationRuntimeStopInfo_h_
+#define liblldb_InstrumentationRuntimeStopInfo_h_
+
+// C Includes
+// C++ Includes
+#include <string>
+
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Target/StopInfo.h"
+#include "lldb/Core/StructuredData.h"
+
+namespace lldb_private {
+
+class InstrumentationRuntimeStopInfo : public StopInfo
+{
+public:
+    
+    virtual ~InstrumentationRuntimeStopInfo()
+    {
+    }
+    
+    virtual lldb::StopReason
+    GetStopReason () const
+    {
+        return lldb::eStopReasonInstrumentation;
+    }
+    
+    virtual const char *
+    GetDescription ();
+    
+    static lldb::StopInfoSP
+    CreateStopReasonWithInstrumentationData (Thread &thread, std::string description, StructuredData::ObjectSP additional_data);
+    
+private:
+    
+    InstrumentationRuntimeStopInfo(Thread &thread, std::string description, StructuredData::ObjectSP additional_data);
+    
+};
+
+} // namespace lldb_private
+
+#endif  // liblldb_InstrumentationRuntimeStopInfo_h_

include/lldb/Target/Process.h

 #include "lldb/Target/Memory.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/ProcessInfo.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/QueueList.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/PseudoTerminal.h"
+#include "lldb/Target/InstrumentationRuntime.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // ProcessProperties
 //----------------------------------------------------------------------
 class ProcessProperties : public Properties
 {

     std::string                 m_stderr_data;
     Mutex                       m_profile_data_comm_mutex;
     std::vector<std::string>    m_profile_data;
     Predicate<bool>             m_iohandler_sync;
     MemoryCache                 m_memory_cache;
     AllocatedMemoryCache        m_allocated_memory_cache;
     bool                        m_should_detach;   /// Should we detach if the process object goes away with an explicit call to Kill or Detach?
     LanguageRuntimeCollection   m_language_runtimes;
+    InstrumentationRuntimeCollection m_instrumentation_runtimes;
     std::unique_ptr<NextEventAction> m_next_event_action_ap;
     std::vector<PreResumeCallbackAndBaton> m_pre_resume_actions;
     ProcessRunLock              m_public_run_lock;
     ProcessRunLock              m_private_run_lock;
     Predicate<bool>             m_currently_handling_event; // This predicate is set in HandlePrivateEvent while all its business is being done.
     bool                        m_currently_handling_do_on_removals;
     bool                        m_resume_requested;         // If m_currently_handling_event or m_currently_handling_do_on_removals are true, Resume will only request a resume, using this flag to check.
     bool                        m_finalize_called;

include/lldb/Target/StopInfo.h

 // C Includes
 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-public.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Core/StructuredData.h"
 
 namespace lldb_private {
 
 class StopInfo
 {
     friend class Process::ProcessEventData;
     friend class ThreadPlanBase;
     

     }
     
     bool
     GetOverriddenShouldStopValue ()
     {
         return m_override_should_stop == eLazyBoolYes;
     }
     
+    StructuredData::ObjectSP
+    GetExtendedInfo ()
+    {
+        return m_extended_info;
+    }
+    
     static lldb::StopInfoSP
     CreateStopReasonWithBreakpointSiteID (Thread &thread, lldb::break_id_t break_id);
 
     // This creates a StopInfo for the thread where the should_stop is already set, and won't be recalculated.
     static lldb::StopInfoSP
     CreateStopReasonWithBreakpointSiteID (Thread &thread, lldb::break_id_t break_id, bool should_stop);
 
     static lldb::StopInfoSP

     lldb::ThreadWP  m_thread_wp;   // The thread corresponding to the stop reason.
     uint32_t        m_stop_id;  // The process stop ID for which this stop info is valid
     uint32_t        m_resume_id; // This is the resume ID when we made this stop ID.
     uint64_t        m_value;    // A generic value that can be used for things pertaining to this stop info
     std::string     m_description; // A textual description describing this stop.
     LazyBool        m_override_should_notify;
     LazyBool        m_override_should_stop;
     
+    StructuredData::ObjectSP m_extended_info; // The extended info for this stop info
+    
     // This determines whether the target has run since this stop info.
     // N.B. running to evaluate a user expression does not count. 
     bool HasTargetRunSinceMe ();
 
     // MakeStopInfoValid is necessary to allow saved stop infos to resurrect themselves as valid.
     // It should only be used by Thread::RestoreThreadStateFromCheckpoint and to make sure the one-step
     // needed for before-the-fact watchpoints does not prevent us from stopping
     void

include/lldb/Target/Thread.h

         // threads for memory threads can change, we need a way to clear the backing
         // thread for all memory threads each time we stop.
     }
 
     void
     DumpUsingSettingsFormat (Stream &strm, uint32_t frame_idx);
 
     bool
-    GetDescription (Stream &s, lldb::DescriptionLevel level, bool json_output);
+    GetDescription (Stream &s, lldb::DescriptionLevel level, bool print_json_thread, bool print_json_stopinfo);
 
     //------------------------------------------------------------------
     /// Default implementation for stepping into.
     ///
     /// This function is designed to be used by commands where the
     /// process is publicly stopped.
     ///
     /// @param[in] source_step

include/lldb/lldb-enumerations.h

         eStopReasonNone,
         eStopReasonTrace,
         eStopReasonBreakpoint,
         eStopReasonWatchpoint,
         eStopReasonSignal,
         eStopReasonException,
         eStopReasonExec,        // Program was re-exec'ed
         eStopReasonPlanComplete,
-        eStopReasonThreadExiting
+        eStopReasonThreadExiting,
+        eStopReasonInstrumentation
     } StopReason;
 
     //----------------------------------------------------------------------
     // Command Return Status Types
     //----------------------------------------------------------------------
     typedef enum ReturnStatus
     {
         eReturnStatusInvalid,

         eLanguageTypeOCaml           = 0x001b,   ///< OCaml.
         eLanguageTypeRust            = 0x001c,   ///< Rust.
         eLanguageTypeC11             = 0x001d,   ///< ISO C:2011.
         eLanguageTypeSwift           = 0x001e,   ///< Swift.
         eLanguageTypeJulia           = 0x001f,   ///< Julia.
         eLanguageTypeDylan           = 0x0020,   ///< Dylan.
         eNumLanguageTypes
     } LanguageType;
+    
+    typedef enum InstrumentationRuntimeType {
+        eInstrumentationRuntimeTypeAddressSanitizer = 0x0000,
+        eNumInstrumentationRuntimeTypes
+    } InstrumentationRuntimeType;
 
     typedef enum DynamicValueType
     {
         eNoDynamicValues = 0,
         eDynamicCanRunTarget    = 1,
         eDynamicDontRunTarget   = 2
     } DynamicValueType;
     

include/lldb/lldb-forward.h

 class   FormatManager;
 class   FormattersMatchCandidate;
 class   FuncUnwinders;
 class   Function;
 class   FunctionInfo;
 class   InlineFunctionInfo;
 class   Instruction;
 class   InstructionList;
+class   InstrumentationRuntime;
 class   IOHandler;
 class   IOObject;
 class   IRExecutionUnit;
 class   JITLoader;
 class   LanguageRuntime;
 class   SystemRuntime;
 class   LineTable;
 class   Listener;

     typedef std::shared_ptr<lldb_private::DynamicLoader> DynamicLoaderSP;
     typedef std::shared_ptr<lldb_private::Event> EventSP;
     typedef std::shared_ptr<lldb_private::ExecutionContextRef> ExecutionContextRefSP;
     typedef std::shared_ptr<lldb_private::File> FileSP;
     typedef std::shared_ptr<lldb_private::Function> FunctionSP;
     typedef std::shared_ptr<lldb_private::FuncUnwinders> FuncUnwindersSP;
     typedef std::shared_ptr<lldb_private::InlineFunctionInfo> InlineFunctionInfoSP;
     typedef std::shared_ptr<lldb_private::Instruction> InstructionSP;
+    typedef std::shared_ptr<lldb_private::InstrumentationRuntime> InstrumentationRuntimeSP;
     typedef std::shared_ptr<lldb_private::IOHandler> IOHandlerSP;
     typedef std::shared_ptr<lldb_private::IOObject> IOObjectSP;
     typedef std::shared_ptr<lldb_private::JITLoader> JITLoaderSP;
     typedef std::shared_ptr<lldb_private::LanguageRuntime> LanguageRuntimeSP;
     typedef std::shared_ptr<lldb_private::SystemRuntime> SystemRuntimeSP;
     typedef std::shared_ptr<lldb_private::LineTable> LineTableSP;
     typedef std::shared_ptr<lldb_private::Listener> ListenerSP;
     typedef std::shared_ptr<lldb_private::LogChannel> LogChannelSP;

include/lldb/lldb-private-interfaces.h

     typedef SymbolFile* (*SymbolFileCreateInstance) (ObjectFile* obj_file);
     typedef SymbolVendor* (*SymbolVendorCreateInstance) (const lldb::ModuleSP &module_sp, lldb_private::Stream *feedback_strm);   // Module can be NULL for default system symbol vendor
     typedef bool (*BreakpointHitCallback) (void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
     typedef bool (*WatchpointHitCallback) (void *baton, StoppointCallbackContext *context, lldb::user_id_t watch_id);
     typedef bool (*ThreadPlanShouldStopHereCallback) (ThreadPlan *current_plan, Flags &flags, lldb::FrameComparison operation, void *baton);
     typedef lldb::ThreadPlanSP (*ThreadPlanStepFromHereCallback) (ThreadPlan *current_plan, Flags &flags, lldb::FrameComparison operation, void *baton);
     typedef UnwindAssembly* (*UnwindAssemblyCreateInstance) (const ArchSpec &arch);
     typedef lldb::MemoryHistorySP (*MemoryHistoryCreateInstance) (const lldb::ProcessSP &process_sp);
+    typedef lldb::InstrumentationRuntimeType (*InstrumentationRuntimeGetType) ();
+    typedef lldb::InstrumentationRuntimeSP (*InstrumentationRuntimeCreateInstance) (const lldb::ProcessSP &process_sp);
     typedef int (*ComparisonFunction)(const void *, const void *);
     typedef void (*DebuggerInitializeCallback)(Debugger &debugger);
 
 } // namespace lldb_private
 
 #endif  // #if defined(__cplusplus)
 
 #endif  // liblldb_lldb_private_interfaces_h_

lldb.xcodeproj/project.pbxproj

     4CF3D80C15AF4DC800845BF3 /* Security.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = EDB919B414F6F10D008FF64B /* Security.framework */; };
     4CF52AF51428291E0051E832 /* SBFileSpecList.h in Headers */ = {isa = PBXBuildFile; fileRef = 4CF52AF41428291E0051E832 /* SBFileSpecList.h */; settings = {ATTRIBUTES = (Public, ); }; };
     4CF52AF8142829390051E832 /* SBFileSpecList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4CF52AF7142829390051E832 /* SBFileSpecList.cpp */; };
     8C2D6A53197A1EAF006989C9 /* MemoryHistory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C2D6A52197A1EAF006989C9 /* MemoryHistory.cpp */; };
     8C2D6A5E197A250F006989C9 /* MemoryHistoryASan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C2D6A5A197A1FDC006989C9 /* MemoryHistoryASan.cpp */; };
     8CCB017E19BA28A80009FD44 /* ThreadCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CCB017A19BA283D0009FD44 /* ThreadCollection.cpp */; };
     8CCB018219BA4E270009FD44 /* SBThreadCollection.h in Headers */ = {isa = PBXBuildFile; fileRef = 8CCB018119BA4E210009FD44 /* SBThreadCollection.h */; settings = {ATTRIBUTES = (Public, ); }; };
     8CCB018319BA51BF0009FD44 /* SBThreadCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CCB017F19BA4DD00009FD44 /* SBThreadCollection.cpp */; };
+    8CF02AE919DCC01900B14BE0 /* InstrumentationRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CF02ADF19DCBF3B00B14BE0 /* InstrumentationRuntime.cpp */; };
+    8CF02AEA19DCC02100B14BE0 /* AddressSanitizerRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CF02AE519DCBF8400B14BE0 /* AddressSanitizerRuntime.cpp */; };
+    8CF02AEF19DD16B100B14BE0 /* InstrumentationRuntimeStopInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CF02AED19DD15CF00B14BE0 /* InstrumentationRuntimeStopInfo.cpp */; };
     94094C6B163B6F840083A547 /* ValueObjectCast.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 94094C69163B6CD90083A547 /* ValueObjectCast.cpp */; };
     940B02F619DC96E700AD0F52 /* SBExecutionContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 940B02F519DC96E700AD0F52 /* SBExecutionContext.cpp */; };
     94145431175E63B500284436 /* lldb-versioning.h in Headers */ = {isa = PBXBuildFile; fileRef = 94145430175D7FDE00284436 /* lldb-versioning.h */; settings = {ATTRIBUTES = (Public, ); }; };
     941BCC7F14E48C4000BB969C /* SBTypeFilter.h in Headers */ = {isa = PBXBuildFile; fileRef = 9461568614E355F2003A195C /* SBTypeFilter.h */; settings = {ATTRIBUTES = (Public, ); }; };
     941BCC8014E48C4000BB969C /* SBTypeFormat.h in Headers */ = {isa = PBXBuildFile; fileRef = 9461568714E355F2003A195C /* SBTypeFormat.h */; settings = {ATTRIBUTES = (Public, ); }; };
     941BCC8114E48C4000BB969C /* SBTypeSummary.h in Headers */ = {isa = PBXBuildFile; fileRef = 9461568814E355F2003A195C /* SBTypeSummary.h */; settings = {ATTRIBUTES = (Public, ); }; };
     941BCC8214E48C4000BB969C /* SBTypeSynthetic.h in Headers */ = {isa = PBXBuildFile; fileRef = 9461568914E355F2003A195C /* SBTypeSynthetic.h */; settings = {ATTRIBUTES = (Public, ); }; };
     94380B8219940B0A00BFE4A8 /* StringLexer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 94380B8119940B0A00BFE4A8 /* StringLexer.cpp */; };

     8C2D6A54197A1EBE006989C9 /* MemoryHistory.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = MemoryHistory.h; path = include/lldb/Target/MemoryHistory.h; sourceTree = "<group>"; };
     8C2D6A5A197A1FDC006989C9 /* MemoryHistoryASan.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MemoryHistoryASan.cpp; sourceTree = "<group>"; };
     8C2D6A5B197A1FDC006989C9 /* MemoryHistoryASan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MemoryHistoryASan.h; sourceTree = "<group>"; };
     8CCB017A19BA283D0009FD44 /* ThreadCollection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ThreadCollection.cpp; path = source/Target/ThreadCollection.cpp; sourceTree = "<group>"; };
     8CCB017C19BA289B0009FD44 /* ThreadCollection.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = ThreadCollection.h; path = include/lldb/Target/ThreadCollection.h; sourceTree = "<group>"; };
     8CCB017F19BA4DD00009FD44 /* SBThreadCollection.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = SBThreadCollection.cpp; path = source/API/SBThreadCollection.cpp; sourceTree = "<group>"; };
     8CCB018119BA4E210009FD44 /* SBThreadCollection.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SBThreadCollection.h; path = include/lldb/API/SBThreadCollection.h; sourceTree = "<group>"; };
     8CCB018419BA54930009FD44 /* SBThreadCollection.i */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBThreadCollection.i; sourceTree = "<group>"; };
+    8CF02ADF19DCBF3B00B14BE0 /* InstrumentationRuntime.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = InstrumentationRuntime.cpp; path = source/Target/InstrumentationRuntime.cpp; sourceTree = "<group>"; };
+    8CF02AE019DCBF3B00B14BE0 /* InstrumentationRuntime.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = InstrumentationRuntime.h; path = include/lldb/Target/InstrumentationRuntime.h; sourceTree = "<group>"; };
+    8CF02AE519DCBF8400B14BE0 /* AddressSanitizerRuntime.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AddressSanitizerRuntime.cpp; sourceTree = "<group>"; };
+    8CF02AE619DCBF8400B14BE0 /* AddressSanitizerRuntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AddressSanitizerRuntime.h; sourceTree = "<group>"; };
+    8CF02AED19DD15CF00B14BE0 /* InstrumentationRuntimeStopInfo.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = InstrumentationRuntimeStopInfo.cpp; path = source/Target/InstrumentationRuntimeStopInfo.cpp; sourceTree = "<group>"; };
+    8CF02AEE19DD15CF00B14BE0 /* InstrumentationRuntimeStopInfo.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = InstrumentationRuntimeStopInfo.h; path = include/lldb/Target/InstrumentationRuntimeStopInfo.h; sourceTree = "<group>"; };
     94005E0313F438DF001EF42D /* python-wrapper.swig */ = {isa = PBXFileReference; lastKnownFileType = text; path = "python-wrapper.swig"; sourceTree = "<group>"; };
     94005E0513F45A1B001EF42D /* embedded_interpreter.py */ = {isa = PBXFileReference; lastKnownFileType = text.script.python; name = embedded_interpreter.py; path = source/Interpreter/embedded_interpreter.py; sourceTree = "<group>"; };
     94031A9F13CF5B3D00DCFF3C /* PriorityPointerPair.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = PriorityPointerPair.h; path = include/lldb/Utility/PriorityPointerPair.h; sourceTree = "<group>"; };
     94094C68163B6CCC0083A547 /* ValueObjectCast.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = ValueObjectCast.h; path = include/lldb/Core/ValueObjectCast.h; sourceTree = "<group>"; };
     94094C69163B6CD90083A547 /* ValueObjectCast.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ValueObjectCast.cpp; path = source/Core/ValueObjectCast.cpp; sourceTree = "<group>"; };
     940B02F419DC96CB00AD0F52 /* SBExecutionContext.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SBExecutionContext.h; path = include/lldb/API/SBExecutionContext.h; sourceTree = "<group>"; };
     940B02F519DC96E700AD0F52 /* SBExecutionContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBExecutionContext.cpp; path = source/API/SBExecutionContext.cpp; sourceTree = "<group>"; };
     940B02F719DC970900AD0F52 /* SBExecutionContext.i */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBExecutionContext.i; sourceTree = "<group>"; };

         23AB0531199FF639003B8084 /* ProcessMonitor.cpp */,
       );
       path = FreeBSD;
       sourceTree = "<group>";
     };
     260C897110F57C5600BB2B04 /* Plugins */ = {
       isa = PBXGroup;
       children = (
+        8CF02ADD19DCBEC200B14BE0 /* InstrumentationRuntime */,
         8C2D6A58197A1FB9006989C9 /* MemoryHistory */,
         26DB3E051379E7AD0080DC73 /* ABI */,
         260C897210F57C5600BB2B04 /* Disassembler */,
         260C897810F57C5600BB2B04 /* DynamicLoader */,
         26D9FDCA12F785120003F2EE /* Instruction */,
         AF2BCA6518C7EFDE005B4526 /* JITLoader */,
         4CCA643A13B40B82003BDF98 /* LanguageRuntime */,
         260C897E10F57C5600BB2B04 /* ObjectContainer */,

         26BC7F0C10F1B8DD00F91463 /* ScriptInterpreterPython.cpp */,
       );
       name = Interpreter;
       sourceTree = "<group>";
     };
     26BC7DEF10F1B80200F91463 /* Target */ = {
       isa = PBXGroup;
       children = (
+        8CF02AE019DCBF3B00B14BE0 /* InstrumentationRuntime.h */,
+        8CF02ADF19DCBF3B00B14BE0 /* InstrumentationRuntime.cpp */,
+        8CF02AEE19DD15CF00B14BE0 /* InstrumentationRuntimeStopInfo.h */,
+        8CF02AED19DD15CF00B14BE0 /* InstrumentationRuntimeStopInfo.cpp */,
         3FDFD6C3199C396E009756A7 /* FileAction.h */,
         3FDFDDBC199C3A06009756A7 /* FileAction.cpp */,
         23EDE3311926843600F6A132 /* NativeRegisterContext.h */,
         23EDE3301926839700F6A132 /* NativeRegisterContext.cpp */,
         497E7B331188ED300065CCA1 /* ABI.h */,
         497E7B9D1188F6690065CCA1 /* ABI.cpp */,
         4CB443BB1249920C00C13DC2 /* CPPLanguageRuntime.h */,
         4CB443BC1249920C00C13DC2 /* CPPLanguageRuntime.cpp */,

       isa = PBXGroup;
       children = (
         8C2D6A5A197A1FDC006989C9 /* MemoryHistoryASan.cpp */,
         8C2D6A5B197A1FDC006989C9 /* MemoryHistoryASan.h */,
       );
       path = asan;
       sourceTree = "<group>";
     };
+    8CF02ADD19DCBEC200B14BE0 /* InstrumentationRuntime */ = {
+      isa = PBXGroup;
+      children = (
+        8CF02ADE19DCBEE600B14BE0 /* AddressSanitizer */,
+      );
+      path = InstrumentationRuntime;
+      sourceTree = "<group>";
+    };
+    8CF02ADE19DCBEE600B14BE0 /* AddressSanitizer */ = {
+      isa = PBXGroup;
+      children = (
+        8CF02AE519DCBF8400B14BE0 /* AddressSanitizerRuntime.cpp */,
+        8CF02AE619DCBF8400B14BE0 /* AddressSanitizerRuntime.h */,
+      );
+      path = AddressSanitizer;
+      sourceTree = "<group>";
+    };
     9457596415349416005A9070 /* POSIX */ = {
       isa = PBXGroup;
       children = (
         945759651534941F005A9070 /* PlatformPOSIX.cpp */,
         945759661534941F005A9070 /* PlatformPOSIX.h */,
       );
       name = POSIX;
       sourceTree = "<group>";

         2689000313353DB600698AC0 /* BreakpointResolverFileLine.cpp in Sources */,
         26474CA818D0CB070073DEBA /* RegisterContextFreeBSD_i386.cpp in Sources */,
         449ACC98197DEA0B008D175E /* FastDemangle.cpp in Sources */,
         94CD705216F8F5BC00CF1E42 /* LibCxxMap.cpp in Sources */,
         2689000513353DB600698AC0 /* BreakpointResolverName.cpp in Sources */,
         2689000713353DB600698AC0 /* BreakpointSite.cpp in Sources */,
         2689000913353DB600698AC0 /* BreakpointSiteList.cpp in Sources */,
         26474CC918D0CB5B0073DEBA /* RegisterContextMemory.cpp in Sources */,
+        8CF02AEA19DCC02100B14BE0 /* AddressSanitizerRuntime.cpp in Sources */,
         26474CB218D0CB180073DEBA /* RegisterContextLinux_i386.cpp in Sources */,
         26474CCB18D0CB5B0073DEBA /* RegisterContextPOSIX_mips64.cpp in Sources */,
         2689000B13353DB600698AC0 /* Stoppoint.cpp in Sources */,
         2689000D13353DB600698AC0 /* StoppointCallbackContext.cpp in Sources */,
         2689000F13353DB600698AC0 /* StoppointLocation.cpp in Sources */,
         2689001113353DB600698AC0 /* Watchpoint.cpp in Sources */,
         2689001213353DDE00698AC0 /* CommandObjectApropos.cpp in Sources */,
         23042D121976CA1D00621B2C /* PlatformKalimba.cpp in Sources */,

         2689002413353DDE00698AC0 /* CommandObjectSettings.cpp in Sources */,
         2689002513353DDE00698AC0 /* CommandObjectSource.cpp in Sources */,
         2689002613353DDE00698AC0 /* CommandObjectSyntax.cpp in Sources */,
         26BC179918C7F2B300D2196D /* JITLoader.cpp in Sources */,
         2689002713353DDE00698AC0 /* CommandObjectTarget.cpp in Sources */,
         2689002813353DDE00698AC0 /* CommandObjectThread.cpp in Sources */,
         2689002913353DDE00698AC0 /* CommandObjectVersion.cpp in Sources */,
         2689002A13353E0400698AC0 /* Address.cpp in Sources */,
+        8CF02AE919DCC01900B14BE0 /* InstrumentationRuntime.cpp in Sources */,
         2689002B13353E0400698AC0 /* AddressRange.cpp in Sources */,
         236124A41986B4E2004EFC37 /* IOObject.cpp in Sources */,
         2689002C13353E0400698AC0 /* AddressResolver.cpp in Sources */,
         2689002D13353E0400698AC0 /* AddressResolverFileLine.cpp in Sources */,
         2689002E13353E0400698AC0 /* AddressResolverName.cpp in Sources */,
         2689002F13353E0400698AC0 /* ArchSpec.cpp in Sources */,
         2689003013353E0400698AC0 /* Baton.cpp in Sources */,
         2689003113353E0400698AC0 /* Broadcaster.cpp in Sources */,

         268900F513353E6F00698AC0 /* StackID.cpp in Sources */,
         268900F613353E6F00698AC0 /* StopInfo.cpp in Sources */,
         268900F713353E6F00698AC0 /* Target.cpp in Sources */,
         268900F813353E6F00698AC0 /* TargetList.cpp in Sources */,
         268900F913353E6F00698AC0 /* Thread.cpp in Sources */,
         268900FA13353E6F00698AC0 /* ThreadList.cpp in Sources */,
         268900FB13353E6F00698AC0 /* ThreadPlan.cpp in Sources */,
         232CB619191E00CD00EF39FC /* NativeProcessProtocol.cpp in Sources */,
+        8CF02AEF19DD16B100B14BE0 /* InstrumentationRuntimeStopInfo.cpp in Sources */,
         268900FC13353E6F00698AC0 /* ThreadPlanBase.cpp in Sources */,
         268900FD13353E6F00698AC0 /* ThreadPlanCallFunction.cpp in Sources */,
         268900FE13353E6F00698AC0 /* ThreadPlanCallUserExpression.cpp in Sources */,
         268900FF13353E6F00698AC0 /* ThreadPlanShouldStopHere.cpp in Sources */,
         2689010013353E6F00698AC0 /* ThreadPlanStepInstruction.cpp in Sources */,
         232CB61B191E00CD00EF39FC /* NativeThreadProtocol.cpp in Sources */,
         2689010113353E6F00698AC0 /* ThreadPlanStepOut.cpp in Sources */,
         2689010213353E6F00698AC0 /* ThreadPlanStepOverBreakpoint.cpp in Sources */,

scripts/Python/interface/SBThread.i

     /// eStopReasonSignal        1     unix signal number
     /// eStopReasonException     N     exception data
     /// eStopReasonExec          0
     /// eStopReasonPlanComplete  0
     //--------------------------------------------------------------------------
     ") GetStopReasonDataAtIndex;
     uint64_t
     GetStopReasonDataAtIndex(uint32_t idx);
+        
+    %feature("autodoc", "
+    Collects a thread's stop reason extended information dictionary and prints it
+    into the SBStream in a JSON format. The format of this JSON dictionary depends
+    on the stop reason and is currently used only for instrumentation plugins.
+    ") GetStopReasonExtendedInfoAsJSON;
+    bool
+    GetStopReasonExtendedInfoAsJSON (lldb::SBStream &stream);
 
     %feature("autodoc", "
     Pass only an (int)length and expect to get a Python string describing the
     stop reason.
     ") GetStopDescription;
     size_t
     GetStopDescription (char *dst, size_t dst_len);
 

source/API/SBThread.cpp

                 switch (reason)
                 {
                 case eStopReasonInvalid:
                 case eStopReasonNone:
                 case eStopReasonTrace:
                 case eStopReasonExec:
                 case eStopReasonPlanComplete:
                 case eStopReasonThreadExiting:
+                case eStopReasonInstrumentation:
                     // There is no data for these stop reasons.
                     return 0;
 
                 case eStopReasonBreakpoint:
                     {
                         break_id_t site_id = stop_info_sp->GetValue();
                         lldb::BreakpointSiteSP bp_site_sp (exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID (site_id));
                         if (bp_site_sp)

                 switch (reason)
                 {
                 case eStopReasonInvalid:
                 case eStopReasonNone:
                 case eStopReasonTrace:
                 case eStopReasonExec:
                 case eStopReasonPlanComplete:
                 case eStopReasonThreadExiting:
+                case eStopReasonInstrumentation:
                     // There is no data for these stop reasons.
                     return 0;
 
                 case eStopReasonBreakpoint:
                     {
                         break_id_t site_id = stop_info_sp->GetValue();
                         lldb::BreakpointSiteSP bp_site_sp (exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID (site_id));
                         if (bp_site_sp)

             if (log)
                 log->Printf ("SBThread(%p)::GetStopReasonDataAtIndex() => error: process is running",
                              static_cast<void*>(exe_ctx.GetThreadPtr()));
         }
     }
     return 0;
 }
 
+bool
+SBThread::GetStopReasonExtendedInfoAsJSON (lldb::SBStream &stream)
+{
+    Stream &strm = stream.ref();
+    
+    ExecutionContext exe_ctx (m_opaque_sp.get());
+    if (! exe_ctx.HasThreadScope())
+        return false;
+
+    
+    StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo();
+    StructuredData::ObjectSP info = stop_info->GetExtendedInfo();
+    if (! info)
+        return false;
+
+    info->Dump(strm);
+    
+    return true;
+}
+
 size_t
 SBThread::GetStopDescription (char *dst, size_t dst_len)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
     Mutex::Locker api_locker;
     ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
 

source/Commands/CommandObjectThread.cpp

             Options (interpreter)
         {
             OptionParsingStarting ();
         }
 
         void
         OptionParsingStarting ()
         {
-            m_json = false;
+            m_json_thread = false;
+            m_json_stopinfo = false;
         }
 
         virtual
         ~CommandOptions ()
         {
         }
 
         virtual Error
         SetOptionValue (uint32_t option_idx, const char *option_arg)
         {
             const int short_option = m_getopt_table[option_idx].val;
             Error error;
 
             switch (short_option)
             {
                 case 'j':
-                    m_json = true;
+                    m_json_thread = true;
+                    break;
+                    
+                case 's':
+                    m_json_stopinfo = true;
                     break;
 
-                 default:
                     return Error("invalid short option character '%c'", short_option);
 
             }
             return error;
         }
 
         const OptionDefinition*
         GetDefinitions ()
         {
             return g_option_table;
         }
 
-        bool m_json;
+        bool m_json_thread;
+        bool m_json_stopinfo;
 
         static OptionDefinition g_option_table[];
     };
 
     virtual
     Options *
     GetOptions ()
     {
         return &m_options;
     }
 
 
     virtual
     ~CommandObjectThreadInfo ()
     {
     }
 
     virtual bool
     HandleOneThread (Thread &thread, CommandReturnObject &result)
     {
         Stream &strm = result.GetOutputStream();
-        if (!thread.GetDescription (strm, eDescriptionLevelFull, m_options.m_json))
+        if (!thread.GetDescription (strm, eDescriptionLevelFull, m_options.m_json_thread, m_options.m_json_stopinfo))
         {
             result.AppendErrorWithFormat ("error displaying info for thread: \"%d\"\n", thread.GetIndexID());
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
         return true;
     }
 
     CommandOptions m_options;
 
 };
 
 OptionDefinition
 CommandObjectThreadInfo::CommandOptions::g_option_table[] =
 {
     { LLDB_OPT_SET_ALL, false, "json",'j', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Display the thread info in JSON format."},
+    { LLDB_OPT_SET_ALL, false, "stop-info",'s', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Display the extended stop info in JSON format."},
 
     { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
 };
 
 
 //-------------------------------------------------------------------------
 // CommandObjectThreadReturn
 //-------------------------------------------------------------------------

source/Core/Debugger.cpp

                                             
                                         case eStopReasonTrace:
                                         case eStopReasonBreakpoint:
                                         case eStopReasonWatchpoint:
                                         case eStopReasonSignal:
                                         case eStopReasonException:
                                         case eStopReasonExec:
                                         case eStopReasonThreadExiting:
+                                        case eStopReasonInstrumentation:
                                             if (!other_thread)
                                                 other_thread = thread;
                                             break;
                                         case eStopReasonPlanComplete:
                                             if (!plan_thread)
                                                 plan_thread = thread;
                                             break;
                                     }

source/Core/PluginManager.cpp

         {
             if (name == pos->name)
                 return pos->create_callback;
         }
     }
     return NULL;
 }
 
+#pragma mark InstrumentationRuntime
+
+struct InstrumentationRuntimeInstance
+{
+    InstrumentationRuntimeInstance() :
+    name(),
+    description(),
+    create_callback(NULL)
+    {
+    }
+    
+    ConstString name;
+    std::string description;
+    InstrumentationRuntimeCreateInstance create_callback;
+    InstrumentationRuntimeGetType get_type_callback;
+};
+
+typedef std::vector<InstrumentationRuntimeInstance> InstrumentationRuntimeInstances;
+
+static Mutex &
+GetInstrumentationRuntimeMutex ()
+{
+    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    return g_instances_mutex;
+}
+
+static InstrumentationRuntimeInstances &
+GetInstrumentationRuntimeInstances ()
+{
+    static InstrumentationRuntimeInstances g_instances;
+    return g_instances;
+}
+
+bool
+PluginManager::RegisterPlugin
+(
+ const ConstString &name,
+ const char *description,
+ InstrumentationRuntimeCreateInstance create_callback,
+ InstrumentationRuntimeGetType get_type_callback
+ )
+{
+    if (create_callback)
+    {
+        InstrumentationRuntimeInstance instance;
+        assert ((bool)name);
+        instance.name = name;
+        if (description && description[0])
+            instance.description = description;
+        instance.create_callback = create_callback;
+        instance.get_type_callback = get_type_callback;
+        Mutex::Locker locker (GetInstrumentationRuntimeMutex ());
+        GetInstrumentationRuntimeInstances ().push_back (instance);
+    }
+    return false;
+}
+
+bool
+PluginManager::UnregisterPlugin (InstrumentationRuntimeCreateInstance create_callback)
+{
+    if (create_callback)
+    {
+        Mutex::Locker locker (GetInstrumentationRuntimeMutex ());
+        InstrumentationRuntimeInstances &instances = GetInstrumentationRuntimeInstances ();
+        
+        InstrumentationRuntimeInstances::iterator pos, end = instances.end();
+        for (pos = instances.begin(); pos != end; ++ pos)
+        {
+            if (pos->create_callback == create_callback)
+            {
+                instances.erase(pos);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+InstrumentationRuntimeGetType
+PluginManager::GetInstrumentationRuntimeGetTypeCallbackAtIndex (uint32_t idx)
+{
+    Mutex::Locker locker (GetInstrumentationRuntimeMutex ());
+    InstrumentationRuntimeInstances &instances = GetInstrumentationRuntimeInstances ();
+    if (idx < instances.size())
+        return instances[idx].get_type_callback;
+    return NULL;
+}
+
+InstrumentationRuntimeCreateInstance
+PluginManager::GetInstrumentationRuntimeCreateCallbackAtIndex (uint32_t idx)
+{
+    Mutex::Locker locker (GetInstrumentationRuntimeMutex ());
+    InstrumentationRuntimeInstances &instances = GetInstrumentationRuntimeInstances ();
+    if (idx < instances.size())
+        return instances[idx].create_callback;
+    return NULL;
+}
+
+
+InstrumentationRuntimeCreateInstance
+PluginManager::GetInstrumentationRuntimeCreateCallbackForPluginName (const ConstString &name)
+{
+    if (name)
+    {
+        Mutex::Locker locker (GetInstrumentationRuntimeMutex ());
+        InstrumentationRuntimeInstances &instances = GetInstrumentationRuntimeInstances ();
+        
+        InstrumentationRuntimeInstances::iterator pos, end = instances.end();
+        for (pos = instances.begin(); pos != end; ++ pos)
+        {
+            if (name == pos->name)
+                return pos->create_callback;
+        }
+    }
+    return NULL;
+}
+
+#pragma mark PluginManager
+
 void
 PluginManager::DebuggerInitialize (Debugger &debugger)
 {
     // Initialize the DynamicLoader plugins
     {
         Mutex::Locker locker (GetDynamicLoaderMutex ());
         DynamicLoaderInstances &instances = GetDynamicLoaderInstances ();
     

source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.h

+//===-- AddressSanitizerRuntime.h -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_AddressSanitizerRuntime_h_
+#define liblldb_AddressSanitizerRuntime_h_
+
+#include "lldb/lldb-private.h"
+#include "lldb/Target/ABI.h"
+#include "lldb/Target/InstrumentationRuntime.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Core/StructuredData.h"
+
+namespace lldb_private {
+    
+class AddressSanitizerRuntime : public lldb_private::InstrumentationRuntime
+{
+public:
+    
+    static lldb::InstrumentationRuntimeSP
+    CreateInstance (const lldb::ProcessSP &process_sp);
+    
+    static void
+    Initialize();
+    
+    static void
+    Terminate();
+    
+    static lldb_private::ConstString
+    GetPluginNameStatic();
+    
+    static lldb::InstrumentationRuntimeType
+    GetTypeStatic();
+    
+    virtual
+    ~AddressSanitizerRuntime();
+    
+    virtual lldb_private::ConstString
+    GetPluginName() { return GetPluginNameStatic(); }
+    
+    virtual lldb::InstrumentationRuntimeType
+    GetType() { return GetTypeStatic(); }
+    
+    virtual uint32_t
+    GetPluginVersion() { return 1; }
+    
+    virtual void
+    ModulesDidLoad(lldb_private::ModuleList &module_list);
+    
+    virtual bool
+    IsActive();
+    
+private:
+    
+    AddressSanitizerRuntime(const lldb::ProcessSP &process_sp);
+    
+    void
+    Activate();
+    
+    void
+    Deactivate();
+    
+    static bool
+    NotifyBreakpointHit(void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
+    
+    StructuredData::ObjectSP
+    RetrieveReportData();
+    
+    std::string
+    FormatDescription(StructuredData::ObjectSP report);
+    
+    bool m_is_active;
+    lldb::ModuleSP m_runtime_module;
+    lldb::ProcessSP m_process;
+    lldb::user_id_t m_breakpoint_id;
+
+};
+    
+} // namespace lldb_private
+
+#endif  // liblldb_InstrumentationRuntime_h_

source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.cpp

+//===-- AddressSanitizerRuntime.cpp -----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AddressSanitizerRuntime.h"
+
+#include "lldb/Core/PluginInterface.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/ModuleList.h"
+#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Target/StopInfo.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Breakpoint/StoppointCallbackContext.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Target/InstrumentationRuntimeStopInfo.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/StreamFile.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+lldb::InstrumentationRuntimeSP
+AddressSanitizerRuntime::CreateInstance (const lldb::ProcessSP &process_sp)
+{
+    return InstrumentationRuntimeSP(new AddressSanitizerRuntime(process_sp));
+}
+
+void
+AddressSanitizerRuntime::Initialize()
+{
+    PluginManager::RegisterPlugin (GetPluginNameStatic(),
+                                   "AddressSanitizer instrumentation runtime plugin.",
+                                   CreateInstance,
+                                   GetTypeStatic);
+}
+
+void
+AddressSanitizerRuntime::Terminate()
+{
+    PluginManager::UnregisterPlugin (CreateInstance);
+}
+
+lldb_private::ConstString
+AddressSanitizerRuntime::GetPluginNameStatic()
+{
+    return ConstString("AddressSanitizer");
+}
+
+lldb::InstrumentationRuntimeType
+AddressSanitizerRuntime::GetTypeStatic()
+{
+    return eInstrumentationRuntimeTypeAddressSanitizer;
+}
+
+AddressSanitizerRuntime::AddressSanitizerRuntime(const ProcessSP &process_sp) :
+    m_is_active(false),
+    m_runtime_module(),
+    m_process(process_sp),
+    m_breakpoint_id(0)
+{
+}
+
+AddressSanitizerRuntime::~AddressSanitizerRuntime()
+{
+    Deactivate();
+}
+
+bool ModuleContainsASanRuntime(Module * module)
+{
+    SymbolContextList sc_list;
+    const bool include_symbols = true;
+    const bool append = true;
+    const bool include_inlines = true;
+    
+    size_t num_matches = module->FindFunctions(ConstString("__asan_get_alloc_stack"), NULL, eFunctionNameTypeAuto, include_symbols, include_inlines, append, sc_list);
+    
+    return num_matches > 0;
+}
+
+void
+AddressSanitizerRuntime::ModulesDidLoad(lldb_private::ModuleList &module_list)
+{
+    if (IsActive())
+        return;
+    
+    if (m_runtime_module) {
+        Activate();
+        return;
+    }
+    
+    Mutex::Locker modules_locker(module_list.GetMutex());
+    const size_t num_modules = module_list.GetSize();
+    for (size_t i = 0; i < num_modules; ++i)
+    {
+        Module *module_pointer = module_list.GetModulePointerAtIndexUnlocked(i);
+        const FileSpec & file_spec = module_pointer->GetFileSpec();
+        if (! file_spec)
+            continue;
+        
+        static RegularExpression g_asan_runtime_regex("libclang_rt.asan_(.*)_dynamic\\.dylib");
+        if (g_asan_runtime_regex.Execute (file_spec.GetFilename().GetCString()) || module_pointer->IsExecutable())
+        {
+            if (ModuleContainsASanRuntime(module_pointer))
+            {
+                m_runtime_module = module_pointer->shared_from_this();
+                Activate();
+                return;
+            }
+        }
+    }
+}
+
+bool
+AddressSanitizerRuntime::IsActive()
+{
+    return m_is_active;
+}
+
+#define RETRIEVE_REPORT_DATA_FUNCTION_TIMEOUT_USEC 2*1000*1000
+
+const char *
+address_sanitizer_retrieve_report_data_command = R"(
+    struct {
+        int present;
+        void *pc, *bp, *sp, *address;
+        int access_type;
+        size_t access_size;
+        const char *description;
+    } t;
+
+    t.present = ((int (*) ())__asan_report_present)();
+    t.pc = ((void * (*) ())__asan_get_report_pc)();
+    /* commented out because rdar://problem/18533301
+    t.bp = ((void * (*) ())__asan_get_report_bp)();
+    t.sp = ((void * (*) ())__asan_get_report_sp)();
+    */
+    t.address = ((void * (*) ())__asan_get_report_address)();
+    t.description = ((const char * (*) ())__asan_get_report_description)();
+    t.access_type = ((int (*) ())__asan_get_report_access_type)();
+    t.access_size = ((size_t (*) ())__asan_get_report_access_size)();
+
+    t;
+)";
+
+StructuredData::ObjectSP
+AddressSanitizerRuntime::RetrieveReportData()
+{
+    ThreadSP thread_sp = m_process->GetThreadList().GetSelectedThread();
+    StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
+    
+    if (!frame_sp)
+        return StructuredData::ObjectSP();
+    
+    EvaluateExpressionOptions options;
+    options.SetUnwindOnError(true);
+    options.SetTryAllThreads(true);
+    options.SetStopOthers(true);
+    options.SetIgnoreBreakpoints(true);
+    options.SetTimeoutUsec(RETRIEVE_REPORT_DATA_FUNCTION_TIMEOUT_USEC);
+    
+    ValueObjectSP return_value_sp;
+    if (m_process->GetTarget().EvaluateExpression(address_sanitizer_retrieve_report_data_command, frame_sp.get(), return_value_sp, options) != eExpressionCompleted)
+        return StructuredData::ObjectSP();
+    
+    int present = return_value_sp->GetValueForExpressionPath(".present")->GetValueAsUnsigned(0);
+    if (present != 1)
+        return StructuredData::ObjectSP();
+        
+    addr_t pc = return_value_sp->GetValueForExpressionPath(".pc")->GetValueAsUnsigned(0);
+    addr_t bp = return_value_sp->GetValueForExpressionPath(".bp")->GetValueAsUnsigned(0);
+    addr_t sp = return_value_sp->GetValueForExpressionPath(".sp")->GetValueAsUnsigned(0);
+    addr_t address = return_value_sp->GetValueForExpressionPath(".address")->GetValueAsUnsigned(0);
+    addr_t access_type = return_value_sp->GetValueForExpressionPath(".access_type")->GetValueAsUnsigned(0);
+    addr_t access_size = return_value_sp->GetValueForExpressionPath(".access_size")->GetValueAsUnsigned(0);
+    addr_t description_ptr = return_value_sp->GetValueForExpressionPath(".description")->GetValueAsUnsigned(0);
+    std::string description;
+    Error error;
+    m_process->ReadCStringFromMemory(description_ptr, description, error);
+    
+    StructuredData::Dictionary *dict = new StructuredData::Dictionary();
+    dict->AddStringItem("instrumentation_class", "AddressSanitizer");
+    dict->AddStringItem("stop_type", "fatal_error");
+    dict->AddIntegerItem("pc", pc);
+    dict->AddIntegerItem("bp", bp);
+    dict->AddIntegerItem("sp", sp);
+    dict->AddIntegerItem("address", address);
+    dict->AddIntegerItem("access_type", access_type);
+    dict->AddIntegerItem("access_size", access_size);
+    dict->AddStringItem("description", description);
+
+    return StructuredData::ObjectSP(dict);
+}
+
+std::string
+AddressSanitizerRuntime::FormatDescription(StructuredData::ObjectSP report)
+{
+    std::string description = report->GetAsDictionary()->GetValueForKey("description")->GetAsString()->GetValue();
+    if (description == "heap-use-after-free") {
+        return "Use of deallocated memory detected";
+    } else if (description == "heap-buffer-overflow") {
+        return "Heap buffer overflow detected";
+    } else if (description == "stack-buffer-underflow") {
+        return "Stack buffer underflow detected";
+    } else if (description == "initialization-order-fiasco") {
+        return "Initialization order problem detected";
+    } else if (description == "stack-buffer-overflow") {
+        return "Stack buffer overflow detected";
+    } else if (description == "stack-use-after-return") {
+        return "Use of returned stack memory detected";
+    } else if (description == "use-after-poison") {
+        return "Use of poisoned memory detected";
+    } else if (description == "container-overflow") {
+        return "Container overflow detected";
+    } else if (description == "stack-use-after-scope") {
+        return "Use of out-of-scope stack memory detected";
+    } else if (description == "global-buffer-overflow") {
+        return "Global buffer overflow detected";
+    } else if (description == "unknown-crash") {
+        return "Invalid memory access detected";
+    }
+    
+    // for unknown report codes just show the code
+    return description;
+}
+
+bool
+AddressSanitizerRuntime::NotifyBreakpointHit(void *baton, StoppointCallbackContext *context, user_id_t break_id, user_id_t break_loc_id)
+{
+    assert (baton && "null baton");
+    if (!baton)
+        return false;
+    
+    AddressSanitizerRuntime *const instance = static_cast<AddressSanitizerRuntime*>(baton);
+    
+    StructuredData::ObjectSP report = instance->RetrieveReportData();
+    std::string description;
+    if (report) {
+        description = instance->FormatDescription(report);
+    }
+    ThreadSP thread = context->exe_ctx_ref.GetThreadSP();
+    thread->SetStopInfo(InstrumentationRuntimeStopInfo::CreateStopReasonWithInstrumentationData(*thread, description.c_str(), report));
+
+    instance->m_runtime_module->ReportWarning("AddressSanitizer report breakpoint hit. Use 'thread info -s' to get extended information about the report.\n");
+    
+    // Return true to stop the target, false to just let the target run.
+    return true;
+}
+
+void
+AddressSanitizerRuntime::Activate()
+{
+    if (m_is_active)
+        return;
+
+    ConstString symbol_name ("__asan::AsanDie()");
+    const Symbol *symbol = m_runtime_module->FindFirstSymbolWithNameAndType (symbol_name, eSymbolTypeCode);
+    
+    if (symbol == NULL)
+        return;
+    
+    if (!symbol->GetAddress().IsValid())
+        return;
+    
+    Target &target = m_process->GetTarget();
+    addr_t symbol_address = symbol->GetAddress().GetOpcodeLoadAddress(&target);
+    
+    if (symbol_address == LLDB_INVALID_ADDRESS)
+        return;
+    
+    bool internal = true;
+    bool hardware = false;
+    Breakpoint *breakpoint = m_process->GetTarget().CreateBreakpoint(symbol_address, internal, hardware).get();
+    breakpoint->SetCallback (AddressSanitizerRuntime::NotifyBreakpointHit, this, true);
+    breakpoint->SetBreakpointKind ("address-sanitizer-report");
+    m_breakpoint_id = breakpoint->GetID();
+    
+    m_runtime_module->ReportWarning("AddressSanitizer debugger support is active. Memory error breakpoint has been installed and you can now use the 'memory history' command.\n");
+    
+    m_is_active = true;
+}
+
+void
+AddressSanitizerRuntime::Deactivate()
+{
+    if (m_breakpoint_id != LLDB_INVALID_BREAK_ID)
+    {
+        m_process->GetTarget().RemoveBreakpointByID(m_breakpoint_id);
+        m_breakpoint_id = LLDB_INVALID_BREAK_ID;
+    }
+    m_is_active = false;
+}

source/Plugins/InstrumentationRuntime/AddressSanitizer/CMakeLists.txt

+set(LLVM_NO_RTTI 1)
+
+add_lldb_library(lldbPluginInstrumentationRuntimeAddressSanitizer
+  AddressSanitizerRuntime.cpp
+  )

source/Plugins/InstrumentationRuntime/AddressSanitizer/Makefile

+##===- source/Plugins/InstrumentationRuntime/AddressSanitizer  Makefile -*-===##
+# 
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+# 
+##===----------------------------------------------------------------------===##
+
+LLDB_LEVEL := ../../../..
+LIBRARYNAME := lldbPluginInstrumentationRuntimeAddressSanitizer
+BUILD_ARCHIVE = 1
+
+include $(LLDB_LEVEL)/Makefile

source/Plugins/InstrumentationRuntime/CMakeLists.txt

+add_subdirectory(AddressSanitizer)

source/Target/CMakeLists.txt

 set(LLVM_NO_RTTI 1)
 
 include_directories(../Plugins/Process/Utility)
 
 add_lldb_library(lldbTarget
   ABI.cpp
   CPPLanguageRuntime.cpp
   ExecutionContext.cpp
   FileAction.cpp
   JITLoader.cpp
   JITLoaderList.cpp
+  InstrumentationRuntime.cpp
+  InstrumentationRuntimeStopInfo.cpp
   LanguageRuntime.cpp
   Memory.cpp
   MemoryHistory.cpp
   NativeRegisterContext.cpp
   NativeRegisterContextRegisterInfo.cpp
   ObjCLanguageRuntime.cpp
   OperatingSystem.cpp
   PathMappingList.cpp

source/Target/InstrumentationRuntime.cpp

+//===-- InstrumentationRuntime.cpp ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/lldb-private.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Target/InstrumentationRuntime.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+void
+InstrumentationRuntime::ModulesDidLoad(lldb_private::ModuleList &module_list, lldb_private::Process *process, InstrumentationRuntimeCollection &runtimes)
+{
+    InstrumentationRuntimeCreateInstance create_callback = NULL;
+    InstrumentationRuntimeGetType get_type_callback;
+    for (uint32_t idx = 0; ; ++idx)
+    {
+        create_callback = PluginManager::GetInstrumentationRuntimeCreateCallbackAtIndex(idx);
+        if (create_callback == NULL)
+            break;
+        get_type_callback = PluginManager::GetInstrumentationRuntimeGetTypeCallbackAtIndex(idx);
+        InstrumentationRuntimeType type = get_type_callback();
+        
+        InstrumentationRuntimeCollection::iterator pos;
+        pos = runtimes.find (type);
+        if (pos == runtimes.end()) {
+            runtimes[type] = create_callback(process->shared_from_this());
+        }
+    }
+}
+
+void
+InstrumentationRuntime::ModulesDidLoad(lldb_private::ModuleList &module_list)
+{
+}
+
+bool
+InstrumentationRuntime::IsActive()
+{
+    return false;
+}

source/Target/InstrumentationRuntimeStopInfo.cpp

+//===-- InstrumentationRuntimeStopInfo.cpp ----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Target/InstrumentationRuntimeStopInfo.h"
+
+#include "lldb/lldb-private.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/InstrumentationRuntime.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+InstrumentationRuntimeStopInfo::InstrumentationRuntimeStopInfo(Thread &thread, std::string description, StructuredData::ObjectSP additional_data) :
+    StopInfo(thread, 0)
+{
+    m_extended_info = additional_data;
+    m_description = description;
+}
+
+const char *
+InstrumentationRuntimeStopInfo::GetDescription ()
+{
+    return m_description.c_str();
+}
+
+StopInfoSP
+InstrumentationRuntimeStopInfo::CreateStopReasonWithInstrumentationData (Thread &thread, std::string description, StructuredData::ObjectSP additionalData)
+{
+    return StopInfoSP(new InstrumentationRuntimeStopInfo(thread, description, additionalData));
+}

source/Target/Process.cpp

 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanBase.h"
+#include "lldb/Target/InstrumentationRuntime.h"
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 
 // Comment out line below to disable memory caching, overriding the process setting
 // target.process.disable-memory-cache

     m_queue_list.Clear();
     m_queue_list_stop_id = 0;
     std::vector<Notifications> empty_notifications;
     m_notifications.swap(empty_notifications);
     m_image_tokens.clear();
     m_memory_cache.Clear();
     m_allocated_memory_cache.Clear();
     m_language_runtimes.clear();
+    m_instrumentation_runtimes.clear();
     m_next_event_action_ap.reset();
 //#ifdef LLDB_CONFIGURATION_DEBUG
 //    StreamFile s(stdout, false);
 //    EventSP event_sp;
 //    while (m_private_state_listener.GetNextEvent(event_sp))
 //    {
 //        event_sp->Dump (&s);
 //        s.EOL();

     m_abi_sp.reset();
     m_system_runtime_ap.reset();
     m_os_ap.reset();
     m_dyld_ap.reset();
     m_jit_loaders_ap.reset();
     m_image_tokens.clear();
     m_allocated_memory_cache.Clear();
     m_language_runtimes.clear();
+    m_instrumentation_runtimes.clear();
     m_thread_list.DiscardThreadPlans();
     m_memory_cache.Clear(true);
     DoDidExec();
     CompleteAttach ();
     // Flush the process (threads and all stack frames) after running CompleteAttach()
     // in case the dynamic loader loaded things in new locations.
     Flush();
     

         }
     }
     return function_addr;
 }
 
 void
 Process::ModulesDidLoad (ModuleList &module_list)
 {
     SystemRuntime *sys_runtime = GetSystemRuntime();
     if (sys_runtime)
     {
         sys_runtime->ModulesDidLoad (module_list);
     }
+
+    GetJITLoaders().ModulesDidLoad (module_list);
+    
+    // Give runtimes a chance to be created.
+    InstrumentationRuntime::ModulesDidLoad(module_list, this, m_instrumentation_runtimes);
+    
+    // Tell runtimes about new modules.
+    for (auto pos = m_instrumentation_runtimes.begin(); pos != m_instrumentation_runtimes.end(); ++pos)
+    {
+        InstrumentationRuntimeSP runtime = pos->second;
+        runtime->ModulesDidLoad(module_list);
+    }
 
-  GetJITLoaders().ModulesDidLoad (module_list);
 }
 
 ThreadCollectionSP
 Process::GetHistoryThreads(lldb::addr_t addr)
 {
     ThreadCollectionSP threads;
     
     const MemoryHistorySP &memory_history = MemoryHistory::FindPlugin(shared_from_this());

source/Target/StopInfo.cpp

 using namespace lldb_private;
 
 StopInfo::StopInfo (Thread &thread, uint64_t value) :
     m_thread_wp (thread.shared_from_this()),
     m_stop_id (thread.GetProcess()->GetStopID()),
     m_resume_id (thread.GetProcess()->GetResumeID()),
     m_value (value),
     m_override_should_notify (eLazyBoolCalculate),
-    m_override_should_stop (eLazyBoolCalculate)
+    m_override_should_stop (eLazyBoolCalculate),
+    m_extended_info()
 {
 }
 
 bool
 StopInfo::IsValid () const
 {
     ThreadSP thread_sp (m_thread_wp.lock());
     if (thread_sp)

source/Target/Thread.cpp

     case eStopReasonTrace:         return "trace";
     case eStopReasonBreakpoint:    return "breakpoint";
     case eStopReasonWatchpoint:    return "watchpoint";
     case eStopReasonSignal:        return "signal";
     case eStopReasonException:     return "exception";
     case eStopReasonExec:          return "exec";
     case eStopReasonPlanComplete:  return "plan complete";
     case eStopReasonThreadExiting: return "thread exiting";
+    case eStopReasonInstrumentation: return "instrumentation break";
     }
 
 
     static char unknown_state_string[64];
     snprintf(unknown_state_string, sizeof (unknown_state_string), "StopReason = %i", reason);
     return unknown_state_string;
 }
 

         if (num_frames == 1)
             strm.IndentLess();
         strm.IndentLess();
     }
     return num_frames_shown;
 }
 
 bool
-Thread::GetDescription (Stream &strm, lldb::DescriptionLevel level, bool print_json)
+Thread::GetDescription (Stream &strm, lldb::DescriptionLevel level, bool print_json_thread, bool print_json_stopinfo)
 {
     DumpUsingSettingsFormat (strm, 0);
     strm.Printf("\n");
 
     StructuredData::ObjectSP thread_info = GetExtendedInfo();
-
-    if (thread_info && print_json)
+    StructuredData::ObjectSP stop_info = m_stop_info_sp->GetExtendedInfo();
+    
+    if (print_json_thread || print_json_stopinfo)
     {
-        thread_info->Dump (strm);
-        strm.Printf("\n");
+        if (thread_info && print_json_thread)
+        {
+            thread_info->Dump (strm);
+            strm.Printf("\n");
+        }
+        
+        if (stop_info && print_json_stopinfo)
+        {
+            stop_info->Dump (strm);
+            strm.Printf("\n");
+        }
+        
         return true;
     }
 
     if (thread_info)
     {
         StructuredData::ObjectSP activity = thread_info->GetObjectForDotSeparatedPath("activity");
         StructuredData::ObjectSP breadcrumb = thread_info->GetObjectForDotSeparatedPath("breadcrumb");
         StructuredData::ObjectSP messages = thread_info->GetObjectForDotSeparatedPath("trace_messages");

source/lldb.cpp

 #include "Plugins/Process/POSIX/ProcessPOSIX.h"
 #include "Plugins/Process/FreeBSD/ProcessFreeBSD.h"
 #endif
 
 #include "Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
 #include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"
 #include "Plugins/MemoryHistory/asan/MemoryHistoryASan.h"
+#include "Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static void fatal_error_handler(void *user_data, const std::string& reason,
                                 bool gen_crash_diag) {
     Host::SetCrashDescription(reason.c_str());
     ::abort();

         ItaniumABILanguageRuntime::Initialize();
 #ifndef LLDB_DISABLE_PYTHON
         ScriptInterpreterPython::InitializePrivate();
         OperatingSystemPython::Initialize();
 #endif
         JITLoaderGDB::Initialize();
         ProcessElfCore::Initialize();
         MemoryHistoryASan::Initialize();
+        AddressSanitizerRuntime::Initialize();
         
 #if defined (__APPLE__)
         //----------------------------------------------------------------------
         // Apple/Darwin hosted plugins
         //----------------------------------------------------------------------
         DynamicLoaderMacOSXDYLD::Initialize();
         DynamicLoaderDarwinKernel::Initialize();
         AppleObjCRuntimeV2::Initialize();

     SymbolFileDWARFDebugMap::Terminate();
     ItaniumABILanguageRuntime::Terminate();
 #ifndef LLDB_DISABLE_PYTHON
     OperatingSystemPython::Terminate();
 #endif
     JITLoaderGDB::Terminate();
     ProcessElfCore::Terminate();
     MemoryHistoryASan::Terminate();
+    AddressSanitizerRuntime::Terminate();
     
 #if defined (__APPLE__)
     DynamicLoaderMacOSXDYLD::Terminate();
     DynamicLoaderDarwinKernel::Terminate();
     AppleObjCRuntimeV2::Terminate();
     AppleObjCRuntimeV1::Terminate();
     ObjectContainerUniversalMachO::Terminate();
     ObjectFileMachO::Terminate();

test/functionalities/asan/TestAsan.py

-"""
-Test that ASan memory history provider returns correct stack traces
-"""
-
-import os, time
-import unittest2
-import lldb
-from lldbtest import *
-import lldbutil
-
-class AsanTestCase(TestBase):
-
-    mydir = TestBase.compute_mydir(__file__)
-
-    # The default compiler ("clang") may not support Address Sanitizer or it
-    # may not have the debugging API which was recently added, so we're calling
-    # self.useBuiltClang() to use clang from the llvm-build directory instead
-
-    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
-    @skipIfRemote
-    @dsym_test
-    def test_with_dsym (self):
-        compiler = self.findBuiltClang ()
-        self.buildDsym (None, compiler)
-        self.asan_tests ()
-
-    @expectedFailureFreeBSD("llvm.org/pr21136") # runtimes not yet available by default
-    @skipIfRemote
-    @dwarf_test
-    def test_with_dwarf (self):
-        compiler = self.findBuiltClang ()
-        self.buildDwarf (None, compiler)
-        self.asan_tests ()
-
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-        self.line_malloc = line_number('main.c', '// malloc line')
-        self.line_malloc2 = line_number('main.c', '// malloc2 line')
-        self.line_free = line_number('main.c', '// free line')
-        self.line_breakpoint = line_number('main.c', '// break line')
-
-    def asan_tests (self):
-        exe = os.path.join (os.getcwd(), "a.out")
-        self.expect("file " + exe, patterns = [ "Current executable set to .*a.out" ])
-
-        self.runCmd("breakpoint set -f main.c -l %d" % self.line_breakpoint)
-
-        # "memory history" command should not work without a process
-        self.expect("memory history 0",
-            error = True,
-            substrs = ["invalid process"])
-
-        self.runCmd("run")
-
-        # ASan will relaunch the process to insert its library.
-        self.expect("thread list", "Process should be stopped due to exec.",
-            substrs = ['stopped', 'stop reason = exec'])
-
-        self.runCmd("continue")
-
-        # the stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped', 'stop reason = breakpoint'])
-
-        # test that the ASan dylib is present
-        self.expect("image lookup -n __asan_describe_address", "__asan_describe_address should be present",
-            substrs = ['1 match found'])
-
-        # test the 'memory history' command
-        self.expect("memory history 'pointer'",
-            substrs = [
-                'Memory allocated at', 'a.out`f1', 'main.c:%d' % self.line_malloc,
-                'Memory deallocated at', 'a.out`f2', 'main.c:%d' % self.line_free])
-
-        # do the same using SB API
-        process = self.dbg.GetSelectedTarget().process
-        val = process.GetSelectedThread().GetSelectedFrame().EvaluateExpression("pointer")
-        addr = val.GetValueAsUnsigned()
-        threads = process.GetHistoryThreads(addr);
-        self.assertEqual(threads.GetSize(), 2)
-        
-        history_thread = threads.GetThreadAtIndex(0)
-        self.assertTrue(history_thread.num_frames >= 2)
-        self.assertEqual(history_thread.frames[1].GetLineEntry().GetFileSpec().GetFilename(), "main.c")
-        self.assertEqual(history_thread.frames[1].GetLineEntry().GetLine(), self.line_malloc)
-        
-        history_thread = threads.GetThreadAtIndex(1)
-        self.assertTrue(history_thread.num_frames >= 2)
-        self.assertEqual(history_thread.frames[1].GetLineEntry().GetFileSpec().GetFilename(), "main.c")
-        self.assertEqual(history_thread.frames[1].GetLineEntry().GetLine(), self.line_free)
-
-        # let's free the container (SBThreadCollection) and see if the SBThreads still live
-        threads = None
-        self.assertTrue(history_thread.num_frames >= 2)
-        self.assertEqual(history_thread.frames[1].GetLineEntry().GetFileSpec().GetFilename(), "main.c")
-        self.assertEqual(history_thread.frames[1].GetLineEntry().GetLine(), self.line_free)
-
-        # now let's break when an ASan report occurs and try the API then
-        self.runCmd("breakpoint set -n __asan_report_error")
-
-        self.runCmd("continue")
-
-        # the stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped', 'stop reason = breakpoint'])
-
-        # make sure the 'memory history' command still works even when we're generating a report now
-        self.expect("memory history 'another_pointer'",
-            substrs = [
-                'Memory allocated at', 'a.out`f1', 'main.c:%d' % self.line_malloc2])
-
-if __name__ == '__main__':
-    import atexit
-    lldb.SBDebugger.Initialize()
-    atexit.register(lambda: lldb.SBDebugger.Terminate())
-    unittest2.main()

test/functionalities/asan/TestReportData.py

+"""
+Test the AddressSanitizer runtime support for report breakpoint and data extraction.
+"""
+
+import os, time
+import unittest2
+import lldb
+from lldbtest import *
+import lldbutil
+import json
+
+class AsanTestReportDataCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    # The default compiler ("clang") may not support Address Sanitizer or it
+    # may not have the debugging API which was recently added, so we're calling
+    # self.useBuiltClang() to use clang from the llvm-build directory instead
+
+    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
+    @skipIfRemote
+    @dsym_test
+    def test_with_dsym (self):
+        compiler = self.findBuiltClang ()
+        self.buildDsym (None, compiler)
+        self.asan_tests ()
+
+    @skipIfRemote
+    @dwarf_test
+    def test_with_dwarf (self):
+        compiler = self.findBuiltClang ()
+        self.buildDwarf (None, compiler)
+        self.asan_tests ()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        self.line_malloc = line_number('main.c', '// malloc line')
+        self.line_malloc2 = line_number('main.c', '// malloc2 line')
+        self.line_free = line_number('main.c', '// free line')
+        self.line_breakpoint = line_number('main.c', '// break line')
+        self.line_crash = line_number('main.c', '// BOOM line')
+
+    def asan_tests (self):
+        exe = os.path.join (os.getcwd(), "a.out")
+        self.expect("file " + exe, patterns = [ "Current executable set to .*a.out" ])
+        self.runCmd("run")
+
+        # ASan will relaunch the process to insert its library.
+        self.expect("thread list", "Process should be stopped due to exec.",
+            substrs = ['stopped', 'stop reason = exec'])
+
+        # no extended info when we have no ASan report
+        thread = self.dbg.GetSelectedTarget().process.GetSelectedThread()
+        s = lldb.SBStream()
+        self.assertFalse(thread.GetStopReasonExtendedInfoAsJSON(s))
+
+        self.runCmd("continue")
+
+        self.expect("thread list", "Process should be stopped due to ASan report",
+            substrs = ['stopped', 'stop reason = Use of deallocated memory detected'])
+
+        self.assertEqual(self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason(), lldb.eStopReasonInstrumentation)
+
+        self.expect("bt", "The backtrace should show the crashing line",
+            substrs = ['main.c:%d' % self.line_crash])
+
+        self.expect("thread info -s", "The extended stop info should contain the ASan provided fields",
+            substrs = ["access_size", "access_type", "address", "pc", "description", "heap-use-after-free"])
+
+        output_lines = self.res.GetOutput().split('\n')
+        json_line = output_lines[2]
+        data = json.loads(json_line)
+        self.assertEqual(data["description"], "heap-use-after-free")
+        self.assertEqual(data["instrumentation_class"], "AddressSanitizer")
+        self.assertEqual(data["stop_type"], "fatal_error")
+
+        # now let's try the SB API
+        process = self.dbg.GetSelectedTarget().process
+        thread = process.GetSelectedThread()
+
+        s = lldb.SBStream()
+        self.assertTrue(thread.GetStopReasonExtendedInfoAsJSON(s))
+        s = s.GetData()
+        data2 = json.loads(s)
+        self.assertEqual(data, data2)
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

test/functionalities/asan/main.c

 
 int main (int argc, char const *argv[])
 {
     f1();
     f2();
 
     printf("Hello world!\n"); // break line
 
-    pointer[0] = 'A'; // BOOM
+    pointer[0] = 'A'; // BOOM line
 
     return 0;
 }