For PR797:

Final removal of exceptions from lib/System and adjustment of users to
accommodate.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@29846 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/Support/GraphWriter.h

@@ -251,7 +251,11 @@ sys::Path WriteGraph(const GraphType &G,
     return Filename;
   }
   Filename.appendComponent(Name + ".dot");
-  Filename.makeUnique();
+  if (Filename.makeUnique(true,&ErrMsg)) {
+    std::cerr << "Error: " << ErrMsg << "\n";
+    return sys::Path();
+  }
+
   std::cerr << "Writing '" << Filename << "'... ";
   
   std::ofstream O(Filename.c_str());

include/llvm/System/Path.h

@@ -414,7 +414,7 @@ namespace sys {
       /// already unique.
       /// @throws std::string if an unrecoverable error occurs.
       /// @brief Make the current path name unique in the file system.
-      void makeUnique( bool reuse_current = true );
+      bool makeUnique( bool reuse_current /*= true*/, std::string* ErrMsg );
 
     /// @}
     /// @name Disk Mutators
@@ -529,9 +529,9 @@ namespace sys {
 
   /// This function can be used to copy the file specified by Src to the
   /// file specified by Dest. If an error occurs, Dest is removed.
-  /// @throws std::string if an error opening or writing the files occurs.
+  /// @returns true if an error occurs, false otherwise
   /// @brief Copy one file to another.
-  void CopyFile(const Path& Dest, const Path& Src);
+  bool CopyFile(const Path& Dest, const Path& Src, std::string* ErrMsg);
 }
 
 std::ostream& operator<<(std::ostream& strm, const sys::Path& aPath);

lib/System/Unix/Memory.inc

@@ -35,7 +35,7 @@ llvm::sys::Memory::AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock,
 #ifdef NEED_DEV_ZERO_FOR_MMAP
   static int zero_fd = open("/dev/zero", O_RDWR);
   if (zero_fd == -1) {
-    GetErrno("Can't open /dev/zero device", ErrMsg);
+    MakeErrMsg(ErrMsg, "Can't open /dev/zero device");
     return MemoryBlock();
   }
   fd = zero_fd;
@@ -58,7 +58,7 @@ llvm::sys::Memory::AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock,
     if (NearBlock) //Try again without a near hint
       return AllocateRWX(NumBytes, 0);
 
-    GetErrno("Can't allocate RWX Memory", ErrMsg);
+    MakeErrMsg(ErrMsg, "Can't allocate RWX Memory");
     return MemoryBlock();
   }
   MemoryBlock result;
@@ -70,7 +70,7 @@ llvm::sys::Memory::AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock,
 bool llvm::sys::Memory::ReleaseRWX(MemoryBlock &M, std::string *ErrMsg) {
   if (M.Address == 0 || M.Size == 0) return false;
   if (0 != ::munmap(M.Address, M.Size))
-    return GetErrno("Can't release RWX Memory", ErrMsg);
+    return MakeErrMsg(ErrMsg, "Can't release RWX Memory");
   return false;
 }
 

lib/System/Unix/Path.inc

@@ -169,6 +169,7 @@ Path::GetTemporaryDirectory(std::string* ErrMsg ) {
     MakeErrMsg(ErrMsg, 
       std::string(pathname) + ": can't create temporary directory");
     return Path();
+  }
   Path result;
   result.set(pathname);
   assert(result.isValid() && "mkstemp didn't create a valid pathname!");
@@ -359,7 +360,8 @@ bool
 Path::getFileStatus(FileStatus &info, std::string *ErrStr) const {
   struct stat buf;
   if (0 != stat(path.c_str(), &buf))
-    return GetErrno(path + ": can't get status of file '" + path + "'", ErrStr);
+    return MakeErrMsg(ErrStr, 
+      path + ": can't get status of file '" + path + "'");
   info.fileSize = buf.st_size;
   info.modTime.fromEpochTime(buf.st_mtime);
   info.mode = buf.st_mode;
@@ -566,7 +568,8 @@ Path::createFileOnDisk(std::string* ErrMsg) {
 bool
 Path::createTemporaryFileOnDisk(bool reuse_current, std::string* ErrMsg) {
   // Make this into a unique file name
-  makeUnique( reuse_current );
+  if (makeUnique( reuse_current, ErrMsg ))
+    return true;
 
   // create the file
   int fd = ::open(path.c_str(), O_WRONLY|O_CREAT|O_TRUNC, 0666);
@@ -589,7 +592,7 @@ Path::eraseFromDisk(bool remove_contents, std::string *ErrStr) const {
   // or other things that aren't "regular" files. 
   if (Status.isFile) {
     if (unlink(path.c_str()) != 0)
-      return GetErrno(path + ": can't destroy file", ErrStr);
+      return MakeErrMsg(ErrStr, path + ": can't destroy file");
     return false;
   }
   
@@ -614,8 +617,8 @@ Path::eraseFromDisk(bool remove_contents, std::string *ErrStr) const {
     pathname[lastchar+1] = 0;
     
   if (rmdir(pathname) != 0)
-    return GetErrno(std::string(pathname) + ": can't destroy directory",
+    return MakeErrMsg(ErrStr, 
-                    ErrStr);
+      std::string(pathname) + ": can't destroy directory");
   return false;
 }
 
@@ -633,59 +636,63 @@ Path::setStatusInfoOnDisk(const FileStatus &si, std::string *ErrStr) const {
   utb.actime = si.modTime.toPosixTime();
   utb.modtime = utb.actime;
   if (0 != ::utime(path.c_str(),&utb))
-    return GetErrno(path + ": can't set file modification time", ErrStr);
+    return MakeErrMsg(ErrStr, path + ": can't set file modification time");
   if (0 != ::chmod(path.c_str(),si.mode))
-    return GetErrno(path + ": can't set mode", ErrStr);
+    return MakeErrMsg(ErrStr, path + ": can't set mode");
   return false;
 }
 
-void 
+bool 
-sys::CopyFile(const sys::Path &Dest, const sys::Path &Src) {
+sys::CopyFile(const sys::Path &Dest, const sys::Path &Src, std::string* ErrMsg){
   int inFile = -1;
   int outFile = -1;
-  try {
+  inFile = ::open(Src.c_str(), O_RDONLY);
-    inFile = ::open(Src.c_str(), O_RDONLY);
+  if (inFile == -1)
-    if (inFile == -1)
+    return MakeErrMsg(ErrMsg, Src.toString() + 
-      ThrowErrno(Src.toString() + ": can't open source file to copy: ");
+      ": can't open source file to copy");
 
-    outFile = ::open(Dest.c_str(), O_WRONLY|O_CREAT, 0666);
+  outFile = ::open(Dest.c_str(), O_WRONLY|O_CREAT, 0666);
-    if (outFile == -1)
+  if (outFile == -1) {
-      ThrowErrno(Dest.toString() +": can't create destination file for copy: ");
+    ::close(inFile);
+    return MakeErrMsg(ErrMsg, Dest.toString() +
+      ": can't create destination file for copy");
+  }
 
-    char Buffer[16*1024];
+  char Buffer[16*1024];
-    while (ssize_t Amt = ::read(inFile, Buffer, 16*1024)) {
+  while (ssize_t Amt = ::read(inFile, Buffer, 16*1024)) {
-      if (Amt == -1) {
+    if (Amt == -1) {
-        if (errno != EINTR && errno != EAGAIN) 
+      if (errno != EINTR && errno != EAGAIN) {
-          ThrowErrno(Src.toString()+": can't read source file: ");
+        ::close(inFile);
-      } else {
+        ::close(outFile);
-        char *BufPtr = Buffer;
+        return MakeErrMsg(ErrMsg, Src.toString()+": can't read source file: ");
-        while (Amt) {
+      }
-          ssize_t AmtWritten = ::write(outFile, BufPtr, Amt);
+    } else {
-          if (AmtWritten == -1) {
+      char *BufPtr = Buffer;
-            if (errno != EINTR && errno != EAGAIN) 
+      while (Amt) {
-              ThrowErrno(Dest.toString() + ": can't write destination file: ");
+        ssize_t AmtWritten = ::write(outFile, BufPtr, Amt);
-          } else {
+        if (AmtWritten == -1) {
-            Amt -= AmtWritten;
+          if (errno != EINTR && errno != EAGAIN) {
-            BufPtr += AmtWritten;
+            ::close(inFile);
+            ::close(outFile);
+            return MakeErrMsg(ErrMsg, Dest.toString() + 
+              ": can't write destination file: ");
           }
+        } else {
+          Amt -= AmtWritten;
+          BufPtr += AmtWritten;
         }
       }
     }
-    ::close(inFile);
-    ::close(outFile);
-  } catch (...) {
-    if (inFile != -1)
-      ::close(inFile);
-    if (outFile != -1)
-      ::close(outFile);
-    throw;
   }
+  ::close(inFile);
+  ::close(outFile);
+  return false;
 }
 
-void 
+bool 
-Path::makeUnique(bool reuse_current) {
+Path::makeUnique(bool reuse_current, std::string* ErrMsg) {
   if (reuse_current && !exists())
-    return; // File doesn't exist already, just use it!
+    return false; // File doesn't exist already, just use it!
 
   // Append an XXXXXX pattern to the end of the file for use with mkstemp, 
   // mktemp or our own implementation.
@@ -695,9 +702,8 @@ Path::makeUnique(bool reuse_current) {
 
 #if defined(HAVE_MKSTEMP)
   int TempFD;
-  if ((TempFD = mkstemp(FNBuffer)) == -1) {
+  if ((TempFD = mkstemp(FNBuffer)) == -1)
-    ThrowErrno(path + ": can't make unique filename");
+    return MakeErrMsg(ErrMsg, path + ": can't make unique filename");
-  }
 
   // We don't need to hold the temp file descriptor... we will trust that no one
   // will overwrite/delete the file before we can open it again.
@@ -707,9 +713,8 @@ Path::makeUnique(bool reuse_current) {
   path = FNBuffer;
 #elif defined(HAVE_MKTEMP)
   // If we don't have mkstemp, use the old and obsolete mktemp function.
-  if (mktemp(FNBuffer) == 0) {
+  if (mktemp(FNBuffer) == 0)
-    ThrowErrno(path + ": can't make unique filename");
+    return MakeErrMsg(ErrMsg, path + ": can't make unique filename");
-  }
 
   // Save the name
   path = FNBuffer;
@@ -722,9 +727,11 @@ Path::makeUnique(bool reuse_current) {
     path = FNBuffer;
   }
   if (FCounter > 999999)
-    throw std::string(path + ": can't make unique filename: too many files");
+    return MakeErrMsg(ErrMsg, 
+      path + ": can't make unique filename: too many files");
 #endif
-
+  return false;
-}
 }
 
+} // end llvm namespace
+

lib/System/Unix/Unix.h

@@ -66,59 +66,6 @@
 # define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
 #endif
 
-inline bool GetErrno(const std::string &prefix, std::string *ErrDest,
-                     int errnum = -1) {
-  char buffer[MAXPATHLEN];
-  
-  if (ErrDest == 0) return true;
-  
-  buffer[0] = 0;
-  if (errnum == -1)
-    errnum = errno;
-#ifdef HAVE_STRERROR_R
-  // strerror_r is thread-safe.
-  if (errnum)
-    strerror_r(errnum, buffer, MAXPATHLEN-1);
-#elif HAVE_STRERROR
-  // Copy the thread un-safe result of strerror into
-  // the buffer as fast as possible to minimize impact
-  // of collision of strerror in multiple threads.
-  if (errnum)
-    strncpy(buffer, strerror(errnum), MAXPATHLEN-1);
-  buffer[MAXPATHLEN-1] = 0;
-#else
-  // Strange that this system doesn't even have strerror
-  // but, oh well, just use a generic message
-  sprintf(buffer, "Error #%d", errnum);
-#endif
-  *ErrDest = prefix + ": " + buffer;
-  return true;
-}
-
-inline void ThrowErrno(const std::string& prefix, int errnum = -1) {
-  char buffer[MAXPATHLEN];
-  buffer[0] = 0;
-  if (errnum == -1)
-    errnum = errno;
-#ifdef HAVE_STRERROR_R
-  // strerror_r is thread-safe.
-  if (errnum)
-    strerror_r(errnum,buffer,MAXPATHLEN-1);
-#elif HAVE_STRERROR
-  // Copy the thread un-safe result of strerror into
-  // the buffer as fast as possible to minimize impact
-  // of collision of strerror in multiple threads.
-  if (errnum)
-    strncpy(buffer,strerror(errnum),MAXPATHLEN-1);
-  buffer[MAXPATHLEN-1] = 0;
-#else
-  // Strange that this system doesn't even have strerror
-  // but, oh well, just use a generic message
-  sprintf(buffer, "Error #%d", errnum);
-#endif
-  throw prefix + ": " + buffer;
-}
-
 /// This function builds an error message into \p ErrMsg using the \p prefix
 /// string and the Unix error number given by \p errnum. If errnum is -1, the
 /// default then the value of errno is used.

tools/bugpoint/ExecutionDriver.cpp

@@ -161,7 +161,12 @@ bool BugDriver::initializeExecutionEnvironment() {
 void BugDriver::compileProgram(Module *M) {
   // Emit the program to a bytecode file...
   sys::Path BytecodeFile ("bugpoint-test-program.bc");
-  BytecodeFile.makeUnique();
+  std::string ErrMsg;
+  if (BytecodeFile.makeUnique(true,&ErrMsg)) {
+    std::cerr << ToolName << ": Error making unique filename: " << ErrMsg 
+              << "\n";
+    exit(1);
+  }
   if (writeProgramToFile(BytecodeFile.toString(), M)) {
     std::cerr << ToolName << ": Error emitting bytecode to file '"
               << BytecodeFile << "'!\n";
@@ -188,10 +193,15 @@ std::string BugDriver::executeProgram(std::string OutputFile,
   if (AI == 0) AI = Interpreter;
   assert(AI && "Interpreter should have been created already!");
   bool CreatedBytecode = false;
+  std::string ErrMsg;
   if (BytecodeFile.empty()) {
     // Emit the program to a bytecode file...
     sys::Path uniqueFilename("bugpoint-test-program.bc");
-    uniqueFilename.makeUnique();
+    if (uniqueFilename.makeUnique(true, &ErrMsg)) {
+      std::cerr << ToolName << ": Error making unique filename: " 
+                << ErrMsg << "!\n";
+      exit(1);
+    }
     BytecodeFile = uniqueFilename.toString();
 
     if (writeProgramToFile(BytecodeFile, Program)) {
@@ -210,7 +220,11 @@ std::string BugDriver::executeProgram(std::string OutputFile,
 
   // Check to see if this is a valid output filename...
   sys::Path uniqueFile(OutputFile);
-  uniqueFile.makeUnique();
+  if (uniqueFile.makeUnique(true, &ErrMsg)) {
+    std::cerr << ToolName << ": Error making unique filename: "
+              << ErrMsg << "\n";
+    exit(1);
+  }
   OutputFile = uniqueFile.toString();
 
   // Figure out which shared objects to run, if any.

tools/bugpoint/Miscompilation.cpp

@@ -776,7 +776,12 @@ static bool TestCodeGenerator(BugDriver &BD, Module *Test, Module *Safe) {
   CleanupAndPrepareModules(BD, Test, Safe);
 
   sys::Path TestModuleBC("bugpoint.test.bc");
-  TestModuleBC.makeUnique();
+  std::string ErrMsg;
+  if (TestModuleBC.makeUnique(true, &ErrMsg)) {
+    std::cerr << BD.getToolName() << "Error making unique filename: "
+              << ErrMsg << "\n";
+    exit(1);
+  }
   if (BD.writeProgramToFile(TestModuleBC.toString(), Test)) {
     std::cerr << "Error writing bytecode to `" << TestModuleBC << "'\nExiting.";
     exit(1);
@@ -785,7 +790,11 @@ static bool TestCodeGenerator(BugDriver &BD, Module *Test, Module *Safe) {
 
   // Make the shared library
   sys::Path SafeModuleBC("bugpoint.safe.bc");
-  SafeModuleBC.makeUnique();
+  if (SafeModuleBC.makeUnique(true, &ErrMsg)) {
+    std::cerr << BD.getToolName() << "Error making unique filename: "
+              << ErrMsg << "\n";
+    exit(1);
+  }
 
   if (BD.writeProgramToFile(SafeModuleBC.toString(), Safe)) {
     std::cerr << "Error writing bytecode to `" << SafeModuleBC << "'\nExiting.";
@@ -836,7 +845,12 @@ bool BugDriver::debugCodeGenerator() {
   CleanupAndPrepareModules(*this, ToCodeGen, ToNotCodeGen);
 
   sys::Path TestModuleBC("bugpoint.test.bc");
-  TestModuleBC.makeUnique();
+  std::string ErrMsg;
+  if (TestModuleBC.makeUnique(true, &ErrMsg)) {
+    std::cerr << getToolName() << "Error making unique filename: "
+              << ErrMsg << "\n";
+    exit(1);
+  }
 
   if (writeProgramToFile(TestModuleBC.toString(), ToCodeGen)) {
     std::cerr << "Error writing bytecode to `" << TestModuleBC << "'\nExiting.";
@@ -846,7 +860,11 @@ bool BugDriver::debugCodeGenerator() {
 
   // Make the shared library
   sys::Path SafeModuleBC("bugpoint.safe.bc");
-  SafeModuleBC.makeUnique();
+  if (SafeModuleBC.makeUnique(true, &ErrMsg)) {
+    std::cerr << getToolName() << "Error making unique filename: "
+              << ErrMsg << "\n";
+    exit(1);
+  }
 
   if (writeProgramToFile(SafeModuleBC.toString(), ToNotCodeGen)) {
     std::cerr << "Error writing bytecode to `" << SafeModuleBC << "'\nExiting.";

tools/bugpoint/OptimizerDriver.cpp

@@ -139,12 +139,21 @@ bool BugDriver::runPasses(const std::vector<const PassInfo*> &Passes,
   // setup the output file name
   std::cout << std::flush;
   sys::Path uniqueFilename("bugpoint-output.bc");
-  uniqueFilename.makeUnique();
+  std::string ErrMsg;
+  if (uniqueFilename.makeUnique(true, &ErrMsg)) {
+    std::cerr << getToolName() << ": Error making unique filename: " 
+              << ErrMsg << "\n";
+    return(1);
+  }
   OutputFilename = uniqueFilename.toString();
 
   // set up the input file name
   sys::Path inputFilename("bugpoint-input.bc");
-  inputFilename.makeUnique();
+  if (inputFilename.makeUnique(true, &ErrMsg)) {
+    std::cerr << getToolName() << ": Error making unique filename: " 
+              << ErrMsg << "\n";
+    return(1);
+  }
   std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
                                std::ios::binary;
   std::ofstream InFile(inputFilename.c_str(), io_mode);
@@ -179,7 +188,6 @@ bool BugDriver::runPasses(const std::vector<const PassInfo*> &Passes,
   args[n++] = 0;
 
   sys::Path prog(sys::Program::FindProgramByName(ToolName));
-  std::string ErrMsg;
   int result = sys::Program::ExecuteAndWait(prog,args,0,0,Timeout,&ErrMsg);
 
   // If we are supposed to delete the bytecode file or if the passes crashed,

tools/bugpoint/ToolRunner.cpp

@@ -53,7 +53,11 @@ static void ProcessFailure(sys::Path ProgPath, const char** Args) {
 
   // Rerun the compiler, capturing any error messages to print them.
   sys::Path ErrorFilename("error_messages");
-  ErrorFilename.makeUnique();
+  std::string ErrMsg;
+  if (ErrorFilename.makeUnique(true, &ErrMsg)) {
+    std::cerr << "Error making unique filename: " << ErrMsg << "\n";
+    exit(1);
+  }
   RunProgramWithTimeout(ProgPath, Args, sys::Path(""), ErrorFilename,
                         ErrorFilename); // FIXME: check return code ?
 
@@ -153,7 +157,11 @@ AbstractInterpreter *AbstractInterpreter::createLLI(const std::string &ProgPath,
 //
 void LLC::OutputAsm(const std::string &Bytecode, sys::Path &OutputAsmFile) {
   sys::Path uniqueFile(Bytecode+".llc.s");
-  uniqueFile.makeUnique();
+  std::string ErrMsg;
+  if (uniqueFile.makeUnique(true, &ErrMsg)) {
+    std::cerr << "Error making unique filename: " << ErrMsg << "\n";
+    exit(1);
+  }
   OutputAsmFile = uniqueFile;
   std::vector<const char *> LLCArgs;
   LLCArgs.push_back (LLCPath.c_str());
@@ -307,7 +315,11 @@ AbstractInterpreter *AbstractInterpreter::createJIT(const std::string &ProgPath,
 
 void CBE::OutputC(const std::string &Bytecode, sys::Path& OutputCFile) {
   sys::Path uniqueFile(Bytecode+".cbe.c");
-  uniqueFile.makeUnique();
+  std::string ErrMsg;
+  if (uniqueFile.makeUnique(true, &ErrMsg)) {
+    std::cerr << "Error making unique filename: " << ErrMsg << "\n";
+    exit(1);
+  }
   OutputCFile = uniqueFile;
   std::vector<const char *> LLCArgs;
   LLCArgs.push_back (LLCPath.c_str());
@@ -409,7 +421,11 @@ int GCC::ExecuteProgram(const std::string &ProgramFile,
   GCCArgs.push_back("none");
   GCCArgs.push_back("-o");
   sys::Path OutputBinary (ProgramFile+".gcc.exe");
-  OutputBinary.makeUnique();
+  std::string ErrMsg;
+  if (OutputBinary.makeUnique(true, &ErrMsg)) {
+    std::cerr << "Error making unique filename: " << ErrMsg << "\n";
+    exit(1);
+  }
   GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file...
 
   // Add any arguments intended for GCC. We locate them here because this is
@@ -462,7 +478,11 @@ int GCC::MakeSharedObject(const std::string &InputFile, FileType fileType,
                           std::string &OutputFile,
                           const std::vector<std::string> &ArgsForGCC) {
   sys::Path uniqueFilename(InputFile+LTDL_SHLIB_EXT);
-  uniqueFilename.makeUnique();
+  std::string ErrMsg;
+  if (uniqueFilename.makeUnique(true, &ErrMsg)) {
+    std::cerr << "Error making unique filename: " << ErrMsg << "\n";
+    exit(1);
+  }
   OutputFile = uniqueFilename.toString();
 
   std::vector<const char*> GCCArgs;