Simplify writeArchive return type.

[ruiu]

Summary

writeArchive returned a pair, but the first element of the pair is always
its first argument on failure, so it doesn't make sense to return it from
the function. This patch change the return type so that it does't return it.

[pcc]

LGTM

lld/trunk/COFF/Driver.cpp

filterBitcodeFiles(StringRef Path, std::vector<std::string> &TemporaryFiles) {
 
   SmallString<128> S;
   if (auto EC = sys::fs::createTemporaryFile("lld-" + sys::path::stem(Path),
                                              ".lib", S))
     fatal(EC, "cannot create a temporary file");
   std::string Temp = S.str();
   TemporaryFiles.push_back(Temp);
 
-  std::pair<StringRef, std::error_code> Ret =
+  std::error_code EC =
       llvm::writeArchive(Temp, New, /*WriteSymtab=*/true, Archive::Kind::K_GNU,
                          /*Deterministics=*/true,
                          /*Thin=*/false);
-  if (Ret.second)
-    error("failed to create a new archive " + S.str() + ": " + Ret.first);
+  if (EC)
+    error("failed to create a new archive " + S.str() + ": " + EC.message());
   return Temp;
 }
 
 // Create response file contents and invoke the MSVC linker.
 void LinkerDriver::invokeMSVC(opt::InputArgList &Args) {
   std::string Rsp = "/nologo\n";
   std::vector<std::string> Temps;
 

llvm/trunk/include/llvm/Object/ArchiveWriter.h

struct NewArchiveMember {
 
   static Expected<NewArchiveMember>
   getOldMember(const object::Archive::Child &OldMember, bool Deterministic);
 
   static Expected<NewArchiveMember> getFile(StringRef FileName,
                                             bool Deterministic);
 };
 
-std::pair<StringRef, std::error_code>
+std::error_code
 writeArchive(StringRef ArcName, std::vector<NewArchiveMember> &NewMembers,
              bool WriteSymtab, object::Archive::Kind Kind, bool Deterministic,
              bool Thin, std::unique_ptr<MemoryBuffer> OldArchiveBuf = nullptr);
 }
 
 #endif

llvm/trunk/lib/Object/ArchiveWriter.cpp

if (isBSDLike(Kind))
     print32(Out, Kind, NumSyms * 8);
   else
     print32(Out, Kind, NumSyms);
 
   Out.seek(Pos);
   return BodyStartOffset + 4;
 }
 
-std::pair<StringRef, std::error_code>
-llvm::writeArchive(StringRef ArcName,
-                   std::vector<NewArchiveMember> &NewMembers,
+std::error_code
+llvm::writeArchive(StringRef ArcName, std::vector<NewArchiveMember> &NewMembers,
                    bool WriteSymtab, object::Archive::Kind Kind,
                    bool Deterministic, bool Thin,
                    std::unique_ptr<MemoryBuffer> OldArchiveBuf) {
   assert((!Thin || !isBSDLike(Kind)) && "Only the gnu format has a thin mode");
   SmallString<128> TmpArchive;
   int TmpArchiveFD;
   if (auto EC = sys::fs::createUniqueFile(ArcName + ".temp-archive-%%%%%%%.a",
                                           TmpArchiveFD, TmpArchive))
-    return std::make_pair(ArcName, EC);
+    return EC;
 
   tool_output_file Output(TmpArchive, TmpArchiveFD);
   raw_fd_ostream &Out = Output.os();
   if (Thin)
     Out << "!<thin>\n";
   else
     Out << "!<arch>\n";
 
   std::vector<unsigned> MemberOffsetRefs;
 
   unsigned MemberReferenceOffset = 0;
   if (WriteSymtab) {
     ErrorOr<unsigned> MemberReferenceOffsetOrErr = writeSymbolTable(
         Out, Kind, NewMembers, MemberOffsetRefs, Deterministic);
     if (auto EC = MemberReferenceOffsetOrErr.getError())
-      return std::make_pair(ArcName, EC);
+      return EC;
     MemberReferenceOffset = MemberReferenceOffsetOrErr.get();
   }
 
   std::vector<unsigned> StringMapIndexes;
   if (!isBSDLike(Kind))
     writeStringTable(Out, ArcName, NewMembers, StringMapIndexes, Thin);
 
   std::vector<unsigned>::iterator StringMapIndexIter = StringMapIndexes.begin();
llvm::writeArchive(StringRef ArcName, std::vector<NewArchiveMember> &NewMembers,
   // temporary file (actually the original file renamed) because
   // a file cannot be deleted while there's a handle open on it,
   // only renamed. So by freeing this buffer, this ensures that
   // the last open handle on the destination file, if any, is
   // closed before we attempt to rename.
   OldArchiveBuf.reset();
 
   sys::fs::rename(TmpArchive, ArcName);
-  return std::make_pair("", std::error_code());
+  return std::error_code();
 }

llvm/trunk/lib/Object/COFFImportFile.cpp

for (COFFShortExport E : Exports) {
     if (!Name) {
       return errorToErrorCode(Name.takeError());
     }
 
     Members.push_back(
         OF.createShortImport(*Name, E.Ordinal, ImportType, NameType));
   }
 
-  std::pair<StringRef, std::error_code> Result =
-      writeArchive(Path, Members, /*WriteSymtab*/ true, object::Archive::K_GNU,
+  return writeArchive(Path, Members, /*WriteSymtab*/ true,
+                      object::Archive::K_GNU,
                       /*Deterministic*/ true, /*Thin*/ false);
-
-  return Result.second;
 }
 
 } // namespace object
 } // namespace llvm

llvm/trunk/lib/ToolDrivers/llvm-lib/LibDriver.cpp

if (Magic != llvm::file_magic::coff_object &&
         Magic != llvm::file_magic::windows_resource) {
       llvm::errs() << Arg->getValue()
                    << ": not a COFF object, bitcode or resource file\n";
       return 1;
     }
     Members.emplace_back(std::move(*MOrErr));
   }
 
-  std::pair<StringRef, std::error_code> Result =
-      llvm::writeArchive(getOutputPath(&Args, Members[0]), Members,
+  std::string OutputPath = getOutputPath(&Args, Members[0]);
+  std::error_code EC =
+      llvm::writeArchive(OutputPath, Members,
                          /*WriteSymtab=*/true, object::Archive::K_GNU,
                          /*Deterministic*/ true, Args.hasArg(OPT_llvmlibthin));
 
-  if (Result.second) {
-    if (Result.first.empty())
-      Result.first = ArgsArr[0];
-    llvm::errs() << Result.first << ": " << Result.second.message() << "\n";
+  if (EC) {
+    llvm::errs() << OutputPath << ": " << EC.message() << "\n";
     return 1;
   }
 
   return 0;
 }

llvm/trunk/tools/llvm-ar/llvm-ar.cpp

case BSD:
     break;
   case DARWIN:
     if (Thin)
       fail("Only the gnu format has a thin mode");
     Kind = object::Archive::K_DARWIN;
     break;
   }
 
-  std::pair<StringRef, std::error_code> Result =
+  std::error_code EC =
       writeArchive(ArchiveName, NewMembersP ? *NewMembersP : NewMembers, Symtab,
                    Kind, Deterministic, Thin, std::move(OldArchiveBuf));
-  failIfError(Result.second, Result.first);
+  failIfError(EC, ArchiveName);
 }
 
 static void createSymbolTable(object::Archive *OldArchive) {
   // When an archive is created or modified, if the s option is given, the
   // resulting archive will have a current symbol table. If the S option
   // is given, it will have no symbol table.
   // In summary, we only need to update the symbol table if we have none.
   // This is actually very common because of broken build systems that think