[ELF] Reorder BitcodeFiles.empty() to call thinLTOCreateEmptyIndexFiles() in only one place

[MaskRay]

Summary

It makes the --plugin-opt=obj-path= and --plugin-opt=thinlto-index-only=
behavior more consistent - the files will be created in the
BitcodeFiles.empty() case, but I assume whether it behaves this way is
not required by anyone.

LTOObj->run() cannot run with empty BitcodeFiles. There would be an error:

ld.lld: error: No available targets are compatible with triple ""

[ruiu]

LGTM

lld/trunk/ELF/LTO.h

 private:
   std::unique_ptr<llvm::lto::LTO> LTOObj;
   std::vector<SmallString<0>> Buf;
   std::vector<std::unique_ptr<MemoryBuffer>> Files;
   llvm::DenseSet<StringRef> UsedStartStop;
   std::unique_ptr<llvm::raw_fd_ostream> IndexFile;
   llvm::DenseSet<StringRef> ThinIndices;
 };
-
-void thinLTOCreateEmptyIndexFiles();
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/LTO.cpp

for (size_t I = 0, E = Syms.size(); I != E; ++I) {
     R.LinkerRedefined = !Sym->CanInline;
   }
   checkError(LTOObj->add(std::move(F.Obj), Resols));
 }
 
 // If LazyObjFile has not been added to link, emit empty index files.
 // This is needed because this is what GNU gold plugin does and we have a
 // distributed build system that depends on that behavior.
-void elf::thinLTOCreateEmptyIndexFiles() {
+static void thinLTOCreateEmptyIndexFiles() {
   for (LazyObjFile *F : LazyObjFiles) {
     if (F->AddedToLink || !isBitcode(F->MB))
       continue;
     std::string Path = replaceThinLTOSuffix(getThinLTOOutputFile(F->getName()));
     std::unique_ptr<raw_fd_ostream> OS = openFile(Path + ".thinlto.bc");
     if (!OS)
       continue;
 
std::vector<InputFile *> BitcodeCompiler::compile() {
   lto::NativeObjectCache Cache;
   if (!Config->ThinLTOCacheDir.empty())
     Cache = check(
         lto::localCache(Config->ThinLTOCacheDir,
                         [&](size_t Task, std::unique_ptr<MemoryBuffer> MB) {
                           Files[Task] = std::move(MB);
                         }));
 
+  if (!BitcodeFiles.empty())
     checkError(LTOObj->run(
         [&](size_t Task) {
           return llvm::make_unique<lto::NativeObjectStream>(
               llvm::make_unique<raw_svector_ostream>(Buf[Task]));
         },
         Cache));
 
   // Emit empty index files for non-indexed files
   for (StringRef S : ThinIndices) {
     std::string Path = getThinLTOOutputFile(S);
     openFile(Path + ".thinlto.bc");
     if (Config->ThinLTOEmitImportsFiles)
       openFile(Path + ".imports");
   }

lld/trunk/ELF/SymbolTable.cpp

 // This function is where all the optimizations of link-time
 // optimization happens. When LTO is in use, some input files are
 // not in native object file format but in the LLVM bitcode format.
 // This function compiles bitcode files into a few big native files
 // using LLVM functions and replaces bitcode symbols with the results.
 // Because all bitcode files that the program consists of are passed
 // to the compiler at once, it can do whole-program optimization.
 template <class ELFT> void SymbolTable::addCombinedLTOObject() {
-  if (BitcodeFiles.empty()) {
-    if (Config->ThinLTOIndexOnly)
-      thinLTOCreateEmptyIndexFiles();
-    return;
-  }
-
   // Compile bitcode files and replace bitcode symbols.
   LTO.reset(new BitcodeCompiler);
   for (BitcodeFile *F : BitcodeFiles)
     LTO->add(*F);
 
   for (InputFile *File : LTO->compile()) {
     DenseSet<CachedHashStringRef> DummyGroups;
     auto *Obj = cast<ObjFile<ELFT>>(File);