Fix main executable path name resolution on FreeBSD, patch by

[oota-llvm.git] / lib / System / Unix / Program.inc

diff --git a/lib/System/Unix/Program.inc b/lib/System/Unix/Program.inc
index 5961dae5ad0e379c9df8db2b2027022eff733259..2426900578b2696797f2f7923b86e8f6cd801bcb 100644 (file)
--- a/lib/System/Unix/Program.inc
+++ b/lib/System/Unix/Program.inc
@@ -2,8 +2,8 @@
 // 
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Reid Spencer and is distributed under the 
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 // 
 //===----------------------------------------------------------------------===//
 //
@@ -22,6 +22,9 @@
 #if HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
+#if HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
 #if HAVE_SIGNAL_H
 #include <signal.h>
 #endif
@@ -55,7 +58,7 @@ Program::FindProgramByName(const std::string& progName) {
     return Path();
 
   // Now we have a colon separated list of directories to search; try them.
-  unsigned PathLen = strlen(PathStr);
+  size_t PathLen = strlen(PathStr);
   while (PathLen) {
     // Find the first colon...
     const char *Colon = std::find(PathStr, PathStr+PathLen, ':');
@@ -81,8 +84,16 @@ Program::FindProgramByName(const std::string& progName) {
   return Path();
 }
 
-static bool RedirectFD(const std::string &File, int FD, std::string* ErrMsg) {
-  if (File.empty()) return false;  // Noop
+static bool RedirectIO(const Path *Path, int FD, std::string* ErrMsg) {
+  if (Path == 0)
+    // Noop
+    return false;
+  std::string File;
+  if (Path->isEmpty())
+    // Redirect empty paths to /dev/null
+    File = "/dev/null";
+  else
+    File = Path->toString();
 
   // Open the file
   int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
@@ -106,12 +117,38 @@ static void TimeOutHandler(int Sig) {
   Timeout = true;
 }
 
+static void SetMemoryLimits (unsigned size)
+{
+#if HAVE_SYS_RESOURCE_H
+  struct rlimit r;
+  __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur)) (size) * 1048576;
+
+  // Heap size
+  getrlimit (RLIMIT_DATA, &r);
+  r.rlim_cur = limit;
+  setrlimit (RLIMIT_DATA, &r);
+#ifdef RLIMIT_RSS
+  // Resident set size.
+  getrlimit (RLIMIT_RSS, &r);
+  r.rlim_cur = limit;
+  setrlimit (RLIMIT_RSS, &r);
+#endif
+#ifdef RLIMIT_AS  // e.g. NetBSD doesn't have it.
+  // Virtual memory.
+  getrlimit (RLIMIT_AS, &r);
+  r.rlim_cur = limit;
+  setrlimit (RLIMIT_AS, &r);
+#endif
+#endif
+}
+
 int 
 Program::ExecuteAndWait(const Path& path, 
                         const char** args,
                         const char** envp,
                         const Path** redirects,
                         unsigned secondsToWait,
+                        unsigned memoryLimit,
                         std::string* ErrMsg) 
 {
   if (!path.canExecute()) {
@@ -133,38 +170,34 @@ Program::ExecuteAndWait(const Path& path,
     case 0: {
       // Redirect file descriptors...
       if (redirects) {
-        if (redirects[0]) {
-          if (redirects[0]->isEmpty()) {
-            if (RedirectFD("/dev/null",0,ErrMsg)) { return -1; }
-          } else {
-            if (RedirectFD(redirects[0]->toString(), 0,ErrMsg)) { return -1; }
-          }
-        }
-        if (redirects[1]) {
-          if (redirects[1]->isEmpty()) {
-            if (RedirectFD("/dev/null",1,ErrMsg)) { return -1; }
-          } else {
-            if (RedirectFD(redirects[1]->toString(),1,ErrMsg)) { return -1; }
-          }
-        }
+        // Redirect stdin
+        if (RedirectIO(redirects[0], 0, ErrMsg)) { return -1; }
+        // Redirect stdout
+        if (RedirectIO(redirects[1], 1, ErrMsg)) { return -1; }
         if (redirects[1] && redirects[2] && 
-            *(redirects[1]) != *(redirects[2])) {
-          if (redirects[2]->isEmpty()) {
-            if (RedirectFD("/dev/null",2,ErrMsg)) { return -1; }
-          } else {
-            if (RedirectFD(redirects[2]->toString(), 2,ErrMsg)) { return -1; }
+            *(redirects[1]) == *(redirects[2])) {
+          // If stdout and stderr should go to the same place, redirect stderr
+          // to the FD already open for stdout.
+          if (-1 == dup2(1,2)) {
+            MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout");
+            return -1;
           }
-        } else if (-1 == dup2(1,2)) {
-          MakeErrMsg(ErrMsg, "Can't redirect");
-          return -1;
+        } else {
+          // Just redirect stderr
+          if (RedirectIO(redirects[2], 2, ErrMsg)) { return -1; }
         }
       }
 
+      // Set memory limits
+      if (memoryLimit!=0) {
+        SetMemoryLimits(memoryLimit);
+      }
+      
       // Execute!
       if (envp != 0)
-        execve (path.c_str(), (char** const)args, (char**)envp);
+        execve (path.c_str(), (char**)args, (char**)envp);
       else
-        execv (path.c_str(), (char** const)args);
+        execv (path.c_str(), (char**)args);
       // If the execve() failed, we should exit and let the parent pick up
       // our non-zero exit status.
       exit (errno);
@@ -208,9 +241,11 @@ Program::ExecuteAndWait(const Path& path,
       // Wait for child to die
       if (wait(&status) != child)
         MakeErrMsg(ErrMsg, "Child timed out but wouldn't die");
-        
+      else
+        MakeErrMsg(ErrMsg, "Child timed out", 0);
+
       return -1;   // Timeout detected
-    } else {
+    } else if (errno != EINTR) {
       MakeErrMsg(ErrMsg, "Error waiting for child process");
       return -1;
     }