[lldb] s/FileSpec::Equal/FileSpec::Match

[labath]

Summary

The FileSpec class is often used as a sort of a pattern -- one specifies
a bare file name to search, and we check if in matches the full file
name of an existing module (for example).

These comparisons used FileSpec::Equal, which had some support for it
(via the full=false argument), but it was not a good fit for this job.

For one, it did a symmetric comparison, which makes sense for a function
called "equal", but not for typical searches (when searching for
"/foo/bar.so", we don't want to find a module whose name is just
"bar.so"). This resulted in patterns like:

if (FileSpec::Equal(pattern, file, pattern.GetDirectory()))

which would request a "full" match only if the pattern really contained
a directory. This worked, but the intended behavior was very unobvious.

On top of that, a lot of the code wanted to handle the case of an
"empty" pattern, and treat it as matching everything. This resulted in
conditions like:

if (pattern && !FileSpec::Equal(pattern, file, pattern.GetDirectory())

which are nearly impossible to decipher.

This patch introduces a FileSpec::Match function, which does exactly
what most of FileSpec::Equal callers want, an asymmetric match between a
"pattern" FileSpec and a an actual FileSpec. Empty paterns match
everything, filename-only patterns match only the filename component.

I've tried to update all callers of FileSpec::Equal to use a simpler
interface. Those that hardcoded full=true have been changed to use
operator==. Those passing full=pattern.GetDirectory() have been changed
to use FileSpec::Match.

There was also a handful of places which hardcoded full=false. I've
changed these to use FileSpec::Match too. This is a slight change in
semantics, but it does not look like that was ever intended, and it was
more likely a result of a misunderstanding of the "proper" way to use
FileSpec::Equal.

[In an ideal world a "FileSpec" and a "FileSpec pattern" would be two
different types, but given how widespread FileSpec is, it is unlikely
we'll get there in one go. This at least provides a good starting point
by centralizing all matching behavior.]

[JDevlieghere]

LGTM assuming the answer to my inline comment is negative :-)

lldb/include/lldb/Utility/FileSpec.h

196

Why do we still need the Equal method? Are there cases where full is only decided at runtime? Would it be worth to update the call sites to use == or ::Match directly? I think having both Match and Equal with these semantics is confusing and will likely reintroduce the things you just cleaned up.

[clayborg]

lldb/include/lldb/Utility/FileSpec.h

196

I agree with JDev here.

202

Maybe rename to "Matches"?

[labath]

lldb/include/lldb/Utility/FileSpec.h

196

I also wanted to delete it completely, but then I ran into FileSpecList::FindFirstFile, which forwards the full parameter to this function. I believe the calls to *that* function all have "static" values of the full argument, but the way this argument is used in this function is so convoluted, I thought I'd be best to leave that for a separate patch. (I'm pretty sure the convolutedness is not intentional, but also a result of the misunderstanding of how FileSpec::Equal works, but that means that fixing *that* will not be NFC.

202

Match seems to be the prevalent choice in other match-like apis (re.match, pcre_match, etc.).

[JDevlieghere]

Okay, sound sensible. LGTM!

[clayborg]

lgtm

lldb/include/lldb/Core/ModuleSpec.h

public:
   bool Matches(const ModuleSpec &match_module_spec,
                bool exact_arch_match) const {
     if (match_module_spec.GetUUIDPtr() &&
         match_module_spec.GetUUID() != GetUUID())
       return false;
     if (match_module_spec.GetObjectName() &&
         match_module_spec.GetObjectName() != GetObjectName())
       return false;
-    if (match_module_spec.GetFileSpecPtr()) {
-      const FileSpec &fspec = match_module_spec.GetFileSpec();
-      if (!FileSpec::Equal(fspec, GetFileSpec(),
-                           !fspec.GetDirectory().IsEmpty()))
-        return false;
-    }
-    if (GetPlatformFileSpec() && match_module_spec.GetPlatformFileSpecPtr()) {
-      const FileSpec &fspec = match_module_spec.GetPlatformFileSpec();
-      if (!FileSpec::Equal(fspec, GetPlatformFileSpec(),
-                           !fspec.GetDirectory().IsEmpty()))
-        return false;
+    if (!FileSpec::Match(match_module_spec.GetFileSpec(), GetFileSpec()))
+    if (GetPlatformFileSpec() &&
+        !FileSpec::Match(match_module_spec.GetPlatformFileSpec(),
+                         GetPlatformFileSpec())) {
     }
     // Only match the symbol file spec if there is one in this ModuleSpec
-    if (GetSymbolFileSpec() && match_module_spec.GetSymbolFileSpecPtr()) {
-      const FileSpec &fspec = match_module_spec.GetSymbolFileSpec();
-      if (!FileSpec::Equal(fspec, GetSymbolFileSpec(),
-                           !fspec.GetDirectory().IsEmpty()))
-        return false;
+    if (GetSymbolFileSpec() &&
+        !FileSpec::Match(match_module_spec.GetSymbolFileSpec(),
+                         GetSymbolFileSpec())) {
     }
     if (match_module_spec.GetArchitecturePtr()) {
       if (exact_arch_match) {
         if (!GetArchitecture().IsExactMatch(
                 match_module_spec.GetArchitecture()))
           return false;
       } else {
         if (!GetArchitecture().IsCompatibleMatch(

lldb/include/lldb/Core/SourceManager.h

void FindLinesMatchingRegex(RegularExpression &regex, uint32_t start_line,
                                 std::vector<uint32_t> &match_lines);
 
     bool GetLine(uint32_t line_no, std::string &buffer);
 
     uint32_t GetLineOffset(uint32_t line);
 
     bool LineIsValid(uint32_t line);
 
-    bool FileSpecMatches(const FileSpec &file_spec);
-
     const FileSpec &GetFileSpec() { return m_file_spec; }
 
     uint32_t GetSourceMapModificationID() const { return m_source_map_mod_id; }
 
     const char *PeekLineData(uint32_t line);
 
     uint32_t GetLineLength(uint32_t line, bool include_newline_chars);
 

lldb/include/lldb/Utility/FileSpec.h

public:
   ///     and either directory from \a lhs or \a rhs is empty, then
   ///     only the filename will be compared, else a full comparison
   ///     is done.
   ///
   /// \return -1 if \a lhs is less than \a rhs, 0 if \a lhs is equal to \a rhs,
   ///     1 if \a lhs is greater than \a rhs
   static int Compare(const FileSpec &lhs, const FileSpec &rhs, bool full);
 
   static bool Equal(const FileSpec &a, const FileSpec &b, bool full);
 
+  /// Match FileSpec \a pattern against FileSpec \a file. If \a pattern has a
+  /// directory component, then the \a file must have the same directory
+  /// component. Otherwise, just it matches just the filename. An empty \a
+  /// pattern matches everything.
+  static bool Match(const FileSpec &pattern, const FileSpec &file);
+
   /// Attempt to guess path style for a given path string. It returns a style,
   /// if it was able to make a reasonable guess, or None if it wasn't. The guess
   /// will be correct if the input path was a valid absolute path on the system
   /// which produced it. On other paths the result of this function is
   /// unreliable (e.g. "c:\foo.txt" is a valid relative posix path).
   static llvm::Optional<Style> GuessPathStyle(llvm::StringRef absolute_path);
 
   /// Case sensitivity of path.

lldb/source/Breakpoint/Breakpoint.cpp

if (old_sc.comp_unit && new_sc.comp_unit &&
       }
     } else if (old_sc.symbol && new_sc.symbol &&
                (old_sc.symbol == new_sc.symbol)) {
       equivalent_scs = true;
     }
   } else {
     // Otherwise we will compare by name...
     if (old_sc.comp_unit && new_sc.comp_unit) {
-      if (FileSpec::Equal(old_sc.comp_unit->GetPrimaryFile(),
-                          new_sc.comp_unit->GetPrimaryFile(), true)) {
+      if (old_sc.comp_unit->GetPrimaryFile() ==
+          new_sc.comp_unit->GetPrimaryFile()) {
         // Now check the functions:
         if (old_sc.function && new_sc.function &&
             (old_sc.function->GetName() == new_sc.function->GetName())) {
           equivalent_scs = true;
         }
       }
     } else if (old_sc.symbol && new_sc.symbol) {
       if (Mangled::Compare(old_sc.symbol->GetMangled(),

lldb/source/Commands/CommandObjectSource.cpp

uint32_t DumpLinesInSymbolContexts(Stream &strm,
                                      const ModuleList &module_list,
                                      const FileSpec &file_spec) {
     uint32_t start_line = m_options.start_line;
     uint32_t end_line = m_options.end_line;
     uint32_t num_lines = m_options.num_lines;
     Target *target = m_exe_ctx.GetTargetPtr();
 
     uint32_t num_matches = 0;
-    bool has_path = false;
-    if (file_spec) {
-      assert(file_spec.GetFilename().AsCString());
-      has_path = (file_spec.GetDirectory().AsCString() != nullptr);
-    }
-
     // Dump all the line entries for the file in the list.
     ConstString last_module_file_name;
     uint32_t num_scs = sc_list.GetSize();
     for (uint32_t i = 0; i < num_scs; ++i) {
       SymbolContext sc;
       sc_list.GetContextAtIndex(i, sc);
       if (sc.comp_unit) {
         Module *module = sc.module_sp.get();
         CompileUnit *cu = sc.comp_unit;
         const LineEntry &line_entry = sc.line_entry;
         assert(module && cu);
 
         // Are we looking for specific modules, files or lines?
         if (module_list.GetSize() &&
             module_list.GetIndexForModule(module) == LLDB_INVALID_INDEX32)
           continue;
-        if (file_spec && !lldb_private::FileSpec::Equal(
-                             file_spec, line_entry.file, has_path))
+        if (!FileSpec::Match(file_spec, line_entry.file))
           continue;
         if (start_line > 0 && line_entry.line < start_line)
           continue;
         if (end_line > 0 && line_entry.line > end_line)
           continue;
         if (num_lines > 0 && num_matches > num_lines)
           continue;
 
if (cu) {
 
           // Loop through to find any other entries for this line, dumping
           // each.
           line = line_entry.line;
           do {
             num_matches++;
             if (num_lines > 0 && num_matches > num_lines)
               break;
-            assert(lldb_private::FileSpec::Equal(cu_file_spec, line_entry.file,
-                                                 has_path));
+            assert(cu_file_spec == line_entry.file);
             if (!cu_header_printed) {
               if (num_matches > 0)
                 strm << "\n\n";
               strm << "Lines found for file " << file_spec_name
                    << " in compilation unit "
                    << cu->GetPrimaryFile().GetFilename() << " in `"
                    << module_file_name << "\n";
               cu_header_printed = true;

lldb/source/Core/IOHandler.cpp

if (update_location) {
         if (m_sc.line_entry.IsValid()) {
           m_pc_line = m_sc.line_entry.line;
           if (m_pc_line != UINT32_MAX)
             --m_pc_line; // Convert to zero based line number...
           // Update the selected line if the stop ID changed...
           if (context_changed)
             m_selected_line = m_pc_line;
 
-          if (m_file_sp && m_file_sp->FileSpecMatches(m_sc.line_entry.file)) {
+          if (m_file_sp && m_file_sp->GetFileSpec() == m_sc.line_entry.file) {
             // Same file, nothing to do, we should either have the lines or not
             // (source file missing)
             if (m_selected_line >= static_cast<size_t>(m_first_visible_line)) {
               if (m_selected_line >= m_first_visible_line + num_visible_lines)
                 m_first_visible_line = m_selected_line - 10;
             } else {
               if (m_selected_line > 10)
                 m_first_visible_line = m_selected_line - 10;

lldb/source/Core/Module.cpp

if (symbols)
     symbols->FindGlobalVariables(regex, max_matches, variables);
 }
 
 void Module::FindCompileUnits(const FileSpec &path,
                               SymbolContextList &sc_list) {
   const size_t num_compile_units = GetNumCompileUnits();
   SymbolContext sc;
   sc.module_sp = shared_from_this();
-  const bool compare_directory = (bool)path.GetDirectory();
   for (size_t i = 0; i < num_compile_units; ++i) {
     sc.comp_unit = GetCompileUnitAtIndex(i).get();
     if (sc.comp_unit) {
-      if (FileSpec::Equal(sc.comp_unit->GetPrimaryFile(), path,
-                          compare_directory))
+      if (FileSpec::Match(path, sc.comp_unit->GetPrimaryFile()))
         sc_list.Append(sc);
     }
   }
 }
 
 Module::LookupInfo::LookupInfo(ConstString name,
                                FunctionNameType name_type_mask,
                                LanguageType language)
bool Module::MatchesModuleSpec(const ModuleSpec &module_ref) {
   const UUID &uuid = module_ref.GetUUID();
 
   if (uuid.IsValid()) {
     // If the UUID matches, then nothing more needs to match...
     return (uuid == GetUUID());
   }
 
   const FileSpec &file_spec = module_ref.GetFileSpec();
-  if (file_spec) {
-    if (!FileSpec::Equal(file_spec, m_file, (bool)file_spec.GetDirectory()) &&
-        !FileSpec::Equal(file_spec, m_platform_file,
-                         (bool)file_spec.GetDirectory()))
-      return false;
-  }
+  if (!FileSpec::Match(file_spec, m_file) &&
+      !FileSpec::Match(file_spec, m_platform_file))
 
   const FileSpec &platform_file_spec = module_ref.GetPlatformFileSpec();
-  if (platform_file_spec) {
-    if (!FileSpec::Equal(platform_file_spec, GetPlatformFileSpec(),
-                         (bool)platform_file_spec.GetDirectory()))
-      return false;
-  }
+  if (!FileSpec::Match(platform_file_spec, GetPlatformFileSpec()))
 
   const ArchSpec &arch = module_ref.GetArchitecture();
   if (arch.IsValid()) {
     if (!m_arch.IsCompatibleMatch(arch))
       return false;
   }
 
   ConstString object_name = module_ref.GetObjectName();

lldb/source/Core/SearchFilter.cpp

 SearchFilterByModule::SearchFilterByModule(const lldb::TargetSP &target_sp,
                                            const FileSpec &module)
     : SearchFilter(target_sp, FilterTy::ByModule), m_module_spec(module) {}
 
 SearchFilterByModule::~SearchFilterByModule() = default;
 
 bool SearchFilterByModule::ModulePasses(const ModuleSP &module_sp) {
   return (module_sp &&
-          FileSpec::Equal(module_sp->GetFileSpec(), m_module_spec, false));
+          FileSpec::Match(m_module_spec, module_sp->GetFileSpec()));
 }
 
 bool SearchFilterByModule::ModulePasses(const FileSpec &spec) {
-  // Do a full match only if "spec" has a directory
-  const bool full_match = (bool)spec.GetDirectory();
-  return FileSpec::Equal(spec, m_module_spec, full_match);
+  return FileSpec::Match(m_module_spec, spec);
 }
 
 bool SearchFilterByModule::AddressPasses(Address &address) {
   // FIXME: Not yet implemented
   return true;
 }
 
 bool SearchFilterByModule::CompUnitPasses(FileSpec &fileSpec) { return true; }
void SearchFilterByModule::Search(Searcher &searcher) {
   // find the ones that match the file name.
 
   const ModuleList &target_modules = m_target_sp->GetImages();
   std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
 
   const size_t num_modules = target_modules.GetSize();
   for (size_t i = 0; i < num_modules; i++) {
     Module *module = target_modules.GetModulePointerAtIndexUnlocked(i);
-    const bool full_match = (bool)m_module_spec.GetDirectory();
-    if (FileSpec::Equal(m_module_spec, module->GetFileSpec(), full_match)) {
+    if (FileSpec::Match(m_module_spec, module->GetFileSpec())) {
       SymbolContext matchingContext(m_target_sp, module->shared_from_this());
       Searcher::CallbackReturn shouldContinue;
 
       shouldContinue = DoModuleIteration(matchingContext, searcher);
       if (shouldContinue == Searcher::eCallbackReturnStop)
         return;
     }
   }

lldb/source/Core/SourceManager.cpp

SourceManager::SourceManager(const DebuggerSP &debugger_sp)
     : m_last_file_sp(), m_last_line(0), m_last_count(0), m_default_set(false),
       m_target_wp(), m_debugger_wp(debugger_sp) {}
 
 // Destructor
 SourceManager::~SourceManager() {}
 
 SourceManager::FileSP SourceManager::GetFile(const FileSpec &file_spec) {
   bool same_as_previous =
-      m_last_file_sp && m_last_file_sp->FileSpecMatches(file_spec);
+      m_last_file_sp &&
+      FileSpec::Match(file_spec, m_last_file_sp->GetFileSpec());
 
   DebuggerSP debugger_sp(m_debugger_wp.lock());
   FileSP file_sp;
   if (same_as_previous)
     file_sp = m_last_file_sp;
   else if (debugger_sp)
     file_sp = debugger_sp->GetSourceFileCache().FindSourceFile(file_spec);
 
for (uint32_t line_no = start_line; line_no < end_line; line_no++) {
     if (!GetLine(line_no, buffer))
       break;
     if (regex.Execute(buffer)) {
       match_lines.push_back(line_no);
     }
   }
 }
 
-bool SourceManager::File::FileSpecMatches(const FileSpec &file_spec) {
-  return FileSpec::Equal(m_file_spec, file_spec, false);
-}
-
 bool lldb_private::operator==(const SourceManager::File &lhs,
                               const SourceManager::File &rhs) {
   if (lhs.m_file_spec != rhs.m_file_spec)
     return false;
   return lhs.m_mod_time == rhs.m_mod_time;
 }
 
 bool SourceManager::File::CalculateLineOffsets(uint32_t line) {

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 
 lldb_private::Status
 PlatformPOSIX::PutFile(const lldb_private::FileSpec &source,
                        const lldb_private::FileSpec &destination, uint32_t uid,
                        uint32_t gid) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
 
   if (IsHost()) {
-    if (FileSpec::Equal(source, destination, true))
+    if (source == destination)
       return Status();
     // cp src dst
     // chown uid:gid dst
     std::string src_path(source.GetPath());
     if (src_path.empty())
       return Status("unable to get file path for source");
     std::string dst_path(destination.GetPath());
     if (dst_path.empty())
lldb_private::Status PlatformPOSIX::GetFile(
   // Check the args, first.
   std::string src_path(source.GetPath());
   if (src_path.empty())
     return Status("unable to get file path for source");
   std::string dst_path(destination.GetPath());
   if (dst_path.empty())
     return Status("unable to get file path for destination");
   if (IsHost()) {
-    if (FileSpec::Equal(source, destination, true))
+    if (source == destination)
       return Status("local scenario->source and destination are the same file "
                     "path: no operation performed");
     // cp src dst
     StreamString cp_command;
     cp_command.Printf("cp %s %s", src_path.c_str(), dst_path.c_str());
     int status;
     RunShellCommand(cp_command.GetData(), nullptr, &status, nullptr, nullptr,
                     std::chrono::seconds(10));

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

uint32_t SymbolFileDWARF::ResolveSymbolContext(const FileSpec &file_spec,
   const uint32_t prev_size = sc_list.GetSize();
   if (resolve_scope & eSymbolContextCompUnit) {
     for (uint32_t cu_idx = 0, num_cus = GetNumCompileUnits(); cu_idx < num_cus;
          ++cu_idx) {
       CompileUnit *dc_cu = ParseCompileUnitAtIndex(cu_idx).get();
       if (!dc_cu)
         continue;
 
-      const bool full_match = (bool)file_spec.GetDirectory();
       bool file_spec_matches_cu_file_spec =
-          FileSpec::Equal(file_spec, dc_cu->GetPrimaryFile(), full_match);
+          FileSpec::Match(file_spec, dc_cu->GetPrimaryFile());
       if (check_inlines || file_spec_matches_cu_file_spec) {
         SymbolContext sc(m_objfile_sp->GetModule());
         sc.comp_unit = dc_cu;
         uint32_t file_idx = UINT32_MAX;
 
         // If we are looking for inline functions only and we don't find it
         // in the support files, we are done.
         if (check_inlines) {

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

uint32_t SymbolFileDWARFDebugMap::ResolveSymbolContext(
 
   for (uint32_t i = 0; i < cu_count; ++i) {
     // 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) {
       FileSpec so_file_spec;
-      if (GetFileSpecForSO(i, so_file_spec)) {
-        // Match the full path if the incoming file_spec has a directory (not
-        // just a basename)
-        const bool full_match = (bool)file_spec.GetDirectory();
-        resolve = FileSpec::Equal(file_spec, so_file_spec, full_match);
-      }
+      if (GetFileSpecForSO(i, so_file_spec))
+        resolve = FileSpec::Match(file_spec, so_file_spec);
     }
     if (resolve) {
       SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(i);
       if (oso_dwarf)
         oso_dwarf->ResolveSymbolContext(file_spec, line, check_inlines,
                                         resolve_scope, sc_list);
     }
   }

lldb/source/Symbol/CompileUnit.cpp

void CompileUnit::ResolveSymbolContext(const FileSpec &file_spec,
                                        uint32_t line, bool check_inlines,
                                        bool exact,
                                        SymbolContextItem resolve_scope,
                                        SymbolContextList &sc_list) {
   // First find all of the file indexes that match our "file_spec". If
   // "file_spec" has an empty directory, then only compare the basenames when
   // finding file indexes
   std::vector<uint32_t> file_indexes;
-  const bool full_match = (bool)file_spec.GetDirectory();
   bool file_spec_matches_cu_file_spec =
-      FileSpec::Equal(file_spec, this->GetPrimaryFile(), full_match);
+      FileSpec::Match(file_spec, this->GetPrimaryFile());
 
   // If we are not looking for inlined functions and our file spec doesn't
   // match then we are done...
   if (!file_spec_matches_cu_file_spec && !check_inlines)
     return;
 
   uint32_t file_idx =
       GetSupportFiles().FindFileIndex(1, file_spec, true);

lldb/source/Symbol/Declaration.cpp

 
 bool Declaration::FileAndLineEqual(const Declaration &declaration) const {
   int file_compare = FileSpec::Compare(this->m_file, declaration.m_file, true);
   return file_compare == 0 && this->m_line == declaration.m_line;
 }
 
 bool lldb_private::operator==(const Declaration &lhs, const Declaration &rhs) {
 #ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-  if (lhs.GetColumn() == rhs.GetColumn())
-    if (lhs.GetLine() == rhs.GetLine())
-      return lhs.GetFile() == rhs.GetFile();
+  if (lhs.GetColumn() != rhs.GetColumn())
+    return false;
 #else
-  if (lhs.GetLine() == rhs.GetLine())
-    return FileSpec::Equal(lhs.GetFile(), rhs.GetFile(), true);
+  return lhs.GetLine() == rhs.GetLine() && lhs.GetFile() == rhs.GetFile();
 #endif
-  return false;
 }

lldb/source/Symbol/SymbolContext.cpp

bool SymbolContextSpecifier::SymbolContextMatches(SymbolContext &sc) {
 
   if (m_type & eModuleSpecified) {
     if (sc.module_sp) {
       if (m_module_sp.get() != nullptr) {
         if (m_module_sp.get() != sc.module_sp.get())
           return false;
       } else {
         FileSpec module_file_spec(m_module_spec);
-        if (!FileSpec::Equal(module_file_spec, sc.module_sp->GetFileSpec(),
-                             false))
+        if (!FileSpec::Match(module_file_spec, sc.module_sp->GetFileSpec()))
           return false;
       }
     }
   }
   if (m_type & eFileSpecified) {
     if (m_file_spec_up) {
       // If we don't have a block or a comp_unit, then we aren't going to match
       // a source file.
       if (sc.block == nullptr && sc.comp_unit == nullptr)
         return false;
 
       // Check if the block is present, and if so is it inlined:
       bool was_inlined = false;
       if (sc.block != nullptr) {
         const InlineFunctionInfo *inline_info =
             sc.block->GetInlinedFunctionInfo();
         if (inline_info != nullptr) {
           was_inlined = true;
-          if (!FileSpec::Equal(inline_info->GetDeclaration().GetFile(),
-                               *(m_file_spec_up.get()), false))
+          if (!FileSpec::Match(*m_file_spec_up,
+                               inline_info->GetDeclaration().GetFile()))
             return false;
         }
       }
 
       // Next check the comp unit, but only if the SymbolContext was not
       // inlined.
       if (!was_inlined && sc.comp_unit != nullptr) {
-        if (!FileSpec::Equal(sc.comp_unit->GetPrimaryFile(), *m_file_spec_up,
-                             false))
+        if (!FileSpec::Match(*m_file_spec_up, sc.comp_unit->GetPrimaryFile()))
           return false;
       }
     }
   }
   if (m_type & eLineStartSpecified || m_type & eLineEndSpecified) {
     if (sc.line_entry.line < m_start_line || sc.line_entry.line > m_end_line)
       return false;
   }

lldb/source/Target/TargetList.cpp

bool TargetList::DeleteTarget(TargetSP &target_sp) {
   }
   return false;
 }
 
 TargetSP TargetList::FindTargetWithExecutableAndArchitecture(
     const FileSpec &exe_file_spec, const ArchSpec *exe_arch_ptr) const {
   std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
   TargetSP target_sp;
-  bool full_match = (bool)exe_file_spec.GetDirectory();
-
   collection::const_iterator pos, end = m_target_list.end();
   for (pos = m_target_list.begin(); pos != end; ++pos) {
     Module *exe_module = (*pos)->GetExecutableModulePointer();
 
     if (exe_module) {
-      if (FileSpec::Equal(exe_file_spec, exe_module->GetFileSpec(),
-                          full_match)) {
+      if (FileSpec::Match(exe_file_spec, exe_module->GetFileSpec())) {
         if (exe_arch_ptr) {
           if (!exe_arch_ptr->IsCompatibleMatch(exe_module->GetArchitecture()))
             continue;
         }
         target_sp = *pos;
         break;
       }
     }

lldb/source/Target/ThreadPlanStepInRange.cpp

bool ThreadPlanStepInRange::FrameMatchesAvoidCriteria() {
   size_t num_libraries = libraries_to_avoid.GetSize();
   if (num_libraries > 0) {
     SymbolContext sc(frame->GetSymbolContext(eSymbolContextModule));
     FileSpec frame_library(sc.module_sp->GetFileSpec());
 
     if (frame_library) {
       for (size_t i = 0; i < num_libraries; i++) {
         const FileSpec &file_spec(libraries_to_avoid.GetFileSpecAtIndex(i));
-        if (FileSpec::Equal(file_spec, frame_library, false)) {
+        if (FileSpec::Match(file_spec, frame_library)) {
           libraries_say_avoid = true;
           break;
         }
       }
     }
   }
   if (libraries_say_avoid)
     return true;

lldb/source/Utility/FileSpec.cpp

 
 bool FileSpec::Equal(const FileSpec &a, const FileSpec &b, bool full) {
   if (full || (a.GetDirectory() && b.GetDirectory()))
     return a == b;
 
   return a.FileEquals(b);
 }
 
+bool FileSpec::Match(const FileSpec &pattern, const FileSpec &file) {
+  if (pattern.GetDirectory())
+    return pattern == file;
+  if (pattern.GetFilename())
+    return pattern.FileEquals(file);
+  return true;
+}
+
 llvm::Optional<FileSpec::Style> FileSpec::GuessPathStyle(llvm::StringRef absolute_path) {
   if (absolute_path.startswith("/"))
     return Style::posix;
   if (absolute_path.startswith(R"(\\)"))
     return Style::windows;
   if (absolute_path.size() > 3 && llvm::isAlpha(absolute_path[0]) &&
       absolute_path.substr(1, 2) == R"(:\)")
     return Style::windows;

lldb/unittests/Utility/FileSpecTest.cpp

TEST(FileSpecTest, Equal) {
   EXPECT_FALSE(Eq("/bar/foo", "/baz/foo", false));
 
   EXPECT_FALSE(Eq("/bar/foo", "foo", true));
   EXPECT_TRUE(Eq("/bar/foo", "foo", false));
 
   EXPECT_FALSE(Eq("foo", "/bar/foo", true));
   EXPECT_TRUE(Eq("foo", "/bar/foo", false));
 }
+
+TEST(FileSpecTest, Match) {
+  auto Match = [](const char *pattern, const char *file) {
+    return FileSpec::Match(PosixSpec(pattern), PosixSpec(file));
+  };
+  EXPECT_TRUE(Match("/foo/bar", "/foo/bar"));
+  EXPECT_FALSE(Match("/foo/bar", "/oof/bar"));
+  EXPECT_FALSE(Match("/foo/bar", "/foo/baz"));
+  EXPECT_FALSE(Match("/foo/bar", "bar"));
+  EXPECT_FALSE(Match("/foo/bar", ""));
+
+  EXPECT_TRUE(Match("bar", "/foo/bar"));
+  EXPECT_FALSE(Match("bar", "/foo/baz"));
+  EXPECT_TRUE(Match("bar", "bar"));
+  EXPECT_FALSE(Match("bar", "baz"));
+  EXPECT_FALSE(Match("bar", ""));
+
+  EXPECT_TRUE(Match("", "/foo/bar"));
+  EXPECT_TRUE(Match("", ""));
+
+}