InstrProf: Detect magic numbers in a more scalable way

No functionality change.

<rdar://problem/15950346>

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

diff --git a/include/llvm/ProfileData/InstrProfReader.h b/include/llvm/ProfileData/InstrProfReader.h
index e2c59cf186bb1daaf5d200b541a78becca30a5c1..3cfbf805a5fd12cbbc1b7241995b14f481870044 100644 (file)
--- a/include/llvm/ProfileData/InstrProfReader.h
+++ b/include/llvm/ProfileData/InstrProfReader.h
@@ -163,6 +163,7 @@ private:
 public:
   RawInstrProfReader(std::unique_ptr<MemoryBuffer> &DataBuffer);
 
+  static bool hasFormat(const MemoryBuffer &DataBuffer);
   error_code readHeader() override;
   error_code readNextRecord(InstrProfRecord &Record) override;
 

diff --git a/lib/ProfileData/InstrProfReader.cpp b/lib/ProfileData/InstrProfReader.cpp
index d2e5fbd9b9a132c33d4e76f3b2a40965cefb608e..c317a457bb6d898fc508307855bc83754799e94d 100644 (file)
--- a/lib/ProfileData/InstrProfReader.cpp
+++ b/lib/ProfileData/InstrProfReader.cpp
@@ -19,18 +19,6 @@
 
 using namespace llvm;
 
-static uint64_t getRawMagic() {
-  return
-    uint64_t('l') << 56 |
-    uint64_t('p') << 48 |
-    uint64_t('r') << 40 |
-    uint64_t('o') << 32 |
-    uint64_t('f') << 24 |
-    uint64_t('r') << 16 |
-    uint64_t('a') <<  8 |
-    uint64_t('w');
-}
-
 error_code InstrProfReader::create(std::string Path,
                                    std::unique_ptr<InstrProfReader> &Result) {
   std::unique_ptr<MemoryBuffer> Buffer;
@@ -41,17 +29,13 @@ error_code InstrProfReader::create(std::string Path,
   if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
     return instrprof_error::too_large;
 
-  if (Buffer->getBufferSize() < sizeof(uint64_t)) {
-    Result.reset(new TextInstrProfReader(Buffer));
-    return Result->readHeader();
-  }
-
-  uint64_t Magic = *(uint64_t *)Buffer->getBufferStart();
-  uint64_t SwappedMagic = sys::SwapByteOrder(Magic);
-  if (Magic == getRawMagic() || SwappedMagic == getRawMagic())
+  // Create the reader.
+  if (RawInstrProfReader::hasFormat(*Buffer))
     Result.reset(new RawInstrProfReader(Buffer));
   else
     Result.reset(new TextInstrProfReader(Buffer));
+
+  // Read the header and return the result.
   return Result->readHeader();
 }
 
@@ -101,29 +85,43 @@ error_code TextInstrProfReader::readNextRecord(InstrProfRecord &Record) {
   return success();
 }
 
-static uint64_t getRawVersion() {
-  return 1;
-}
-namespace {
-}
 RawInstrProfReader::RawInstrProfReader(std::unique_ptr<MemoryBuffer> &DataBuffer)
     : DataBuffer(DataBuffer.release()) { }
 
+static uint64_t getRawMagic() {
+  return
+    uint64_t('l') << 56 |
+    uint64_t('p') << 48 |
+    uint64_t('r') << 40 |
+    uint64_t('o') << 32 |
+    uint64_t('f') << 24 |
+    uint64_t('r') << 16 |
+    uint64_t('a') <<  8 |
+    uint64_t('w');
+}
+
+bool RawInstrProfReader::hasFormat(const MemoryBuffer &DataBuffer) {
+  if (DataBuffer.getBufferSize() < sizeof(getRawMagic()))
+    return false;
+  const RawHeader *Header = (const RawHeader *)DataBuffer.getBufferStart();
+  return getRawMagic() == Header->Magic ||
+    sys::SwapByteOrder(getRawMagic()) == Header->Magic;
+}
+
 error_code RawInstrProfReader::readHeader() {
+  if (!hasFormat(*DataBuffer))
+    return error(instrprof_error::bad_magic);
   if (DataBuffer->getBufferSize() < sizeof(RawHeader))
     return error(instrprof_error::bad_header);
-  const RawHeader *Header = (RawHeader *)DataBuffer->getBufferStart();
-  if (Header->Magic == getRawMagic())
-    ShouldSwapBytes = false;
-  else {
-    if (sys::SwapByteOrder(Header->Magic) != getRawMagic())
-      return error(instrprof_error::bad_magic);
-
-    ShouldSwapBytes = true;
-  }
+  const RawHeader *Header = (const RawHeader *)DataBuffer->getBufferStart();
+  ShouldSwapBytes = Header->Magic != getRawMagic();
   return readHeader(*Header);
 }
 
+static uint64_t getRawVersion() {
+  return 1;
+}
+
 error_code RawInstrProfReader::readHeader(const RawHeader &Header) {
   if (swap(Header.Version) != getRawVersion())
     return error(instrprof_error::unsupported_version);