Invert ArchSpec<->Platform dependency

[labath]

Summary

ArchSpec::SetTriple was taking a Platform as an argument, and used it to
fill in missing pieces of the specified triple. I invert the dependency
by moving this code to other classes. For this purpose, I've created
three new functions.

• HostInfo::GetAugmentedArchSpec: fills in the triple using the host platform (this used to be implemented by passing a null platform pointer). By putting this code in the Host module, we can provide a way to anyone who does not have a platform instance (lldb-server) an easy way to get Host data.
• Platform::GetAugmentedArchSpec: if you have a platform instance, you can call this to let it fill in the triple.
• static Platform::GetAugmentedArchSpec: implements the "if platform == 0 then use_host() else use_platform()" part.

After this change, it becomes possible to move the ArchSpec into the
Utility module, as it has no external dependencies.

[zturner]

include/lldb/Host/HostInfoBase.h

85

s/contains/does/

include/lldb/Target/Platform.h

524

Should this function be marked const?

Another possible interface would be void AugmentArchSpec(ArchSpec &spec);

source/API/SBDebugger.cpp

698

Is arch_name here actually a triple? If so, is it worth renaming this variable?

source/API/SBInstruction.cpp

263

Why does this one use HostInfo instead of Platform?

source/Core/ArchSpec.cpp

888–889

Should this function be marked const?

source/Host/common/HostInfoBase.cpp

257–261

I don't *think* this is very performance sensitive, but it's unfortunate that this ends up calling normalize twice. If there's a clean way to re-write it that would probably be nice.

source/Target/Platform.cpp

975–976

Same here, this method ends up normalizing twice, once inside of ContainsMoreThanArch and once inside of this function.

984

Can you early-return here?

986–991

Are these cases even possible? Why would the vendor and os ever be empty? I thought only the environment could be empty.

[labath]

source/Target/Platform.cpp

986–991

It is possible, because in some cases, we actually only specify the architecture in calls to this function (see the arch_name comment above). There (I think) its only purpose is to disambiguate which slice in a fat binary are you talking about (and in that case, you don't really need to specify anything other than an architecture).

However, in that case, it is true that what we are passing is not really a triple.

[zturner]

source/Target/Platform.cpp

986–991

Right, but you are specifically checking against the normalized triple. I'm pretty sure Triple::normalize will never set these to empty strings. Maybe I'm wrong though (I'm actually about to test)

[zturner]

source/Target/Platform.cpp

986–991

Huh. Ok, I guess you're right. The unit tests have this check:

EXPECT_EQ("i386", Triple::normalize("i386"));

I assumed that would return i386-unknown-unknown since they are not considered "optional" components.

[labath]

include/lldb/Target/Platform.h

524

Unfortunately it's not possible, as it ends up calling a couple of other function, which are not const, and some of them are virtual.

I don't think the other signature would be very practical, as all the present uses pass in a string, and they don't have an ArchSpec around.

source/API/SBDebugger.cpp

698

As discussed, this is probably expected to only be an architecture name (although, nothing is stopping it from being a triple).

source/API/SBInstruction.cpp

263

Since it is hard-coding a null platform, I figured it is best to be explicit that it is going to pick up data from the host.

As to why is it doing that, I have no idea, but there doesn't seem to be an easy way to fetch a platform instance here.

source/Core/ArchSpec.cpp

888–889

This function is static.

source/Host/common/HostInfoBase.cpp

257–261

I've made the function assume that the incoming triple in normalized. That way, we can just normalize once here, and then pass the normalized triple. I've also inverted the function name to ContainsOnlyArch which is slightly clearer, I think.

[labath]

Address review comments

[zturner]

source/Core/ArchSpec.cpp

890

Should you also add !triple.getArchName().empty() to the condition? Also, perhaps name this parameter normalized_triple to document the expectation to the caller.

[labath]

rename argument to normalized_triple, check that the architecture is not empty.

include/lldb/Core/ArchSpec.h

public:
   /// Constructor over triple.
   ///
   /// Constructs an ArchSpec with properties consistent with the given
   /// Triple.
   //------------------------------------------------------------------
   explicit ArchSpec(const llvm::Triple &triple);
   explicit ArchSpec(const char *triple_cstr);
   explicit ArchSpec(llvm::StringRef triple_str);
-  ArchSpec(const char *triple_cstr, Platform *platform);
-  ArchSpec(llvm::StringRef triple_str, Platform *platform);
   //------------------------------------------------------------------
   /// Constructor over architecture name.
   ///
   /// Constructs an ArchSpec with properties consistent with the given
   /// object type and architecture name.
   //------------------------------------------------------------------
   explicit ArchSpec(ArchitectureType arch_type, uint32_t cpu_type,
                     uint32_t cpu_subtype);
 
   //------------------------------------------------------------------
   /// Destructor.
   //------------------------------------------------------------------
   ~ArchSpec();
 
   //------------------------------------------------------------------
   /// Assignment operator.
   ///
   /// @param[in] rhs another ArchSpec object to copy.
   ///
   /// @return A const reference to this object.
   //------------------------------------------------------------------
   const ArchSpec &operator=(const ArchSpec &rhs);
 
+  //---------------------------------------------------------------------------
+  /// Returns true if the OS, vendor and environment fields of the triple are
+  /// unset. The triple is expected to be normalized (llvm::Triple::normalize).
+  //---------------------------------------------------------------------------
+  static bool ContainsOnlyArch(const llvm::Triple &normalized_triple);
+
   static size_t AutoComplete(llvm::StringRef name, StringList &matches);
 
   //------------------------------------------------------------------
   /// Returns a static string representing the current architecture.
   ///
   /// @return A static string correcponding to the current
   ///         architecture.
   //------------------------------------------------------------------
public:
   /// environment components are used to further resolve the CPU type
   /// and subtype, endian characteristics, etc.
   ///
   /// @return A triple describing this ArchSpec.
   //------------------------------------------------------------------
   bool SetTriple(const llvm::Triple &triple);
 
   bool SetTriple(llvm::StringRef triple_str);
-  bool SetTriple(llvm::StringRef triple_str, Platform *platform);
-
-  bool SetTriple(const char *triple_cstr);
-  bool SetTriple(const char *triple_cstr, Platform *platform);
 
   //------------------------------------------------------------------
   /// Returns the default endianness of the architecture.
   ///
   /// @return The endian enumeration for the default endianness of
   ///         the architecture.
   //------------------------------------------------------------------
   lldb::ByteOrder GetDefaultEndian() const;

include/lldb/Host/HostInfoBase.h

public:
   /// @param[in] file_spec
   ///     A file spec that gets filled in with the appropriate path.
   ///
   /// @return
   ///     \b true if \a resource_path was resolved, \a false otherwise.
   //------------------------------------------------------------------
   static bool GetLLDBPath(lldb::PathType type, FileSpec &file_spec);
 
+  //---------------------------------------------------------------------------
+  /// If the triple does not specify the vendor, os, and environment parts, we
+  /// "augment" these using information from the host and return the resulting
+  /// ArchSpec object.
+  //---------------------------------------------------------------------------
+  static ArchSpec GetAugmentedArchSpec(llvm::StringRef triple);
+
 protected:
   static bool ComputeSharedLibraryDirectory(FileSpec &file_spec);
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static bool ComputeProcessTempFileDirectory(FileSpec &file_spec);
   static bool ComputeGlobalTempFileDirectory(FileSpec &file_spec);
   static bool ComputeTempFileBaseDirectory(FileSpec &file_spec);
   static bool ComputeHeaderDirectory(FileSpec &file_spec);
   static bool ComputeSystemPluginsDirectory(FileSpec &file_spec);

include/lldb/Target/Platform.h

public:
   // Find an existing platform plug-in by name
   static lldb::PlatformSP Find(const ConstString &name);
 
   static lldb::PlatformSP Create(const ConstString &name, Status &error);
 
   static lldb::PlatformSP Create(const ArchSpec &arch,
                                  ArchSpec *platform_arch_ptr, Status &error);
 
-  static uint32_t GetNumConnectedRemotePlatforms();
-
-  static lldb::PlatformSP GetConnectedRemotePlatformAtIndex(uint32_t idx);
+  //------------------------------------------------------------------------
+  /// Augments the triple either with information from platform or the host
+  /// system (if platform is null).
+  //------------------------------------------------------------------------
+  static ArchSpec GetAugmentedArchSpec(Platform *platform,
+                                       llvm::StringRef triple);
 
   //------------------------------------------------------------------
   /// Find a platform plugin for a given process.
   ///
   /// Scans the installed Platform plug-ins and tries to find
   /// an instance that can be used for \a process
   ///
   /// @param[in] process
public:
   const ArchSpec &GetSystemArchitecture();
 
   void SetSystemArchitecture(const ArchSpec &arch) {
     m_system_arch = arch;
     if (IsHost())
       m_os_version_set_while_connected = m_system_arch.IsValid();
   }
 
+  //---------------------------------------------------------------------------
+  /// If the triple contains not specify the vendor, os, and environment parts,
+  /// we "augment" these using information from the platform and return the
+  /// resulting ArchSpec object.
+  //---------------------------------------------------------------------------
+  ArchSpec GetAugmentedArchSpec(llvm::StringRef triple);
+
   // Used for column widths
   size_t GetMaxUserIDNameLength() const { return m_max_uid_name_len; }
 
   // Used for column widths
   size_t GetMaxGroupIDNameLength() const { return m_max_gid_name_len; }
 
   const ConstString &GetSDKRootDirectory() const { return m_sdk_sysroot; }
 

packages/Python/lldbsuite/test/source-manager/main.c

-#include <stdio.h>
-
-int main(int argc, char const *argv[]) {
-    printf("Hello world.\n"); // Set break point at this line.
-    return 0;
-}

source/API/SBDebugger.cpp

SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
   return sb_target;
 }
 
 SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
                                                const char *arch_name) {
   SBTarget sb_target;
   if (m_opaque_sp && filename && filename[0]) {
     // No need to lock, the target list is thread safe
-    ArchSpec arch(arch_name,
-                  m_opaque_sp->GetPlatformList().GetSelectedPlatform().get());
+    ArchSpec arch = Platform::GetAugmentedArchSpec(
+        m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name);
     TargetSP target_sp(
         m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(
             FileSpec(filename, false), arch_name ? &arch : nullptr));
     sb_target.SetSP(target_sp);
   }
   return sb_target;
 }
 

source/API/SBInstruction.cpp

 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"
 
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/EmulateInstruction.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 
 //----------------------------------------------------------------------
 // We recently fixed a leak in one of the Instruction subclasses where
if (inst_sp) {
     }
   }
   return false;
 }
 
 bool SBInstruction::DumpEmulation(const char *triple) {
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp && triple) {
-    lldb_private::ArchSpec arch(triple, NULL);
-    return inst_sp->DumpEmulation(arch);
+    return inst_sp->DumpEmulation(HostInfo::GetAugmentedArchSpec(triple));
   }
   return false;
 }
 
 bool SBInstruction::TestEmulation(lldb::SBStream &output_stream,
                                   const char *test_file) {
   if (!m_opaque_sp)
     SetOpaque(lldb::DisassemblerSP(),

source/API/SBTarget.cpp

if (target_sp) {
     ModuleSpec module_spec;
     if (path)
       module_spec.GetFileSpec().SetFile(path, false);
 
     if (uuid_cstr)
       module_spec.GetUUID().SetFromCString(uuid_cstr);
 
     if (triple)
-      module_spec.GetArchitecture().SetTriple(triple,
-                                              target_sp->GetPlatform().get());
+      module_spec.GetArchitecture() = Platform::GetAugmentedArchSpec(
+          target_sp->GetPlatform().get(), triple);
     else
       module_spec.GetArchitecture() = target_sp->GetArchitecture();
 
     if (symfile)
       module_spec.GetSymbolFileSpec().SetFile(symfile, false);
 
     sb_module.SetSP(target_sp->GetSharedModule(module_spec));
   }

source/Commands/CommandObjectDisassemble.cpp

case 'f':
     some_location_specified = true;
     break;
 
   case 'A':
     if (execution_context) {
       auto target_sp =
           execution_context ? execution_context->GetTargetSP() : TargetSP();
       auto platform_sp = target_sp ? target_sp->GetPlatform() : PlatformSP();
-      if (!arch.SetTriple(option_arg, platform_sp.get()))
-        arch.SetTriple(option_arg);
+      arch = Platform::GetAugmentedArchSpec(platform_sp.get(), option_arg);
     }
     break;
 
   case 'a': {
     symbol_containing_addr = Args::StringToAddress(
         execution_context, option_arg, LLDB_INVALID_ADDRESS, &error);
     if (symbol_containing_addr != LLDB_INVALID_ADDRESS) {
       some_location_specified = true;

source/Commands/CommandObjectPlatform.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         TargetSP target_sp =
             execution_context ? execution_context->GetTargetSP() : TargetSP();
         DebuggerSP debugger_sp =
             target_sp ? target_sp->GetDebugger().shared_from_this()
                       : DebuggerSP();
         PlatformSP platform_sp =
             debugger_sp ? debugger_sp->GetPlatformList().GetSelectedPlatform()
                         : PlatformSP();
-        match_info.GetProcessInfo().GetArchitecture().SetTriple(
-            option_arg, platform_sp.get());
+        match_info.GetProcessInfo().GetArchitecture() =
+            Platform::GetAugmentedArchSpec(platform_sp.get(), option_arg);
       } break;
 
       case 'n':
         match_info.GetProcessInfo().GetExecutableFile().SetFile(option_arg,
                                                                 false);
         match_info.SetNameMatchType(NameMatch::Equals);
         break;
 

source/Core/ArchSpec.cpp

 //===-- ArchSpec.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ArchSpec.h"
 
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Target/Platform.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/Stream.h" // for Stream
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-defines.h" // for LLDB_INVALID_C...
 #include "lldb/lldb-forward.h" // for RegisterContextSP
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Twine.h" // for Twine
FindArchDefinitionEntry(const ArchDefinition *def, ArchSpec::Core core) {
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Constructors and destructors.
 
 ArchSpec::ArchSpec() {}
 
-ArchSpec::ArchSpec(const char *triple_cstr, Platform *platform) {
-  if (triple_cstr)
-    SetTriple(triple_cstr, platform);
-}
-
-ArchSpec::ArchSpec(llvm::StringRef triple_str, Platform *platform) {
-  SetTriple(triple_str, platform);
-}
-
 ArchSpec::ArchSpec(const char *triple_cstr) {
   if (triple_cstr)
     SetTriple(triple_cstr);
 }
 
 ArchSpec::ArchSpec(llvm::StringRef triple_str) { SetTriple(triple_str); }
 
 ArchSpec::ArchSpec(const llvm::Triple &triple) { SetTriple(triple); }
bool lldb_private::ParseMachCPUDashSubtypeTriple(llvm::StringRef triple_str,
   if (!vendor.empty() && !os.empty()) {
     arch.GetTriple().setVendorName(vendor);
     arch.GetTriple().setOSName(os);
   }
 
   return true;
 }
 
-bool ArchSpec::SetTriple(const char *triple_cstr) {
-  llvm::StringRef str(triple_cstr ? triple_cstr : "");
-  return SetTriple(str);
-}
-
-bool ArchSpec::SetTriple(const char *triple_cstr, Platform *platform) {
-  llvm::StringRef str(triple_cstr ? triple_cstr : "");
-  return SetTriple(str, platform);
-}
-
 bool ArchSpec::SetTriple(llvm::StringRef triple) {
   if (triple.empty()) {
     Clear();
     return false;
   }
 
   if (ParseMachCPUDashSubtypeTriple(triple, *this))
     return true;
 
   if (triple.startswith(LLDB_ARCH_DEFAULT)) {
     // Special case for the current host default architectures...
     if (triple.equals(LLDB_ARCH_DEFAULT_32BIT))
       *this = HostInfo::GetArchitecture(HostInfo::eArchKind32);
     else if (triple.equals(LLDB_ARCH_DEFAULT_64BIT))
       *this = HostInfo::GetArchitecture(HostInfo::eArchKind64);
     else if (triple.equals(LLDB_ARCH_DEFAULT))
       *this = HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
   } else {
     SetTriple(llvm::Triple(llvm::Triple::normalize(triple)));
   }
   return IsValid();
 }
 
-bool ArchSpec::SetTriple(llvm::StringRef triple, Platform *platform) {
-  if (triple.empty()) {
-    Clear();
-    return false;
-  }
-  if (ParseMachCPUDashSubtypeTriple(triple, *this))
-    return true;
-
-  if (triple.startswith(LLDB_ARCH_DEFAULT)) {
-    // Special case for the current host default architectures...
-    if (triple.equals(LLDB_ARCH_DEFAULT_32BIT))
-      *this = HostInfo::GetArchitecture(HostInfo::eArchKind32);
-    else if (triple.equals(LLDB_ARCH_DEFAULT_64BIT))
-      *this = HostInfo::GetArchitecture(HostInfo::eArchKind64);
-    else if (triple.equals(LLDB_ARCH_DEFAULT))
-      *this = HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
-    return IsValid();
-  }
-
-  ArchSpec raw_arch(triple);
-
-  llvm::Triple normalized_triple(llvm::Triple::normalize(triple));
-
-  const bool os_specified = !normalized_triple.getOSName().empty();
-  const bool vendor_specified = !normalized_triple.getVendorName().empty();
-  const bool env_specified = !normalized_triple.getEnvironmentName().empty();
-
-  if (os_specified || vendor_specified || env_specified) {
-    SetTriple(normalized_triple);
-    return IsValid();
-  }
-
-  // We got an arch only.  If there is no platform, fallback to the host system
-  // for defaults.
-  if (!platform) {
-    llvm::Triple host_triple(llvm::sys::getDefaultTargetTriple());
-    if (!vendor_specified)
-      normalized_triple.setVendor(host_triple.getVendor());
-    if (!vendor_specified)
-      normalized_triple.setOS(host_triple.getOS());
-    if (!env_specified && host_triple.getEnvironmentName().size())
-      normalized_triple.setEnvironment(host_triple.getEnvironment());
-    SetTriple(normalized_triple);
-    return IsValid();
-  }
-
-  // If we were given a platform, use the platform's system architecture. If
-  // this is not available (might not be connected) use the first supported
-  // architecture.
-  ArchSpec compatible_arch;
-  if (!platform->IsCompatibleArchitecture(raw_arch, false, &compatible_arch)) {
-    *this = raw_arch;
-    return IsValid();
-  }
-
-  if (compatible_arch.IsValid()) {
-    const llvm::Triple &compatible_triple = compatible_arch.GetTriple();
-    if (!vendor_specified)
-      normalized_triple.setVendor(compatible_triple.getVendor());
-    if (!os_specified)
-      normalized_triple.setOS(compatible_triple.getOS());
-    if (!env_specified && compatible_triple.hasEnvironment())
-      normalized_triple.setEnvironment(compatible_triple.getEnvironment());
-  }
-
-  SetTriple(normalized_triple);
-  return IsValid();
+bool ArchSpec::ContainsOnlyArch(const llvm::Triple &normalized_triple) {
+  return !normalized_triple.getArchName().empty() &&
+         normalized_triple.getOSName().empty() &&
+         normalized_triple.getVendorName().empty() &&
+         normalized_triple.getEnvironmentName().empty();
 }
 
 void ArchSpec::MergeFrom(const ArchSpec &other) {
   if (TripleVendorIsUnspecifiedUnknown() &&
       !other.TripleVendorIsUnspecifiedUnknown())
     GetTriple().setVendor(other.GetTriple().getVendor());
   if (TripleOSIsUnspecifiedUnknown() && !other.TripleOSIsUnspecifiedUnknown())
     GetTriple().setOS(other.GetTriple().getOS());

source/Host/common/HostInfoBase.cpp

#endif
   }
 
   if (!result)
     return false;
   file_spec = *result;
   return true;
 }
 
+ArchSpec HostInfoBase::GetAugmentedArchSpec(llvm::StringRef triple) {
+  if (triple.empty())
+    return ArchSpec();
+  llvm::Triple normalized_triple(llvm::Triple::normalize(triple));
+  if (!ArchSpec::ContainsOnlyArch(normalized_triple))
+    return ArchSpec(triple);
+
+  llvm::Triple host_triple(llvm::sys::getDefaultTargetTriple());
+
+  if (normalized_triple.getVendorName().empty())
+    normalized_triple.setVendor(host_triple.getVendor());
+  if (normalized_triple.getOSName().empty())
+    normalized_triple.setOS(host_triple.getOS());
+  if (normalized_triple.getEnvironmentName().empty())
+    normalized_triple.setEnvironment(host_triple.getEnvironment());
+  return ArchSpec(normalized_triple);
+}
+
 bool HostInfoBase::ComputeSharedLibraryDirectory(FileSpec &file_spec) {
   // To get paths related to LLDB we get the path to the executable that
   // contains this function. On MacOSX this will be "LLDB.framework/.../LLDB",
   // on linux this is assumed to be the "lldb" main executable. If LLDB on
   // linux is actually in a shared library (liblldb.so) then this function will
   // need to be modified to "do the right thing".
 
   FileSpec lldb_file_spec(

source/Interpreter/OptionGroupArchitecture.cpp

 //===-- OptionGroupArchitecture.cpp -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionGroupArchitecture.h"
-
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "lldb/Host/OptionParser.h"
+#include "lldb/Target/Platform.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 OptionGroupArchitecture::OptionGroupArchitecture() : m_arch_str() {}
 
 OptionGroupArchitecture::~OptionGroupArchitecture() {}
 
 static OptionDefinition g_option_table[] = {
     {LLDB_OPT_SET_1, false, "arch", 'a', OptionParser::eRequiredArgument,
      nullptr, nullptr, 0, eArgTypeArchitecture,
      "Specify the architecture for the target."},
 };
 
 llvm::ArrayRef<OptionDefinition> OptionGroupArchitecture::GetDefinitions() {
   return llvm::makeArrayRef(g_option_table);
 }
 
 bool OptionGroupArchitecture::GetArchitecture(Platform *platform,
                                               ArchSpec &arch) {
-  if (m_arch_str.empty())
-    arch.Clear();
-  else
-    arch.SetTriple(m_arch_str.c_str(), platform);
+  arch = Platform::GetAugmentedArchSpec(platform, m_arch_str);
   return arch.IsValid();
 }
 
 Status
 OptionGroupArchitecture::SetOptionValue(uint32_t option_idx,
                                         llvm::StringRef option_arg,
                                         ExecutionContext *execution_context) {
   Status error;

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

while (packet.GetNameColonValue(key, value)) {
         uint32_t gid = UINT32_MAX;
         if (value.getAsInteger(0, gid))
           return SendErrorResponse(2);
         match_info.GetProcessInfo().SetEffectiveGroupID(gid);
       } else if (key.equals("all_users")) {
         match_info.SetMatchAllUsers(
             Args::StringToBoolean(value, false, &success));
       } else if (key.equals("triple")) {
-        match_info.GetProcessInfo().GetArchitecture().SetTriple(
-            value.str().c_str(), NULL);
+        match_info.GetProcessInfo().GetArchitecture() =
+            HostInfo::GetAugmentedArchSpec(value);
       } else {
         success = false;
       }
 
       if (!success)
         return SendErrorResponse(2);
     }
   }

 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_QLaunchArch(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("QLaunchArch:"));
   const uint32_t bytes_left = packet.GetBytesLeft();
   if (bytes_left > 0) {
     const char *arch_triple = packet.Peek();
-    ArchSpec arch_spec(arch_triple, NULL);
-    m_process_launch_info.SetArchitecture(arch_spec);
+    m_process_launch_info.SetArchitecture(HostInfo::GetAugmentedArchSpec(arch_triple));
     return SendOKResponse();
   }
   return SendErrorResponse(13);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_A(StringExtractorGDBRemote &packet) {
   // The 'A' packet is the most over designed packet ever here with

source/Target/Platform.cpp

PlatformSP Platform::Create(const ArchSpec &arch, ArchSpec *platform_arch_ptr,
   } else
     error.SetErrorString("invalid platform name");
   if (platform_arch_ptr)
     platform_arch_ptr->Clear();
   platform_sp.reset();
   return platform_sp;
 }
 
+ArchSpec Platform::GetAugmentedArchSpec(Platform *platform, llvm::StringRef triple) {
+  if (platform)
+    return platform->GetAugmentedArchSpec(triple);
+  return HostInfo::GetAugmentedArchSpec(triple);
+}
+
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 Platform::Platform(bool is_host)
     : m_is_host(is_host), m_os_version_set_while_connected(false),
       m_system_arch_set_while_connected(false), m_sdk_sysroot(), m_sdk_build(),
       m_working_dir(), m_remote_url(), m_name(), m_major_os_version(UINT32_MAX),
       m_minor_os_version(UINT32_MAX), m_update_os_version(UINT32_MAX),
if (IsHost()) {
     if (fetch) {
       m_system_arch = GetRemoteSystemArchitecture();
       m_system_arch_set_while_connected = m_system_arch.IsValid();
     }
   }
   return m_system_arch;
 }
 
+ArchSpec Platform::GetAugmentedArchSpec(llvm::StringRef triple) {
+  if (triple.empty())
+    return ArchSpec();
+  llvm::Triple normalized_triple(llvm::Triple::normalize(triple));
+  if (!ArchSpec::ContainsOnlyArch(normalized_triple))
+    return ArchSpec(triple);
+
+  ArchSpec compatible_arch;
+  ArchSpec raw_arch(triple);
+  if (!IsCompatibleArchitecture(raw_arch, false, &compatible_arch))
+    return raw_arch;
+
+  if (!compatible_arch.IsValid())
+    return ArchSpec(normalized_triple);
+
+  const llvm::Triple &compatible_triple = compatible_arch.GetTriple();
+  if (normalized_triple.getVendorName().empty())
+    normalized_triple.setVendor(compatible_triple.getVendor());
+  if (normalized_triple.getOSName().empty())
+    normalized_triple.setOS(compatible_triple.getOS());
+  if (normalized_triple.getEnvironmentName().empty())
+    normalized_triple.setEnvironment(compatible_triple.getEnvironment());
+  return ArchSpec(normalized_triple);
+}
+
 Status Platform::ConnectRemote(Args &args) {
   Status error;
   if (IsHost())
     error.SetErrorStringWithFormat("The currently selected platform (%s) is "
                                    "the host platform and is always connected.",
                                    GetPluginName().GetCString());
   else
     error.SetErrorStringWithFormat(

source/Target/Process.cpp

case 't': // Open process in new terminal window
     launch_info.GetFlags().Set(eLaunchFlagLaunchInTTY);
     break;
 
   case 'a': {
     TargetSP target_sp =
         execution_context ? execution_context->GetTargetSP() : TargetSP();
     PlatformSP platform_sp =
         target_sp ? target_sp->GetPlatform() : PlatformSP();
-    if (!launch_info.GetArchitecture().SetTriple(option_arg, platform_sp.get()))
-      launch_info.GetArchitecture().SetTriple(option_arg);
+    launch_info.GetArchitecture() =
+        Platform::GetAugmentedArchSpec(platform_sp.get(), option_arg);
   } break;
 
   case 'A': // Disable ASLR.
   {
     bool success;
     const bool disable_aslr_arg =
         Args::StringToBoolean(option_arg, true, &success);
     if (success)

unittests/Host/CMakeLists.txt

 set (FILES
   FileSpecTest.cpp
   FileSystemTest.cpp
+  HostInfoTest.cpp
   HostTest.cpp
   MainLoopTest.cpp
   SocketAddressTest.cpp
   SocketTest.cpp
   SymbolsTest.cpp
   TaskPoolTest.cpp
 )
 

unittests/Host/HostInfoTest.cpp

+//===-- HostTest.cpp --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/HostInfo.h"
+#include "gtest/gtest.h"
+
+using namespace lldb_private;
+using namespace llvm;
+
+namespace {
+class HostInfoTest: public ::testing::Test {
+  public:
+    void SetUp() override { HostInfo::Initialize(); }
+    void TearDown() override { HostInfo::Terminate(); }
+};
+}
+
+TEST_F(HostInfoTest, GetAugmentedArchSpec) {
+  // Fully specified triple should not be changed.
+  ArchSpec spec = HostInfo::GetAugmentedArchSpec("x86_64-pc-linux-gnu");
+  EXPECT_EQ(spec.GetTriple().getTriple(), "x86_64-pc-linux-gnu");
+
+  // Same goes if we specify at least one of (os, vendor, env).
+  spec = HostInfo::GetAugmentedArchSpec("x86_64-pc");
+  EXPECT_EQ(spec.GetTriple().getTriple(), "x86_64-pc");
+
+  // But if we specify only an arch, we should fill in the rest from the host.
+  spec = HostInfo::GetAugmentedArchSpec("x86_64");
+  Triple triple(sys::getDefaultTargetTriple());
+  EXPECT_EQ(spec.GetTriple().getArch(), Triple::x86_64);
+  EXPECT_EQ(spec.GetTriple().getOS(), triple.getOS());
+  EXPECT_EQ(spec.GetTriple().getVendor(), triple.getVendor());
+  EXPECT_EQ(spec.GetTriple().getEnvironment(), triple.getEnvironment());
+}

unittests/UnwindAssembly/InstEmulation/TestArm64InstEmulation.cpp

 }
 
 void TestArm64InstEmulation::TearDownTestCase() {
   DisassemblerLLVMC::Terminate();
   EmulateInstructionARM64::Terminate();
 }
 
 TEST_F(TestArm64InstEmulation, TestSimpleDarwinFunction) {
-  ArchSpec arch("arm64-apple-ios10", nullptr);
+  ArchSpec arch("arm64-apple-ios10");
   UnwindAssemblyInstEmulation *engine =
       static_cast<UnwindAssemblyInstEmulation *>(
           UnwindAssemblyInstEmulation::CreateInstance(arch));
   ASSERT_NE(nullptr, engine);
 
   UnwindPlan::RowSP row_sp;
   AddressRange sample_range;
   UnwindPlan unwind_plan(eRegisterKindLLDB);
TEST_F(TestArm64InstEmulation, TestSimpleDarwinFunction) {
   row_sp = unwind_plan.GetRowForFunctionOffset(20);
   EXPECT_EQ(20ull, row_sp->GetOffset());
   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
 }
 
 TEST_F(TestArm64InstEmulation, TestMediumDarwinFunction) {
-  ArchSpec arch("arm64-apple-ios10", nullptr);
+  ArchSpec arch("arm64-apple-ios10");
   UnwindAssemblyInstEmulation *engine =
       static_cast<UnwindAssemblyInstEmulation *>(
           UnwindAssemblyInstEmulation::CreateInstance(arch));
   ASSERT_NE(nullptr, engine);
 
   UnwindPlan::RowSP row_sp;
   AddressRange sample_range;
   UnwindPlan unwind_plan(eRegisterKindLLDB);
TEST_F(TestArm64InstEmulation, TestMediumDarwinFunction) {
   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x21_arm64, regloc));
   EXPECT_TRUE(regloc.IsSame());
 
   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x22_arm64, regloc));
   EXPECT_TRUE(regloc.IsSame());
 }
 
 TEST_F(TestArm64InstEmulation, TestFramelessThreeEpilogueFunction) {
-  ArchSpec arch("arm64-apple-ios10", nullptr);
+  ArchSpec arch("arm64-apple-ios10");
   UnwindAssemblyInstEmulation *engine =
       static_cast<UnwindAssemblyInstEmulation *>(
           UnwindAssemblyInstEmulation::CreateInstance(arch));
   ASSERT_NE(nullptr, engine);
 
   UnwindPlan::RowSP row_sp;
   AddressRange sample_range;
   UnwindPlan unwind_plan(eRegisterKindLLDB);
TEST_F(TestArm64InstEmulation, TestFramelessThreeEpilogueFunction) {
 
   row_sp = unwind_plan.GetRowForFunctionOffset(60);
   EXPECT_TRUE(row_sp->GetCFAValue().GetRegisterNumber() == gpr_sp_arm64);
   EXPECT_TRUE(row_sp->GetCFAValue().IsRegisterPlusOffset() == true);
   EXPECT_EQ(0, row_sp->GetCFAValue().GetOffset());
 }
 
 TEST_F(TestArm64InstEmulation, TestRegisterSavedTwice) {
-  ArchSpec arch("arm64-apple-ios10", nullptr);
+  ArchSpec arch("arm64-apple-ios10");
   UnwindAssemblyInstEmulation *engine =
       static_cast<UnwindAssemblyInstEmulation *>(
           UnwindAssemblyInstEmulation::CreateInstance(arch));
   ASSERT_NE(nullptr, engine);
 
   UnwindPlan::RowSP row_sp;
   AddressRange sample_range;
   UnwindPlan unwind_plan(eRegisterKindLLDB);
TEST_F(TestArm64InstEmulation, TestRegisterSavedTwice) {
   EXPECT_EQ(16, row_sp->GetCFAValue().GetOffset());
 
   EXPECT_TRUE(row_sp->GetRegisterInfo(gpr_x20_arm64, regloc));
   EXPECT_TRUE(regloc.IsAtCFAPlusOffset());
   EXPECT_EQ(-32, regloc.GetOffset());
 }
 
 TEST_F(TestArm64InstEmulation, TestRegisterDoubleSpills) {
-  ArchSpec arch("arm64-apple-ios10", nullptr);
+  ArchSpec arch("arm64-apple-ios10");
   UnwindAssemblyInstEmulation *engine =
       static_cast<UnwindAssemblyInstEmulation *>(
           UnwindAssemblyInstEmulation::CreateInstance(arch));
   ASSERT_NE(nullptr, engine);
 
   UnwindPlan::RowSP row_sp;
   AddressRange sample_range;
   UnwindPlan unwind_plan(eRegisterKindLLDB);

unittests/UnwindAssembly/x86/Testx86AssemblyInspectionEngine.cpp

enum i386_regs {
   k_ebp = 5,
   k_esi = 6,
   k_edi = 7,
   k_eip = 8
 };
 
 std::unique_ptr<x86AssemblyInspectionEngine> Getx86_64Inspector() {
 
-  ArchSpec arch("x86_64-apple-macosx", nullptr);
+  ArchSpec arch("x86_64-apple-macosx");
   std::unique_ptr<x86AssemblyInspectionEngine> engine(
       new x86AssemblyInspectionEngine(arch));
 
   std::vector<x86AssemblyInspectionEngine::lldb_reg_info> lldb_regnums;
   int i = 0;
   for (const auto &name : x86_64_reg_names) {
     x86AssemblyInspectionEngine::lldb_reg_info ri;
     ri.name = name;
     ri.lldb_regnum = i++;
     lldb_regnums.push_back(ri);
   }
 
   engine->Initialize(lldb_regnums);
   return engine;
 }
 
 std::unique_ptr<x86AssemblyInspectionEngine> Geti386Inspector() {
 
-  ArchSpec arch("i386-apple-macosx", nullptr);
+  ArchSpec arch("i386-apple-macosx");
   std::unique_ptr<x86AssemblyInspectionEngine> engine(
       new x86AssemblyInspectionEngine(arch));
 
   std::vector<x86AssemblyInspectionEngine::lldb_reg_info> lldb_regnums;
   int i = 0;
   for (const auto &name : i386_reg_names) {
     x86AssemblyInspectionEngine::lldb_reg_info ri;
     ri.name = name;