Add an OperatingSystem plugin to support goroutines

The Go runtime schedules user level threads (goroutines) across real threads.
This adds an OS plugin to create memory threads for goroutines.
It supports the 1.4 and 1.5 go runtime.

Differential Revision: http://reviews.llvm.org/D5871

llvm-svn: 247852

18 files changed, 744 insertions, 11 deletions

diff --git a/lldb/source/Core/PluginManager.cpp b/lldb/source/Core/PluginManager.cpp
index 2770bbb258a..4c0d2e772f0 100644
--- a/lldb/source/Core/PluginManager.cpp
+++ b/lldb/source/Core/PluginManager.cpp
@@ -771,16 +771,18 @@ PluginManager::GetEmulateInstructionCreateCallbackForPluginName (const ConstStri
 
 struct OperatingSystemInstance
 {
-    OperatingSystemInstance() :
-        name(),
-        description(),
-        create_callback(NULL)
+    OperatingSystemInstance () :
+        name (),
+        description (),
+        create_callback (nullptr),
+        debugger_init_callback (nullptr)
     {
     }
     
     ConstString name;
     std::string description;
     OperatingSystemCreateInstance create_callback;
+    DebuggerInitializeCallback debugger_init_callback;
 };
 
 typedef std::vector<OperatingSystemInstance> OperatingSystemInstances;
@@ -800,9 +802,9 @@ GetOperatingSystemInstances ()
 }
 
 bool
-PluginManager::RegisterPlugin (const ConstString &name,
-                               const char *description,
-                               OperatingSystemCreateInstance create_callback)
+PluginManager::RegisterPlugin(const ConstString &name, const char *description,
+                              OperatingSystemCreateInstance create_callback,
+                              DebuggerInitializeCallback debugger_init_callback)
 {
     if (create_callback)
     {
@@ -812,6 +814,7 @@ PluginManager::RegisterPlugin (const ConstString &name,
         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
+        instance.debugger_init_callback = debugger_init_callback;
         Mutex::Locker locker (GetOperatingSystemMutex ());
         GetOperatingSystemInstances ().push_back (instance);
     }
@@ -2579,6 +2582,16 @@ PluginManager::DebuggerInitialize (Debugger &debugger)
                 sym_file.debugger_init_callback (debugger);
         }
     }
+
+    // Initialize the OperatingSystem plugins
+    {
+        Mutex::Locker locker(GetOperatingSystemMutex());
+        for (auto &os : GetOperatingSystemInstances())
+        {
+            if (os.debugger_init_callback)
+                os.debugger_init_callback(debugger);
+        }
+    }
 }
 
 // This is the preferred new way to register plugin specific settings.  e.g.
@@ -2823,3 +2836,38 @@ PluginManager::CreateSettingForJITLoaderPlugin (Debugger &debugger,
                                   description,
                                   is_global_property);
 }
+
+static const char *kOperatingSystemPluginName("os");
+
+lldb::OptionValuePropertiesSP
+PluginManager::GetSettingForOperatingSystemPlugin(Debugger &debugger, const ConstString &setting_name)
+{
+    lldb::OptionValuePropertiesSP properties_sp;
+    lldb::OptionValuePropertiesSP plugin_type_properties_sp(
+        GetDebuggerPropertyForPlugins(debugger, ConstString(kOperatingSystemPluginName),
+                                      ConstString(), // not creating to so we don't need the description
+                                      false));
+    if (plugin_type_properties_sp)
+        properties_sp = plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
+    return properties_sp;
+}
+
+bool
+PluginManager::CreateSettingForOperatingSystemPlugin(Debugger &debugger,
+                                                     const lldb::OptionValuePropertiesSP &properties_sp,
+                                                     const ConstString &description, bool is_global_property)
+{
+    if (properties_sp)
+    {
+        lldb::OptionValuePropertiesSP plugin_type_properties_sp(
+            GetDebuggerPropertyForPlugins(debugger, ConstString(kOperatingSystemPluginName),
+                                          ConstString("Settings for operating system plug-ins"), true));
+        if (plugin_type_properties_sp)
+        {
+            plugin_type_properties_sp->AppendProperty(properties_sp->GetName(), description, is_global_property,
+                                                      properties_sp);
+            return true;
+        }
+    }
+    return false;
+}
diff --git a/lldb/source/Initialization/SystemInitializerCommon.cpp b/lldb/source/Initialization/SystemInitializerCommon.cpp
index c17b979c9cb..89a3afe0947 100644
--- a/lldb/source/Initialization/SystemInitializerCommon.cpp
+++ b/lldb/source/Initialization/SystemInitializerCommon.cpp
@@ -25,6 +25,7 @@
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
 #include "Plugins/OperatingSystem/Python/OperatingSystemPython.h"
+#include "Plugins/OperatingSystem/Go/OperatingSystemGo.h"
 #include "Plugins/Platform/Android/PlatformAndroid.h"
 #include "Plugins/Platform/FreeBSD/PlatformFreeBSD.h"
 #include "Plugins/Platform/Kalimba/PlatformKalimba.h"
@@ -142,6 +143,7 @@ SystemInitializerCommon::Initialize()
 #ifndef LLDB_DISABLE_PYTHON
     OperatingSystemPython::Initialize();
 #endif
+    OperatingSystemGo::Initialize();
 }
 
 void
@@ -181,6 +183,7 @@ SystemInitializerCommon::Terminate()
 #ifndef LLDB_DISABLE_PYTHON
     OperatingSystemPython::Terminate();
 #endif
+    OperatingSystemGo::Terminate();
 
     Log::Terminate();
 }
diff --git a/lldb/source/Plugins/Makefile b/lldb/source/Plugins/Makefile
index fe0826f7293..776b6e64b62 100644
--- a/lldb/source/Plugins/Makefile
+++ b/lldb/source/Plugins/Makefile
@@ -33,6 +33,7 @@ PARALLEL_DIRS := ABI/MacOSX-arm ABI/MacOSX-arm64 ABI/MacOSX-i386 ABI/SysV-i386 A
 	DynamicLoader/Windows-DYLD \
 	JITLoader/GDB \
 	ExpressionParser/Clang \
+	OperatingSystem/Go \
 	OperatingSystem/Python \
 	SystemRuntime/MacOSX \
 	SymbolVendor/ELF \
diff --git a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
index a846beee05d..4c6782d59c8 100644
--- a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
+++ b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
@@ -1720,6 +1720,7 @@ ObjectFileELF::CreateSections(SectionList &unified_section_list)
             static ConstString g_sect_name_dwarf_debug_str_dwo (".debug_str.dwo");
             static ConstString g_sect_name_dwarf_debug_str_offsets_dwo (".debug_str_offsets.dwo");
             static ConstString g_sect_name_eh_frame (".eh_frame");
+            static ConstString g_sect_name_go_symtab (".gosymtab");
 
             SectionType sect_type = eSectionTypeOther;
 
@@ -1772,6 +1773,7 @@ ObjectFileELF::CreateSections(SectionList &unified_section_list)
             else if (name == g_sect_name_dwarf_debug_str_dwo)         sect_type = eSectionTypeDWARFDebugStr;
             else if (name == g_sect_name_dwarf_debug_str_offsets_dwo) sect_type = eSectionTypeDWARFDebugStrOffsets;
             else if (name == g_sect_name_eh_frame)                    sect_type = eSectionTypeEHFrame;
+            else if (name == g_sect_name_go_symtab)                   sect_type = eSectionTypeGoSymtab;
 
             switch (header.sh_type)
             {
diff --git a/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp b/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
index 4decef69113..855a6dbeea4 100644
--- a/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
+++ b/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
@@ -1318,6 +1318,7 @@ ObjectFileMachO::GetAddressClass (lldb::addr_t file_addr)
                     case eSectionTypeZeroFill:
                     case eSectionTypeDataObjCMessageRefs:
                     case eSectionTypeDataObjCCFStrings:
+                    case eSectionTypeGoSymtab:
                         return eAddressClassData;
 
                     case eSectionTypeDebug:
@@ -1777,6 +1778,7 @@ ObjectFileMachO::CreateSections (SectionList &unified_section_list)
                                     static ConstString g_sect_name_compact_unwind ("__unwind_info");
                                     static ConstString g_sect_name_text ("__text");
                                     static ConstString g_sect_name_data ("__data");
+                                    static ConstString g_sect_name_go_symtab ("__gosymtab");
 
 
                                     if (section_name == g_sect_name_dwarf_debug_abbrev)
@@ -1819,6 +1821,8 @@ ObjectFileMachO::CreateSections (SectionList &unified_section_list)
                                         sect_type = eSectionTypeCompactUnwind;
                                     else if (section_name == g_sect_name_cfstring)
                                         sect_type = eSectionTypeDataObjCCFStrings;
+                                    else if (section_name == g_sect_name_go_symtab)
+                                        sect_type = eSectionTypeGoSymtab;
                                     else if (section_name == g_sect_name_objc_data ||
                                              section_name == g_sect_name_objc_classrefs ||
                                              section_name == g_sect_name_objc_superrefs ||
diff --git a/lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp b/lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp
index 8189f10bd30..8b994590504 100644
--- a/lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp
+++ b/lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp
@@ -693,6 +693,7 @@ ObjectFilePECOFF::CreateSections (SectionList &unified_section_list)
                 static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges");
                 static ConstString g_sect_name_dwarf_debug_str (".debug_str");
                 static ConstString g_sect_name_eh_frame (".eh_frame");
+                static ConstString g_sect_name_go_symtab (".gosymtab");
                 SectionType section_type = eSectionTypeOther;
                 if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_CNT_CODE &&
                     ((const_sect_name == g_code_sect_name) || (const_sect_name == g_CODE_sect_name)))
@@ -736,6 +737,7 @@ ObjectFilePECOFF::CreateSections (SectionList &unified_section_list)
                 else if (const_sect_name == g_sect_name_dwarf_debug_ranges)    section_type = eSectionTypeDWARFDebugRanges;
                 else if (const_sect_name == g_sect_name_dwarf_debug_str)       section_type = eSectionTypeDWARFDebugStr;
                 else if (const_sect_name == g_sect_name_eh_frame)              section_type = eSectionTypeEHFrame;
+                else if (const_sect_name == g_sect_name_go_symtab)             section_type = eSectionTypeGoSymtab;
                 else if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_CNT_CODE)
                 {
                     section_type = eSectionTypeCode;
diff --git a/lldb/source/Plugins/OperatingSystem/CMakeLists.txt b/lldb/source/Plugins/OperatingSystem/CMakeLists.txt
index 655007a0aab..1f017adcd02 100644
--- a/lldb/source/Plugins/OperatingSystem/CMakeLists.txt
+++ b/lldb/source/Plugins/OperatingSystem/CMakeLists.txt
@@ -1 +1,2 @@
+add_subdirectory(Go)
 add_subdirectory(Python)
diff --git a/lldb/source/Plugins/OperatingSystem/Go/CMakeLists.txt b/lldb/source/Plugins/OperatingSystem/Go/CMakeLists.txt
new file mode 100644
index 00000000000..1ca82c46206
--- /dev/null
+++ b/lldb/source/Plugins/OperatingSystem/Go/CMakeLists.txt
@@ -0,0 +1,3 @@
+add_lldb_library(lldbPluginOSGo
+  OperatingSystemGo.cpp
+  )
diff --git a/lldb/source/Plugins/OperatingSystem/Go/Makefile b/lldb/source/Plugins/OperatingSystem/Go/Makefile
new file mode 100644
index 00000000000..7d06d483d3a
--- /dev/null
+++ b/lldb/source/Plugins/OperatingSystem/Go/Makefile
@@ -0,0 +1,14 @@
+##==- source/Plugins/OperatingSystem/Go/Makefile --------*- 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 := lldbPluginOSGo
+BUILD_ARCHIVE = 1
+
+include $(LLDB_LEVEL)/Makefile
diff --git a/lldb/source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp b/lldb/source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp
new file mode 100644
index 00000000000..2709afc2743
--- /dev/null
+++ b/lldb/source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp
@@ -0,0 +1,560 @@
+//===-- OperatingSystemGo.cpp --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "OperatingSystemGo.h"
+
+// C Includes
+// C++ Includes
+#include <unordered_map>
+
+// Other libraries and framework includes
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/RegisterValue.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Core/ValueObjectVariable.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/OptionValueProperties.h"
+#include "lldb/Interpreter/Options.h"
+#include "lldb/Interpreter/OptionGroupBoolean.h"
+#include "lldb/Interpreter/OptionGroupUInt64.h"
+#include "lldb/Interpreter/Property.h"
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Symbol/Type.h"
+#include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/StopInfo.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/ThreadList.h"
+#include "lldb/Target/Thread.h"
+#include "Plugins/Process/Utility/DynamicRegisterInfo.h"
+#include "Plugins/Process/Utility/RegisterContextMemory.h"
+#include "Plugins/Process/Utility/ThreadMemory.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace
+{
+
+static PropertyDefinition g_properties[] = {{"enable", OptionValue::eTypeBoolean, true, true, nullptr, nullptr,
+                                             "Specify whether goroutines should be treated as threads."},
+                                            {NULL, OptionValue::eTypeInvalid, false, 0, NULL, NULL, NULL}};
+
+enum
+{
+    ePropertyEnableGoroutines,
+};
+
+class PluginProperties : public Properties
+{
+  public:
+    static ConstString
+    GetSettingName()
+    {
+        return OperatingSystemGo::GetPluginNameStatic();
+    }
+
+    PluginProperties()
+        : Properties()
+    {
+        m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+        m_collection_sp->Initialize(g_properties);
+    }
+
+    virtual ~PluginProperties() {}
+
+    bool
+    GetEnableGoroutines()
+    {
+        const uint32_t idx = ePropertyEnableGoroutines;
+        return m_collection_sp->GetPropertyAtIndexAsBoolean(NULL, idx, g_properties[idx].default_uint_value);
+    }
+
+    bool
+    SetEnableGoroutines(bool enable)
+    {
+        const uint32_t idx = ePropertyEnableGoroutines;
+        return m_collection_sp->SetPropertyAtIndexAsUInt64(NULL, idx, enable);
+    }
+};
+
+typedef std::shared_ptr<PluginProperties> OperatingSystemGoPropertiesSP;
+
+static const OperatingSystemGoPropertiesSP &
+GetGlobalPluginProperties()
+{
+    static OperatingSystemGoPropertiesSP g_settings_sp;
+    if (!g_settings_sp)
+        g_settings_sp.reset(new PluginProperties());
+    return g_settings_sp;
+}
+
+class RegisterContextGo : public RegisterContextMemory
+{
+  public:
+    //------------------------------------------------------------------
+    // Constructors and Destructors
+    //------------------------------------------------------------------
+    RegisterContextGo(lldb_private::Thread &thread, uint32_t concrete_frame_idx, DynamicRegisterInfo &reg_info,
+                      lldb::addr_t reg_data_addr)
+        : RegisterContextMemory(thread, concrete_frame_idx, reg_info, reg_data_addr)
+    {
+        const RegisterInfo *sp = reg_info.GetRegisterInfoAtIndex(
+            reg_info.ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP));
+        const RegisterInfo *pc = reg_info.GetRegisterInfoAtIndex(
+            reg_info.ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC));
+        size_t byte_size = std::max(sp->byte_offset + sp->byte_size, pc->byte_offset + pc->byte_size);
+
+        DataBufferSP reg_data_sp(new DataBufferHeap(byte_size, 0));
+        m_reg_data.SetData(reg_data_sp);
+    }
+
+    virtual ~RegisterContextGo() {}
+
+    virtual bool
+    ReadRegister(const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &reg_value)
+    {
+        switch (reg_info->kinds[eRegisterKindGeneric])
+        {
+            case LLDB_REGNUM_GENERIC_SP:
+            case LLDB_REGNUM_GENERIC_PC:
+                return RegisterContextMemory::ReadRegister(reg_info, reg_value);
+            default:
+                reg_value.SetValueToInvalid();
+                return true;
+        }
+    }
+
+    virtual bool
+    WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &reg_value)
+    {
+        switch (reg_info->kinds[eRegisterKindGeneric])
+        {
+            case LLDB_REGNUM_GENERIC_SP:
+            case LLDB_REGNUM_GENERIC_PC:
+                return RegisterContextMemory::WriteRegister(reg_info, reg_value);
+            default:
+                return false;
+        }
+    }
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(RegisterContextGo);
+};
+
+}  // namespace
+
+struct OperatingSystemGo::Goroutine
+{
+    uint64_t m_lostack;
+    uint64_t m_histack;
+    uint64_t m_goid;
+    addr_t m_gobuf;
+    uint32_t m_status;
+};
+
+void
+OperatingSystemGo::Initialize()
+{
+    PluginManager::RegisterPlugin(GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance,
+                                  DebuggerInitialize);
+}
+
+void
+OperatingSystemGo::DebuggerInitialize(Debugger &debugger)
+{
+    if (!PluginManager::GetSettingForOperatingSystemPlugin(debugger, PluginProperties::GetSettingName()))
+    {
+        const bool is_global_setting = true;
+        PluginManager::CreateSettingForOperatingSystemPlugin(
+            debugger, GetGlobalPluginProperties()->GetValueProperties(),
+            ConstString("Properties for the goroutine thread plug-in."), is_global_setting);
+    }
+}
+
+void
+OperatingSystemGo::Terminate()
+{
+    PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+OperatingSystem *
+OperatingSystemGo::CreateInstance(Process *process, bool force)
+{
+    if (!force)
+    {
+        TargetSP target_sp = process->CalculateTarget();
+        if (!target_sp)
+            return nullptr;
+        ModuleList &module_list = target_sp->GetImages();
+        Mutex::Locker modules_locker(module_list.GetMutex());
+        const size_t num_modules = module_list.GetSize();
+        bool found_go_runtime = false;
+        for (size_t i = 0; i < num_modules; ++i)
+        {
+            Module *module = module_list.GetModulePointerAtIndexUnlocked(i);
+            const SectionList *section_list = module->GetSectionList();
+            if (section_list)
+            {
+                SectionSP section_sp(section_list->FindSectionByType(eSectionTypeGoSymtab, true));
+                if (section_sp)
+                {
+                    found_go_runtime = true;
+                    break;
+                }
+            }
+        }
+        if (!found_go_runtime)
+            return nullptr;
+    }
+    return new OperatingSystemGo(process);
+}
+
+ConstString
+OperatingSystemGo::GetPluginNameStatic()
+{
+    static ConstString g_name("goroutines");
+    return g_name;
+}
+
+const char *
+OperatingSystemGo::GetPluginDescriptionStatic()
+{
+    return "Operating system plug-in that reads runtime data-structures for goroutines.";
+}
+
+OperatingSystemGo::OperatingSystemGo(lldb_private::Process *process)
+    : OperatingSystem(process)
+    , m_reginfo(new DynamicRegisterInfo)
+{
+}
+
+OperatingSystemGo::~OperatingSystemGo()
+{
+}
+
+bool
+OperatingSystemGo::Init(ThreadList &threads)
+{
+    if (threads.GetSize(false) < 1)
+        return false;
+    TargetSP target_sp = m_process->CalculateTarget();
+    if (!target_sp)
+        return false;
+    m_allg_sp = FindGlobal(target_sp, "runtime.allg");
+    m_allglen_sp = FindGlobal(target_sp, "runtime.allglen");
+
+    if (m_allg_sp && !m_allglen_sp)
+    {
+        StreamSP error_sp = target_sp->GetDebugger().GetAsyncErrorStream();
+        error_sp->Printf("Unsupported Go runtime version detected.");
+        return false;
+    }
+
+    if (!m_allg_sp)
+        return false;
+
+    RegisterContextSP real_registers_sp = threads.GetThreadAtIndex(0, false)->GetRegisterContext();
+
+    std::unordered_map<size_t, ConstString> register_sets;
+    for (size_t set_idx = 0; set_idx < real_registers_sp->GetRegisterSetCount(); ++set_idx)
+    {
+        const RegisterSet *set = real_registers_sp->GetRegisterSet(set_idx);
+        ConstString name(set->name);
+        for (size_t reg_idx = 0; reg_idx < set->num_registers; ++reg_idx)
+        {
+            register_sets[reg_idx] = name;
+        }
+    }
+    TypeSP gobuf_sp = FindType(target_sp, "runtime.gobuf");
+    if (!gobuf_sp)
+    {
+        Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));
+
+        if (log)
+            log->Printf("OperatingSystemGo unable to find struct Gobuf");
+        return false;
+    }
+    CompilerType gobuf_type(gobuf_sp->GetLayoutCompilerType());
+    for (size_t idx = 0; idx < real_registers_sp->GetRegisterCount(); ++idx)
+    {
+        RegisterInfo reg = *real_registers_sp->GetRegisterInfoAtIndex(idx);
+        int field_index = -1;
+        if (reg.kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_SP)
+        {
+            field_index = 0;
+        }
+        else if (reg.kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_PC)
+        {
+            field_index = 1;
+        }
+        if (field_index == -1)
+        {
+            reg.byte_offset = ~0;
+        }
+        else
+        {
+            std::string field_name;
+            uint64_t bit_offset = 0;
+            CompilerType field_type =
+                gobuf_type.GetFieldAtIndex(field_index, field_name, &bit_offset, nullptr, nullptr);
+            reg.byte_size = field_type.GetByteSize(nullptr);
+            reg.byte_offset = bit_offset / 8;
+        }
+        ConstString name(reg.name);
+        ConstString alt_name(reg.alt_name);
+        m_reginfo->AddRegister(reg, name, alt_name, register_sets[idx]);
+    }
+    return true;
+}
+
+//------------------------------------------------------------------
+// PluginInterface protocol
+//------------------------------------------------------------------
+ConstString
+OperatingSystemGo::GetPluginName()
+{
+    return GetPluginNameStatic();
+}
+
+uint32_t
+OperatingSystemGo::GetPluginVersion()
+{
+    return 1;
+}
+
+bool
+OperatingSystemGo::UpdateThreadList(ThreadList &old_thread_list, ThreadList &real_thread_list,
+                                    ThreadList &new_thread_list)
+{
+    new_thread_list = real_thread_list;
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));
+
+    if (!(m_allg_sp || Init(real_thread_list)) || (m_allg_sp && !m_allglen_sp) ||
+        !GetGlobalPluginProperties()->GetEnableGoroutines())
+    {
+        return new_thread_list.GetSize(false) > 0;
+    }
+
+    if (log)
+        log->Printf("OperatingSystemGo::UpdateThreadList(%d, %d, %d) fetching thread data from Go for pid %" PRIu64,
+                    old_thread_list.GetSize(false), real_thread_list.GetSize(false), new_thread_list.GetSize(0),
+                    m_process->GetID());
+    uint64_t allglen = m_allglen_sp->GetValueAsUnsigned(0);
+    if (allglen == 0)
+    {
+        return new_thread_list.GetSize(false) > 0;
+    }
+    std::vector<Goroutine> goroutines;
+    // The threads that are in "new_thread_list" upon entry are the threads from the
+    // lldb_private::Process subclass, no memory threads will be in this list.
+
+    Error err;
+    for (uint64_t i = 0; i < allglen; ++i)
+    {
+        goroutines.push_back(CreateGoroutineAtIndex(i, err));
+        if (err.Fail())
+        {
+            err.PutToLog(log, "OperatingSystemGo::UpdateThreadList");
+            return new_thread_list.GetSize(false) > 0;
+        }
+    }
+    // Make a map so we can match goroutines with backing threads.
+    std::map<uint64_t, ThreadSP> stack_map;
+    for (uint32_t i = 0; i < real_thread_list.GetSize(false); ++i)
+    {
+        ThreadSP thread = real_thread_list.GetThreadAtIndex(i, false);
+        stack_map[thread->GetRegisterContext()->GetSP()] = thread;
+    }
+    for (const Goroutine &goroutine : goroutines)
+    {
+        if (0 /* Gidle */ == goroutine.m_status || 6 /* Gdead */ == goroutine.m_status)
+        {
+            continue;
+        }
+        ThreadSP memory_thread = old_thread_list.FindThreadByID(goroutine.m_goid, false);
+        if (memory_thread && IsOperatingSystemPluginThread(memory_thread) && memory_thread->IsValid())
+        {
+            memory_thread->ClearBackingThread();
+        }
+        else
+        {
+            memory_thread.reset(new ThreadMemory(*m_process, goroutine.m_goid, nullptr, nullptr, goroutine.m_gobuf));
+        }
+        // Search for the backing thread if the goroutine is running.
+        if (2 == (goroutine.m_status & 0xfff))
+        {
+            auto backing_it = stack_map.lower_bound(goroutine.m_lostack);
+            if (backing_it != stack_map.end())
+            {
+                if (goroutine.m_histack >= backing_it->first)
+                {
+                    if (log)
+                        log->Printf("OperatingSystemGo::UpdateThreadList found backing thread %" PRIx64 " (%" PRIx64
+                                    ") for thread %" PRIx64 "",
+                                    backing_it->second->GetID(), backing_it->second->GetProtocolID(),
+                                    memory_thread->GetID());
+                    memory_thread->SetBackingThread(backing_it->second);
+                    new_thread_list.RemoveThreadByID(backing_it->second->GetID(), false);
+                }
+            }
+        }
+        new_thread_list.AddThread(memory_thread);
+    }
+
+    return new_thread_list.GetSize(false) > 0;
+}
+
+void
+OperatingSystemGo::ThreadWasSelected(Thread *thread)
+{
+}
+
+RegisterContextSP
+OperatingSystemGo::CreateRegisterContextForThread(Thread *thread, addr_t reg_data_addr)
+{
+    RegisterContextSP reg_ctx_sp;
+    if (!thread)
+        return reg_ctx_sp;
+
+    if (!IsOperatingSystemPluginThread(thread->shared_from_this()))
+        return reg_ctx_sp;
+
+    reg_ctx_sp.reset(new RegisterContextGo(*thread, 0, *m_reginfo, reg_data_addr));
+    return reg_ctx_sp;
+}
+
+StopInfoSP
+OperatingSystemGo::CreateThreadStopReason(lldb_private::Thread *thread)
+{
+    StopInfoSP stop_info_sp;
+    return stop_info_sp;
+}
+
+lldb::ThreadSP
+OperatingSystemGo::CreateThread(lldb::tid_t tid, addr_t context)
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));
+
+    if (log)
+        log->Printf("OperatingSystemGo::CreateThread (tid = 0x%" PRIx64 ", context = 0x%" PRIx64 ") not implemented",
+                    tid, context);
+
+    return ThreadSP();
+}
+
+ValueObjectSP
+OperatingSystemGo::FindGlobal(TargetSP target, const char *name)
+{
+    VariableList variable_list;
+    const bool append = true;
+
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));
+
+    if (log)
+    {
+        log->Printf("exe: %s", target->GetExecutableModule()->GetSpecificationDescription().c_str());
+        log->Printf("modules: %zu", target->GetImages().GetSize());
+    }
+
+    uint32_t match_count = target->GetImages().FindGlobalVariables(ConstString(name), append, 1, variable_list);
+    if (match_count > 0)
+    {
+        ExecutionContextScope *exe_scope = target->GetProcessSP().get();
+        if (exe_scope == NULL)
+            exe_scope = target.get();
+        return ValueObjectVariable::Create(exe_scope, variable_list.GetVariableAtIndex(0));
+    }
+    return ValueObjectSP();
+}
+
+TypeSP
+OperatingSystemGo::FindType(TargetSP target_sp, const char *name)
+{
+    ConstString const_typename(name);
+    SymbolContext sc;
+    const bool exact_match = false;
+
+    const ModuleList &module_list = target_sp->GetImages();
+    size_t count = module_list.GetSize();
+    for (size_t idx = 0; idx < count; idx++)
+    {
+        ModuleSP module_sp(module_list.GetModuleAtIndex(idx));
+        if (module_sp)
+        {
+            TypeSP type_sp(module_sp->FindFirstType(sc, const_typename, exact_match));
+            if (type_sp)
+                return type_sp;
+        }
+    }
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));
+
+    if (log)
+        log->Printf("OperatingSystemGo::FindType(%s): not found", name);
+    return TypeSP();
+}
+
+OperatingSystemGo::Goroutine
+OperatingSystemGo::CreateGoroutineAtIndex(uint64_t idx, Error &err)
+{
+    err.Clear();
+    Goroutine result;
+    ValueObjectSP g = m_allg_sp->GetSyntheticArrayMember(idx, true)->Dereference(err);
+    if (err.Fail())
+    {
+        return result;
+    }
+
+    ConstString name("goid");
+    ValueObjectSP val = g->GetChildMemberWithName(name, true);
+    bool success = false;
+    result.m_goid = val->GetValueAsUnsigned(0, &success);
+    if (!success)
+    {
+        err.SetErrorToGenericError();
+        err.SetErrorString("unable to read goid");
+        return result;
+    }
+    name.SetCString("atomicstatus");
+    val = g->GetChildMemberWithName(name, true);
+    result.m_status = (uint32_t)val->GetValueAsUnsigned(0, &success);
+    if (!success)
+    {
+        err.SetErrorToGenericError();
+        err.SetErrorString("unable to read atomicstatus");
+        return result;
+    }
+    name.SetCString("sched");
+    val = g->GetChildMemberWithName(name, true);
+    result.m_gobuf = val->GetAddressOf(false);
+    name.SetCString("stack");
+    val = g->GetChildMemberWithName(name, true);
+    name.SetCString("lo");
+    ValueObjectSP child = val->GetChildMemberWithName(name, true);
+    result.m_lostack = child->GetValueAsUnsigned(0, &success);
+    if (!success)
+    {
+        err.SetErrorToGenericError();
+        err.SetErrorString("unable to read stack.lo");
+        return result;
+    }
+    name.SetCString("hi");
+    child = val->GetChildMemberWithName(name, true);
+    result.m_histack = child->GetValueAsUnsigned(0, &success);
+    if (!success)
+    {
+        err.SetErrorToGenericError();
+        err.SetErrorString("unable to read stack.hi");
+        return result;
+    }
+    return result;
+}
diff --git a/lldb/source/Plugins/OperatingSystem/Go/OperatingSystemGo.h b/lldb/source/Plugins/OperatingSystem/Go/OperatingSystemGo.h
new file mode 100644
index 00000000000..b543f61be6a
--- /dev/null
+++ b/lldb/source/Plugins/OperatingSystem/Go/OperatingSystemGo.h
@@ -0,0 +1,85 @@
+//===-- OperatingSystemGo.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_OperatingSystemGo_h_
+#define _liblldb_OperatingSystemGo_h_
+
+#include <iostream>
+
+#include "lldb/Target/OperatingSystem.h"
+
+class DynamicRegisterInfo;
+
+class OperatingSystemGo : public lldb_private::OperatingSystem
+{
+  public:
+    //------------------------------------------------------------------
+    // Static Functions
+    //------------------------------------------------------------------
+    static lldb_private::OperatingSystem *CreateInstance(lldb_private::Process *process, bool force);
+
+    static void Initialize();
+
+    static void DebuggerInitialize(lldb_private::Debugger &debugger);
+
+    static void Terminate();
+
+    static lldb_private::ConstString GetPluginNameStatic();
+
+    static const char *GetPluginDescriptionStatic();
+
+    //------------------------------------------------------------------
+    // Class Methods
+    //------------------------------------------------------------------
+    OperatingSystemGo(lldb_private::Process *process);
+
+    virtual ~OperatingSystemGo();
+
+    //------------------------------------------------------------------
+    // lldb_private::PluginInterface Methods
+    //------------------------------------------------------------------
+    virtual lldb_private::ConstString GetPluginName();
+
+    virtual uint32_t GetPluginVersion();
+
+    //------------------------------------------------------------------
+    // lldb_private::OperatingSystem Methods
+    //------------------------------------------------------------------
+    virtual bool UpdateThreadList(lldb_private::ThreadList &old_thread_list, lldb_private::ThreadList &real_thread_list,
+                                  lldb_private::ThreadList &new_thread_list);
+
+    virtual void ThreadWasSelected(lldb_private::Thread *thread);
+
+    virtual lldb::RegisterContextSP CreateRegisterContextForThread(lldb_private::Thread *thread,
+                                                                   lldb::addr_t reg_data_addr);
+
+    virtual lldb::StopInfoSP CreateThreadStopReason(lldb_private::Thread *thread);
+
+    //------------------------------------------------------------------
+    // Method for lazy creation of threads on demand
+    //------------------------------------------------------------------
+    virtual lldb::ThreadSP CreateThread(lldb::tid_t tid, lldb::addr_t context);
+
+  private:
+    struct Goroutine;
+
+    static lldb::ValueObjectSP FindGlobal(lldb::TargetSP target, const char *name);
+
+    static lldb::TypeSP FindType(lldb::TargetSP target_sp, const char *name);
+
+    bool Init(lldb_private::ThreadList &threads);
+
+    Goroutine CreateGoroutineAtIndex(uint64_t idx, lldb_private::Error &err);
+
+    std::unique_ptr<DynamicRegisterInfo> m_reginfo;
+    lldb::ValueObjectSP m_allg_sp;
+    lldb::ValueObjectSP m_allglen_sp;
+};
+
+#endif // #ifndef liblldb_OperatingSystemGo_h_
diff --git a/lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp b/lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp
index 93a52d1206e..a556b0e84e8 100644
--- a/lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp
+++ b/lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp
@@ -42,9 +42,7 @@ using namespace lldb_private;
 void
 OperatingSystemPython::Initialize()
 {
-    PluginManager::RegisterPlugin (GetPluginNameStatic(),
-                                   GetPluginDescriptionStatic(),
-                                   CreateInstance);
+    PluginManager::RegisterPlugin(GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance, nullptr);
 }
 
 void
diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index 2d5b76c3a9d..09947738321 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -2044,6 +2044,10 @@ ProcessGDBRemote::SetThreadStopInfo (lldb::tid_t tid,
             if (!thread_sp->StopInfoIsUpToDate())
             {
                 thread_sp->SetStopInfo (StopInfoSP());
+                // If there's a memory thread backed by this thread, we need to use it to calcualte StopInfo.
+                ThreadSP memory_thread_sp = m_thread_list.FindThreadByProtocolID(thread_sp->GetProtocolID());
+                if (memory_thread_sp)
+                    thread_sp = memory_thread_sp;
 
                 if (exc_type != 0)
                 {
diff --git a/lldb/source/Symbol/ObjectFile.cpp b/lldb/source/Symbol/ObjectFile.cpp
index b61d499d2eb..e8a963e5767 100644
--- a/lldb/source/Symbol/ObjectFile.cpp
+++ b/lldb/source/Symbol/ObjectFile.cpp
@@ -351,6 +351,7 @@ ObjectFile::GetAddressClass (addr_t file_addr)
                     case eSectionTypeZeroFill:
                     case eSectionTypeDataObjCMessageRefs:
                     case eSectionTypeDataObjCCFStrings:
+                    case eSectionTypeGoSymtab:
                         return eAddressClassData;
                     case eSectionTypeDebug:
                     case eSectionTypeDWARFDebugAbbrev:
diff --git a/lldb/source/Target/Process.cpp b/lldb/source/Target/Process.cpp
index e2bb2e48c41..a8f43c36a04 100644
--- a/lldb/source/Target/Process.cpp
+++ b/lldb/source/Target/Process.cpp
@@ -6553,6 +6553,8 @@ Process::ModulesDidLoad (ModuleList &module_list)
         if (language_runtime_sp)
             language_runtime_sp->ModulesDidLoad(module_list);
     }
+
+    LoadOperatingSystemPlugin(false);
 }
 
 void
diff --git a/lldb/source/Target/StackFrameList.cpp b/lldb/source/Target/StackFrameList.cpp
index b93e80806de..a7ee6df06f5 100644
--- a/lldb/source/Target/StackFrameList.cpp
+++ b/lldb/source/Target/StackFrameList.cpp
@@ -108,6 +108,8 @@ StackFrameList::ResetCurrentInlinedDepth ()
     if (m_show_inlined_frames)
     {        
         GetFramesUpTo(0);
+        if (m_frames.size() == 0)
+            return;
         if (!m_frames[0]->IsInlined())
         {
             m_current_inlined_depth = UINT32_MAX;
diff --git a/lldb/source/Target/ThreadList.cpp b/lldb/source/Target/ThreadList.cpp
index 3ccadfd81b8..a342b8ae5f9 100644
--- a/lldb/source/Target/ThreadList.cpp
+++ b/lldb/source/Target/ThreadList.cpp
@@ -773,7 +773,8 @@ ThreadList::Update (ThreadList &rhs)
             const uint32_t num_threads = m_threads.size();
             for (uint32_t idx = 0; idx < num_threads; ++idx)
             {
-                if (m_threads[idx]->GetID() == tid)
+                ThreadSP backing_thread = m_threads[idx]->GetBackingThread();
+                if (m_threads[idx]->GetID() == tid || (backing_thread && backing_thread->GetID() == tid))
                 {
                     thread_is_alive = true;
                     break;
diff --git a/lldb/source/Utility/ConvertEnum.cpp b/lldb/source/Utility/ConvertEnum.cpp
index 8c18d6d4af5..f7dab08498c 100644
--- a/lldb/source/Utility/ConvertEnum.cpp
+++ b/lldb/source/Utility/ConvertEnum.cpp
@@ -107,6 +107,8 @@ lldb_private::GetSectionTypeAsCString(lldb::SectionType sect_type)
             return "eh-frame";
         case eSectionTypeCompactUnwind:
             return "compact-unwind";
+        case eSectionTypeGoSymtab:
+            return "go-symtab";
         case eSectionTypeOther:
             return "regular";
     }