Replace regex match with rfind (NFCish)

[aprantl]

Summary

This change is mostly performance-neutral since our regex engine is fast, but it's IMHO slightly more readable.
Also, matching matching parenthesis is not a great match for regular expressions.

[labath]

lldb/source/Symbol/ObjectFile.cpp

85–86

now that this is self-resizing, this can probably be something smaller (PATH_MAX on windows is 32k, sort of)..

577

.back() ?

lldb/include/lldb/Symbol/ObjectFile.h

public:
   ///     the name of the object inside the archive.
   ///
   /// \return
   ///     \b true if the path matches the pattern of archive + object
   ///     and \a archive_file and \a archive_object are modified,
   ///     \b false otherwise and \a archive_file and \a archive_object
   ///     are guaranteed to be remain unchanged.
   static bool SplitArchivePathWithObject(
-      const char *path_with_object, lldb_private::FileSpec &archive_file,
+      llvm::StringRef path_with_object, lldb_private::FileSpec &archive_file,
       lldb_private::ConstString &archive_object, bool must_exist);
 
   // LLVM RTTI support
   static char ID;
   virtual bool isA(const void *ClassID) const { return ClassID == &ID; }
 
   /// Gets the address size in bytes for the current object file.
   ///

lldb/source/Symbol/ObjectFile.cpp

 #include "lldb/Symbol/ObjectContainer.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
-#include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/lldb-private.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 char ObjectFile::ID;
 
if (file) {
           data_sp = FileSystem::Instance().CreateDataBuffer(file->GetPath(),
                                                             512, file_offset);
           data_offset = 0;
         }
       }
 
       if (!data_sp || data_sp->GetByteSize() == 0) {
         // Check for archive file with format "/path/to/archive.a(object.o)"
-        char path_with_object[PATH_MAX * 2];
-        module_sp->GetFileSpec().GetPath(path_with_object,
-                                         sizeof(path_with_object));
+        llvm::SmallString<256> path_with_object;
+        module_sp->GetFileSpec().GetPath(path_with_object);
 
         ConstString archive_object;
         const bool must_exist = true;
         if (ObjectFile::SplitArchivePathWithObject(
                 path_with_object, archive_file, archive_object, must_exist)) {
           file_size = FileSystem::Instance().GetByteSize(archive_file);
           if (file_size > 0) {
             file = &archive_file;
if (IsInMemory()) {
     if (!section->IsRelocated())
       RelocateSection(section);
 
     return GetData(section->GetFileOffset(), section->GetFileSize(),
                    section_data);
   }
 }
 
-bool ObjectFile::SplitArchivePathWithObject(const char *path_with_object,
+bool ObjectFile::SplitArchivePathWithObject(llvm::StringRef path_with_object,
                                             FileSpec &archive_file,
                                             ConstString &archive_object,
                                             bool must_exist) {
-  llvm::SmallVector<llvm::StringRef, 3> matches;
-  RegularExpression g_object_regex(llvm::StringRef("(.*)\\(([^\\)]+)\\)$"));
-  if (g_object_regex.Execute(llvm::StringRef::withNullAsEmpty(path_with_object),
-                             &matches)) {
-    std::string path = matches[1].str();
-    std::string obj = matches[2].str();
-    archive_file.SetFile(path, FileSpec::Style::native);
-    archive_object.SetCString(obj.c_str());
-    return !(must_exist && !FileSystem::Instance().Exists(archive_file));
-  }
+  size_t len = path_with_object.size();
+  if (len < 2 || path_with_object.back() != ')')
+    return false;
+  llvm::StringRef archive = path_with_object.substr(0, path_with_object.rfind('('));
+  if (archive.empty())
+    return false;
+  llvm::StringRef object = path_with_object.substr(archive.size() + 1).drop_back();
+  archive_file.SetFile(archive, FileSpec::Style::native);
+  if (must_exist && !FileSystem::Instance().Exists(archive_file))
     return false;
+  archive_object.SetString(object);
+  return true;
 }
 
 void ObjectFile::ClearSymtab() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
     LLDB_LOGF(log, "%p ObjectFile::ClearSymtab () symtab = %p",