Add small text file reader facility.

[dnovillo]

Summary

This adds a new utility class in lib/Support: A class to read small
text files one line at a time. It's meant to be a very simple file
reading interface with support for keeping track of line numbers and
specifying a character to mark line comments.

The code has been factored out of the sample profiler pass.

include/llvm/Support/FileUtilities.h

 // This file defines a family of utility functions which are useful for doing
 // various things with files.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_FILEUTILITIES_H
 #define LLVM_SUPPORT_FILEUTILITIES_H
 
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
 namespace llvm {
 
   /// DiffFilesWithTolerance - Compare the two files specified, returning 0 if
   /// the files match, 1 if they are different, and 2 if there is a file error.
   /// This function allows you to specify an absolute and relative FP error that
void setFile(const Twine& filename, bool deleteIt = true) {
       filename.toVector(Filename);
       DeleteIt = deleteIt;
     }
 
     /// releaseFile - Take ownership of the file away from the FileRemover so it
     /// will not be removed when the object is destroyed.
     void releaseFile() { DeleteIt = false; }
   };
+
+  /// \brief Small text file reader.
+  ///
+  /// This class defines a very simple interface to read text files one line
+  /// at a time. It keeps track of line number information and location of
+  /// the file pointer. Users of this class are responsible for actually
+  /// parsing the lines returned by the readLine() function.
+  ///
+  /// The reader optionally supports comment markers. A comment marker is
+  /// a single character. If a comment marker is specified
+  /// at construction time, lines starting with that marker will be
+  /// ignored. In those cases, readLine() will return an empty StringRef.
+  ///
+  /// Note that this uses MemoryBuffer for reading the file, so it
+  /// should not be used on large files.
+  class FileReader {
+  public:
+    FileReader(StringRef F, const char Marker = '\0')
+        : Filename(F), CommentMarker(Marker) {
+      error_code EC;
+      EC = MemoryBuffer::getFile(Filename, Buffer);
+      if (EC)
+        report_fatal_error("Could not open file " + Filename + ": " +
+                           EC.message());
+      FP = Buffer->getBufferStart();
+      Lineno = 0;
+    }
+
+    /// \brief Read a line from the mapped file.
+    StringRef readLine() {
+      size_t Length = 0;
+      const char *start = FP;
+      while (FP != Buffer->getBufferEnd() && *FP != '\n') {
+        Length++;
+        FP++;
+      }
+      if (FP != Buffer->getBufferEnd())
+        FP++;
+      Lineno++;
+      // If we are using comment markers and the line started with one,
+      // return an empty string.
+      if (CommentMarker && start[0] == CommentMarker)
+        return StringRef();
+      return StringRef(start, Length);
+    }
+
+    /// \brief Return true, if we've reached EOF.
+    bool atEOF() const { return FP == Buffer->getBufferEnd(); }
+
+    /// \brief Return the current line number.
+    int64_t getLineno() const { return Lineno; }
+
+    /// \brief Report a parse error message and stop compilation.
+    void reportParseError(Twine Msg) const {
+      report_fatal_error(Filename + ":" + Twine(Lineno) + ": " + Msg + "\n");
+    }
+
+  private:
+    /// \brief Memory buffer holding the text file.
+    OwningPtr<MemoryBuffer> Buffer;
+
+    /// \brief Current position into the memory buffer.
+    const char *FP;
+
+    /// \brief Current line number.
+    int64_t Lineno;
+
+    /// \brief Path name to the file being read.
+    StringRef Filename;
+
+    /// \brief Comment marker. If this is non-zero, lines starting with
+    /// this character are ignored.
+    const char CommentMarker;
+  };
+
 } // End llvm namespace
 
 #endif

lib/Support/FileUtilities.cpp

if (!CompareFailed && (!F1AtEnd || !F2AtEnd)) {
 
     // If we found the end, we succeeded.
     if (F1P < File1End || F2P < File2End)
       CompareFailed = true;
   }
 
   return CompareFailed;
 }
+
+/// \brief Loader class for text-based profiles.
+///
+/// This class defines a simple interface to read text files containing
+/// profiles. It keeps track of line number information and location of
+/// the file pointer. Users of this class are responsible for actually
+/// parsing the lines returned by the readLine function.
+///
+/// TODO - This does not really belong here. It is a generic text file
+/// reader. It should be moved to the Support library and made more general.
+class ExternalProfileTextLoader {
+public:
+  ExternalProfileTextLoader(StringRef F) : Filename(F) {
+    error_code EC;
+    EC = MemoryBuffer::getFile(Filename, Buffer);
+    if (EC)
+      report_fatal_error("Could not open profile file " + Filename + ": " +
+                         EC.message());
+    FP = Buffer->getBufferStart();
+    Lineno = 0;
+  }
+
+  /// \brief Read a line from the mapped file.
+  StringRef readLine() {
+    size_t Length = 0;
+    const char *start = FP;
+    while (FP != Buffer->getBufferEnd() && *FP != '\n') {
+      Length++;
+      FP++;
+    }
+    if (FP != Buffer->getBufferEnd())
+      FP++;
+    Lineno++;
+    return StringRef(start, Length);
+  }
+
+  /// \brief Return true, if we've reached EOF.
+  bool atEOF() const { return FP == Buffer->getBufferEnd(); }
+
+  /// \brief Report a parse error message and stop compilation.
+  void reportParseError(Twine Msg) const {
+    report_fatal_error(Filename + ":" + Twine(Lineno) + ": " + Msg + "\n");
+  }
+
+private:
+  /// \brief Memory buffer holding the text file.
+  OwningPtr<MemoryBuffer> Buffer;
+
+  /// \brief Current position into the memory buffer.
+  const char *FP;
+
+  /// \brief Current line number.
+  int64_t Lineno;
+
+  /// \brief Path name where to the profile file.
+  StringRef Filename;
+};
+

lib/Transforms/Scalar/SampleProfile.cpp

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/InstIterator.h"
-#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Scalar.h"
 
 using namespace llvm;
 
 // Command line option to specify the file to read samples from. This is
 // mainly used for debugging.
protected:
   ///
   /// The format of this file is defined by each profiler
   /// independently. If possible, the profiler should have a text
   /// version of the profile format to be used in constructing test
   /// cases and debugging.
   StringRef Filename;
 };
 
-/// \brief Loader class for text-based profiles.
-///
-/// This class defines a simple interface to read text files containing
-/// profiles. It keeps track of line number information and location of
-/// the file pointer. Users of this class are responsible for actually
-/// parsing the lines returned by the readLine function.
-///
-/// TODO - This does not really belong here. It is a generic text file
-/// reader. It should be moved to the Support library and made more general.
-class ExternalProfileTextLoader {
-public:
-  ExternalProfileTextLoader(StringRef F) : Filename(F) {
-    error_code EC;
-    EC = MemoryBuffer::getFile(Filename, Buffer);
-    if (EC)
-      report_fatal_error("Could not open profile file " + Filename + ": " +
-                         EC.message());
-    FP = Buffer->getBufferStart();
-    Lineno = 0;
-  }
-
-  /// \brief Read a line from the mapped file.
-  StringRef readLine() {
-    size_t Length = 0;
-    const char *start = FP;
-    while (FP != Buffer->getBufferEnd() && *FP != '\n') {
-      Length++;
-      FP++;
-    }
-    if (FP != Buffer->getBufferEnd())
-      FP++;
-    Lineno++;
-    return StringRef(start, Length);
-  }
-
-  /// \brief Return true, if we've reached EOF.
-  bool atEOF() const { return FP == Buffer->getBufferEnd(); }
-
-  /// \brief Report a parse error message and stop compilation.
-  void reportParseError(Twine Msg) const {
-    report_fatal_error(Filename + ":" + Twine(Lineno) + ": " + Msg + "\n");
-  }
-
-private:
-  /// \brief Memory buffer holding the text file.
-  OwningPtr<MemoryBuffer> Buffer;
-
-  /// \brief Current position into the memory buffer.
-  const char *FP;
-
-  /// \brief Current line number.
-  int64_t Lineno;
-
-  /// \brief Path name where to the profile file.
-  StringRef Filename;
-};
-
 /// \brief Sample profile pass.
 ///
 /// This pass reads profile data from the file specified by
 /// -sample-profile-file and annotates every affected function with the
 /// profile information found in that file.
 class SampleProfileLoader : public FunctionPass {
 public:
   // Class identification, replacement for typeinfo

 /// TODO - flat profiles are too imprecise to provide good optimization
 /// opportunities. Convert them to context-sensitive profile.
 ///
 /// This textual representation is useful to generate unit tests and
 /// for debugging purposes, but it should not be used to generate
 /// profiles for large programs, as the representation is extremely
 /// inefficient.
 void SampleModuleProfile::loadText() {
-  ExternalProfileTextLoader Loader(Filename);
+  FileReader Loader(Filename, '#');
 
   // Read the symbol table.
   StringRef Line = Loader.readLine();
   if (Line != "symbol table")
     Loader.reportParseError("Expected 'symbol table', found " + Line);
   int NumSymbols;
   Line = Loader.readLine();
   if (Line.getAsInteger(10, NumSymbols))

unittests/Support/CMakeLists.txt

add_llvm_unittest(SupportTests
   CommandLineTest.cpp
   CompressionTest.cpp
   ConstantRangeTest.cpp
   ConvertUTFTest.cpp
   DataExtractorTest.cpp
   EndianTest.cpp
   ErrorOrTest.cpp
   FileOutputBufferTest.cpp
+  FileReaderTest.cpp
   LeakDetectorTest.cpp
   LockFileManagerTest.cpp
   ManagedStatic.cpp
   MathExtrasTest.cpp
   MD5Test.cpp
   MemoryBufferTest.cpp
   MemoryTest.cpp
   Path.cpp

unittests/Support/FileReaderTest.cpp

+//===- llvm/unittest/Support/FileReader.cpp - unit tests ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/FileOutputBuffer.h"
+#include "llvm/Support/FileUtilities.h"
+#include "llvm/ADT/OwningPtr.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::sys;
+
+#define ASSERT_NO_ERROR(x)                                                     \
+  if (error_code ASSERT_NO_ERROR_ec = x) {                                     \
+    errs() << #x ": did not return errc::success.\n"                           \
+           << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"           \
+           << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";       \
+  } else {                                                                     \
+  }
+
+namespace {
+
+TEST(FileReader, Test) {
+  // Create unique temporary directory for these tests.
+  SmallString<128> TestDirectory;
+  {
+    ASSERT_NO_ERROR(
+        fs::createUniqueDirectory("FileReader-test", TestDirectory));
+  }
+
+  // Create a small text file.
+  SmallString<128> File(TestDirectory);
+  File.append("/file.txt");
+  OwningPtr<FileOutputBuffer> Buffer;
+  ASSERT_NO_ERROR(FileOutputBuffer::create(File, 8192, Buffer));
+  const char contents[] = "line 1\nline 2\nline 3\n; commented line\n";
+  memcpy(Buffer->getBufferStart(), contents, sizeof(contents));
+  ASSERT_NO_ERROR(Buffer->commit());
+
+  // Test 1: Read it with no comment markers.
+  {
+    FileReader Reader(File);
+    EXPECT_FALSE(Reader.atEOF());
+    StringRef Line;
+    Line = Reader.readLine();
+    EXPECT_EQ(Line, "line 1");
+    Line = Reader.readLine();
+    EXPECT_EQ(Line, "line 2");
+    EXPECT_EQ(Reader.getLineno(), 2);
+    Line = Reader.readLine();
+    EXPECT_EQ(Line, "line 3");
+    Line = Reader.readLine();
+    EXPECT_EQ(Line, "; commented line");
+    Reader.readLine();
+    EXPECT_EQ(Reader.getLineno(), 5);
+    EXPECT_TRUE(Reader.atEOF());
+  }
+
+  // Test 2: Read it with ';' as a comment marker.
+  {
+    FileReader Reader(File, ';');
+    for (int i = 0; i < 3; ++i)
+      Reader.readLine();
+    EXPECT_EQ(Reader.getLineno(), 3);
+    StringRef Empty = Reader.readLine();
+    EXPECT_EQ(Empty, "");
+    Reader.readLine();
+    EXPECT_TRUE(Reader.atEOF());
+  }
+
+  // Clean up.
+  uint32_t RemovedCount;
+  ASSERT_NO_ERROR(fs::remove_all(TestDirectory.str(), RemovedCount));
+}
+
+} // anonymous namespace