Update LLDB snapshot to upstream r216948 (git 50f7fe44)

This is approximately "LLDB 3.5" although with a little bit of skew,
and will go along with the Clang 3.5 import.

Sponsored by:	DARPA, AFRL

1 files changed, 136 insertions, 47 deletions

diff --git a/contrib/llvm/tools/lldb/source/Target/TargetList.cpp b/contrib/llvm/tools/lldb/source/Target/TargetList.cpp
index c4da84f..5ee75ff 100644
--- a/contrib/llvm/tools/lldb/source/Target/TargetList.cpp
+++ b/contrib/llvm/tools/lldb/source/Target/TargetList.cpp
@@ -28,6 +28,8 @@
 #include "lldb/Target/Process.h"
 #include "lldb/Target/TargetList.h"
 
+#include "llvm/ADT/SmallString.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
@@ -85,12 +87,31 @@ TargetList::CreateTarget (Debugger &debugger,
     
     ArchSpec platform_arch(arch);
 
+    bool prefer_platform_arch = false;
+    
+    CommandInterpreter &interpreter = debugger.GetCommandInterpreter();
+    if (platform_options && platform_options->PlatformWasSpecified ())
+    {
+        const bool select_platform = true;
+        platform_sp = platform_options->CreatePlatformWithOptions (interpreter,
+                                                                   arch,
+                                                                   select_platform,
+                                                                   error,
+                                                                   platform_arch);
+        if (!platform_sp)
+            return error;
+    }
     
     if (user_exe_path && user_exe_path[0])
     {
         ModuleSpecList module_specs;
         ModuleSpec module_spec;
         module_spec.GetFileSpec().SetFile(user_exe_path, true);
+        
+        // Resolve the executable in case we are given a path to a application bundle
+        // like a .app bundle on MacOSX
+        Host::ResolveExecutableInBundle (module_spec.GetFileSpec());
+
         lldb::offset_t file_offset = 0;
         lldb::offset_t file_size = 0;
         const size_t num_specs = ObjectFile::GetModuleSpecifications (module_spec.GetFileSpec(), file_offset, file_size, module_specs);
@@ -104,7 +125,17 @@ TargetList::CreateTarget (Debugger &debugger,
                 {
                     if (platform_arch.IsValid())
                     {
-                        if (!platform_arch.IsCompatibleMatch(matching_module_spec.GetArchitecture()))
+                        if (platform_arch.IsCompatibleMatch(matching_module_spec.GetArchitecture()))
+                        {
+                            // If the OS or vendor weren't specified, then adopt the module's
+                            // architecture so that the platform matching can be more accurate
+                            if (!platform_arch.TripleOSWasSpecified() || !platform_arch.TripleVendorWasSpecified())
+                            {
+                                prefer_platform_arch = true;
+                                platform_arch = matching_module_spec.GetArchitecture();
+                            }
+                        }
+                        else
                         {
                             error.SetErrorStringWithFormat("the specified architecture '%s' is not compatible with '%s' in '%s'",
                                                            platform_arch.GetTriple().str().c_str(),
@@ -116,6 +147,7 @@ TargetList::CreateTarget (Debugger &debugger,
                     else
                     {
                         // Only one arch and none was specified
+                        prefer_platform_arch = true;
                         platform_arch = matching_module_spec.GetArchitecture();
                     }
                 }
@@ -127,48 +159,114 @@ TargetList::CreateTarget (Debugger &debugger,
                     module_spec.GetArchitecture() = arch;
                     if (module_specs.FindMatchingModuleSpec(module_spec, matching_module_spec))
                     {
+                        prefer_platform_arch = true;
                         platform_arch = matching_module_spec.GetArchitecture();
                     }
                 }
-                // Don't just select the first architecture, we want to let the platform select
-                // the best architecture first when there are multiple archs.
-//                else
-//                {
-//                    // No arch specified, select the first arch
-//                    if (module_specs.GetModuleSpecAtIndex(0, matching_module_spec))
-//                    {
-//                        platform_arch = matching_module_spec.GetArchitecture();
-//                    }
-//                }
+                else
+                {
+                    // No architecture specified, check if there is only one platform for
+                    // all of the architectures.
+                    
+                    typedef std::vector<PlatformSP> PlatformList;
+                    PlatformList platforms;
+                    PlatformSP host_platform_sp = Platform::GetDefaultPlatform();
+                    for (size_t i=0; i<num_specs; ++i)
+                    {
+                        ModuleSpec module_spec;
+                        if (module_specs.GetModuleSpecAtIndex(i, module_spec))
+                        {
+                            // See if there was a selected platform and check that first
+                            // since the user may have specified it.
+                            if (platform_sp)
+                            {
+                                if (platform_sp->IsCompatibleArchitecture(module_spec.GetArchitecture(), false, NULL))
+                                {
+                                    platforms.push_back(platform_sp);
+                                    continue;
+                                }
+                            }
+                            
+                            // Next check the host platform it if wasn't already checked above
+                            if (host_platform_sp && (!platform_sp || host_platform_sp->GetName() != platform_sp->GetName()))
+                            {
+                                if (host_platform_sp->IsCompatibleArchitecture(module_spec.GetArchitecture(), false, NULL))
+                                {
+                                    platforms.push_back(host_platform_sp);
+                                    continue;
+                                }
+                            }
+                            
+                            // Just find a platform that matches the architecture in the executable file
+                            platforms.push_back(Platform::GetPlatformForArchitecture(module_spec.GetArchitecture(), nullptr));
+                        }
+                    }
+                    
+                    Platform *platform_ptr = NULL;
+                    for (const auto &the_platform_sp : platforms)
+                    {
+                        if (platform_ptr)
+                        {
+                            if (platform_ptr->GetName() != the_platform_sp->GetName())
+                            {
+                                platform_ptr = NULL;
+                                break;
+                            }
+                        }
+                        else
+                        {
+                            platform_ptr = the_platform_sp.get();
+                        }
+                    }
+                    
+                    if (platform_ptr)
+                    {
+                        // All platforms for all modules in the exectuable match, so we can select this platform
+                        platform_sp = platforms.front();
+                    }
+                    else
+                    {
+                        // More than one platform claims to support this file, so the --platform option must be specified
+                        StreamString error_strm;
+                        std::set<Platform *> platform_set;
+                        error_strm.Printf ("more than one platform supports this executable (");
+                        for (const auto &the_platform_sp : platforms)
+                        {
+                            if (platform_set.find(the_platform_sp.get()) == platform_set.end())
+                            {
+                                if (!platform_set.empty())
+                                    error_strm.PutCString(", ");
+                                error_strm.PutCString(the_platform_sp->GetName().GetCString());
+                                platform_set.insert(the_platform_sp.get());
+                            }
+                        }
+                        error_strm.Printf("), use the --platform option to specify a platform");
+                        error.SetErrorString(error_strm.GetString().c_str());
+                        return error;
+                    }
+                }
             }
         }
     }
 
-    CommandInterpreter &interpreter = debugger.GetCommandInterpreter();
-    if (platform_options)
-    {
-        if (platform_options->PlatformWasSpecified ())
-        {
-            const bool select_platform = true;
-            platform_sp = platform_options->CreatePlatformWithOptions (interpreter,
-                                                                       arch,
-                                                                       select_platform, 
-                                                                       error,
-                                                                       platform_arch);
-            if (!platform_sp)
-                return error;
-        }
-    }
-    
     if (!platform_sp)
     {
         // Get the current platform and make sure it is compatible with the
         // current architecture if we have a valid architecture.
         platform_sp = debugger.GetPlatformList().GetSelectedPlatform ();
         
-        if (arch.IsValid() && !platform_sp->IsCompatibleArchitecture(arch, false, &platform_arch))
+        if (!prefer_platform_arch && arch.IsValid())
         {
-            platform_sp = Platform::GetPlatformForArchitecture(arch, &platform_arch);
+            if (!platform_sp->IsCompatibleArchitecture(arch, false, &platform_arch))
+                platform_sp = Platform::GetPlatformForArchitecture(arch, &platform_arch);
+        }
+        else if (platform_arch.IsValid())
+        {
+            // if "arch" isn't valid, yet "platform_arch" is, it means we have an executable file with
+            // a single architecture which should be used
+            ArchSpec fixed_platform_arch;
+            if (!platform_sp->IsCompatibleArchitecture(platform_arch, false, &fixed_platform_arch))
+                platform_sp = Platform::GetPlatformForArchitecture(platform_arch, &fixed_platform_arch);
         }
     }
     
@@ -200,17 +298,10 @@ TargetList::CreateTarget (Debugger &debugger,
 
     ArchSpec arch(specified_arch);
 
-    if (platform_sp)
+    if (arch.IsValid())
     {
-        if (arch.IsValid())
-        {
-            if (!platform_sp->IsCompatibleArchitecture(arch, false, NULL))
-                platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch);
-        }
-    }
-    else if (arch.IsValid())
-    {
-        platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch);
+        if (!platform_sp || !platform_sp->IsCompatibleArchitecture(arch, false, NULL))
+            platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch);
     }
     
     if (!platform_sp)
@@ -224,15 +315,13 @@ TargetList::CreateTarget (Debugger &debugger,
     {
         // we want to expand the tilde but we don't want to resolve any symbolic links
         // so we can't use the FileSpec constructor's resolve flag
-        char unglobbed_path[PATH_MAX];
-        unglobbed_path[0] = '\0';
-
-        size_t return_count = FileSpec::ResolveUsername(user_exe_path, unglobbed_path, sizeof(unglobbed_path));
-
-        if (return_count == 0 || return_count >= sizeof(unglobbed_path))
-            ::snprintf (unglobbed_path, sizeof(unglobbed_path), "%s", user_exe_path);
+        llvm::SmallString<64> unglobbed_path(user_exe_path);
+        FileSpec::ResolveUsername(unglobbed_path);
 
-        file = FileSpec(unglobbed_path, false);
+        if (unglobbed_path.empty())
+            file = FileSpec(user_exe_path, false);
+        else
+            file = FileSpec(unglobbed_path.c_str(), false);
     }
 
     bool user_exe_path_is_bundle = false;