For PR789:

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

diff --git a/lib/System/Unix/Program.inc b/lib/System/Unix/Program.inc
index 47810bdbeba72eba13eb0774000600eb385d36c1..77d74a18c67735b123078758a4f57b39e2cecadd 100644 (file)
--- a/lib/System/Unix/Program.inc
+++ b/lib/System/Unix/Program.inc
@@ -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
@@ -29,8 +32,6 @@
 #include <fcntl.h>
 #endif
 
-extern char** environ;
-
 namespace llvm {
 using namespace sys;
 
@@ -83,18 +84,24 @@ Program::FindProgramByName(const std::string& progName) {
   return Path();
 }
 
-static void RedirectFD(const std::string &File, int FD) {
-  if (File.empty()) return;  // Noop
+static bool RedirectFD(const std::string &File, int FD, std::string* ErrMsg) {
+  if (File.empty()) return false;  // Noop
 
   // Open the file
   int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
   if (InFD == -1) {
-    ThrowErrno("Cannot open file '" + File + "' for "
+    MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for "
               + (FD == 0 ? "input" : "output") + "!\n");
+    return true;
   }
 
-  dup2(InFD, FD);   // Install it as the requested FD
+  // Install it as the requested FD
+  if (-1 == dup2(InFD, FD)) {
+    MakeErrMsg(ErrMsg, "Cannot dup2");
+    return true;
+  }
   close(InFD);      // Close the original FD
+  return false;
 }
 
 static bool Timeout = false;
@@ -102,15 +109,41 @@ 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);
+  // Resident set size.
+  getrlimit (RLIMIT_RSS, &r);
+  r.rlim_cur = limit;
+  setrlimit (RLIMIT_RSS, &r);
+  // Virtual memory.
+  getrlimit (RLIMIT_AS, &r);
+  r.rlim_cur = limit;
+  setrlimit (RLIMIT_AS, &r);
+#endif
+}
+
 int 
 Program::ExecuteAndWait(const Path& path, 
                         const char** args,
                         const char** envp,
                         const Path** redirects,
-                        unsigned secondsToWait
-) {
-  if (!path.canExecute())
-    throw path.toString() + " is not executable"; 
+                        unsigned secondsToWait,
+                        unsigned memoryLimit,
+                        std::string* ErrMsg) 
+{
+  if (!path.canExecute()) {
+    if (ErrMsg)
+      *ErrMsg = path.toString() + " is not executable";
+    return -1;
+  }
 
 #ifdef HAVE_SYS_WAIT_H
   // Create a child process.
@@ -118,42 +151,50 @@ Program::ExecuteAndWait(const Path& path,
   switch (child) {
     // An error occured:  Return to the caller.
     case -1:
-      ThrowErrno(std::string("Couldn't execute program '") + path.toString() + 
-                 "'");
-      break;
+      MakeErrMsg(ErrMsg, "Couldn't fork");
+      return -1;
 
     // Child process: Execute the program.
     case 0: {
       // Redirect file descriptors...
       if (redirects) {
-        if (redirects[0])
-          if (redirects[0]->isEmpty())
-            RedirectFD("/dev/null",0);
-          else
-            RedirectFD(redirects[0]->toString(), 0);
-        if (redirects[1])
-          if (redirects[1]->isEmpty())
-            RedirectFD("/dev/null",1);
-          else
-            RedirectFD(redirects[1]->toString(), 1);
+        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; }
+          }
+        }
         if (redirects[1] && redirects[2] && 
             *(redirects[1]) != *(redirects[2])) {
-          if (redirects[2]->isEmpty())
-            RedirectFD("/dev/null",2);
-          else
-            RedirectFD(redirects[2]->toString(), 2);
-        } else {
-          dup2(1, 2);
+          if (redirects[2]->isEmpty()) {
+            if (RedirectFD("/dev/null",2,ErrMsg)) { return -1; }
+          } else {
+            if (RedirectFD(redirects[2]->toString(), 2,ErrMsg)) { return -1; }
+          }
+        } else if (-1 == dup2(1,2)) {
+          MakeErrMsg(ErrMsg, "Can't redirect");
+          return -1;
         }
       }
 
-      // Set up the environment
-      char** env = environ;
-      if (envp != 0)
-        env = (char**) envp;
-
+      // Set memory limits
+      if (memoryLimit!=0) {
+        SetMemoryLimits(memoryLimit);
+      }
+      
       // Execute!
-      execve (path.c_str(), (char** const)args, env);
+      if (envp != 0)
+        execve (path.c_str(), (char** const)args, (char**)envp);
+      else
+        execv (path.c_str(), (char** const)args);
       // If the execve() failed, we should exit and let the parent pick up
       // our non-zero exit status.
       exit (errno);
@@ -196,11 +237,12 @@ Program::ExecuteAndWait(const Path& path,
 
       // Wait for child to die
       if (wait(&status) != child)
-        ThrowErrno("Child timedout but wouldn't die");
+        MakeErrMsg(ErrMsg, "Child timed out but wouldn't die");
         
       return -1;   // Timeout detected
     } else {
-      ThrowErrno("Error waiting for child process");
+      MakeErrMsg(ErrMsg, "Error waiting for child process");
+      return -1;
     }
 
   // We exited normally without timeout, so turn off the timer.
@@ -212,12 +254,12 @@ Program::ExecuteAndWait(const Path& path,
   // Return the proper exit status. 0=success, >0 is programs' exit status,
   // <0 means a signal was returned, -9999999 means the program dumped core.
   int result = 0;
-  if (WIFEXITED (status))
+  if (WIFEXITED(status))
     result = WEXITSTATUS(status);
   else if (WIFSIGNALED(status))
     result = 0 - WTERMSIG(status);
 #ifdef WCOREDUMP
-  if (WCOREDUMP(status))
+  else if (WCOREDUMP(status))
     result |= 0x01000000;
 #endif
   return result;
@@ -227,4 +269,14 @@ Program::ExecuteAndWait(const Path& path,
     
 }
 
+bool Program::ChangeStdinToBinary(){
+  // Do nothing, as Unix doesn't differentiate between text and binary.
+  return false;
+}
+
+bool Program::ChangeStdoutToBinary(){
+  // Do nothing, as Unix doesn't differentiate between text and binary.
+  return false;
+}
+
 }