<rdar://problem/11757916>

Make breakpoint setting by file and line much more efficient by only looking for inlined breakpoint locations if we are setting a breakpoint in anything but a source implementation file. Implementing this complex for a many reasons. Turns out that parsing compile units lazily had some issues with respect to how we need to do things with DWARF in .o files. So the fixes in the checkin for this makes these changes:
- Add a new setting called "target.inline-breakpoint-strategy" which can be set to "never", "always", or "headers". "never" will never try and set any inlined breakpoints (fastest). "always" always looks for inlined breakpoint locations (slowest, but most accurate). "headers", which is the default setting, will only look for inlined breakpoint locations if the breakpoint is set in what are consudered to be header files, which is realy defined as "not in an implementation source file". 
- modify the breakpoint setting by file and line to check the current "target.inline-breakpoint-strategy" setting and act accordingly
- Modify compile units to be able to get their language and other info lazily. This allows us to create compile units from the debug map and not have to fill all of the details in, and then lazily discover this information as we go on debuggging. This is needed to avoid parsing all .o files when setting breakpoints in implementation only files (no inlines). Otherwise we would need to parse the .o file, the object file (mach-o in our case) and the symbol file (DWARF in the object file) just to see what the compile unit was.
- modify the "SymbolFileDWARFDebugMap" to subclass lldb_private::Module so that the virtual "GetObjectFile()" and "GetSymbolVendor()" functions can be intercepted when the .o file contenst are later lazilly needed. Prior to this fix, when we first instantiated the "SymbolFileDWARFDebugMap" class, we would also make modules, object files and symbol files for every .o file in the debug map because we needed to fix up the sections in the .o files with information that is in the executable debug map. Now we lazily do this in the DebugMapModule::GetObjectFile()

Cleaned up header includes a bit as well.

llvm-svn: 162860

34 files changed, 724 insertions, 445 deletions

diff --git a/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp b/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
index cb4f97f1de8..8c263d617ba 100644
--- a/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
+++ b/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
@@ -14,6 +14,7 @@
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/Module.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ExecutionContext.h"
diff --git a/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp b/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
index fb7272de966..5edd3684108 100644
--- a/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
+++ b/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
@@ -13,7 +13,9 @@
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
@@ -302,6 +304,31 @@ DynamicLoaderDarwinKernel::OSKextLoadedKextSummary::LoadImageUsingMemoryModule (
     return is_loaded;
 }
 
+uint32_t
+DynamicLoaderDarwinKernel::OSKextLoadedKextSummary::GetAddressByteSize ()
+{
+    if (module_sp)
+        return module_sp->GetArchitecture().GetAddressByteSize();
+    return 0;
+}
+
+lldb::ByteOrder
+DynamicLoaderDarwinKernel::OSKextLoadedKextSummary::GetByteOrder()
+{
+    if (module_sp)
+        return module_sp->GetArchitecture().GetByteOrder();
+    return lldb::endian::InlHostByteOrder();
+}
+
+lldb_private::ArchSpec
+DynamicLoaderDarwinKernel::OSKextLoadedKextSummary::GetArchitecture () const
+{
+    if (module_sp)
+        return module_sp->GetArchitecture();
+    return lldb_private::ArchSpec ();
+}
+
+
 //----------------------------------------------------------------------
 // Load the kernel module and initialize the "m_kernel" member. Return
 // true _only_ if the kernel is loaded the first time through (subsequent
@@ -826,3 +853,25 @@ DynamicLoaderDarwinKernel::GetPluginVersion()
     return 1;
 }
 
+lldb::ByteOrder
+DynamicLoaderDarwinKernel::GetByteOrderFromMagic (uint32_t magic)
+{
+    switch (magic)
+    {
+        case llvm::MachO::HeaderMagic32:
+        case llvm::MachO::HeaderMagic64:
+            return lldb::endian::InlHostByteOrder();
+            
+        case llvm::MachO::HeaderMagic32Swapped:
+        case llvm::MachO::HeaderMagic64Swapped:
+            if (lldb::endian::InlHostByteOrder() == lldb::eByteOrderBig)
+                return lldb::eByteOrderLittle;
+            else
+                return lldb::eByteOrderBig;
+            
+        default:
+            break;
+    }
+    return lldb::eByteOrderInvalid;
+}
+
diff --git a/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h b/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h
index 005f5ea3903..9a6f90f7984 100644
--- a/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h
+++ b/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h
@@ -119,26 +119,8 @@ protected:
     }
 
     static lldb::ByteOrder
-    GetByteOrderFromMagic (uint32_t magic)
-    {
-        switch (magic)
-        {
-            case llvm::MachO::HeaderMagic32:
-            case llvm::MachO::HeaderMagic64:
-                return lldb::endian::InlHostByteOrder();
-
-            case llvm::MachO::HeaderMagic32Swapped:
-            case llvm::MachO::HeaderMagic64Swapped:
-                if (lldb::endian::InlHostByteOrder() == lldb::eByteOrderBig)
-                    return lldb::eByteOrderLittle;
-                else
-                    return lldb::eByteOrderBig;
-
-            default:
-                break;
-        }
-        return lldb::eByteOrderInvalid;
-    }
+    GetByteOrderFromMagic (uint32_t magic);
+
     enum
     {
         KERNEL_MODULE_MAX_NAME = 64u,
@@ -229,28 +211,13 @@ protected:
         }
 
         uint32_t
-        GetAddressByteSize ()
-        {
-            if (module_sp)
-                return module_sp->GetArchitecture().GetAddressByteSize();
-            return 0;
-        }
+        GetAddressByteSize ();
 
         lldb::ByteOrder
-        GetByteOrder()
-        {
-            if (module_sp)
-                return module_sp->GetArchitecture().GetByteOrder();
-            return lldb::endian::InlHostByteOrder();
-        }
+        GetByteOrder();
 
         lldb_private::ArchSpec
-        GetArchitecture () const
-        {
-            if (module_sp)
-                return module_sp->GetArchitecture();
-            return lldb_private::ArchSpec ();
-        }
+        GetArchitecture () const;
 
         void
         PutToLog (lldb_private::Log *log) const;
diff --git a/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
index bc87588f0ea..5504c64b673 100644
--- a/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
+++ b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
@@ -15,8 +15,11 @@
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
+#include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/RegisterContext.h"
@@ -1771,3 +1774,50 @@ DynamicLoaderMacOSXDYLD::GetPluginVersion()
     return 1;
 }
 
+uint32_t
+DynamicLoaderMacOSXDYLD::AddrByteSize()
+{
+    switch (m_dyld.header.magic)
+    {
+        case llvm::MachO::HeaderMagic32:
+        case llvm::MachO::HeaderMagic32Swapped:
+            return 4;
+            
+        case llvm::MachO::HeaderMagic64:
+        case llvm::MachO::HeaderMagic64Swapped:
+            return 8;
+            
+        default:
+            break;
+    }
+    return 0;
+}
+
+lldb::ByteOrder
+DynamicLoaderMacOSXDYLD::GetByteOrderFromMagic (uint32_t magic)
+{
+    switch (magic)
+    {
+        case llvm::MachO::HeaderMagic32:
+        case llvm::MachO::HeaderMagic64:
+            return lldb::endian::InlHostByteOrder();
+            
+        case llvm::MachO::HeaderMagic32Swapped:
+        case llvm::MachO::HeaderMagic64Swapped:
+            if (lldb::endian::InlHostByteOrder() == lldb::eByteOrderBig)
+                return lldb::eByteOrderLittle;
+            else
+                return lldb::eByteOrderBig;
+            
+        default:
+            break;
+    }
+    return lldb::eByteOrderInvalid;
+}
+
+lldb::ByteOrder
+DynamicLoaderMacOSXDYLD::DYLDImageInfo::GetByteOrder()
+{
+    return DynamicLoaderMacOSXDYLD::GetByteOrderFromMagic(header.magic);
+}
+
diff --git a/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h
index 9e7ec751f1c..f7e9ac5665a 100644
--- a/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h
+++ b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h
@@ -118,45 +118,10 @@ protected:
                          lldb::user_id_t break_loc_id);
 
     uint32_t
-    AddrByteSize()
-    {
-        switch (m_dyld.header.magic)
-        {
-            case llvm::MachO::HeaderMagic32:
-            case llvm::MachO::HeaderMagic32Swapped:
-                return 4;
-
-            case llvm::MachO::HeaderMagic64:
-            case llvm::MachO::HeaderMagic64Swapped:
-                return 8;
-
-            default:
-                break;
-        }
-        return 0;
-    }
+    AddrByteSize();
 
     static lldb::ByteOrder
-    GetByteOrderFromMagic (uint32_t magic)
-    {
-        switch (magic)
-        {
-            case llvm::MachO::HeaderMagic32:
-            case llvm::MachO::HeaderMagic64:
-                return lldb::endian::InlHostByteOrder();
-
-            case llvm::MachO::HeaderMagic32Swapped:
-            case llvm::MachO::HeaderMagic64Swapped:
-                if (lldb::endian::InlHostByteOrder() == lldb::eByteOrderBig)
-                    return lldb::eByteOrderLittle;
-                else
-                    return lldb::eByteOrderBig;
-
-            default:
-                break;
-        }
-        return lldb::eByteOrderInvalid;
-    }
+    GetByteOrderFromMagic (uint32_t magic);
 
     bool
     ReadMachHeader (lldb::addr_t addr,
@@ -269,26 +234,7 @@ protected:
         }
 
         lldb::ByteOrder
-        GetByteOrder()
-        {
-            switch (header.magic)
-            {
-            case llvm::MachO::HeaderMagic32:        // MH_MAGIC
-            case llvm::MachO::HeaderMagic64:        // MH_MAGIC_64
-                return lldb::endian::InlHostByteOrder();
-
-            case llvm::MachO::HeaderMagic32Swapped: // MH_CIGAM
-            case llvm::MachO::HeaderMagic64Swapped: // MH_CIGAM_64
-                if (lldb::endian::InlHostByteOrder() == lldb::eByteOrderLittle)
-                    return lldb::eByteOrderBig;
-                else
-                    return lldb::eByteOrderLittle;
-            default:
-                assert (!"invalid header.magic value");
-                break;
-            }
-            return lldb::endian::InlHostByteOrder();
-        }
+        GetByteOrder();
 
         lldb_private::ArchSpec
         GetArchitecture () const
diff --git a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
index ee643327c5b..404f4b1927b 100644
--- a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
+++ b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
@@ -13,6 +13,7 @@
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
diff --git a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
index b863f11e097..251590fac16 100644
--- a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
+++ b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
@@ -12,6 +12,10 @@
 // Other libraries and framework includes
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
diff --git a/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp b/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp
index ef79001fe76..9b15ea8e49c 100644
--- a/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp
+++ b/lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp
@@ -9,6 +9,8 @@
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Target.h"
 
 #include "DynamicLoaderStatic.h"
diff --git a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp
index 1797ef20abc..aaa3cd34f77 100644
--- a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp
+++ b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp
@@ -19,6 +19,8 @@
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp
index f00d947e774..1e0bf4d881f 100644
--- a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp
+++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp
@@ -25,11 +25,13 @@
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Scalar.h"
+#include "lldb/Core/Section.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Expression/ClangFunction.h"
 #include "lldb/Expression/ClangUtilityFunction.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCSymbolVendor.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCSymbolVendor.cpp
index 00c90c6eacd..fba909b8701 100644
--- a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCSymbolVendor.cpp
+++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCSymbolVendor.cpp
@@ -10,6 +10,7 @@
 #include "AppleObjCSymbolVendor.h"
 
 #include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
index 4578801a0b3..d84bccd69b6 100644
--- a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
+++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
@@ -26,6 +26,7 @@
 #include "lldb/Expression/ClangUtilityFunction.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
diff --git a/lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp b/lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp
index 1d9158ac93c..db4e25146de 100644
--- a/lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp
+++ b/lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp
@@ -15,7 +15,6 @@
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/ObjectFile.h"
diff --git a/lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp b/lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp
index 45d3cdc55e0..a5babca7947 100644
--- a/lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp
+++ b/lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp
@@ -18,6 +18,8 @@
 // Project includes
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Debugger.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/Host.h"
 
diff --git a/lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp b/lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp
index c4dd4a8044f..74de15a7eb2 100644
--- a/lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp
+++ b/lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp
@@ -20,6 +20,7 @@
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
+#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/FileSpec.h"
diff --git a/lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp b/lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp
index 3bdff311379..dc5658ba703 100644
--- a/lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp
+++ b/lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp
@@ -16,7 +16,10 @@
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Error.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
diff --git a/lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp b/lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp
index 7b1a7274046..c22c1ab5969 100644
--- a/lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp
+++ b/lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp
@@ -18,6 +18,7 @@
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
+#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/FileSpec.h"
diff --git a/lldb/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp b/lldb/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp
index 5dfa11bffc1..6e63bd2b062 100644
--- a/lldb/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp
+++ b/lldb/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp
@@ -18,6 +18,7 @@
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
+#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/FileSpec.h"
diff --git a/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp b/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
index 3c08a147246..948ce9fec36 100644
--- a/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
+++ b/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
@@ -16,8 +16,10 @@
 #include "lldb/Core/ConnectionFileDescriptor.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Module.h"
 #include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
diff --git a/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp b/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
index a68f7d38def..4d634f421e7 100644
--- a/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
+++ b/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
@@ -10,6 +10,7 @@
 #include "InferiorCallPOSIX.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObject.h"
+#include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
diff --git a/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp b/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp
index cbc98d845b1..d811fee9366 100644
--- a/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp
+++ b/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp
@@ -13,13 +13,15 @@
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Value.h"
+#include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/Function.h"
+#include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Symbol.h"
-#include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
diff --git a/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp b/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp
index 90913b961d5..ffce985c26b 100644
--- a/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp
+++ b/lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp
@@ -12,6 +12,9 @@
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ArchSpec.h"
+#include "lldb/Symbol/Function.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index 7045f2ba050..26104e5f15a 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -31,6 +31,7 @@
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Core/InputReader.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
diff --git a/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp b/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp
index e9fe81e8b53..d82b6a72436 100644
--- a/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp
+++ b/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp
@@ -18,8 +18,12 @@
 // Other libraries and framework includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
@@ -452,3 +456,8 @@ ProcessMachCore::GetImageInfoAddress()
 }
 
 
+lldb_private::ObjectFile *
+ProcessMachCore::GetCoreObjectFile ()
+{
+    return m_core_module_sp->GetObjectFile();
+}
diff --git a/lldb/source/Plugins/Process/mach-core/ProcessMachCore.h b/lldb/source/Plugins/Process/mach-core/ProcessMachCore.h
index e20276f1da2..e5564a9dda3 100644
--- a/lldb/source/Plugins/Process/mach-core/ProcessMachCore.h
+++ b/lldb/source/Plugins/Process/mach-core/ProcessMachCore.h
@@ -121,10 +121,7 @@ protected:
                       lldb_private::ThreadList &new_thread_list);
     
     lldb_private::ObjectFile *
-    GetCoreObjectFile ()
-    {
-        return m_core_module_sp->GetObjectFile();
-    }
+    GetCoreObjectFile ();
 private:
     bool 
     GetDynamicLoaderAddress (lldb::addr_t addr);
diff --git a/lldb/source/Plugins/Process/mach-core/ThreadMachCore.cpp b/lldb/source/Plugins/Process/mach-core/ThreadMachCore.cpp
index c0eefe125b1..3568dc76b54 100644
--- a/lldb/source/Plugins/Process/mach-core/ThreadMachCore.cpp
+++ b/lldb/source/Plugins/Process/mach-core/ThreadMachCore.cpp
@@ -16,6 +16,7 @@
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/State.h"
+#include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
index bce6c2f8134..954f13b87d8 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
+++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
@@ -229,7 +229,7 @@ SymbolFileDWARF::CreateInstance (ObjectFile* obj_file)
 TypeList *          
 SymbolFileDWARF::GetTypeList ()
 {
-    if (m_debug_map_symfile)
+    if (GetDebugMapSymfile ())
         return m_debug_map_symfile->GetTypeList();
     return m_obj_file->GetModule()->GetTypeList();
 
@@ -263,6 +263,7 @@ GetParentSymbolContextDIE(const DWARFDebugInfoEntry *child_die)
 SymbolFileDWARF::SymbolFileDWARF(ObjectFile* objfile) :
     SymbolFile (objfile),
     UserID (0),  // Used by SymbolFileDWARFDebugMap to when this class parses .o files to contain the .o file index/ID
+    m_debug_map_module_wp (),
     m_debug_map_symfile (NULL),
     m_clang_tu_decl (NULL),
     m_flags(),
@@ -321,7 +322,7 @@ GetDWARFMachOSegmentName ()
 UniqueDWARFASTTypeMap &
 SymbolFileDWARF::GetUniqueDWARFASTTypeMap ()
 {
-    if (m_debug_map_symfile)
+    if (GetDebugMapSymfile ())
         return m_debug_map_symfile->GetUniqueDWARFASTTypeMap ();
     return m_unique_ast_type_map;
 }
@@ -329,7 +330,7 @@ SymbolFileDWARF::GetUniqueDWARFASTTypeMap ()
 ClangASTContext &       
 SymbolFileDWARF::GetClangASTContext ()
 {
-    if (m_debug_map_symfile)
+    if (GetDebugMapSymfile ())
         return m_debug_map_symfile->GetClangASTContext ();
 
     ClangASTContext &ast = m_obj_file->GetModule()->GetClangASTContext();
@@ -659,11 +660,27 @@ SymbolFileDWARF::DebugInfo() const
 }
 
 DWARFCompileUnit*
-SymbolFileDWARF::GetDWARFCompileUnitForUID(lldb::user_id_t cu_uid)
+SymbolFileDWARF::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit)
 {
     DWARFDebugInfo* info = DebugInfo();
-    if (info && UserIDMatches(cu_uid))
-        return info->GetCompileUnit((dw_offset_t)cu_uid).get();
+    if (info)
+    {
+        if (GetDebugMapSymfile ())
+        {
+            // The debug map symbol file made the compile units for this DWARF
+            // file which is .o file with DWARF in it, and we should have
+            // only 1 compile unit which is at offset zero in the DWARF.
+            // TODO: modify to support LTO .o files where each .o file might
+            // have multiple DW_TAG_compile_unit tags.
+            return info->GetCompileUnit(0).get();
+        }
+        else
+        {
+            // Just a normal DWARF file whose user ID for the compile unit is
+            // the DWARF offset itself
+            return info->GetCompileUnit((dw_offset_t)comp_unit->GetID()).get();
+        }
+    }
     return NULL;
 }
 
@@ -704,59 +721,58 @@ SymbolFileDWARF::ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx)
         }
         else
         {
-            ModuleSP module_sp (m_obj_file->GetModule());
-            if (module_sp)
+            if (GetDebugMapSymfile ())
+            {
+                // Let the debug map create the compile unit
+                cu_sp = m_debug_map_symfile->GetCompileUnit(this);
+                dwarf_cu->SetUserData(cu_sp.get());
+            }
+            else
             {
-                const DWARFDebugInfoEntry * cu_die = dwarf_cu->GetCompileUnitDIEOnly ();
-                if (cu_die)
+                ModuleSP module_sp (m_obj_file->GetModule());
+                if (module_sp)
                 {
-                    const char * cu_die_name = cu_die->GetName(this, dwarf_cu);
-                    const char * cu_comp_dir = cu_die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_comp_dir, NULL);
-                    LanguageType cu_language = (LanguageType)cu_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_language, 0);
-                    if (cu_die_name)
+                    const DWARFDebugInfoEntry * cu_die = dwarf_cu->GetCompileUnitDIEOnly ();
+                    if (cu_die)
                     {
-                        std::string ramapped_file;
-                        FileSpec cu_file_spec;
-
-                        if (cu_die_name[0] == '/' || cu_comp_dir == NULL || cu_comp_dir[0] == '\0')
-                        {
-                            // If we have a full path to the compile unit, we don't need to resolve
-                            // the file.  This can be expensive e.g. when the source files are NFS mounted.
-                            if (module_sp->RemapSourceFile(cu_die_name, ramapped_file))
-                                cu_file_spec.SetFile (ramapped_file.c_str(), false);
-                            else
-                                cu_file_spec.SetFile (cu_die_name, false);
-                        }
-                        else
+                        const char * cu_die_name = cu_die->GetName(this, dwarf_cu);
+                        const char * cu_comp_dir = cu_die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_comp_dir, NULL);
+                        LanguageType cu_language = (LanguageType)cu_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_language, 0);
+                        if (cu_die_name)
                         {
-                            std::string fullpath(cu_comp_dir);
-                            if (*fullpath.rbegin() != '/')
-                                fullpath += '/';
-                            fullpath += cu_die_name;
-                            if (module_sp->RemapSourceFile (fullpath.c_str(), ramapped_file))
-                                cu_file_spec.SetFile (ramapped_file.c_str(), false);
-                            else
-                                cu_file_spec.SetFile (fullpath.c_str(), false);
-                        }
+                            std::string ramapped_file;
+                            FileSpec cu_file_spec;
 
-                        cu_sp.reset(new CompileUnit (module_sp,
-                                                     dwarf_cu,
-                                                     cu_file_spec, 
-                                                     MakeUserID(dwarf_cu->GetOffset()),
-                                                     cu_language));
-                        if (cu_sp)
-                        {
-                            dwarf_cu->SetUserData(cu_sp.get());
-                            
-                            if (m_debug_map_symfile)
+                            if (cu_die_name[0] == '/' || cu_comp_dir == NULL || cu_comp_dir[0] == '\0')
                             {
-                                // Let the symbol file register the compile unit with
-                                // the symbol vendor using its compile unit index
-                                // when we are doing DWARF in .o files + debug map
-                                m_debug_map_symfile->SetCompileUnit(this, cu_sp);
+                                // If we have a full path to the compile unit, we don't need to resolve
+                                // the file.  This can be expensive e.g. when the source files are NFS mounted.
+                                if (module_sp->RemapSourceFile(cu_die_name, ramapped_file))
+                                    cu_file_spec.SetFile (ramapped_file.c_str(), false);
+                                else
+                                    cu_file_spec.SetFile (cu_die_name, false);
                             }
                             else
                             {
+                                std::string fullpath(cu_comp_dir);
+                                if (*fullpath.rbegin() != '/')
+                                    fullpath += '/';
+                                fullpath += cu_die_name;
+                                if (module_sp->RemapSourceFile (fullpath.c_str(), ramapped_file))
+                                    cu_file_spec.SetFile (ramapped_file.c_str(), false);
+                                else
+                                    cu_file_spec.SetFile (fullpath.c_str(), false);
+                            }
+
+                            cu_sp.reset(new CompileUnit (module_sp,
+                                                         dwarf_cu,
+                                                         cu_file_spec, 
+                                                         MakeUserID(dwarf_cu->GetOffset()),
+                                                         cu_language));
+                            if (cu_sp)
+                            {
+                                dwarf_cu->SetUserData(cu_sp.get());
+                                
                                 // Figure out the compile unit index if we weren't given one
                                 if (cu_idx == UINT32_MAX)
                                     DebugInfo()->GetCompileUnit(dwarf_cu->GetOffset(), &cu_idx);
@@ -897,18 +913,33 @@ SymbolFileDWARF::ParseCompileUnitFunction (const SymbolContext& sc, DWARFCompile
     return NULL;
 }
 
+lldb::LanguageType
+SymbolFileDWARF::ParseCompileUnitLanguage (const SymbolContext& sc)
+{
+    assert (sc.comp_unit);
+    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+    if (dwarf_cu)
+    {
+        const DWARFDebugInfoEntry *die = dwarf_cu->GetCompileUnitDIEOnly();
+        const uint32_t language = die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_language, 0);
+        if (language)
+            return (lldb::LanguageType)language;
+    }
+    return eLanguageTypeUnknown;
+}
+
 size_t
 SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc)
 {
     assert (sc.comp_unit);
     size_t functions_added = 0;
-    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnitForUID(sc.comp_unit->GetID());
+    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
     if (dwarf_cu)
     {
         DWARFDIECollection function_dies;
-        const size_t num_funtions = dwarf_cu->AppendDIEsWithTag (DW_TAG_subprogram, function_dies);
+        const size_t num_functions = dwarf_cu->AppendDIEsWithTag (DW_TAG_subprogram, function_dies);
         size_t func_idx;
-        for (func_idx = 0; func_idx < num_funtions; ++func_idx)
+        for (func_idx = 0; func_idx < num_functions; ++func_idx)
         {
             const DWARFDebugInfoEntry *die = function_dies.GetDIEPtrAtIndex(func_idx);
             if (sc.comp_unit->FindFunctionByUID (MakeUserID(die->GetOffset())).get() == NULL)
@@ -926,7 +957,7 @@ bool
 SymbolFileDWARF::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files)
 {
     assert (sc.comp_unit);
-    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnitForUID(sc.comp_unit->GetID());
+    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
     assert (dwarf_cu);
     const DWARFDebugInfoEntry * cu_die = dwarf_cu->GetCompileUnitDIEOnly();
 
@@ -1129,7 +1160,7 @@ SymbolFileDWARF::ParseCompileUnitLineTable (const SymbolContext &sc)
     if (sc.comp_unit->GetLineTable() != NULL)
         return true;
 
-    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnitForUID(sc.comp_unit->GetID());
+    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
     if (dwarf_cu)
     {
         const DWARFDebugInfoEntry *dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();
@@ -1146,7 +1177,7 @@ SymbolFileDWARF::ParseCompileUnitLineTable (const SymbolContext &sc)
                         m_obj_file->GetSectionList(), 
                         0, 
                         0, 
-                        m_debug_map_symfile != NULL, 
+                        GetDebugMapSymfile () != NULL,
                         false, 
                         DWARFDebugLine::Row(), 
                         SectionSP(), 
@@ -2462,7 +2493,8 @@ SymbolFileDWARF::ResolveSymbolContext(const FileSpec& file_spec, uint32_t line,
             for (cu_idx = 0; (dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx)) != NULL; ++cu_idx)
             {
                 CompileUnit *dc_cu = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
-                bool file_spec_matches_cu_file_spec = dc_cu != NULL && FileSpec::Compare(file_spec, *dc_cu, false) == 0;
+                const bool full_match = file_spec.GetDirectory();
+                bool file_spec_matches_cu_file_spec = dc_cu != NULL && FileSpec::Equal(file_spec, *dc_cu, full_match);
                 if (check_inlines || file_spec_matches_cu_file_spec)
                 {
                     SymbolContext sc (m_obj_file->GetModule());
@@ -4339,7 +4371,7 @@ SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type (DWARFCompileUnit *cu)
                 }
             }
         }
-        if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo && m_debug_map_symfile)
+        if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo && GetDebugMapSymfile ())
             return m_debug_map_symfile->Supports_DW_AT_APPLE_objc_complete_type (this);
     }
     return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
@@ -5399,7 +5431,7 @@ SymbolFileDWARF::ParseType (const SymbolContext& sc, DWARFCompileUnit* dwarf_cu,
                             // know it is false), so the real definition is in here somewhere
                             type_sp = FindCompleteObjCDefinitionTypeForDIE (die, type_name_const_str, true);
 
-                            if (!type_sp && m_debug_map_symfile)
+                            if (!type_sp && GetDebugMapSymfile ())
                             {
                                 // We weren't able to find a full declaration in
                                 // this DWARF, see if we have a declaration anywhere    
@@ -5453,7 +5485,7 @@ SymbolFileDWARF::ParseType (const SymbolContext& sc, DWARFCompileUnit* dwarf_cu,
                         //type_sp = FindDefinitionTypeForDIE (dwarf_cu, die, type_name_const_str);
                         type_sp = FindDefinitionTypeForDWARFDeclContext (die_decl_ctx);
 
-                        if (!type_sp && m_debug_map_symfile)
+                        if (!type_sp && GetDebugMapSymfile ())
                         {
                             // We weren't able to find a full declaration in
                             // this DWARF, see if we have a declaration anywhere    
@@ -6333,7 +6365,7 @@ SymbolFileDWARF::ParseFunctionBlocks (const SymbolContext &sc)
 {
     assert(sc.comp_unit && sc.function);
     size_t functions_added = 0;
-    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnitForUID(sc.comp_unit->GetID());
+    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
     if (dwarf_cu)
     {
         dw_offset_t function_die_offset = sc.function->GetID();
@@ -6354,7 +6386,7 @@ SymbolFileDWARF::ParseTypes (const SymbolContext &sc)
     // At least a compile unit must be valid
     assert(sc.comp_unit);
     size_t types_added = 0;
-    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnitForUID(sc.comp_unit->GetID());
+    DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
     if (dwarf_cu)
     {
         if (sc.function)
@@ -6619,7 +6651,7 @@ SymbolFileDWARF::ParseVariableDIE
                         {
                             scope = eValueTypeVariableGlobal;
 
-                            if (m_debug_map_symfile)
+                            if (GetDebugMapSymfile ())
                             {
                                 // When leaving the DWARF in the .o files on darwin,
                                 // when we have a global variable that wasn't initialized,
@@ -7153,4 +7185,20 @@ SymbolFileDWARF::LayoutRecordType (const clang::RecordDecl *record_decl,
 }
 
 
+SymbolFileDWARFDebugMap *
+SymbolFileDWARF::GetDebugMapSymfile ()
+{
+    if (m_debug_map_symfile == NULL && !m_debug_map_module_wp.expired())
+    {
+        lldb::ModuleSP module_sp (m_debug_map_module_wp.lock());
+        if (module_sp)
+        {
+            SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
+            if (sym_vendor)
+                m_debug_map_symfile = (SymbolFileDWARFDebugMap *)sym_vendor->GetSymbolFile();
+        }
+    }
+    return m_debug_map_symfile;
+}
+
 
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
index f8f0846c2f0..64f7fc4e38d 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
+++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
@@ -43,6 +43,7 @@
 //----------------------------------------------------------------------
 // Forward Declarations for this DWARF plugin
 //----------------------------------------------------------------------
+class DebugMapModule;
 class DWARFAbbreviationDeclaration;
 class DWARFAbbreviationDeclarationSet;
 class DWARFileUnit;
@@ -62,7 +63,7 @@ class SymbolFileDWARF : public lldb_private::SymbolFile, public lldb_private::Us
 {
 public:
     friend class SymbolFileDWARFDebugMap;    
-
+    friend class DebugMapModule;
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
@@ -95,6 +96,7 @@ public:
     virtual uint32_t        GetNumCompileUnits();
     virtual lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index);
 
+    virtual lldb::LanguageType ParseCompileUnitLanguage (const lldb_private::SymbolContext& sc);
     virtual size_t          ParseCompileUnitFunctions (const lldb_private::SymbolContext& sc);
     virtual bool            ParseCompileUnitLineTable (const lldb_private::SymbolContext& sc);
     virtual bool            ParseCompileUnitSupportFiles (const lldb_private::SymbolContext& sc, lldb_private::FileSpecList& support_files);
@@ -301,7 +303,7 @@ protected:
 
     DISALLOW_COPY_AND_ASSIGN (SymbolFileDWARF);
     lldb::CompUnitSP        ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx);
-    DWARFCompileUnit*       GetDWARFCompileUnitForUID(lldb::user_id_t cu_uid);
+    DWARFCompileUnit*       GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit);
     DWARFCompileUnit*       GetNextUnparsedDWARFCompileUnit(DWARFCompileUnit* prev_cu);
     lldb_private::CompileUnit*      GetCompUnitForDWARFCompUnit(DWARFCompileUnit* dwarf_cu, uint32_t cu_idx = UINT32_MAX);
     bool                    GetFunction (DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry* func_die, lldb_private::SymbolContext& sc);
@@ -440,10 +442,13 @@ protected:
     
     void                    DumpIndexes();
 
-    void                    SetDebugMapSymfile (SymbolFileDWARFDebugMap *debug_map_symfile)
+    void                    SetDebugMapModule (const lldb::ModuleSP &module_sp)
                             {
-                                m_debug_map_symfile = debug_map_symfile;
+                                m_debug_map_module_wp = module_sp;
                             }
+    
+    SymbolFileDWARFDebugMap *
+                            GetDebugMapSymfile ();
 
     const DWARFDebugInfoEntry *
                             FindBlockContainingSpecification (dw_offset_t func_die_offset, 
@@ -532,6 +537,7 @@ protected:
                                 DWARFCompileUnit* dst_cu,
                                 const DWARFDebugInfoEntry *dst_class_die);
 
+    lldb::ModuleWP                  m_debug_map_module_wp;
     SymbolFileDWARFDebugMap *       m_debug_map_symfile;
     clang::TranslationUnitDecl *    m_clang_tu_decl;
     lldb_private::Flags             m_flags;
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
index 0ed6843823b..4e1b41c74aa 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
+++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
@@ -13,10 +13,14 @@
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegularExpression.h"
+#include "lldb/Core/Section.h"
+#if defined(DEBUG_OSO_DMAP)
 #include "lldb/Core/StreamFile.h"
+#endif
 #include "lldb/Core/Timer.h"
 
 #include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
+#include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/VariableList.h"
@@ -27,6 +31,248 @@
 using namespace lldb;
 using namespace lldb_private;
 
+// Subclass lldb_private::Module so we can intercept the "Module::GetObjectFile()" 
+// (so we can fixup the object file sections) and also for "Module::GetSymbolVendor()"
+// (so we can fixup the symbol file id.
+
+class DebugMapModule : public Module
+{
+public:
+    DebugMapModule (const ModuleSP &exe_module_sp,
+                    uint32_t cu_idx,
+                    const FileSpec& file_spec,
+                    const ArchSpec& arch,
+                    const ConstString *object_name,
+                    off_t object_offset) :
+        Module (file_spec, arch, object_name, object_offset),
+        m_exe_module_wp (exe_module_sp),
+        m_cu_idx (cu_idx)
+    {
+    }
+
+    virtual ObjectFile *
+    GetObjectFile ()
+    {
+        Mutex::Locker locker (m_mutex);
+        if (m_did_load_objfile == false)
+        {
+            ModuleSP exe_module_sp (m_exe_module_wp.lock());
+            if (exe_module_sp)
+            {
+                ObjectFile *exe_objfile = exe_module_sp->GetObjectFile();
+                ObjectFile *oso_objfile = Module::GetObjectFile();
+                SymbolVendor *exe_sym_vendor = exe_module_sp->GetSymbolVendor();
+
+                if (exe_objfile && oso_objfile && exe_sym_vendor)
+                {
+                    SymbolFileDWARFDebugMap *exe_symfile = (SymbolFileDWARFDebugMap *)exe_sym_vendor->GetSymbolFile();
+                    if (exe_symfile)
+                    {
+                        SymbolFileDWARFDebugMap::CompileUnitInfo *comp_unit_info = exe_symfile->GetCompUnitInfo (this);
+                        if (comp_unit_info)
+                        {
+                            // Set the ID of the symbol file DWARF to the index of the OSO
+                            // shifted left by 32 bits to provide a unique prefix for any
+                            // UserID's that get created in the symbol file.
+                            //comp_unit_info->exe_sections_sp.reset(new SectionList);
+                            
+                            Symtab *exe_symtab = exe_objfile->GetSymtab();
+                            ModuleSP oso_module_sp (oso_objfile->GetModule());
+                            Symtab *oso_symtab = oso_objfile->GetSymtab();
+                            //#define DEBUG_OSO_DMAP    // Do not check in with this defined...
+#if defined(DEBUG_OSO_DMAP)
+                            StreamFile s(stdout);
+                            s << "OSO symtab:\n";
+                            oso_symtab->Dump(&s, NULL);
+                            s << "OSO sections before:\n";
+                            oso_objfile->GetSectionList()->Dump(&s, NULL, true);
+#endif
+                    
+                            ///const uint32_t fun_resolve_flags = SymbolContext::Module | eSymbolContextCompUnit | eSymbolContextFunction;
+                            //SectionList *oso_sections = oso_objfile->Sections();
+                            // Now we need to make sections that map from zero based object
+                            // file addresses to where things eneded up in the main executable.
+
+                            assert (comp_unit_info->first_symbol_index != UINT32_MAX);
+                            // End index is one past the last valid symbol index
+                            const uint32_t oso_end_idx = comp_unit_info->last_symbol_index + 1;
+                            uint32_t sect_id = 0x10000;
+                            for (uint32_t idx = comp_unit_info->first_symbol_index + 2; // Skip the N_SO and N_OSO
+                                 idx < oso_end_idx;
+                                 ++idx)
+                            {
+                                Symbol *exe_symbol = exe_symtab->SymbolAtIndex(idx);
+                                if (exe_symbol)
+                                {
+                                    if (exe_symbol->IsDebug() == false)
+                                        continue;
+                                    
+                                    switch (exe_symbol->GetType())
+                                    {
+                                        default:
+                                            break;
+                                            
+                                        case eSymbolTypeCode:
+                                        {
+                                            // For each N_FUN, or function that we run into in the debug map
+                                            // we make a new section that we add to the sections found in the
+                                            // .o file. This new section has the file address set to what the
+                                            // addresses are in the .o file, and the load address is adjusted
+                                            // to match where it ended up in the final executable! We do this
+                                            // before we parse any dwarf info so that when it goes get parsed
+                                            // all section/offset addresses that get registered will resolve
+                                            // correctly to the new addresses in the main executable.
+                                            
+                                            // First we find the original symbol in the .o file's symbol table
+                                            Symbol *oso_fun_symbol = oso_symtab->FindFirstSymbolWithNameAndType(exe_symbol->GetMangled().GetName(Mangled::ePreferMangled), eSymbolTypeCode, Symtab::eDebugNo, Symtab::eVisibilityAny);
+                                            if (oso_fun_symbol)
+                                            {
+                                                // If we found the symbol, then we
+                                                SectionSP exe_fun_section (exe_symbol->GetAddress().GetSection());
+                                                SectionSP oso_fun_section (oso_fun_symbol->GetAddress().GetSection());
+                                                if (oso_fun_section)
+                                                {
+                                                    // Now we create a section that we will add as a child of the
+                                                    // section in which the .o symbol (the N_FUN) exists.
+                                                    
+                                                    // We use the exe_symbol size because the one in the .o file
+                                                    // will just be a symbol with no size, and the exe_symbol
+                                                    // size will reflect any size changes (ppc has been known to
+                                                    // shrink function sizes when it gets rid of jump islands that
+                                                    // aren't needed anymore).
+                                                    SectionSP oso_fun_section_sp (new Section (oso_fun_symbol->GetAddress().GetSection(),
+                                                                                               oso_module_sp,                         // Module (the .o file)
+                                                                                               sect_id++,                          // Section ID starts at 0x10000 and increments so the section IDs don't overlap with the standard mach IDs
+                                                                                               exe_symbol->GetMangled().GetName(Mangled::ePreferMangled), // Name the section the same as the symbol for which is was generated!
+                                                                                               eSectionTypeDebug,
+                                                                                               oso_fun_symbol->GetAddress().GetOffset(),  // File VM address offset in the current section
+                                                                                               exe_symbol->GetByteSize(),          // File size (we need the size from the executable)
+                                                                                               0, 0, 0));
+                                                    
+                                                    oso_fun_section_sp->SetLinkedLocation (exe_fun_section,
+                                                                                           exe_symbol->GetAddress().GetFileAddress() - exe_fun_section->GetFileAddress());
+                                                    oso_fun_section->GetChildren().AddSection(oso_fun_section_sp);
+                                                }
+                                            }
+                                        }
+                                            break;
+                                            
+                                        case eSymbolTypeData:
+                                        {
+                                            // For each N_GSYM we remap the address for the global by making
+                                            // a new section that we add to the sections found in the .o file.
+                                            // This new section has the file address set to what the
+                                            // addresses are in the .o file, and the load address is adjusted
+                                            // to match where it ended up in the final executable! We do this
+                                            // before we parse any dwarf info so that when it goes get parsed
+                                            // all section/offset addresses that get registered will resolve
+                                            // correctly to the new addresses in the main executable. We
+                                            // initially set the section size to be 1 byte, but will need to
+                                            // fix up these addresses further after all globals have been
+                                            // parsed to span the gaps, or we can find the global variable
+                                            // sizes from the DWARF info as we are parsing.
+                                            
+                                            // Next we find the non-stab entry that corresponds to the N_GSYM in the .o file
+                                            Symbol *oso_gsym_symbol = oso_symtab->FindFirstSymbolWithNameAndType (exe_symbol->GetMangled().GetName(),
+                                                                                                                  eSymbolTypeData,
+                                                                                                                  Symtab::eDebugNo,
+                                                                                                                  Symtab::eVisibilityAny);
+                                            
+                                            if (exe_symbol && oso_gsym_symbol && exe_symbol->ValueIsAddress() && oso_gsym_symbol->ValueIsAddress())
+                                            {
+                                                // If we found the symbol, then we
+                                                SectionSP exe_gsym_section (exe_symbol->GetAddress().GetSection());
+                                                SectionSP oso_gsym_section (oso_gsym_symbol->GetAddress().GetSection());
+                                                if (oso_gsym_section)
+                                                {
+                                                    SectionSP oso_gsym_section_sp (new Section (oso_gsym_symbol->GetAddress().GetSection(),
+                                                                                                oso_module_sp,                         // Module (the .o file)
+                                                                                                sect_id++,                          // Section ID starts at 0x10000 and increments so the section IDs don't overlap with the standard mach IDs
+                                                                                                exe_symbol->GetMangled().GetName(Mangled::ePreferMangled), // Name the section the same as the symbol for which is was generated!
+                                                                                                eSectionTypeDebug,
+                                                                                                oso_gsym_symbol->GetAddress().GetOffset(),  // File VM address offset in the current section
+                                                                                                1,                                   // We don't know the size of the global, just do the main address for now.
+                                                                                                0, 0, 0));
+                                                    
+                                                    oso_gsym_section_sp->SetLinkedLocation (exe_gsym_section,
+                                                                                            exe_symbol->GetAddress().GetFileAddress() - exe_gsym_section->GetFileAddress());
+                                                    oso_gsym_section->GetChildren().AddSection(oso_gsym_section_sp);
+                                                }
+                                            }
+                                        }
+                                            break;
+                                    }
+                                }
+                            }
+                            oso_objfile->GetSectionList()->Finalize(); // Now that we're done adding sections, finalize to build fast-lookup caches
+#if defined(DEBUG_OSO_DMAP)
+                            s << "OSO sections after:\n";
+                            oso_objfile->GetSectionList()->Dump(&s, NULL, true);
+#endif
+                        }
+                    }
+                }
+            }
+        }
+        return m_objfile_sp.get();
+    }
+    
+    virtual SymbolVendor*
+    GetSymbolVendor(bool can_create = true)
+    {
+        // Scope for locker
+        if (m_symfile_ap.get() || can_create == false)
+            return m_symfile_ap.get();
+
+        ModuleSP exe_module_sp (m_exe_module_wp.lock());
+        if (exe_module_sp)
+        {
+            // Now get the object file outside of a locking scope
+            ObjectFile *oso_objfile = GetObjectFile ();
+            if (oso_objfile)
+            {
+                Mutex::Locker locker (m_mutex);
+                SymbolVendor* symbol_vendor = Module::GetSymbolVendor(can_create);
+                if (symbol_vendor)
+                {
+                    // Set a a pointer to this class to set our OSO DWARF file know
+                    // that the DWARF is being used along with a debug map and that
+                    // it will have the remapped sections that we do below.
+                    SymbolFileDWARF *oso_symfile = (SymbolFileDWARF *)symbol_vendor->GetSymbolFile();
+                    
+                    if (!oso_symfile)
+                        return NULL;
+
+                    ObjectFile *exe_objfile = exe_module_sp->GetObjectFile();
+                    SymbolVendor *exe_sym_vendor = exe_module_sp->GetSymbolVendor();
+                    
+                    if (exe_objfile && exe_sym_vendor)
+                    {
+                        if (oso_symfile->GetNumCompileUnits() == 1)
+                        {
+                            oso_symfile->SetDebugMapModule(exe_module_sp);
+                            // Set the ID of the symbol file DWARF to the index of the OSO
+                            // shifted left by 32 bits to provide a unique prefix for any
+                            // UserID's that get created in the symbol file.
+                            oso_symfile->SetID (((uint64_t)m_cu_idx + 1ull) << 32ull);
+                        }
+                        else
+                        {
+                            oso_symfile->SetID (UINT64_MAX);
+                        }
+                    }
+                    return symbol_vendor;
+                }
+            }
+        }
+        return NULL;
+    }
+
+protected:
+    ModuleWP m_exe_module_wp;
+    const uint32_t m_cu_idx;
+};
+
 void
 SymbolFileDWARFDebugMap::Initialize()
 {
@@ -93,7 +339,7 @@ SymbolFileDWARFDebugMap::InitializeObject()
 
 
 void
-SymbolFileDWARFDebugMap::InitOSO ()
+SymbolFileDWARFDebugMap::InitOSO()
 {
     if (m_flags.test(kHaveInitializedOSOs))
         return;
@@ -110,9 +356,10 @@ SymbolFileDWARFDebugMap::InitOSO ()
         LogSP log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP));
 
         std::vector<uint32_t> oso_indexes;
+#if defined(DEBUG_OSO_DMAP)
 //      StreamFile s(stdout);
 //      symtab->Dump(&s, NULL, eSortOrderNone);
-
+#endif
         // When a mach-o symbol is encoded, the n_type field is encoded in bits
         // 23:16, and the n_desc field is encoded in bits 15:0.
         // 
@@ -138,24 +385,30 @@ SymbolFileDWARFDebugMap::InitOSO ()
 
             for (uint32_t i=0; i<oso_index_count; ++i)
             {
-                m_compile_unit_infos[i].so_symbol = symtab->SymbolAtIndex(oso_indexes[i] - 1);
-                if (m_compile_unit_infos[i].so_symbol->GetSiblingIndex() == 0)
-                    m_compile_unit_infos[i].so_symbol = symtab->SymbolAtIndex(oso_indexes[i] - 2);
-                m_compile_unit_infos[i].oso_symbol = symtab->SymbolAtIndex(oso_indexes[i]);
-                uint32_t sibling_idx = m_compile_unit_infos[i].so_symbol->GetSiblingIndex();
+                const Symbol *so_symbol = symtab->SymbolAtIndex(oso_indexes[i] - 1);
+                const Symbol *oso_symbol = symtab->SymbolAtIndex(oso_indexes[i]);
+                assert (so_symbol);
+                assert (oso_symbol);
+                assert (so_symbol->GetType() == eSymbolTypeSourceFile);
+                assert (oso_symbol->GetType() == eSymbolTypeObjectFile);
+                m_compile_unit_infos[i].so_file.SetFile(so_symbol->GetName().AsCString(), true);
+                m_compile_unit_infos[i].oso_file.SetFile(oso_symbol->GetName().AsCString(), true);
+                uint32_t sibling_idx = so_symbol->GetSiblingIndex();
                 // The sibling index can't be less that or equal to the current index "i"
                 if (sibling_idx <= i)
                 {
-                    m_obj_file->GetModule()->ReportError ("N_SO in symbol with UID %u has invalid sibling in debug map, please file a bug and attach the binary listed in this error", m_compile_unit_infos[i].so_symbol->GetID());
+                    m_obj_file->GetModule()->ReportError ("N_SO in symbol with UID %u has invalid sibling in debug map, please file a bug and attach the binary listed in this error", so_symbol->GetID());
                 }
                 else
                 {
-                    m_compile_unit_infos[i].last_symbol = symtab->SymbolAtIndex (sibling_idx - 1);
-                    m_compile_unit_infos[i].first_symbol_index = symtab->GetIndexForSymbol(m_compile_unit_infos[i].so_symbol);
-                    m_compile_unit_infos[i].last_symbol_index = symtab->GetIndexForSymbol(m_compile_unit_infos[i].last_symbol);
+                    const Symbol* last_symbol = symtab->SymbolAtIndex (sibling_idx - 1);
+                    m_compile_unit_infos[i].first_symbol_index = symtab->GetIndexForSymbol(so_symbol);
+                    m_compile_unit_infos[i].last_symbol_index = symtab->GetIndexForSymbol(last_symbol);
+                    m_compile_unit_infos[i].first_symbol_id = so_symbol->GetID();
+                    m_compile_unit_infos[i].last_symbol_id = last_symbol->GetID();
                     
                     if (log)
-                        log->Printf("Initialized OSO 0x%8.8x: file=%s", i, m_compile_unit_infos[i].oso_symbol->GetName().GetCString());
+                        log->Printf("Initialized OSO 0x%8.8x: file=%s", i, oso_symbol->GetName().GetCString());
                 }
             }
         }
@@ -176,19 +429,33 @@ SymbolFileDWARFDebugMap::GetModuleByCompUnitInfo (CompileUnitInfo *comp_unit_inf
 {
     if (comp_unit_info->oso_module_sp.get() == NULL && comp_unit_info->symbol_file_supported)
     {
-        Symbol *oso_symbol = comp_unit_info->oso_symbol;
-        if (oso_symbol)
+        if (!comp_unit_info->oso_file.Exists())
         {
-            FileSpec oso_file_spec(oso_symbol->GetMangled().GetName().AsCString(), true);
-            // Always create a new module for .o files. Why? Because we
-            // use the debug map, to add new sections to each .o file and
-            // even though a .o file might not have changed, the sections
-            // that get added to the .o file can change.
-            comp_unit_info->oso_module_sp.reset (new Module (oso_file_spec, 
-                                                             m_obj_file->GetModule()->GetArchitecture(),
-                                                             NULL, 
-                                                             0));
+            char path[PATH_MAX*2];
+            comp_unit_info->oso_file.GetPath(path, sizeof(path));
+            if (ObjectFile::SplitArchivePathWithObject (path,
+                                                        comp_unit_info->oso_file,
+                                                        comp_unit_info->oso_object))
+            {
+                comp_unit_info->oso_file.GetPath(path, sizeof(path));
+                //printf ("resolved archive '%s' and object '%s'\n", path, comp_unit_info->oso_object.GetCString());
+            }
+            else
+            {
+                comp_unit_info->symbol_file_supported = false;
+                return false;
+            }
         }
+        // Always create a new module for .o files. Why? Because we
+        // use the debug map, to add new sections to each .o file and
+        // even though a .o file might not have changed, the sections
+        // that get added to the .o file can change.
+        comp_unit_info->oso_module_sp.reset (new DebugMapModule (GetObjectFile()->GetModule(),
+                                                                 GetCompUnitInfoIndex(comp_unit_info),
+                                                                 comp_unit_info->oso_file,
+                                                                 m_obj_file->GetModule()->GetArchitecture(),
+                                                                 comp_unit_info->oso_object ? &comp_unit_info->oso_object : NULL,
+                                                                 0));
     }
     return comp_unit_info->oso_module_sp.get();
 }
@@ -199,19 +466,11 @@ SymbolFileDWARFDebugMap::GetFileSpecForSO (uint32_t oso_idx, FileSpec &file_spec
 {
     if (oso_idx < m_compile_unit_infos.size())
     {
-        if (!m_compile_unit_infos[oso_idx].so_file)
+        if (m_compile_unit_infos[oso_idx].so_file)
         {
-
-            if (m_compile_unit_infos[oso_idx].so_symbol == NULL)
-                return false;
-
-            std::string so_path (m_compile_unit_infos[oso_idx].so_symbol->GetMangled().GetName().AsCString());
-            if (m_compile_unit_infos[oso_idx].so_symbol[1].GetType() == eSymbolTypeSourceFile)
-                so_path += m_compile_unit_infos[oso_idx].so_symbol[1].GetMangled().GetName().AsCString();
-            m_compile_unit_infos[oso_idx].so_file.SetFile(so_path.c_str(), true);
+            file_spec = m_compile_unit_infos[oso_idx].so_file;
+            return true;
         }
-        file_spec = m_compile_unit_infos[oso_idx].so_file;
-        return true;
     }
     return false;
 }
@@ -270,182 +529,13 @@ SymbolFileDWARFDebugMap::GetSymbolFileByOSOIndex (uint32_t oso_idx)
 SymbolFileDWARF *
 SymbolFileDWARFDebugMap::GetSymbolFileByCompUnitInfo (CompileUnitInfo *comp_unit_info)
 {
-    if (comp_unit_info->oso_symbol_vendor == NULL && comp_unit_info->symbol_file_supported)
+    Module *oso_module = GetModuleByCompUnitInfo (comp_unit_info);
+    if (oso_module)
     {
-        ObjectFile *oso_objfile = GetObjectFileByCompUnitInfo (comp_unit_info);
-
-        if (oso_objfile)
-        {
-            comp_unit_info->oso_symbol_vendor = oso_objfile->GetModule()->GetSymbolVendor();
-//          SymbolFileDWARF *oso_dwarf = new SymbolFileDWARF(oso_objfile);
-//          comp_unit_info->oso_dwarf_sp.reset (oso_dwarf);
-            if (comp_unit_info->oso_symbol_vendor)
-            {
-                // Set a a pointer to this class to set our OSO DWARF file know
-                // that the DWARF is being used along with a debug map and that
-                // it will have the remapped sections that we do below.
-                SymbolFileDWARF *oso_symfile = (SymbolFileDWARF *)comp_unit_info->oso_symbol_vendor->GetSymbolFile();
-                
-                if (!oso_symfile)
-                    return NULL;
-                
-                if (oso_symfile->GetNumCompileUnits() != 1)
-                {
-                    oso_symfile->GetObjectFile()->GetModule()->ReportError ("DWARF for object file '%s' contains multiple translation units!",
-                                                                            oso_symfile->GetObjectFile()->GetFileSpec().GetFilename().AsCString());
-                    comp_unit_info->symbol_file_supported = false;
-                    comp_unit_info->oso_module_sp.reset();
-                    comp_unit_info->oso_compile_unit_sp.reset();
-                    comp_unit_info->oso_symbol_vendor = NULL;
-                    return NULL;
-                }
-                
-                oso_symfile->SetDebugMapSymfile(this);
-                // Set the ID of the symbol file DWARF to the index of the OSO
-                // shifted left by 32 bits to provide a unique prefix for any
-                // UserID's that get created in the symbol file.
-                oso_symfile->SetID (((uint64_t)GetCompUnitInfoIndex(comp_unit_info) + 1ull) << 32ull);
-                comp_unit_info->debug_map_sections_sp.reset(new SectionList);
-
-                Symtab *exe_symtab = m_obj_file->GetSymtab();
-                ModuleSP oso_module_sp (oso_objfile->GetModule());
-                Symtab *oso_symtab = oso_objfile->GetSymtab();
-//#define DEBUG_OSO_DMAP    // Do not check in with this defined...
-#if defined(DEBUG_OSO_DMAP)
-                StreamFile s(stdout);
-                s << "OSO symtab:\n";
-                oso_symtab->Dump(&s, NULL);
-                s << "OSO sections before:\n";
-                oso_objfile->GetSectionList()->Dump(&s, NULL, true);
-#endif
-
-                ///const uint32_t fun_resolve_flags = SymbolContext::Module | eSymbolContextCompUnit | eSymbolContextFunction;
-                //SectionList *oso_sections = oso_objfile->Sections();
-                // Now we need to make sections that map from zero based object
-                // file addresses to where things eneded up in the main executable.
-                uint32_t oso_start_idx = exe_symtab->GetIndexForSymbol (comp_unit_info->oso_symbol);
-                assert (oso_start_idx != UINT32_MAX);
-                oso_start_idx += 1;
-                const uint32_t oso_end_idx = comp_unit_info->so_symbol->GetSiblingIndex();
-                uint32_t sect_id = 0x10000;
-                for (uint32_t idx = oso_start_idx; idx < oso_end_idx; ++idx)
-                {
-                    Symbol *exe_symbol = exe_symtab->SymbolAtIndex(idx);
-                    if (exe_symbol)
-                    {
-                        if (exe_symbol->IsDebug() == false)
-                            continue;
-
-                        switch (exe_symbol->GetType())
-                        {
-                        default:
-                            break;
-
-                        case eSymbolTypeCode:
-                            {
-                                // For each N_FUN, or function that we run into in the debug map
-                                // we make a new section that we add to the sections found in the
-                                // .o file. This new section has the file address set to what the
-                                // addresses are in the .o file, and the load address is adjusted
-                                // to match where it ended up in the final executable! We do this
-                                // before we parse any dwarf info so that when it goes get parsed
-                                // all section/offset addresses that get registered will resolve
-                                // correctly to the new addresses in the main executable.
-
-                                // First we find the original symbol in the .o file's symbol table
-                                Symbol *oso_fun_symbol = oso_symtab->FindFirstSymbolWithNameAndType(exe_symbol->GetMangled().GetName(Mangled::ePreferMangled), eSymbolTypeCode, Symtab::eDebugNo, Symtab::eVisibilityAny);
-                                if (oso_fun_symbol)
-                                {
-                                    // If we found the symbol, then we
-                                    SectionSP exe_fun_section (exe_symbol->GetAddress().GetSection());
-                                    SectionSP oso_fun_section (oso_fun_symbol->GetAddress().GetSection());
-                                    if (oso_fun_section)
-                                    {
-                                        // Now we create a section that we will add as a child of the
-                                        // section in which the .o symbol (the N_FUN) exists.
-
-                                        // We use the exe_symbol size because the one in the .o file
-                                        // will just be a symbol with no size, and the exe_symbol
-                                        // size will reflect any size changes (ppc has been known to
-                                        // shrink function sizes when it gets rid of jump islands that
-                                        // aren't needed anymore).
-                                        SectionSP oso_fun_section_sp (new Section (oso_fun_symbol->GetAddress().GetSection(),
-                                                                                        oso_module_sp,                         // Module (the .o file)
-                                                                                        sect_id++,                          // Section ID starts at 0x10000 and increments so the section IDs don't overlap with the standard mach IDs
-                                                                                        exe_symbol->GetMangled().GetName(Mangled::ePreferMangled), // Name the section the same as the symbol for which is was generated!
-                                                                                        eSectionTypeDebug,
-                                                                                        oso_fun_symbol->GetAddress().GetOffset(),  // File VM address offset in the current section
-                                                                                        exe_symbol->GetByteSize(),          // File size (we need the size from the executable)
-                                                                                        0, 0, 0));
-
-                                        oso_fun_section_sp->SetLinkedLocation (exe_fun_section,
-                                                                               exe_symbol->GetAddress().GetFileAddress() - exe_fun_section->GetFileAddress());
-                                        oso_fun_section->GetChildren().AddSection(oso_fun_section_sp);
-                                        comp_unit_info->debug_map_sections_sp->AddSection(oso_fun_section_sp);
-                                    }
-                                }
-                            }
-                            break;
-
-                        case eSymbolTypeData:
-                            {
-                                // For each N_GSYM we remap the address for the global by making
-                                // a new section that we add to the sections found in the .o file.
-                                // This new section has the file address set to what the
-                                // addresses are in the .o file, and the load address is adjusted
-                                // to match where it ended up in the final executable! We do this
-                                // before we parse any dwarf info so that when it goes get parsed
-                                // all section/offset addresses that get registered will resolve
-                                // correctly to the new addresses in the main executable. We
-                                // initially set the section size to be 1 byte, but will need to
-                                // fix up these addresses further after all globals have been
-                                // parsed to span the gaps, or we can find the global variable
-                                // sizes from the DWARF info as we are parsing.
-
-                                // Next we find the non-stab entry that corresponds to the N_GSYM in the .o file
-                                Symbol *oso_gsym_symbol = oso_symtab->FindFirstSymbolWithNameAndType (exe_symbol->GetMangled().GetName(), 
-                                                                                                      eSymbolTypeData, 
-                                                                                                      Symtab::eDebugNo, 
-                                                                                                      Symtab::eVisibilityAny);
-
-                                if (exe_symbol && oso_gsym_symbol && exe_symbol->ValueIsAddress() && oso_gsym_symbol->ValueIsAddress())
-                                {
-                                    // If we found the symbol, then we
-                                    SectionSP exe_gsym_section (exe_symbol->GetAddress().GetSection());
-                                    SectionSP oso_gsym_section (oso_gsym_symbol->GetAddress().GetSection());
-                                    if (oso_gsym_section)
-                                    {
-                                        SectionSP oso_gsym_section_sp (new Section (oso_gsym_symbol->GetAddress().GetSection(),
-                                                                                    oso_module_sp,                         // Module (the .o file)
-                                                                                    sect_id++,                          // Section ID starts at 0x10000 and increments so the section IDs don't overlap with the standard mach IDs
-                                                                                    exe_symbol->GetMangled().GetName(Mangled::ePreferMangled), // Name the section the same as the symbol for which is was generated!
-                                                                                    eSectionTypeDebug,
-                                                                                    oso_gsym_symbol->GetAddress().GetOffset(),  // File VM address offset in the current section
-                                                                                    1,                                   // We don't know the size of the global, just do the main address for now.
-                                                                                    0, 0, 0));
-
-                                        oso_gsym_section_sp->SetLinkedLocation (exe_gsym_section,
-                                                                                exe_symbol->GetAddress().GetFileAddress() - exe_gsym_section->GetFileAddress());
-                                        oso_gsym_section->GetChildren().AddSection(oso_gsym_section_sp);
-                                        comp_unit_info->debug_map_sections_sp->AddSection(oso_gsym_section_sp);
-                                    }
-                                }
-                            }
-                            break;
-                        }
-                    }
-                }
-                oso_objfile->GetSectionList()->Finalize(); // Now that we're done adding sections, finalize to build fast-lookup caches
-                comp_unit_info->debug_map_sections_sp->Finalize();
-#if defined(DEBUG_OSO_DMAP)
-                s << "OSO sections after:\n";
-                oso_objfile->GetSectionList()->Dump(&s, NULL, true);
-#endif
-            }
-        }
+        SymbolVendor *sym_vendor = oso_module->GetSymbolVendor();
+        if (sym_vendor)
+            return (SymbolFileDWARF *)sym_vendor->GetSymbolFile();
     }
-    if (comp_unit_info->oso_symbol_vendor)
-        return (SymbolFileDWARF *)comp_unit_info->oso_symbol_vendor->GetSymbolFile();
     return NULL;
 }
 
@@ -468,16 +558,19 @@ SymbolFileDWARFDebugMap::CalculateAbilities ()
                                          SymbolFile::VariableTypes |
                                          SymbolFile::LineTables;
 
-        for (uint32_t oso_idx=0; oso_idx<oso_index_count; ++oso_idx)
-        {
-            SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
-            if (oso_dwarf)
-            {
-                uint32_t oso_abilities = oso_dwarf->GetAbilities();
-                if ((oso_abilities & dwarf_abilities) == dwarf_abilities)
-                    return oso_abilities;
-            }
-        }
+        InitOSO();
+        if (!m_compile_unit_infos.empty())
+            return dwarf_abilities;
+//        for (uint32_t oso_idx=0; oso_idx<oso_index_count; ++oso_idx)
+//        {
+//            SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
+//            if (oso_dwarf)
+//            {
+//                uint32_t oso_abilities = oso_dwarf->GetAbilities();
+//                if ((oso_abilities & dwarf_abilities) == dwarf_abilities)
+//                    return oso_abilities;
+//            }
+//        }
     }
     return 0;
 }
@@ -501,30 +594,34 @@ SymbolFileDWARFDebugMap::ParseCompileUnitAtIndex(uint32_t cu_idx)
         if (m_compile_unit_infos[cu_idx].oso_compile_unit_sp.get() == NULL &&
             m_compile_unit_infos[cu_idx].symbol_file_supported)
         {
-            SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (cu_idx);
-            if (oso_dwarf)
+            FileSpec so_file_spec;
+            if (GetFileSpecForSO (cu_idx, so_file_spec))
             {
-                // There is only one compile unit for N_OSO entry right now, so
-                // it will always exist at index zero.
-                m_compile_unit_infos[cu_idx].oso_compile_unit_sp = m_compile_unit_infos[cu_idx].oso_symbol_vendor->GetCompileUnitAtIndex (0);
-            }
+                Module *oso_module = GetModuleByOSOIndex (cu_idx);
+                if (oso_module)
+                {
+                     // User zero as the ID to match the compile unit at offset
+                     // zero in each .o file since each .o file can only have
+                     // one compile unit for now.
+                    lldb::user_id_t cu_id = 0;
+                    m_compile_unit_infos[cu_idx].oso_compile_unit_sp.reset (new CompileUnit (oso_module->shared_from_this(),
+                                                                                             NULL,
+                                                                                             so_file_spec,
+                                                                                             cu_id,
+                                                                                             eLanguageTypeUnknown));
+                }
 
-            if (m_compile_unit_infos[cu_idx].oso_compile_unit_sp.get() == NULL)
-            {
-                // We weren't able to get the DWARF for this N_OSO entry (the
-                // .o file may be missing or not at the specified path), make
-                // one up as best we can from the debug map. We set the uid
-                // of the compile unit to the symbol index with the MSBit set
-                // so that it doesn't collide with any uid values from the DWARF
-                Symbol *so_symbol = m_compile_unit_infos[cu_idx].so_symbol;
-                if (so_symbol)
+                if (!m_compile_unit_infos[cu_idx].oso_compile_unit_sp)
                 {
                     m_compile_unit_infos[cu_idx].oso_compile_unit_sp.reset(new CompileUnit (m_obj_file->GetModule(),
                                                                                             NULL,
-                                                                                            so_symbol->GetMangled().GetName().AsCString(),
+                                                                                            so_file_spec,
                                                                                             cu_idx,
                                                                                             eLanguageTypeUnknown));
-
+                }
+            
+                if (m_compile_unit_infos[cu_idx].oso_compile_unit_sp)
+                {
                     // Let our symbol vendor know about this compile unit
                     m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex (cu_idx,
                                                                                        m_compile_unit_infos[cu_idx].oso_compile_unit_sp);
@@ -549,6 +646,28 @@ SymbolFileDWARFDebugMap::GetCompUnitInfo (const SymbolContext& sc)
     return NULL;
 }
 
+
+SymbolFileDWARFDebugMap::CompileUnitInfo *
+SymbolFileDWARFDebugMap::GetCompUnitInfo (const lldb_private::Module *module)
+{
+    const uint32_t cu_count = GetNumCompileUnits();
+    for (uint32_t i=0; i<cu_count; ++i)
+    {
+        if (module == m_compile_unit_infos[i].oso_module_sp.get())
+            return &m_compile_unit_infos[i];
+    }
+    return NULL;
+}
+
+lldb::LanguageType
+SymbolFileDWARFDebugMap::ParseCompileUnitLanguage (const SymbolContext& sc)
+{
+    SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
+    if (oso_dwarf)
+        return oso_dwarf->ParseCompileUnitLanguage (sc);
+    return eLanguageTypeUnknown;
+}
+
 size_t
 SymbolFileDWARFDebugMap::ParseCompileUnitFunctions (const SymbolContext& sc)
 {
@@ -602,7 +721,7 @@ SymbolFileDWARFDebugMap::ParseVariablesForContext (const SymbolContext& sc)
 {
     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
     if (oso_dwarf)
-        return oso_dwarf->ParseTypes (sc);
+        return oso_dwarf->ParseVariablesForContext (sc);
     return 0;
 }
 
@@ -669,24 +788,31 @@ SymbolFileDWARFDebugMap::ResolveSymbolContext (const Address& exe_so_addr, uint3
 uint32_t
 SymbolFileDWARFDebugMap::ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
 {
-    uint32_t initial = sc_list.GetSize();
+    const uint32_t initial = sc_list.GetSize();
     const uint32_t cu_count = GetNumCompileUnits();
 
-    FileSpec so_file_spec;
     for (uint32_t i=0; i<cu_count; ++i)
     {
-        if (GetFileSpecForSO (i, so_file_spec))
+        // If we are checking for inlines, then we need to look through all
+        // compile units no matter if "file_spec" matches.
+        bool resolve = check_inlines;
+        
+        if (!resolve)
         {
-            // By passing false to the comparison we will be able to match
-            // and files given a filename only. If both file_spec and
-            // so_file_spec have directories, we will still do a full match.
-            if (FileSpec::Compare (file_spec, so_file_spec, false) == 0)
+            FileSpec so_file_spec;
+            if (GetFileSpecForSO (i, so_file_spec))
             {
-                SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (i);
-                if (oso_dwarf)
-                    oso_dwarf->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope, sc_list);
+                // Match the full path if the incoming file_spec has a directory (not just a basename)
+                const bool full_match = file_spec.GetDirectory();
+                resolve = FileSpec::Equal (file_spec, so_file_spec, full_match);
             }
         }
+        if (resolve)
+        {
+            SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (i);
+            if (oso_dwarf)
+                oso_dwarf->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope, sc_list);
+        }
     }
     return sc_list.GetSize() - initial;
 }
@@ -825,10 +951,10 @@ SymbolFileDWARFDebugMap::SymbolContainsSymbolWithID (user_id_t *symbol_idx_ptr,
 {
     const user_id_t symbol_id = *symbol_idx_ptr;
 
-    if (symbol_id < comp_unit_info->so_symbol->GetID())
+    if (symbol_id < comp_unit_info->first_symbol_id)
         return -1;
 
-    if (symbol_id <= comp_unit_info->last_symbol->GetID())
+    if (symbol_id <= comp_unit_info->last_symbol_id)
         return 0;
 
     return 1;
@@ -1113,23 +1239,49 @@ SymbolFileDWARFDebugMap::GetPluginVersion()
     return 1;
 }
 
-void
-SymbolFileDWARFDebugMap::SetCompileUnit (SymbolFileDWARF *oso_dwarf, const CompUnitSP &cu_sp)
+lldb::CompUnitSP
+SymbolFileDWARFDebugMap::GetCompileUnit (SymbolFileDWARF *oso_dwarf)
 {
-    const uint32_t cu_count = GetNumCompileUnits();
-    for (uint32_t cu_idx=0; cu_idx<cu_count; ++cu_idx)
+    if (oso_dwarf)
     {
-        if (m_compile_unit_infos[cu_idx].oso_symbol_vendor &&
-            m_compile_unit_infos[cu_idx].oso_symbol_vendor->GetSymbolFile() == oso_dwarf)
+        const uint32_t cu_count = GetNumCompileUnits();
+        for (uint32_t cu_idx=0; cu_idx<cu_count; ++cu_idx)
         {
-            if (m_compile_unit_infos[cu_idx].oso_compile_unit_sp)
+            SymbolFileDWARF *oso_symfile = GetSymbolFileByCompUnitInfo (&m_compile_unit_infos[cu_idx]);
+            if (oso_symfile == oso_dwarf)
             {
-                assert (m_compile_unit_infos[cu_idx].oso_compile_unit_sp.get() == cu_sp.get());
+                if (!m_compile_unit_infos[cu_idx].oso_compile_unit_sp)
+                    m_compile_unit_infos[cu_idx].oso_compile_unit_sp = ParseCompileUnitAtIndex (cu_idx);
+
+                return m_compile_unit_infos[cu_idx].oso_compile_unit_sp;
             }
-            else
+        }
+    }
+    assert(!"this shouldn't happen");
+    return lldb::CompUnitSP();
+}
+
+
+void
+SymbolFileDWARFDebugMap::SetCompileUnit (SymbolFileDWARF *oso_dwarf, const CompUnitSP &cu_sp)
+{
+    if (oso_dwarf)
+    {
+        const uint32_t cu_count = GetNumCompileUnits();
+        for (uint32_t cu_idx=0; cu_idx<cu_count; ++cu_idx)
+        {
+            SymbolFileDWARF *oso_symfile = GetSymbolFileByCompUnitInfo (&m_compile_unit_infos[cu_idx]);
+            if (oso_symfile == oso_dwarf)
             {
-                m_compile_unit_infos[cu_idx].oso_compile_unit_sp = cu_sp;
-                m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(cu_idx, cu_sp);
+                if (m_compile_unit_infos[cu_idx].oso_compile_unit_sp)
+                {
+                    assert (m_compile_unit_infos[cu_idx].oso_compile_unit_sp.get() == cu_sp.get());
+                }
+                else
+                {
+                    m_compile_unit_infos[cu_idx].oso_compile_unit_sp = cu_sp;
+                    m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(cu_idx, cu_sp);
+                }
             }
         }
     }
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h
index d7b69e0b23e..ecc6f67a686 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h
+++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h
@@ -24,10 +24,12 @@ class SymbolFileDWARF;
 class DWARFCompileUnit;
 class DWARFDebugInfoEntry;
 class DWARFDeclContext;
+class DebugMapModule;
 
 class SymbolFileDWARFDebugMap : public lldb_private::SymbolFile
 {
 public:
+    
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
@@ -62,6 +64,7 @@ public:
     virtual uint32_t        GetNumCompileUnits ();
     virtual lldb::CompUnitSP ParseCompileUnitAtIndex (uint32_t index);
 
+    virtual lldb::LanguageType ParseCompileUnitLanguage (const lldb_private::SymbolContext& sc);
     virtual size_t          ParseCompileUnitFunctions (const lldb_private::SymbolContext& sc);
     virtual bool            ParseCompileUnitLineTable (const lldb_private::SymbolContext& sc);
     virtual bool            ParseCompileUnitSupportFiles (const lldb_private::SymbolContext& sc, lldb_private::FileSpecList &support_files);
@@ -125,39 +128,41 @@ protected:
     };
 
     friend class SymbolFileDWARF;
-
+    friend class DebugMapModule;
     //------------------------------------------------------------------
     // Class specific types
     //------------------------------------------------------------------
     struct CompileUnitInfo
     {
         lldb_private::FileSpec so_file;
-        lldb_private::Symbol *so_symbol;
-        lldb_private::Symbol *oso_symbol;
-        lldb_private::Symbol *last_symbol;
+        lldb_private::FileSpec oso_file;
+        lldb_private::ConstString oso_object; // for archives this will be the .o file in the "oso_file"
+//        lldb_private::Symbol *so_symbol;
+//        lldb_private::Symbol *oso_symbol;
+//        lldb_private::Symbol *last_symbol;
         uint32_t first_symbol_index;
         uint32_t last_symbol_index;
+        uint32_t first_symbol_id;
+        uint32_t last_symbol_id;
         lldb::ModuleSP oso_module_sp;
         lldb::CompUnitSP oso_compile_unit_sp;
-        lldb_private::SymbolVendor *oso_symbol_vendor;
-        std::vector<uint32_t> function_indexes;
-        std::vector<uint32_t> static_indexes;
-        STD_SHARED_PTR(lldb_private::SectionList) debug_map_sections_sp;
+//        SymbolFileDWARF *oso_symfile;
         bool symbol_file_supported;
 
         CompileUnitInfo() :
             so_file (),
-            so_symbol (NULL),
-            oso_symbol (NULL),
-            last_symbol (NULL),
+            oso_file (),
+            oso_object (),
+//            so_symbol (NULL),
+//            oso_symbol (NULL),
+//            last_symbol (NULL),
             first_symbol_index (UINT32_MAX),
             last_symbol_index (UINT32_MAX),
+            first_symbol_id (UINT32_MAX),
+            last_symbol_id (UINT32_MAX),
             oso_module_sp (),
             oso_compile_unit_sp (),
-            oso_symbol_vendor (NULL),
-            function_indexes (),
-            static_indexes (),
-            debug_map_sections_sp (),
+//            oso_symfile (NULL),
             symbol_file_supported (true)
         {
         }
@@ -180,6 +185,9 @@ protected:
     CompileUnitInfo *
     GetCompUnitInfo (const lldb_private::SymbolContext& sc);
 
+    CompileUnitInfo *
+    GetCompUnitInfo (const lldb_private::Module *oso_module);
+    
     lldb_private::Module *
     GetModuleByCompUnitInfo (CompileUnitInfo *comp_unit_info);
 
@@ -227,6 +235,9 @@ protected:
     void
     SetCompileUnit (SymbolFileDWARF *oso_dwarf, const lldb::CompUnitSP &cu_sp);
 
+    lldb::CompUnitSP
+    GetCompileUnit (SymbolFileDWARF *oso_dwarf);
+
     lldb::TypeSP
     FindDefinitionTypeForDWARFDeclContext (const DWARFDeclContext &die_decl_ctx);    
 
diff --git a/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp b/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp
index 5404ab0f8fd..1e1a0f203f3 100644
--- a/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp
+++ b/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp
@@ -12,13 +12,14 @@
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/Timer.h"
+#include "lldb/Symbol/CompileUnit.h"
+#include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
-#include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h"
-#include "lldb/Symbol/Function.h"
+#include "lldb/Symbol/Symtab.h"
+#include "lldb/Symbol/TypeList.h"
 
 using namespace lldb;
 using namespace lldb_private;
@@ -157,6 +158,13 @@ SymbolFileSymtab::ParseCompileUnitAtIndex(uint32_t idx)
     return cu_sp;
 }
 
+lldb::LanguageType
+SymbolFileSymtab::ParseCompileUnitLanguage (const SymbolContext& sc)
+{
+    return eLanguageTypeUnknown;
+}
+
+
 size_t
 SymbolFileSymtab::ParseCompileUnitFunctions (const SymbolContext &sc)
 {
diff --git a/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h b/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h
index bb40f128416..3c90b112d80 100644
--- a/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h
+++ b/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h
@@ -54,6 +54,9 @@ public:
     virtual lldb::CompUnitSP
     ParseCompileUnitAtIndex(uint32_t index);
 
+    virtual lldb::LanguageType
+    ParseCompileUnitLanguage (const lldb_private::SymbolContext& sc);
+
     virtual size_t
     ParseCompileUnitFunctions (const lldb_private::SymbolContext& sc);
 
diff --git a/lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp b/lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp
index 4dc1d0ae8ac..53acf8d6cea 100644
--- a/lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp
+++ b/lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp
@@ -16,6 +16,7 @@
 #include <AvailabilityMacros.h>
 
 #include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamString.h"
diff --git a/lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp b/lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
index 1a2b2244fdc..1a176471189 100644
--- a/lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
+++ b/lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
@@ -14,6 +14,7 @@
 #include "lldb/Core/Address.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"