Replace getcwd with the llvm equivalent

[labath]

Summary

getcwd() is not available (well.. um.. deprecated?) on windows, and the way
PosixApi.h is providing it causes strange compile errors when it's included in
the wrong order. The best way to avoid that is to just not use chdir.

This replaces all uses of getcwd in generic code. There are still a couple of
more uses, but these are in platform-specific code.

chdir() is causing a similar problem, but for that there is no llvm equivalent
for that (yet).

[labath]

Any objections to this, Zach?

lldb/trunk/include/lldb/Host/windows/PosixApi.h

 
 // Various useful posix functions that are not present in Windows.  We provide
 // custom implementations.
 int vasprintf(char **ret, const char *fmt, va_list ap);
 char *strcasestr(const char *s, const char *find);
 char *realpath(const char *name, char *resolved);
 
 int usleep(uint32_t useconds);
-char *getcwd(char *path, int max);
 int chdir(const char *path);
 char *basename(char *path);
 char *dirname(char *path);
 
 int strcasecmp(const char *s1, const char *s2);
 int strncasecmp(const char *s1, const char *s2, size_t n);
 
 // empty functions

lldb/trunk/source/Host/windows/Windows.cpp

 #include <cerrno>
 #include <ctype.h>
 #include <io.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-// These prototypes are defined in <direct.h>, but it also defines chdir() and
-// getcwd(), giving multiply defined errors
+// These prototypes are defined in <direct.h>, but it also defines chdir(),
+// giving multiply defined errors
 extern "C" {
-char *_getcwd(char *buffer, int maxlen);
 int _chdir(const char *path);
 }
 
 namespace {
 bool utf8ToWide(const char *utf8, wchar_t *buf, size_t bufSize) {
   const llvm::UTF8 *sourceStart = reinterpret_cast<const llvm::UTF8 *>(utf8);
   size_t sourceLen = strlen(utf8) + 1 /* convert null too */;
   llvm::UTF16 *target = reinterpret_cast<llvm::UTF16 *>(buf);
char *basename(char *path) {
   char *l2 = strrchr(path, '/');
   if (l2 > l1)
     l1 = l2;
   if (!l1)
     return path; // no base name
   return &l1[1];
 }
 
-// use _getcwd() instead of GetCurrentDirectory() because it updates errno
-char *getcwd(char *path, int max) {
-  assert(path == NULL || max <= PATH_MAX);
-  wchar_t wpath[PATH_MAX];
-  if (wchar_t *wresult = _wgetcwd(wpath, PATH_MAX)) {
-    // Caller is allowed to pass in NULL for `path`.
-    // In that case, we're supposed to allocate a
-    // buffer on the caller's behalf.
-    if (path == NULL) {
-      max = UNI_MAX_UTF8_BYTES_PER_CODE_POINT * wcslen(wresult) + 1;
-      path = (char *)malloc(max);
-      if (path == NULL) {
-        errno = ENOMEM;
-        return NULL;
-      }
-    }
-    if (wideToUtf8(wresult, path, max))
-      return path;
-  }
-  return NULL;
-}
-
 // use _chdir() instead of SetCurrentDirectory() because it updates errno
 int chdir(const char *path) { return _chdir(path); }
 
 char *dirname(char *path) {
   char *l1 = strrchr(path, '\\');
   char *l2 = strrchr(path, '/');
   if (l2 > l1)
     l1 = l2;

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

 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerPlatform::Handle_qGetWorkingDir(
     StringExtractorGDBRemote &packet) {
   // If this packet is sent to a platform, then change the current working
   // directory
 
-  char cwd[PATH_MAX];
-  if (getcwd(cwd, sizeof(cwd)) == NULL)
-    return SendErrorResponse(errno);
+  llvm::SmallString<64> cwd;
+  if (std::error_code ec = llvm::sys::fs::current_path(cwd))
+    return SendErrorResponse(ec.value());
 
   StreamString response;
-  response.PutBytesAsRawHex8(cwd, strlen(cwd));
+  response.PutBytesAsRawHex8(cwd.data(), cwd.size());
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerPlatform::Handle_QSetWorkingDir(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("QSetWorkingDir:"));
   std::string path;

lldb/trunk/source/Target/Platform.cpp

std::vector<std::string> default_compilation_options = {
       "-x", "c++", "-Xclang", "-nostdsysteminc", "-Xclang", "-nostdsysteminc"};
 
   options.insert(options.end(), default_compilation_options.begin(),
                  default_compilation_options.end());
 }
 
 FileSpec Platform::GetWorkingDirectory() {
   if (IsHost()) {
-    char cwd[PATH_MAX];
-    if (getcwd(cwd, sizeof(cwd)))
-      return FileSpec{cwd, true};
-    else
+    llvm::SmallString<64> cwd;
+    if (llvm::sys::fs::current_path(cwd))
       return FileSpec{};
+    else
+      return FileSpec(cwd, true);
   } else {
     if (!m_working_dir)
       m_working_dir = GetRemoteWorkingDirectory();
     return m_working_dir;
   }
 }
 
 struct RecurseCopyBaton {

lldb/trunk/source/Target/ProcessLaunchInfo.cpp

 #include "lldb/Host/Config.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/Target.h"
 
 #include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/FileSystem.h"
 
 #if !defined(_WIN32)
 #include <limits.h>
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
if (m_shell) {
           // Be sure to put quotes around PATH's value in case any paths have
           // spaces...
           std::string new_path("PATH=\"");
           const size_t empty_path_len = new_path.size();
 
           if (working_dir) {
             new_path += working_dir.GetPath();
           } else {
-            char current_working_dir[PATH_MAX];
-            const char *cwd =
-                getcwd(current_working_dir, sizeof(current_working_dir));
-            if (cwd && cwd[0])
+            llvm::SmallString<64> cwd;
+            if (! llvm::sys::fs::current_path(cwd))
               new_path += cwd;
           }
           std::string curr_path;
           if (HostInfo::GetEnvironmentVar("PATH", curr_path)) {
             if (new_path.size() > empty_path_len)
               new_path += ':';
             new_path += curr_path;
           }

lldb/trunk/source/Target/TargetList.cpp

 //===-- TargetList.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-#include "llvm/ADT/SmallString.h"
-
 // Project includes
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/TargetList.h"
 
+// Other libraries and framework includes
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/FileSystem.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 ConstString &TargetList::GetStaticBroadcasterClass() {
   static ConstString class_name("lldb.targetList");
   return class_name;
 }
 
Error TargetList::CreateTargetInternal(Debugger &debugger,
   resolved_bundle_exe_path[0] = '\0';
   if (file) {
     if (file.GetFileType() == FileSpec::eFileTypeDirectory)
       user_exe_path_is_bundle = true;
 
     if (file.IsRelative() && !user_exe_path.empty()) {
       // Ignore paths that start with "./" and "../"
       if (!user_exe_path.startswith("./") && !user_exe_path.startswith("../")) {
-        char cwd[PATH_MAX];
-        if (getcwd(cwd, sizeof(cwd))) {
-          std::string cwd_user_exe_path(cwd);
-          cwd_user_exe_path += '/';
-          cwd_user_exe_path += user_exe_path;
-          FileSpec cwd_file(cwd_user_exe_path, false);
+        llvm::SmallString<64> cwd;
+        if (! llvm::sys::fs::current_path(cwd)) {
+          cwd += '/';
+          cwd += user_exe_path;
+          FileSpec cwd_file(cwd, false);
           if (cwd_file.Exists())
             file = cwd_file;
         }
       }
     }
 
     ModuleSP exe_module_sp;
     if (platform_sp) {