Clang format a few prior patches (NFC)
authorTeresa Johnson <tejohnson@google.com>
Mon, 2 Nov 2015 18:02:11 +0000 (18:02 +0000)
committerTeresa Johnson <tejohnson@google.com>
Mon, 2 Nov 2015 18:02:11 +0000 (18:02 +0000)
I had clang formatted my earlier patches using the wrong style.
Reformatted with the LLVM style.

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

12 files changed:
include/llvm/Bitcode/BitstreamWriter.h
include/llvm/Bitcode/ReaderWriter.h
include/llvm/IR/FunctionInfo.h
include/llvm/Object/Binary.h
include/llvm/Object/FunctionIndexObjectFile.h
lib/Bitcode/Reader/BitcodeReader.cpp
lib/Bitcode/Writer/BitcodeWriter.cpp
lib/Object/FunctionIndexObjectFile.cpp
lib/Transforms/IPO/ElimAvailExtern.cpp
tools/gold/gold-plugin.cpp
tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
tools/llvm-lto/llvm-lto.cpp

index 4988d5f..438f4a6 100644 (file)
@@ -73,9 +73,7 @@ class BitstreamWriter {
                reinterpret_cast<const char *>(&Value + 1));
   }
 
-  size_t GetBufferOffset() const {
-    return Out.size();
-  }
+  size_t GetBufferOffset() const { return Out.size(); }
 
   size_t GetWordIndex() const {
     size_t Offset = GetBufferOffset();
index 938edf2..3308084 100644 (file)
@@ -68,9 +68,10 @@ namespace llvm {
   /// the index. Otherwise skip the function summary section, and only create
   /// an index object with a map from function name to function summary offset.
   /// The index is used to perform lazy function summary reading later.
-  ErrorOr<std::unique_ptr<FunctionInfoIndex>> getFunctionInfoIndex(
-      MemoryBufferRef Buffer, LLVMContext &Context,
-      DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy = false);
+  ErrorOr<std::unique_ptr<FunctionInfoIndex>>
+  getFunctionInfoIndex(MemoryBufferRef Buffer, LLVMContext &Context,
+                       DiagnosticHandlerFunction DiagnosticHandler,
+                       bool IsLazy = false);
 
   /// This method supports lazy reading of function summary data from the
   /// combined index during function importing. When reading the combined index
@@ -78,10 +79,11 @@ namespace llvm {
   /// Then this method is called for each function considered for importing,
   /// to parse the summary information for the given function name into
   /// the index.
-  std::error_code readFunctionSummary(
-      MemoryBufferRef Buffer, LLVMContext &Context,
-      DiagnosticHandlerFunction DiagnosticHandler, StringRef FunctionName,
-      std::unique_ptr<FunctionInfoIndex> Index);
+  std::error_code
+  readFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
+                      DiagnosticHandlerFunction DiagnosticHandler,
+                      StringRef FunctionName,
+                      std::unique_ptr<FunctionInfoIndex> Index);
 
   /// \brief Write the specified module to the specified raw output stream.
   ///
index a8dd2d9..2649547 100644 (file)
@@ -30,7 +30,7 @@ namespace llvm {
 /// This is a separate class from FunctionInfo to enable lazy reading of this
 /// function summary information from the combined index file during imporing.
 class FunctionSummary {
- private:
+private:
   /// \brief Path of module containing function IR, used to locate module when
   /// importing this function.
   ///
@@ -57,7 +57,7 @@ class FunctionSummary {
   /// during the initial compile step when the function index is first built.
   unsigned InstCount;
 
- public:
+public:
   /// Construct a summary object from summary data expected for all
   /// summary records.
   FunctionSummary(unsigned NumInsts) : InstCount(NumInsts) {}
@@ -90,7 +90,7 @@ class FunctionSummary {
 /// record. After parsing the associated summary information from the summary
 /// block the \a FunctionSummary is populated and stored here.
 class FunctionInfo {
- private:
+private:
   /// Function summary information used to help make ThinLTO importing
   /// decisions.
   std::unique_ptr<FunctionSummary> Summary;
@@ -109,7 +109,7 @@ class FunctionInfo {
   /// VST records with the summary records.
   uint64_t BitcodeIndex;
 
- public:
+public:
   /// Constructor used during parsing of VST entries.
   FunctionInfo(uint64_t FuncOffset)
       : Summary(nullptr), BitcodeIndex(FuncOffset) {}
@@ -157,7 +157,7 @@ typedef StringMap<uint64_t> ModulePathStringTableTy;
 /// Class to hold module path string table and function map,
 /// and encapsulate methods for operating on them.
 class FunctionInfoIndex {
- private:
+private:
   /// Map from function name to list of function information instances
   /// for functions of that name (may be duplicates in the COMDAT case, e.g.).
   FunctionInfoMapTy FunctionMap;
@@ -165,7 +165,7 @@ class FunctionInfoIndex {
   /// Holds strings for combined index, mapping to the corresponding module ID.
   ModulePathStringTableTy ModulePathStringTable;
 
- public:
+public:
   FunctionInfoIndex() = default;
   ~FunctionInfoIndex() = default;
 
@@ -190,8 +190,8 @@ class FunctionInfoIndex {
   }
 
   /// Iterator to allow writer to walk through table during emission.
-  iterator_range<StringMap<uint64_t>::const_iterator> modPathStringEntries()
-      const {
+  iterator_range<StringMap<uint64_t>::const_iterator>
+  modPathStringEntries() const {
     return llvm::make_range(ModulePathStringTable.begin(),
                             ModulePathStringTable.end());
   }
@@ -225,6 +225,6 @@ class FunctionInfoIndex {
   }
 };
 
-}  // End llvm namespace
+} // End llvm namespace
 
 #endif
index 36911d8..a0d1127 100644 (file)
@@ -42,7 +42,7 @@ protected:
     ID_Archive,
     ID_MachOUniversalBinary,
     ID_COFFImportFile,
-    ID_IR, // LLVM IR
+    ID_IR,            // LLVM IR
     ID_FunctionIndex, // Function summary index
 
     // Object and children.
@@ -123,9 +123,7 @@ public:
     return TypeID == ID_IR;
   }
 
-  bool isFunctionIndex() const {
-    return TypeID == ID_FunctionIndex;
-  }
+  bool isFunctionIndex() const { return TypeID == ID_FunctionIndex; }
 
   bool isLittleEndian() const {
     return !(TypeID == ID_ELF32B || TypeID == ID_ELF64B ||
index b33fa64..08eff54 100644 (file)
@@ -29,7 +29,7 @@ class ObjectFile;
 class FunctionIndexObjectFile : public SymbolicFile {
   std::unique_ptr<FunctionInfoIndex> Index;
 
- public:
+public:
   FunctionIndexObjectFile(MemoryBufferRef Object,
                           std::unique_ptr<FunctionInfoIndex> I);
   ~FunctionIndexObjectFile() override;
@@ -72,8 +72,8 @@ class FunctionIndexObjectFile : public SymbolicFile {
   /// \brief Finds and returns bitcode in the given memory buffer (which may
   /// be either a bitcode file or a native object file with embedded bitcode),
   /// or an error code if not found.
-  static ErrorOr<MemoryBufferRef> findBitcodeInMemBuffer(
-      MemoryBufferRef Object);
+  static ErrorOr<MemoryBufferRef>
+  findBitcodeInMemBuffer(MemoryBufferRef Object);
 
   /// \brief Looks for function summary in the given memory buffer,
   /// returns true if found, else false.
@@ -83,8 +83,8 @@ class FunctionIndexObjectFile : public SymbolicFile {
   /// \brief Parse function index in the given memory buffer.
   /// Return new FunctionIndexObjectFile instance containing parsed function
   /// summary/index.
-  static ErrorOr<std::unique_ptr<FunctionIndexObjectFile>> create(
-      MemoryBufferRef Object, LLVMContext &Context, bool IsLazy = false);
+  static ErrorOr<std::unique_ptr<FunctionIndexObjectFile>>
+  create(MemoryBufferRef Object, LLVMContext &Context, bool IsLazy = false);
 
   /// \brief Parse the function summary information for function with the
   /// given name out of the given buffer. Parsed information is
index e23f817..1a63e08 100644 (file)
@@ -456,7 +456,7 @@ class FunctionIndexBitcodeReader {
   /// summary records.
   DenseMap<uint64_t, StringRef> ModuleIdMap;
 
- public:
+public:
   std::error_code error(BitcodeError E, const Twine &Message);
   std::error_code error(BitcodeError E);
   std::error_code error(const Twine &Message);
@@ -488,7 +488,7 @@ class FunctionIndexBitcodeReader {
                                        FunctionInfoIndex *I,
                                        size_t FunctionSummaryOffset);
 
- private:
+private:
   std::error_code parseModule();
   std::error_code parseValueSymbolTable();
   std::error_code parseEntireSummary();
@@ -3052,7 +3052,8 @@ std::error_code BitcodeReader::globalCleanup() {
 std::error_code BitcodeReader::rememberAndSkipFunctionBodies() {
   Stream.JumpToBit(NextUnreadBit);
 
-  if (Stream.AtEndOfStream()) return error("Could not find function in stream");
+  if (Stream.AtEndOfStream())
+    return error("Could not find function in stream");
 
   assert(SeenFirstFunctionBody);
   // An old bitcode file with the symbol table at the end would have
@@ -3064,17 +3065,18 @@ std::error_code BitcodeReader::rememberAndSkipFunctionBodies() {
   while (1) {
     BitstreamEntry Entry = Stream.advance();
     switch (Entry.Kind) {
+    default:
+      return error("Expect SubBlock");
+    case BitstreamEntry::SubBlock:
+      switch (Entry.ID) {
       default:
-        return error("Expect SubBlock");
-      case BitstreamEntry::SubBlock:
-        switch (Entry.ID) {
-          default:
-            return error("Expect function block");
-          case bitc::FUNCTION_BLOCK_ID:
-            if (std::error_code EC = rememberAndSkipFunctionBody()) return EC;
-            NextUnreadBit = Stream.GetCurrentBitNo();
-            return std::error_code();
-        }
+        return error("Expect function block");
+      case bitc::FUNCTION_BLOCK_ID:
+        if (std::error_code EC = rememberAndSkipFunctionBody())
+          return EC;
+        NextUnreadBit = Stream.GetCurrentBitNo();
+        return std::error_code();
+      }
     }
   }
 }
@@ -3600,7 +3602,8 @@ BitcodeReader::parseBitcodeInto(std::unique_ptr<DataStreamer> Streamer,
     return EC;
 
   // Sniff for the signature.
-  if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature");
+  if (!hasValidBitcodeHeader(Stream))
+    return error("Invalid bitcode signature");
 
   // We expect a number of well-defined blocks, though we don't necessarily
   // need to understand them all.
@@ -3672,7 +3675,8 @@ ErrorOr<std::string> BitcodeReader::parseTriple() {
     return EC;
 
   // Sniff for the signature.
-  if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature");
+  if (!hasValidBitcodeHeader(Stream))
+    return error("Invalid bitcode signature");
 
   // We expect a number of well-defined blocks, though we don't necessarily
   // need to understand them all.
@@ -5081,7 +5085,8 @@ std::error_code BitcodeReader::findFunctionInStream(
     assert(VSTOffset == 0 || !F->hasName());
     // Parse the next body in the stream and set its position in the
     // DeferredFunctionInfo map.
-    if (std::error_code EC = rememberAndSkipFunctionBodies()) return EC;
+    if (std::error_code EC = rememberAndSkipFunctionBodies())
+      return EC;
   }
   return std::error_code();
 }
@@ -5286,16 +5291,14 @@ FunctionIndexBitcodeReader::FunctionIndexBitcodeReader(
     DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy,
     bool CheckFuncSummaryPresenceOnly)
     : DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
-      Buffer(Buffer),
-      IsLazy(IsLazy),
+      Buffer(Buffer), IsLazy(IsLazy),
       CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {}
 
 FunctionIndexBitcodeReader::FunctionIndexBitcodeReader(
     LLVMContext &Context, DiagnosticHandlerFunction DiagnosticHandler,
     bool IsLazy, bool CheckFuncSummaryPresenceOnly)
     : DiagnosticHandler(getDiagHandler(DiagnosticHandler, Context)),
-      Buffer(nullptr),
-      IsLazy(IsLazy),
+      Buffer(nullptr), IsLazy(IsLazy),
       CheckFuncSummaryPresenceOnly(CheckFuncSummaryPresenceOnly) {}
 
 void FunctionIndexBitcodeReader::freeState() { Buffer = nullptr; }
@@ -5320,58 +5323,58 @@ std::error_code FunctionIndexBitcodeReader::parseValueSymbolTable() {
     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
-      case BitstreamEntry::SubBlock:  // Handled for us already.
-      case BitstreamEntry::Error:
-        return error("Malformed block");
-      case BitstreamEntry::EndBlock:
-        return std::error_code();
-      case BitstreamEntry::Record:
-        // The interesting case.
-        break;
+    case BitstreamEntry::SubBlock: // Handled for us already.
+    case BitstreamEntry::Error:
+      return error("Malformed block");
+    case BitstreamEntry::EndBlock:
+      return std::error_code();
+    case BitstreamEntry::Record:
+      // The interesting case.
+      break;
     }
 
     // Read a record.
     Record.clear();
     switch (Stream.readRecord(Entry.ID, Record)) {
-      default:  // Default behavior: ignore (e.g. VST_CODE_BBENTRY records).
-        break;
-      case bitc::VST_CODE_FNENTRY: {
-        // VST_FNENTRY: [valueid, offset, namechar x N]
-        if (convertToString(Record, 2, ValueName))
-          return error("Invalid record");
-        unsigned ValueID = Record[0];
-        uint64_t FuncOffset = Record[1];
-        std::unique_ptr<FunctionInfo> FuncInfo =
-            llvm::make_unique<FunctionInfo>(FuncOffset);
-        if (foundFuncSummary() && !IsLazy) {
-          DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI =
-              SummaryMap.find(ValueID);
-          assert(SMI != SummaryMap.end() && "Summary info not found");
-          FuncInfo->setFunctionSummary(std::move(SMI->second));
-        }
-        TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo));
-
-        ValueName.clear();
-        break;
+    default: // Default behavior: ignore (e.g. VST_CODE_BBENTRY records).
+      break;
+    case bitc::VST_CODE_FNENTRY: {
+      // VST_FNENTRY: [valueid, offset, namechar x N]
+      if (convertToString(Record, 2, ValueName))
+        return error("Invalid record");
+      unsigned ValueID = Record[0];
+      uint64_t FuncOffset = Record[1];
+      std::unique_ptr<FunctionInfo> FuncInfo =
+          llvm::make_unique<FunctionInfo>(FuncOffset);
+      if (foundFuncSummary() && !IsLazy) {
+        DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI =
+            SummaryMap.find(ValueID);
+        assert(SMI != SummaryMap.end() && "Summary info not found");
+        FuncInfo->setFunctionSummary(std::move(SMI->second));
       }
-      case bitc::VST_CODE_COMBINED_FNENTRY: {
-        // VST_FNENTRY: [offset, namechar x N]
-        if (convertToString(Record, 1, ValueName))
-          return error("Invalid record");
-        uint64_t FuncSummaryOffset = Record[0];
-        std::unique_ptr<FunctionInfo> FuncInfo =
-            llvm::make_unique<FunctionInfo>(FuncSummaryOffset);
-        if (foundFuncSummary() && !IsLazy) {
-          DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI =
-              SummaryMap.find(FuncSummaryOffset);
-          assert(SMI != SummaryMap.end() && "Summary info not found");
-          FuncInfo->setFunctionSummary(std::move(SMI->second));
-        }
-        TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo));
+      TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo));
 
-        ValueName.clear();
-        break;
+      ValueName.clear();
+      break;
+    }
+    case bitc::VST_CODE_COMBINED_FNENTRY: {
+      // VST_FNENTRY: [offset, namechar x N]
+      if (convertToString(Record, 1, ValueName))
+        return error("Invalid record");
+      uint64_t FuncSummaryOffset = Record[0];
+      std::unique_ptr<FunctionInfo> FuncInfo =
+          llvm::make_unique<FunctionInfo>(FuncSummaryOffset);
+      if (foundFuncSummary() && !IsLazy) {
+        DenseMap<uint64_t, std::unique_ptr<FunctionSummary>>::iterator SMI =
+            SummaryMap.find(FuncSummaryOffset);
+        assert(SMI != SummaryMap.end() && "Summary info not found");
+        FuncInfo->setFunctionSummary(std::move(SMI->second));
       }
+      TheIndex->addFunctionInfo(ValueName, std::move(FuncInfo));
+
+      ValueName.clear();
+      break;
+    }
     }
   }
 }
@@ -5391,47 +5394,53 @@ std::error_code FunctionIndexBitcodeReader::parseModule() {
     BitstreamEntry Entry = Stream.advance();
 
     switch (Entry.Kind) {
-      case BitstreamEntry::Error:
-        return error("Malformed block");
-      case BitstreamEntry::EndBlock:
-        return std::error_code();
+    case BitstreamEntry::Error:
+      return error("Malformed block");
+    case BitstreamEntry::EndBlock:
+      return std::error_code();
 
-      case BitstreamEntry::SubBlock:
-        if (CheckFuncSummaryPresenceOnly) {
-          if (Entry.ID == bitc::FUNCTION_SUMMARY_BLOCK_ID)
-            SeenFuncSummary = true;
-          if (Stream.SkipBlock()) return error("Invalid record");
-          // No need to parse the rest since we found the summary.
-          return std::error_code();
-        }
-        switch (Entry.ID) {
-          default:  // Skip unknown content.
-            if (Stream.SkipBlock()) return error("Invalid record");
-            break;
-          case bitc::BLOCKINFO_BLOCK_ID:
-            // Need to parse these to get abbrev ids (e.g. for VST)
-            if (Stream.ReadBlockInfoBlock()) return error("Malformed block");
-            break;
-          case bitc::VALUE_SYMTAB_BLOCK_ID:
-            if (std::error_code EC = parseValueSymbolTable()) return EC;
-            break;
-          case bitc::FUNCTION_SUMMARY_BLOCK_ID:
-            SeenFuncSummary = true;
-            if (IsLazy) {
-              // Lazy parsing of summary info, skip it.
-              if (Stream.SkipBlock()) return error("Invalid record");
-            } else if (std::error_code EC = parseEntireSummary())
-              return EC;
-            break;
-          case bitc::MODULE_STRTAB_BLOCK_ID:
-            if (std::error_code EC = parseModuleStringTable()) return EC;
-            break;
-        }
-        continue;
+    case BitstreamEntry::SubBlock:
+      if (CheckFuncSummaryPresenceOnly) {
+        if (Entry.ID == bitc::FUNCTION_SUMMARY_BLOCK_ID)
+          SeenFuncSummary = true;
+        if (Stream.SkipBlock())
+          return error("Invalid record");
+        // No need to parse the rest since we found the summary.
+        return std::error_code();
+      }
+      switch (Entry.ID) {
+      default: // Skip unknown content.
+        if (Stream.SkipBlock())
+          return error("Invalid record");
+        break;
+      case bitc::BLOCKINFO_BLOCK_ID:
+        // Need to parse these to get abbrev ids (e.g. for VST)
+        if (Stream.ReadBlockInfoBlock())
+          return error("Malformed block");
+        break;
+      case bitc::VALUE_SYMTAB_BLOCK_ID:
+        if (std::error_code EC = parseValueSymbolTable())
+          return EC;
+        break;
+      case bitc::FUNCTION_SUMMARY_BLOCK_ID:
+        SeenFuncSummary = true;
+        if (IsLazy) {
+          // Lazy parsing of summary info, skip it.
+          if (Stream.SkipBlock())
+            return error("Invalid record");
+        } else if (std::error_code EC = parseEntireSummary())
+          return EC;
+        break;
+      case bitc::MODULE_STRTAB_BLOCK_ID:
+        if (std::error_code EC = parseModuleStringTable())
+          return EC;
+        break;
+      }
+      continue;
 
-      case BitstreamEntry::Record:
-        Stream.skipRecord(Entry.ID);
-        continue;
+    case BitstreamEntry::Record:
+      Stream.skipRecord(Entry.ID);
+      continue;
     }
   }
 }
@@ -5449,14 +5458,14 @@ std::error_code FunctionIndexBitcodeReader::parseEntireSummary() {
     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
-      case BitstreamEntry::SubBlock:  // Handled for us already.
-      case BitstreamEntry::Error:
-        return error("Malformed block");
-      case BitstreamEntry::EndBlock:
-        return std::error_code();
-      case BitstreamEntry::Record:
-        // The interesting case.
-        break;
+    case BitstreamEntry::SubBlock: // Handled for us already.
+    case BitstreamEntry::Error:
+      return error("Malformed block");
+    case BitstreamEntry::EndBlock:
+      return std::error_code();
+    case BitstreamEntry::Record:
+      // The interesting case.
+      break;
     }
 
     // Read a record. The record format depends on whether this
@@ -5469,34 +5478,34 @@ std::error_code FunctionIndexBitcodeReader::parseEntireSummary() {
     Record.clear();
     uint64_t CurRecordBit = Stream.GetCurrentBitNo();
     switch (Stream.readRecord(Entry.ID, Record)) {
-      default:  // Default behavior: ignore.
-        break;
-      // FS_PERMODULE_ENTRY: [valueid, islocal, instcount]
-      case bitc::FS_CODE_PERMODULE_ENTRY: {
-        unsigned ValueID = Record[0];
-        bool IsLocal = Record[1];
-        unsigned InstCount = Record[2];
-        std::unique_ptr<FunctionSummary> FS =
-            llvm::make_unique<FunctionSummary>(InstCount);
-        FS->setLocalFunction(IsLocal);
-        // The module path string ref set in the summary must be owned by the
-        // index's module string table. Since we don't have a module path
-        // string table section in the per-module index, we create a single
-        // module path string table entry with an empty (0) ID to take
-        // ownership.
-        FS->setModulePath(
-            TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0));
-        SummaryMap[ValueID] = std::move(FS);
-      }
-      // FS_COMBINED_ENTRY: [modid, instcount]
-      case bitc::FS_CODE_COMBINED_ENTRY: {
-        uint64_t ModuleId = Record[0];
-        unsigned InstCount = Record[1];
-        std::unique_ptr<FunctionSummary> FS =
-            llvm::make_unique<FunctionSummary>(InstCount);
-        FS->setModulePath(ModuleIdMap[ModuleId]);
-        SummaryMap[CurRecordBit] = std::move(FS);
-      }
+    default: // Default behavior: ignore.
+      break;
+    // FS_PERMODULE_ENTRY: [valueid, islocal, instcount]
+    case bitc::FS_CODE_PERMODULE_ENTRY: {
+      unsigned ValueID = Record[0];
+      bool IsLocal = Record[1];
+      unsigned InstCount = Record[2];
+      std::unique_ptr<FunctionSummary> FS =
+          llvm::make_unique<FunctionSummary>(InstCount);
+      FS->setLocalFunction(IsLocal);
+      // The module path string ref set in the summary must be owned by the
+      // index's module string table. Since we don't have a module path
+      // string table section in the per-module index, we create a single
+      // module path string table entry with an empty (0) ID to take
+      // ownership.
+      FS->setModulePath(
+          TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0));
+      SummaryMap[ValueID] = std::move(FS);
+    }
+    // FS_COMBINED_ENTRY: [modid, instcount]
+    case bitc::FS_CODE_COMBINED_ENTRY: {
+      uint64_t ModuleId = Record[0];
+      unsigned InstCount = Record[1];
+      std::unique_ptr<FunctionSummary> FS =
+          llvm::make_unique<FunctionSummary>(InstCount);
+      FS->setModulePath(ModuleIdMap[ModuleId]);
+      SummaryMap[CurRecordBit] = std::move(FS);
+    }
     }
   }
   llvm_unreachable("Exit infinite loop");
@@ -5515,31 +5524,30 @@ std::error_code FunctionIndexBitcodeReader::parseModuleStringTable() {
     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
     switch (Entry.Kind) {
-      case BitstreamEntry::SubBlock:  // Handled for us already.
-      case BitstreamEntry::Error:
-        return error("Malformed block");
-      case BitstreamEntry::EndBlock:
-        return std::error_code();
-      case BitstreamEntry::Record:
-        // The interesting case.
-        break;
+    case BitstreamEntry::SubBlock: // Handled for us already.
+    case BitstreamEntry::Error:
+      return error("Malformed block");
+    case BitstreamEntry::EndBlock:
+      return std::error_code();
+    case BitstreamEntry::Record:
+      // The interesting case.
+      break;
     }
 
     Record.clear();
     switch (Stream.readRecord(Entry.ID, Record)) {
-      default:  // Default behavior: ignore.
-        break;
-      case bitc::MST_CODE_ENTRY: {
-        // MST_ENTRY: [modid, namechar x N]
-        if (convertToString(Record, 1, ModulePath))
-          return error("Invalid record");
-        uint64_t ModuleId = Record[0];
-        StringRef ModulePathInMap =
-            TheIndex->addModulePath(ModulePath, ModuleId);
-        ModuleIdMap[ModuleId] = ModulePathInMap;
-        ModulePath.clear();
-        break;
-      }
+    default: // Default behavior: ignore.
+      break;
+    case bitc::MST_CODE_ENTRY: {
+      // MST_ENTRY: [modid, namechar x N]
+      if (convertToString(Record, 1, ModulePath))
+        return error("Invalid record");
+      uint64_t ModuleId = Record[0];
+      StringRef ModulePathInMap = TheIndex->addModulePath(ModulePath, ModuleId);
+      ModuleIdMap[ModuleId] = ModulePathInMap;
+      ModulePath.clear();
+      break;
+    }
     }
   }
   llvm_unreachable("Exit infinite loop");
@@ -5550,10 +5558,12 @@ std::error_code FunctionIndexBitcodeReader::parseSummaryIndexInto(
     std::unique_ptr<DataStreamer> Streamer, FunctionInfoIndex *I) {
   TheIndex = I;
 
-  if (std::error_code EC = initStream(std::move(Streamer))) return EC;
+  if (std::error_code EC = initStream(std::move(Streamer)))
+    return EC;
 
   // Sniff for the signature.
-  if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature");
+  if (!hasValidBitcodeHeader(Stream))
+    return error("Invalid bitcode signature");
 
   // We expect a number of well-defined blocks, though we don't necessarily
   // need to understand them all.
@@ -5566,13 +5576,16 @@ std::error_code FunctionIndexBitcodeReader::parseSummaryIndexInto(
     BitstreamEntry Entry =
         Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
 
-    if (Entry.Kind != BitstreamEntry::SubBlock) return error("Malformed block");
+    if (Entry.Kind != BitstreamEntry::SubBlock)
+      return error("Malformed block");
 
     // If we see a MODULE_BLOCK, parse it to find the blocks needed for
     // building the function summary index.
-    if (Entry.ID == bitc::MODULE_BLOCK_ID) return parseModule();
+    if (Entry.ID == bitc::MODULE_BLOCK_ID)
+      return parseModule();
 
-    if (Stream.SkipBlock()) return error("Invalid record");
+    if (Stream.SkipBlock())
+      return error("Invalid record");
   }
 }
 
@@ -5586,38 +5599,41 @@ std::error_code FunctionIndexBitcodeReader::parseFunctionSummary(
     size_t FunctionSummaryOffset) {
   TheIndex = I;
 
-  if (std::error_code EC = initStream(std::move(Streamer))) return EC;
+  if (std::error_code EC = initStream(std::move(Streamer)))
+    return EC;
 
   // Sniff for the signature.
-  if (!hasValidBitcodeHeader(Stream)) return error("Invalid bitcode signature");
+  if (!hasValidBitcodeHeader(Stream))
+    return error("Invalid bitcode signature");
 
   Stream.JumpToBit(FunctionSummaryOffset);
 
   BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
 
   switch (Entry.Kind) {
-    default:
-      return error("Malformed block");
-    case BitstreamEntry::Record:
-      // The expected case.
-      break;
+  default:
+    return error("Malformed block");
+  case BitstreamEntry::Record:
+    // The expected case.
+    break;
   }
 
   // TODO: Read a record. This interface will be completed when ThinLTO
   // importing is added so that it can be tested.
   SmallVector<uint64_t, 64> Record;
   switch (Stream.readRecord(Entry.ID, Record)) {
-    case bitc::FS_CODE_COMBINED_ENTRY:
-    default:
-      return error("Invalid record");
+  case bitc::FS_CODE_COMBINED_ENTRY:
+  default:
+    return error("Invalid record");
   }
 
   return std::error_code();
 }
 
-std::error_code FunctionIndexBitcodeReader::initStream(
-    std::unique_ptr<DataStreamer> Streamer) {
-  if (Streamer) return initLazyStream(std::move(Streamer));
+std::error_code
+FunctionIndexBitcodeReader::initStream(std::unique_ptr<DataStreamer> Streamer) {
+  if (Streamer)
+    return initLazyStream(std::move(Streamer));
   return initStreamFromBuffer();
 }
 
@@ -5625,7 +5641,8 @@ std::error_code FunctionIndexBitcodeReader::initStreamFromBuffer() {
   const unsigned char *BufPtr = (const unsigned char *)Buffer->getBufferStart();
   const unsigned char *BufEnd = BufPtr + Buffer->getBufferSize();
 
-  if (Buffer->getBufferSize() & 3) return error("Invalid bitcode signature");
+  if (Buffer->getBufferSize() & 3)
+    return error("Invalid bitcode signature");
 
   // If we have a wrapper header, parse it and ignore the non-bc file contents.
   // The magic number is 0x0B17C0DE stored in little endian.
@@ -5653,7 +5670,8 @@ std::error_code FunctionIndexBitcodeReader::initLazyStream(
   if (Bytes.readBytes(buf, 16, 0) != 16)
     return error("Invalid bitcode signature");
 
-  if (!isBitcode(buf, buf + 16)) return error("Invalid bitcode signature");
+  if (!isBitcode(buf, buf + 16))
+    return error("Invalid bitcode signature");
 
   if (isBitcodeWrapper(buf, buf + 4)) {
     const unsigned char *bitcodeStart = buf;
@@ -5792,9 +5810,10 @@ llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context,
 // the index. Otherwise skip the function summary section, and only create
 // an index object with a map from function name to function summary offset.
 // The index is used to perform lazy function summary reading later.
-ErrorOr<std::unique_ptr<FunctionInfoIndex>> llvm::getFunctionInfoIndex(
-    MemoryBufferRef Buffer, LLVMContext &Context,
-    DiagnosticHandlerFunction DiagnosticHandler, bool IsLazy) {
+ErrorOr<std::unique_ptr<FunctionInfoIndex>>
+llvm::getFunctionInfoIndex(MemoryBufferRef Buffer, LLVMContext &Context,
+                           DiagnosticHandlerFunction DiagnosticHandler,
+                           bool IsLazy) {
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
   FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler, IsLazy);
 
@@ -5802,14 +5821,14 @@ ErrorOr<std::unique_ptr<FunctionInfoIndex>> llvm::getFunctionInfoIndex(
       llvm::make_unique<FunctionInfoIndex>();
 
   auto cleanupOnError = [&](std::error_code EC) {
-    R.releaseBuffer();  // Never take ownership on error.
+    R.releaseBuffer(); // Never take ownership on error.
     return EC;
   };
 
   if (std::error_code EC = R.parseSummaryIndexInto(nullptr, Index.get()))
     return cleanupOnError(EC);
 
-  Buf.release();  // The FunctionIndexBitcodeReader owns it now.
+  Buf.release(); // The FunctionIndexBitcodeReader owns it now.
   return std::move(Index);
 }
 
@@ -5821,14 +5840,14 @@ bool llvm::hasFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
                                true);
 
   auto cleanupOnError = [&](std::error_code EC) {
-    R.releaseBuffer();  // Never take ownership on error.
+    R.releaseBuffer(); // Never take ownership on error.
     return false;
   };
 
   if (std::error_code EC = R.parseSummaryIndexInto(nullptr, nullptr))
     return cleanupOnError(EC);
 
-  Buf.release();  // The FunctionIndexBitcodeReader owns it now.
+  Buf.release(); // The FunctionIndexBitcodeReader owns it now.
   return R.foundFuncSummary();
 }
 
@@ -5838,15 +5857,16 @@ bool llvm::hasFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
 // Then this method is called for each function considered for importing,
 // to parse the summary information for the given function name into
 // the index.
-std::error_code llvm::readFunctionSummary(
-    MemoryBufferRef Buffer, LLVMContext &Context,
-    DiagnosticHandlerFunction DiagnosticHandler, StringRef FunctionName,
-    std::unique_ptr<FunctionInfoIndex> Index) {
+std::error_code
+llvm::readFunctionSummary(MemoryBufferRef Buffer, LLVMContext &Context,
+                          DiagnosticHandlerFunction DiagnosticHandler,
+                          StringRef FunctionName,
+                          std::unique_ptr<FunctionInfoIndex> Index) {
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
   FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler);
 
   auto cleanupOnError = [&](std::error_code EC) {
-    R.releaseBuffer();  // Never take ownership on error.
+    R.releaseBuffer(); // Never take ownership on error.
     return EC;
   };
 
@@ -5861,6 +5881,6 @@ std::error_code llvm::readFunctionSummary(
       return cleanupOnError(EC);
   }
 
-  Buf.release();  // The FunctionIndexBitcodeReader owns it now.
+  Buf.release(); // The FunctionIndexBitcodeReader owns it now.
   return std::error_code();
 }
index 5e90cd1..e9bc507 100644 (file)
@@ -583,7 +583,8 @@ static void writeComdats(const ValueEnumerator &VE, BitstreamWriter &Stream) {
 /// after the real VST is written. Returns the bit offset to backpatch.
 static uint64_t WriteValueSymbolTableForwardDecl(const ValueSymbolTable &VST,
                                                  BitstreamWriter &Stream) {
-  if (VST.empty()) return 0;
+  if (VST.empty())
+    return 0;
 
   // Write a placeholder value in for the offset of the real VST,
   // which is written after the function blocks so that it can include
@@ -2220,8 +2221,8 @@ static void WriteValueSymbolTable(
     // 8-bit fixed-width VST_FNENTRY function strings.
     BitCodeAbbrev *Abbv = new BitCodeAbbrev();
     Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));  // value id
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));  // funcoffset
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
     FnEntry8BitAbbrev = Stream.EmitAbbrev(Abbv);
@@ -2229,8 +2230,8 @@ static void WriteValueSymbolTable(
     // 7-bit fixed width VST_FNENTRY function strings.
     Abbv = new BitCodeAbbrev();
     Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));  // value id
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));  // funcoffset
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
     FnEntry7BitAbbrev = Stream.EmitAbbrev(Abbv);
@@ -2238,8 +2239,8 @@ static void WriteValueSymbolTable(
     // 6-bit char6 VST_FNENTRY function strings.
     Abbv = new BitCodeAbbrev();
     Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_FNENTRY));
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));  // value id
-    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));  // funcoffset
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
+    Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
     Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
     FnEntry6BitAbbrev = Stream.EmitAbbrev(Abbv);
@@ -2303,7 +2304,8 @@ static void WriteValueSymbolTable(
         AbbrevToUse = VST_ENTRY_7_ABBREV;
     }
 
-    for (const auto P : Name.getKey()) NameVals.push_back((unsigned char)P);
+    for (const auto P : Name.getKey())
+      NameVals.push_back((unsigned char)P);
 
     // Emit the finished record.
     Stream.EmitRecord(Code, NameVals, AbbrevToUse);
@@ -2321,7 +2323,7 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index,
   // 8-bit fixed-width VST_COMBINED_FNENTRY function strings.
   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY));
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));  // funcoffset
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
   unsigned FnEntry8BitAbbrev = Stream.EmitAbbrev(Abbv);
@@ -2329,7 +2331,7 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index,
   // 7-bit fixed width VST_COMBINED_FNENTRY function strings.
   Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY));
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));  // funcoffset
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
   unsigned FnEntry7BitAbbrev = Stream.EmitAbbrev(Abbv);
@@ -2337,7 +2339,7 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index,
   // 6-bit char6 VST_COMBINED_FNENTRY function strings.
   Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_COMBINED_FNENTRY));
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));  // funcoffset
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // funcoffset
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
   unsigned FnEntry6BitAbbrev = Stream.EmitAbbrev(Abbv);
@@ -2361,7 +2363,8 @@ static void WriteCombinedValueSymbolTable(const FunctionInfoIndex &Index,
       else if (Bits == SE_Fixed7)
         AbbrevToUse = FnEntry7BitAbbrev;
 
-      for (const auto P : FuncName) NameVals.push_back((unsigned char)P);
+      for (const auto P : FuncName)
+        NameVals.push_back((unsigned char)P);
 
       // Emit the finished record.
       Stream.EmitRecord(bitc::VST_CODE_COMBINED_FNENTRY, NameVals, AbbrevToUse);
@@ -2466,7 +2469,8 @@ static void WriteFunction(
          I != E; ++I) {
       WriteInstruction(*I, InstID, VE, Stream, Vals);
 
-      if (!isa<DbgInfoIntrinsic>(I)) ++NumInsts;
+      if (!isa<DbgInfoIntrinsic>(I))
+        ++NumInsts;
 
       if (!I->getType()->isVoidTy())
         ++InstID;
@@ -2728,7 +2732,8 @@ static void WriteModStrings(const FunctionInfoIndex &I,
 
     NameVals.push_back(MPSE.getValue());
 
-    for (const auto P : MPSE.getKey()) NameVals.push_back((unsigned char)P);
+    for (const auto P : MPSE.getKey())
+      NameVals.push_back((unsigned char)P);
 
     // Emit the finished record.
     Stream.EmitRecord(bitc::MST_CODE_ENTRY, NameVals, AbbrevToUse);
@@ -2761,16 +2766,17 @@ static void WritePerModuleFunctionSummary(
   // Abbrev for FS_CODE_PERMODULE_ENTRY.
   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_PERMODULE_ENTRY));
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));    // valueid
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));  // islocal
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));    // instcount
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // islocal
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount
   unsigned FSAbbrev = Stream.EmitAbbrev(Abbv);
 
   SmallVector<unsigned, 64> NameVals;
   for (auto &I : FunctionIndex) {
     // Skip anonymous functions. We will emit a function summary for
     // any aliases below.
-    if (!I.first->hasName()) continue;
+    if (!I.first->hasName())
+      continue;
 
     WritePerModuleFunctionSummaryRecord(
         NameVals, I.second->functionSummary(),
@@ -2779,9 +2785,11 @@ static void WritePerModuleFunctionSummary(
   }
 
   for (const GlobalAlias &A : M->aliases()) {
-    if (!A.getBaseObject()) continue;
+    if (!A.getBaseObject())
+      continue;
     const Function *F = dyn_cast<Function>(A.getBaseObject());
-    if (!F || F->isDeclaration()) continue;
+    if (!F || F->isDeclaration())
+      continue;
 
     assert(FunctionIndex.count(F) == 1);
     WritePerModuleFunctionSummaryRecord(
@@ -2802,8 +2810,8 @@ static void WriteCombinedFunctionSummary(const FunctionInfoIndex &I,
   // Abbrev for FS_CODE_COMBINED_ENTRY.
   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_COMBINED_ENTRY));
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));  // modid
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));  // instcount
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
   unsigned FSAbbrev = Stream.EmitAbbrev(Abbv);
 
   SmallVector<unsigned, 64> NameVals;
index c5f88fc..b1e8ebc 100644 (file)
@@ -1,4 +1,5 @@
-//===- FunctionIndexObjectFile.cpp - Function index file implementation ----===//
+//===- FunctionIndexObjectFile.cpp - Function index file implementation
+//----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -32,14 +33,16 @@ std::unique_ptr<FunctionInfoIndex> FunctionIndexObjectFile::takeIndex() {
   return std::move(Index);
 }
 
-ErrorOr<MemoryBufferRef> FunctionIndexObjectFile::findBitcodeInObject(
-    const ObjectFile &Obj) {
+ErrorOr<MemoryBufferRef>
+FunctionIndexObjectFile::findBitcodeInObject(const ObjectFile &Obj) {
   for (const SectionRef &Sec : Obj.sections()) {
     StringRef SecName;
-    if (std::error_code EC = Sec.getName(SecName)) return EC;
+    if (std::error_code EC = Sec.getName(SecName))
+      return EC;
     if (SecName == ".llvmbc") {
       StringRef SecContents;
-      if (std::error_code EC = Sec.getContents(SecContents)) return EC;
+      if (std::error_code EC = Sec.getContents(SecContents))
+        return EC;
       return MemoryBufferRef(SecContents, Obj.getFileName());
     }
   }
@@ -47,22 +50,23 @@ ErrorOr<MemoryBufferRef> FunctionIndexObjectFile::findBitcodeInObject(
   return object_error::bitcode_section_not_found;
 }
 
-ErrorOr<MemoryBufferRef> FunctionIndexObjectFile::findBitcodeInMemBuffer(
-    MemoryBufferRef Object) {
+ErrorOr<MemoryBufferRef>
+FunctionIndexObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
   sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer());
   switch (Type) {
-    case sys::fs::file_magic::bitcode:
-      return Object;
-    case sys::fs::file_magic::elf_relocatable:
-    case sys::fs::file_magic::macho_object:
-    case sys::fs::file_magic::coff_object: {
-      ErrorOr<std::unique_ptr<ObjectFile>> ObjFile =
-          ObjectFile::createObjectFile(Object, Type);
-      if (!ObjFile) return ObjFile.getError();
-      return findBitcodeInObject(*ObjFile->get());
-    }
-    default:
-      return object_error::invalid_file_type;
+  case sys::fs::file_magic::bitcode:
+    return Object;
+  case sys::fs::file_magic::elf_relocatable:
+  case sys::fs::file_magic::macho_object:
+  case sys::fs::file_magic::coff_object: {
+    ErrorOr<std::unique_ptr<ObjectFile>> ObjFile =
+        ObjectFile::createObjectFile(Object, Type);
+    if (!ObjFile)
+      return ObjFile.getError();
+    return findBitcodeInObject(*ObjFile->get());
+  }
+  default:
+    return object_error::invalid_file_type;
   }
 }
 
@@ -71,7 +75,8 @@ ErrorOr<MemoryBufferRef> FunctionIndexObjectFile::findBitcodeInMemBuffer(
 bool FunctionIndexObjectFile::hasFunctionSummaryInMemBuffer(
     MemoryBufferRef Object, LLVMContext &Context) {
   ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
-  if (!BCOrErr) return false;
+  if (!BCOrErr)
+    return false;
 
   return hasFunctionSummary(BCOrErr.get(), Context, nullptr);
 }
@@ -85,12 +90,14 @@ FunctionIndexObjectFile::create(MemoryBufferRef Object, LLVMContext &Context,
   std::unique_ptr<FunctionInfoIndex> Index;
 
   ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
-  if (!BCOrErr) return BCOrErr.getError();
+  if (!BCOrErr)
+    return BCOrErr.getError();
 
   ErrorOr<std::unique_ptr<FunctionInfoIndex>> IOrErr =
       getFunctionInfoIndex(BCOrErr.get(), Context, nullptr, IsLazy);
 
-  if (std::error_code EC = IOrErr.getError()) return EC;
+  if (std::error_code EC = IOrErr.getError())
+    return EC;
 
   Index = std::move(IOrErr.get());
 
@@ -104,11 +111,11 @@ std::error_code FunctionIndexObjectFile::findFunctionSummaryInMemBuffer(
     MemoryBufferRef Object, LLVMContext &Context, StringRef FunctionName) {
   sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer());
   switch (Type) {
-    case sys::fs::file_magic::bitcode: {
-      return readFunctionSummary(Object, Context, nullptr, FunctionName,
-                                 std::move(Index));
-    }
-    default:
-      return object_error::invalid_file_type;
+  case sys::fs::file_magic::bitcode: {
+    return readFunctionSummary(Object, Context, nullptr, FunctionName,
+                               std::move(Index));
+  }
+  default:
+    return object_error::invalid_file_type;
   }
 }
index 4394bfe..e13c00a 100644 (file)
@@ -1,4 +1,5 @@
-//===-- ElimAvailExtern.cpp - DCE unreachable internal functions ----------------===//
+//===-- ElimAvailExtern.cpp - DCE unreachable internal functions
+//----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -26,18 +27,18 @@ STATISTIC(NumFunctions, "Number of functions removed");
 STATISTIC(NumVariables, "Number of global variables removed");
 
 namespace {
-  struct EliminateAvailableExternally : public ModulePass {
-    static char ID; // Pass identification, replacement for typeid
-    EliminateAvailableExternally() : ModulePass(ID) {
-      initializeEliminateAvailableExternallyPass(
-          *PassRegistry::getPassRegistry());
-    }
+struct EliminateAvailableExternally : public ModulePass {
+  static char ID; // Pass identification, replacement for typeid
+  EliminateAvailableExternally() : ModulePass(ID) {
+    initializeEliminateAvailableExternallyPass(
+        *PassRegistry::getPassRegistry());
+  }
 
-    // run - Do the EliminateAvailableExternally pass on the specified module,
-    // optionally updating the specified callgraph to reflect the changes.
-    //
-    bool runOnModule(Module &M) override;
-  };
+  // run - Do the EliminateAvailableExternally pass on the specified module,
+  // optionally updating the specified callgraph to reflect the changes.
+  //
+  bool runOnModule(Module &M) override;
+};
 }
 
 char EliminateAvailableExternally::ID = 0;
@@ -52,7 +53,7 @@ bool EliminateAvailableExternally::runOnModule(Module &M) {
   bool Changed = false;
 
   // Drop initializers of available externally global variables.
-  for (GlobalVariable &GV :M.globals()) {
+  for (GlobalVariable &GV : M.globals()) {
     if (!GV.hasAvailableExternallyLinkage())
       continue;
     if (GV.hasInitializer()) {
index 5365b99..ecf12f8 100644 (file)
@@ -385,7 +385,8 @@ static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file,
 
   // If we are doing ThinLTO compilation, don't need to process the symbols.
   // Later we simply build a combined index file after all files are claimed.
-  if (options::thinlto) return LDPS_OK;
+  if (options::thinlto)
+    return LDPS_OK;
 
   for (auto &Sym : Obj->symbols()) {
     uint32_t Symflags = Sym.getFlags();
@@ -602,8 +603,9 @@ static void freeSymName(ld_plugin_symbol &Sym) {
   Sym.comdat_key = nullptr;
 }
 
-static std::unique_ptr<FunctionInfoIndex> getFunctionIndexForFile(
-    LLVMContext &Context, claimed_file &F, ld_plugin_input_file &Info) {
+static std::unique_ptr<FunctionInfoIndex>
+getFunctionIndexForFile(LLVMContext &Context, claimed_file &F,
+                        ld_plugin_input_file &Info) {
 
   if (get_symbols(F.handle, F.syms.size(), &F.syms[0]) != LDPS_OK)
     message(LDPL_FATAL, "Failed to get symbol information");
index 56f6171..3c82779 100644 (file)
@@ -284,14 +284,16 @@ static const char *GetCodeName(unsigned CodeID, unsigned BlockID,
     }
   case bitc::MODULE_STRTAB_BLOCK_ID:
     switch (CodeID) {
-    default: return nullptr;
-    STRINGIFY_CODE(MST_CODE, ENTRY)
+    default:
+      return nullptr;
+      STRINGIFY_CODE(MST_CODE, ENTRY)
     }
   case bitc::FUNCTION_SUMMARY_BLOCK_ID:
     switch (CodeID) {
-    default: return nullptr;
-    STRINGIFY_CODE(FS_CODE, PERMODULE_ENTRY)
-    STRINGIFY_CODE(FS_CODE, COMBINED_ENTRY)
+    default:
+      return nullptr;
+      STRINGIFY_CODE(FS_CODE, PERMODULE_ENTRY)
+      STRINGIFY_CODE(FS_CODE, COMBINED_ENTRY)
     }
   case bitc::METADATA_ATTACHMENT_ID:
     switch(CodeID) {
@@ -534,7 +536,8 @@ static bool ParseBlock(BitstreamCursor &Stream, unsigned BlockID,
             }
             Str += (char)Record[j];
           }
-          if (ArrayIsPrintable) outs() << " record string = '" << Str << "'";
+          if (ArrayIsPrintable)
+            outs() << " record string = '" << Str << "'";
           break;
         }
       }
index b35384a..cdfe97f 100644 (file)
@@ -59,9 +59,9 @@ static cl::opt<bool>
 UseDiagnosticHandler("use-diagnostic-handler", cl::init(false),
   cl::desc("Use a diagnostic handler to test the handler interface"));
 
-static cl::opt<bool> ThinLTO(
-    "thinlto", cl::init(false),
-    cl::desc("Only write combined global index for ThinLTO backends"));
+static cl::opt<bool>
+    ThinLTO("thinlto", cl::init(false),
+            cl::desc("Only write combined global index for ThinLTO backends"));
 
 static cl::list<std::string>
 InputFilenames(cl::Positional, cl::OneOrMore,
@@ -160,8 +160,9 @@ static int listSymbols(StringRef Command, const TargetOptions &Options) {
 
 /// Parse the function index out of an IR file and return the function
 /// index object if found, or nullptr if not.
-static std::unique_ptr<FunctionInfoIndex> getFunctionIndexForFile(
-    StringRef Path, std::string &Error, LLVMContext &Context) {
+static std::unique_ptr<FunctionInfoIndex>
+getFunctionIndexForFile(StringRef Path, std::string &Error,
+                        LLVMContext &Context) {
   std::unique_ptr<MemoryBuffer> Buffer;
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFile(Path);
@@ -238,7 +239,8 @@ int main(int argc, char **argv) {
   if (ListSymbolsOnly)
     return listSymbols(argv[0], Options);
 
-  if (ThinLTO) return createCombinedFunctionIndex(argv[0]);
+  if (ThinLTO)
+    return createCombinedFunctionIndex(argv[0]);
 
   unsigned BaseArg = 0;