Do not use PATH_MAX with SmallString

[stella.stamenova]

Summary

Instead use a more reasonable value to start and rely on the fact that SmallString will resize if necessary.

source/Commands/CommandCompletions.cpp

if (CompletionBuffer.startswith("~")) {
     size_t FirstSep =
         Buffer.find_if([](char c) { return path::is_separator(c); });
 
     llvm::StringRef Username = Buffer.take_front(FirstSep);
     llvm::StringRef Remainder;
     if (FirstSep != llvm::StringRef::npos)
       Remainder = Buffer.drop_front(FirstSep + 1);
 
-    llvm::SmallString<PATH_MAX> Resolved;
+    llvm::SmallString<256> Resolved;
     if (!Resolver.ResolveExact(Username, Resolved)) {
       // We couldn't resolve it as a full username.  If there were no slashes
       // then this might be a partial username.   We try to resolve it as such
       // but after that, we're done regardless of any matches.
       if (FirstSep == llvm::StringRef::npos) {
         llvm::StringSet<> MatchSet;
         Resolver.ResolvePartial(Username, MatchSet);
         for (const auto &S : MatchSet) {

source/Commands/CommandObjectPlatform.cpp

bool DoExecute(Args &args, CommandReturnObject &result) override {
 
     if (platform_sp) {
       Status error;
       const size_t argc = args.GetArgumentCount();
       Target *target = m_exe_ctx.GetTargetPtr();
       Module *exe_module = target->GetExecutableModulePointer();
       if (exe_module) {
         m_options.launch_info.GetExecutableFile() = exe_module->GetFileSpec();
-        llvm::SmallString<PATH_MAX> exe_path;
+        llvm::SmallString<128> exe_path;
         m_options.launch_info.GetExecutableFile().GetPath(exe_path);
         if (!exe_path.empty())
           m_options.launch_info.GetArguments().AppendArgument(exe_path);
         m_options.launch_info.GetArchitecture() = exe_module->GetArchitecture();
       }
 
       if (argc > 0) {
         if (m_options.launch_info.GetExecutableFile()) {

source/Host/common/Host.cpp

Status Host::RunShellCommand(const Args &args, const FileSpec &working_dir,
   } else {
     // No shell, just run it
     const bool first_arg_is_executable = true;
     launch_info.SetArguments(args, first_arg_is_executable);
   }
 
   if (working_dir)
     launch_info.SetWorkingDirectory(working_dir);
-  llvm::SmallString<PATH_MAX> output_file_path;
+  llvm::SmallString<64> output_file_path;
 
   if (command_output_ptr) {
     // Create a temporary file to get the stdout/stderr and redirect the output
     // of the command into this file. We will later read this file if all goes
     // well and fill the data into "command_output_ptr"
     if (FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir()) {
       tmpdir_file_spec.AppendPathComponent("lldb-shell-output.%%%%%%");
       llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath(),

source/Host/posix/PipePosix.cpp

if (::mkfifo(name.data(), 0660) != 0)
     error.SetErrorToErrno();
 
   return error;
 }
 
 Status PipePosix::CreateWithUniqueName(llvm::StringRef prefix,
                                        bool child_process_inherit,
                                        llvm::SmallVectorImpl<char> &name) {
-  llvm::SmallString<PATH_MAX> named_pipe_path;
-  llvm::SmallString<PATH_MAX> pipe_spec((prefix + ".%%%%%%").str());
+  llvm::SmallString<128> named_pipe_path;
+  llvm::SmallString<128> pipe_spec((prefix + ".%%%%%%").str());
   FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir();
   if (!tmpdir_file_spec)
     tmpdir_file_spec.AppendPathComponent("/tmp");
   tmpdir_file_spec.AppendPathComponent(pipe_spec);
 
   // It's possible that another process creates the target path after we've
   // verified it's available but before we create it, in which case we should
   // try again.

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

ClangExpressionParser::ParseInternal(DiagnosticManager &diagnostic_manager,
   bool should_create_file = completion_consumer != nullptr;
 
   // We also want a real file on disk if we generate full debug info.
   should_create_file |= m_compiler->getCodeGenOpts().getDebugInfo() ==
                         codegenoptions::FullDebugInfo;
 
   if (should_create_file) {
     int temp_fd = -1;
-    llvm::SmallString<PATH_MAX> result_path;
+    llvm::SmallString<128> result_path;
     if (FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir()) {
       tmpdir_file_spec.AppendPathComponent("lldb-%%%%%%.expr");
       std::string temp_source_path = tmpdir_file_spec.GetPath();
       llvm::sys::fs::createUniqueFile(temp_source_path, temp_fd, result_path);
     } else {
       llvm::sys::fs::createTemporaryFile("lldb", "expr", temp_fd, result_path);
     }
 

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

if (ec != std::error_code()) {
                     "import directory entry name: %s",
                     ec.message().c_str());
       continue;
     }
 
     // At this moment we only have the base name of the DLL. The full path can
     // only be seen after the dynamic loading.  Our best guess is Try to get it
     // with the help of the object file's directory.
-    llvm::SmallString<PATH_MAX> dll_fullpath;
+    llvm::SmallString<128> dll_fullpath;
     FileSpec dll_specs(dll_name);
     dll_specs.GetDirectory().SetString(m_file.GetDirectory().GetCString());
 
     if (!llvm::sys::fs::real_path(dll_specs.GetPath(), dll_fullpath))
       m_deps_filespec->Append(FileSpec(dll_fullpath));
     else {
       // Known DLLs or DLL not found in the object file directory.
       m_deps_filespec->Append(FileSpec(dll_name));

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

#endif
 
     // use native registers, not the GDB registers
     debugserver_args.AppendArgument(llvm::StringRef("--native-regs"));
 
     if (launch_info.GetLaunchInSeparateProcessGroup()) {
       debugserver_args.AppendArgument(llvm::StringRef("--setsid"));
     }
 
-    llvm::SmallString<PATH_MAX> named_pipe_path;
+    llvm::SmallString<128> named_pipe_path;
     // socket_pipe is used by debug server to communicate back either
     // TCP port or domain socket name which it listens on.
     // The second purpose of the pipe to serve as a synchronization point -
     // once data is written to the pipe, debug server is up and running.
     Pipe socket_pipe;
 
     // port is null when debug server should listen on domain socket - we're
     // not interested in port value but rather waiting for debug server to

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

else
       g_domainsocket_dir = HostInfo::GetProcessTempDir();
   });
 
   return g_domainsocket_dir;
 }
 
 FileSpec
 GDBRemoteCommunicationServerPlatform::GetDomainSocketPath(const char *prefix) {
-  llvm::SmallString<PATH_MAX> socket_path;
-  llvm::SmallString<PATH_MAX> socket_name(
+  llvm::SmallString<128> socket_path;
+  llvm::SmallString<128> socket_name(
       (llvm::StringRef(prefix) + ".%%%%%%").str());
 
   FileSpec socket_path_spec(GetDomainSocketDir());
   socket_path_spec.AppendPathComponent(socket_name.c_str());
 
   llvm::sys::fs::createUniqueFile(socket_path_spec.GetCString(), socket_path);
   return FileSpec(socket_path.c_str());
 }

source/Target/ProcessInfo.cpp

void ProcessInfo::Dump(Stream &s, Platform *platform) const {
   s.Format("Environment:\n{0}", m_environment);
 }
 
 void ProcessInfo::SetExecutableFile(const FileSpec &exe_file,
                                     bool add_exe_file_as_first_arg) {
   if (exe_file) {
     m_executable = exe_file;
     if (add_exe_file_as_first_arg) {
-      llvm::SmallString<PATH_MAX> filename;
+      llvm::SmallString<128> filename;
       exe_file.GetPath(filename);
       if (!filename.empty())
         m_arguments.InsertArgumentAtIndex(0, filename);
     }
   } else {
     m_executable.Clear();
   }
 }