[lldb] Create an enum to specify the kind of ArchSpec matching

[labath]

Summary

s/true/ArchSpec::ExactMatch
s/false/ArchSpec::CompatibleMatch

[jingham]

That is easier to read for sure.

[JDevlieghere]

Thanks! LGTM

lldb/include/lldb/Target/Platform.h

public:
 
   /// Kill process on a platform.
   virtual Status KillProcess(const lldb::pid_t pid);
 
   /// Lets a platform answer if it is compatible with a given architecture and
   /// the target triple contained within.
   virtual bool IsCompatibleArchitecture(const ArchSpec &arch,
                                         const ArchSpec &process_host_arch,
-                                        bool exact_arch_match,
+                                        ArchSpec::MatchType match,
                                         ArchSpec *compatible_arch_ptr);
 
   /// Not all platforms will support debugging a process by spawning somehow
   /// halted for a debugger (specified using the "eLaunchFlagDebug" launch
   /// flag) and then attaching. If your platform doesn't support this,
   /// override this function and return false.
   virtual bool CanDebugProcess() { return true; }
 

lldb/include/lldb/Utility/ArchSpec.h

public:
 
   /// Returns true if 'char' is a signed type by default in the architecture
   /// false otherwise
   ///
   /// \return True if 'char' is a signed type by default on the
   ///         architecture and false otherwise.
   bool CharIsSignedByDefault() const;
 
-  /// Compare an ArchSpec to another ArchSpec, requiring an exact cpu type
-  /// match between them. e.g. armv7s is not an exact match with armv7 - this
-  /// would return false
+  enum MatchType : bool { CompatibleMatch, ExactMatch };
+
+  /// Compare this ArchSpec to another ArchSpec. \a match specifies the kind of
+  /// matching that is to be done. CompatibleMatch requires only a compatible
+  /// cpu type (e.g., armv7s is compatible with armv7). ExactMatch requires an
+  /// exact match (armv7s is not an exact match with armv7).
   ///
   /// \return true if the two ArchSpecs match.
-  bool IsExactMatch(const ArchSpec &rhs) const;
+  bool IsMatch(const ArchSpec &rhs, MatchType match) const;
 
-  /// Compare an ArchSpec to another ArchSpec, requiring a compatible cpu type
-  /// match between them. e.g. armv7s is compatible with armv7 - this method
-  /// would return true
-  ///
-  /// \return true if the two ArchSpecs are compatible
-  bool IsCompatibleMatch(const ArchSpec &rhs) const;
+  /// Shorthand for IsMatch(rhs, ExactMatch).
+  bool IsExactMatch(const ArchSpec &rhs) const {
+    return IsMatch(rhs, ExactMatch);
+  }
+
+  /// Shorthand for IsMatch(rhs, CompatibleMatch).
+  bool IsCompatibleMatch(const ArchSpec &rhs) const {
+    return IsMatch(rhs, CompatibleMatch);
+  }
 
   bool IsFullySpecifiedTriple() const;
 
   void PiecewiseTripleCompare(const ArchSpec &other, bool &arch_different,
                               bool &vendor_different, bool &os_different,
                               bool &os_version_different,
                               bool &env_different) const;
 
public:
 
   uint32_t GetFlags() const { return m_flags; }
 
   void SetFlags(uint32_t flags) { m_flags = flags; }
 
   void SetFlags(const std::string &elf_abi);
 
 protected:
-  bool IsEqualTo(const ArchSpec &rhs, bool exact_match) const;
   void UpdateCore();
 
   llvm::Triple m_triple;
   Core m_core = kCore_invalid;
   lldb::ByteOrder m_byte_order = lldb::eByteOrderInvalid;
 
   // Additional arch flags which we cannot get from triple and core For MIPS
   // these are application specific extensions like micromips, mips16 etc.

lldb/source/Interpreter/OptionGroupPlatform.cpp

PlatformSP OptionGroupPlatform::CreatePlatformWithOptions(
   if (!m_platform_name.empty()) {
     platform_sp = platforms.Create(m_platform_name);
     if (!platform_sp) {
       error.SetErrorStringWithFormatv(
           "unable to find a plug-in for the platform named \"{0}\"",
           m_platform_name);
     }
     if (platform_sp) {
-      if (platform_arch.IsValid() && !platform_sp->IsCompatibleArchitecture(
-                                         arch, {}, false, &platform_arch)) {
+      if (platform_arch.IsValid() &&
+          !platform_sp->IsCompatibleArchitecture(
+              arch, {}, ArchSpec::CompatibleMatch, &platform_arch)) {
         error.SetErrorStringWithFormatv("platform '{0}' doesn't support '{1}'",
                                         platform_sp->GetPluginName(),
                                         arch.GetTriple().getTriple());
         platform_sp.reset();
         return platform_sp;
       }
     }
   } else if (arch.IsValid()) {

lldb/source/Target/Platform.cpp

ArchSpec Platform::GetAugmentedArchSpec(llvm::StringRef triple) {
   if (!ArchSpec::ContainsOnlyArch(normalized_triple))
     return ArchSpec(triple);
 
   if (auto kind = HostInfo::ParseArchitectureKind(triple))
     return HostInfo::GetArchitecture(*kind);
 
   ArchSpec compatible_arch;
   ArchSpec raw_arch(triple);
-  if (!IsCompatibleArchitecture(raw_arch, {}, false, &compatible_arch))
+  if (!IsCompatibleArchitecture(raw_arch, {}, ArchSpec::CompatibleMatch,
+                                &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());
Platform::CreateArchList(llvm::ArrayRef<llvm::Triple::ArchType> archs,
   }
   return list;
 }
 
 /// Lets a platform answer if it is compatible with a given
 /// architecture and the target triple contained within.
 bool Platform::IsCompatibleArchitecture(const ArchSpec &arch,
                                         const ArchSpec &process_host_arch,
-                                        bool exact_arch_match,
+                                        ArchSpec::MatchType match,
                                         ArchSpec *compatible_arch_ptr) {
   // If the architecture is invalid, we must answer true...
   if (arch.IsValid()) {
     ArchSpec platform_arch;
-    auto match = exact_arch_match ? &ArchSpec::IsExactMatch
-                                  : &ArchSpec::IsCompatibleMatch;
     for (const ArchSpec &platform_arch :
          GetSupportedArchitectures(process_host_arch)) {
-      if ((arch.*match)(platform_arch)) {
+      if (arch.IsMatch(platform_arch, match)) {
         if (compatible_arch_ptr)
           *compatible_arch_ptr = platform_arch;
         return true;
       }
     }
   }
   if (compatible_arch_ptr)
     compatible_arch_ptr->Clear();

 
 PlatformSP PlatformList::GetOrCreate(const ArchSpec &arch,
                                      const ArchSpec &process_host_arch,
                                      ArchSpec *platform_arch_ptr,
                                      Status &error) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   // First try exact arch matches across all platforms already created
   for (const auto &platform_sp : m_platforms) {
-    if (platform_sp->IsCompatibleArchitecture(arch, process_host_arch, true,
-                                              platform_arch_ptr))
+    if (platform_sp->IsCompatibleArchitecture(
+            arch, process_host_arch, ArchSpec::ExactMatch, platform_arch_ptr))
       return platform_sp;
   }
 
   // Next try compatible arch matches across all platforms already created
   for (const auto &platform_sp : m_platforms) {
-    if (platform_sp->IsCompatibleArchitecture(arch, process_host_arch, false,
+    if (platform_sp->IsCompatibleArchitecture(arch, process_host_arch,
+                                              ArchSpec::CompatibleMatch,
                                               platform_arch_ptr))
       return platform_sp;
   }
 
   PlatformCreateInstance create_callback;
   // First try exact arch matches across all platform plug-ins
   uint32_t idx;
   for (idx = 0;
        (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex(idx));
        ++idx) {
     PlatformSP platform_sp = create_callback(false, &arch);
-    if (platform_sp && platform_sp->IsCompatibleArchitecture(
-                           arch, process_host_arch, true, platform_arch_ptr)) {
+    if (platform_sp &&
+        platform_sp->IsCompatibleArchitecture(
+            arch, process_host_arch, ArchSpec::ExactMatch, platform_arch_ptr)) {
       m_platforms.push_back(platform_sp);
       return platform_sp;
     }
   }
   // Next try compatible arch matches across all platform plug-ins
   for (idx = 0;
        (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex(idx));
        ++idx) {
     PlatformSP platform_sp = create_callback(false, &arch);
     if (platform_sp && platform_sp->IsCompatibleArchitecture(
-                           arch, process_host_arch, false, platform_arch_ptr)) {
+                           arch, process_host_arch, ArchSpec::CompatibleMatch,
+                           platform_arch_ptr)) {
       m_platforms.push_back(platform_sp);
       return platform_sp;
     }
   }
   if (platform_arch_ptr)
     platform_arch_ptr->Clear();
   return nullptr;
 }
if (archs.empty())
     return nullptr;
 
   PlatformSP host_platform_sp = Platform::GetHostPlatform();
 
   // Prefer the selected platform if it matches at least one architecture.
   if (m_selected_platform_sp) {
     for (const ArchSpec &arch : archs) {
       if (m_selected_platform_sp->IsCompatibleArchitecture(
-              arch, process_host_arch, false, nullptr))
+              arch, process_host_arch, ArchSpec::CompatibleMatch, nullptr))
         return m_selected_platform_sp;
     }
   }
 
   // Prefer the host platform if it matches at least one architecture.
   if (host_platform_sp) {
     for (const ArchSpec &arch : archs) {
-      if (host_platform_sp->IsCompatibleArchitecture(arch, process_host_arch,
-                                                     false, nullptr))
+      if (host_platform_sp->IsCompatibleArchitecture(
+              arch, process_host_arch, ArchSpec::CompatibleMatch, nullptr))
         return host_platform_sp;
     }
   }
 
   // Collect a list of candidate platforms for the architectures.
   for (const ArchSpec &arch : archs) {
     if (PlatformSP platform = GetOrCreate(arch, process_host_arch, nullptr))
       candidates.push_back(platform);

lldb/source/Target/Process.cpp

void Process::CompleteAttach() {
   // We just attached.  If we have a platform, ask it for the process
   // architecture, and if it isn't the same as the one we've already set,
   // switch architectures.
   PlatformSP platform_sp(GetTarget().GetPlatform());
   assert(platform_sp);
   ArchSpec process_host_arch = GetSystemArchitecture();
   if (platform_sp) {
     const ArchSpec &target_arch = GetTarget().GetArchitecture();
-    if (target_arch.IsValid() &&
-        !platform_sp->IsCompatibleArchitecture(target_arch, process_host_arch,
-                                               false, nullptr)) {
+    if (target_arch.IsValid() && !platform_sp->IsCompatibleArchitecture(
+                                     target_arch, process_host_arch,
+                                     ArchSpec::CompatibleMatch, nullptr)) {
       ArchSpec platform_arch;
       platform_sp = GetTarget().GetDebugger().GetPlatformList().GetOrCreate(
           target_arch, process_host_arch, &platform_arch);
       if (platform_sp) {
         GetTarget().SetPlatform(platform_sp);
         GetTarget().SetArchitecture(platform_arch);
         LLDB_LOG(log,
                  "switching platform to {0} and architecture to {1} based on "

lldb/source/Target/Target.cpp

bool Target::SetArchitecture(const ArchSpec &arch_spec, bool set_platform) {
   ArchSpec other(arch_spec);
 
   // Changing the architecture might mean that the currently selected platform
   // isn't compatible. Set the platform correctly if we are asked to do so,
   // otherwise assume the user will set the platform manually.
   if (set_platform) {
     if (other.IsValid()) {
       auto platform_sp = GetPlatform();
-      if (!platform_sp ||
-          !platform_sp->IsCompatibleArchitecture(other, {}, false, nullptr)) {
+      if (!platform_sp || !platform_sp->IsCompatibleArchitecture(
+                              other, {}, ArchSpec::CompatibleMatch, nullptr)) {
         ArchSpec platform_arch;
         if (PlatformSP arch_platform_sp =
                 GetDebugger().GetPlatformList().GetOrCreate(other, {},
                                                             &platform_arch)) {
           SetPlatform(arch_platform_sp);
           if (platform_arch.IsValid())
             other = platform_arch;
         }

lldb/source/Target/TargetList.cpp

if (num_specs > 0) {
         }
       }
     }
   }
 
   // If we have a valid architecture, make sure the current platform is
   // compatible with that architecture.
   if (!prefer_platform_arch && arch.IsValid()) {
-    if (!platform_sp->IsCompatibleArchitecture(arch, {}, false, nullptr)) {
+    if (!platform_sp->IsCompatibleArchitecture(
+            arch, {}, ArchSpec::CompatibleMatch, nullptr)) {
       platform_sp = platform_list.GetOrCreate(arch, {}, &platform_arch);
       if (platform_sp)
         platform_list.SetSelectedPlatform(platform_sp);
     }
   } 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, nullptr)) {
+    if (!platform_sp->IsCompatibleArchitecture(
+            platform_arch, {}, ArchSpec::CompatibleMatch, nullptr)) {
       platform_sp =
           platform_list.GetOrCreate(platform_arch, {}, &fixed_platform_arch);
       if (platform_sp)
         platform_list.SetSelectedPlatform(platform_sp);
     }
   }
 
   if (!platform_arch.IsValid())
LLDB_SCOPED_TIMERF("TargetList::CreateTarget (file = '%s', arch = '%s')",
                      user_exe_path.str().c_str(),
                      specified_arch.GetArchitectureName());
   Status error;
   const bool is_dummy_target = false;
 
   ArchSpec arch(specified_arch);
 
   if (arch.IsValid()) {
-    if (!platform_sp ||
-        !platform_sp->IsCompatibleArchitecture(arch, {}, false, nullptr))
+    if (!platform_sp || !platform_sp->IsCompatibleArchitecture(
+                            arch, {}, ArchSpec::CompatibleMatch, nullptr))
       platform_sp =
           debugger.GetPlatformList().GetOrCreate(specified_arch, {}, &arch);
   }
 
   if (!platform_sp)
     platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
 
   if (!arch.IsValid())

lldb/source/Utility/ArchSpec.cpp

 
 uint32_t ArchSpec::GetMaximumOpcodeByteSize() const {
   const CoreDefinition *core_def = FindCoreDefinition(m_core);
   if (core_def)
     return core_def->max_opcode_byte_size;
   return 0;
 }
 
-bool ArchSpec::IsExactMatch(const ArchSpec &rhs) const {
-  return IsEqualTo(rhs, true);
-}
-
-bool ArchSpec::IsCompatibleMatch(const ArchSpec &rhs) const {
-  return IsEqualTo(rhs, false);
-}
-
 static bool IsCompatibleEnvironment(llvm::Triple::EnvironmentType lhs,
                                     llvm::Triple::EnvironmentType rhs) {
   if (lhs == rhs)
     return true;
 
   // Apple simulators are a different platform than what they simulate.
   // As the environments are different at this point, if one of them is a
   // simulator, then they are different.
if ((lhs == llvm::Triple::Android && rhs == llvm::Triple::EABI) ||
       (rhs == llvm::Triple::GNUEABI && lhs == llvm::Triple::EABI) ||
       (lhs == llvm::Triple::GNUEABIHF && rhs == llvm::Triple::EABIHF) ||
       (rhs == llvm::Triple::GNUEABIHF && lhs == llvm::Triple::EABIHF))
     return true;
 
   return false;
 }
 
-bool ArchSpec::IsEqualTo(const ArchSpec &rhs, bool exact_match) const {
+bool ArchSpec::IsMatch(const ArchSpec &rhs, MatchType match) const {
   // explicitly ignoring m_distribution_id in this method.
 
   if (GetByteOrder() != rhs.GetByteOrder() ||
-      !cores_match(GetCore(), rhs.GetCore(), true, exact_match))
+      !cores_match(GetCore(), rhs.GetCore(), true, match == ExactMatch))
     return false;
 
   const llvm::Triple &lhs_triple = GetTriple();
   const llvm::Triple &rhs_triple = rhs.GetTriple();
 
   const llvm::Triple::VendorType lhs_triple_vendor = lhs_triple.getVendor();
   const llvm::Triple::VendorType rhs_triple_vendor = rhs_triple.getVendor();
 
   const llvm::Triple::OSType lhs_triple_os = lhs_triple.getOS();
   const llvm::Triple::OSType rhs_triple_os = rhs_triple.getOS();
 
   bool both_windows = lhs_triple.isOSWindows() && rhs_triple.isOSWindows();
 
   // On Windows, the vendor field doesn't have any practical effect, but
   // it is often set to either "pc" or "w64".
   if ((lhs_triple_vendor != rhs_triple_vendor) &&
-      (exact_match || !both_windows)) {
+      (match == ExactMatch || !both_windows)) {
     const bool rhs_vendor_specified = rhs.TripleVendorWasSpecified();
     const bool lhs_vendor_specified = TripleVendorWasSpecified();
     // Both architectures had the vendor specified, so if they aren't equal
     // then we return false
     if (rhs_vendor_specified && lhs_vendor_specified)
       return false;
 
     // Only fail if both vendor types are not unknown
     if (lhs_triple_vendor != llvm::Triple::UnknownVendor &&
         rhs_triple_vendor != llvm::Triple::UnknownVendor)
       return false;
   }
 
   const llvm::Triple::EnvironmentType lhs_triple_env =
       lhs_triple.getEnvironment();
   const llvm::Triple::EnvironmentType rhs_triple_env =
       rhs_triple.getEnvironment();
 
-  if (!exact_match) {
+  if (match == CompatibleMatch) {
     // x86_64-apple-ios-macabi, x86_64-apple-macosx are compatible, no match.
     if ((lhs_triple_os == llvm::Triple::IOS &&
          lhs_triple_env == llvm::Triple::MacABI &&
          rhs_triple_os == llvm::Triple::MacOSX) ||
         (lhs_triple_os == llvm::Triple::MacOSX &&
          rhs_triple_os == llvm::Triple::IOS &&
          rhs_triple_env == llvm::Triple::MacABI))
       return true;
bool ArchSpec::IsMatch(const ArchSpec &rhs, MatchType match) const {
   if (lhs_triple_os != rhs_triple_os) {
     const bool lhs_os_specified = TripleOSWasSpecified();
     const bool rhs_os_specified = rhs.TripleOSWasSpecified();
     // If both OS types are specified and different, fail.
     if (lhs_os_specified && rhs_os_specified)
       return false;
 
     // If the pair of os+env is both unspecified, match any other os+env combo.
-    if (!exact_match && ((!lhs_os_specified && !lhs_triple.hasEnvironment()) ||
-                         (!rhs_os_specified && !rhs_triple.hasEnvironment())))
+    if (match == CompatibleMatch &&
+        ((!lhs_os_specified && !lhs_triple.hasEnvironment()) ||
       return true;
   }
 
-  if (!exact_match && both_windows)
+  if (match == CompatibleMatch && both_windows)
     return true; // The Windows environments (MSVC vs GNU) are compatible
 
   return IsCompatibleEnvironment(lhs_triple_env, rhs_triple_env);
 }
 
 void ArchSpec::UpdateCore() {
   llvm::StringRef arch_name(m_triple.getArchName());
   const CoreDefinition *core_def = FindCoreDefinition(arch_name);