Implement tool to convert bitcode to text.

[kschimpf]

Summary

Provide a new tool for LLVM bitcode files that makes it easier to test
and fuzz. That is, a simple textual form that captures the contents of
binary bitcode files.

The textual form removes all references to abbreviations in the binary
bitcode file. This is done to simplify its form.

A textual bitcode record is a sequence of (unsigned) integers,
separated by commas, and terminated with a semicolin. Each bitcode
record appears on a separate line.

The tool llvm-bcanalyzer also provides a textual version of bitcode
files. However, it doesn't provide anyway to convert the output back
to a binary bitcode file. It is also much more complex.

Besides providing a command line tool, it set up for use with lit
(LLVM Integrated Tester). Invalid bitcode tests, that don't
corresponding to abbreviations and bitstream issues, can be written as
a text file. This text file can run tests and check the results using
FileCheck.

The use of textual bitcode files (unlike the current invalid bitcode
tests) can use a single file to describe the invalid test. It also has
the advantage of being easier to port if the format of bitcode records
change. In such cases, you only need to edit the problematic textual
bitcode records that have changed since the test was added. Current
tests are in binary form, and very difficult to figure out how to
change when the bitcode format changes.

For fuzzing, the text form is easy to model using tokens (the digits,
separator ',', and terminator ';\n'). This allows (local) mutations to
easily be formed by existing fuzzers (such as afl-fuzz) without
modification. The textual-to-binary conversion methods can be used as
a post-processor of the fuzzer, or as a preprocessor to the llvm tool
being tested.

The motivation for this tool has been the success PNaCl
(www.gonacl.com) has had in testing its tools, as well as the ease of
generating invalid test cases.

[jvoung]

Made a quick scan over (not a full review).

Would be nice if folks who are more involved with fuzzing could chime in about whether or not they agree if this tool will be useful to them =)

include/llvm/Bitcode/BitcodeConvert.h

1

Short description next to the file name?

1

BitcodeConvert might be a bit too generic of a name. What does it convert to-from?

I'm sure more experienced reviewers would have a better suggestion. TextualBitcodeConvert ?

13

semicolin -> semicolon (here and below)

16

For "easy to fuzz", I don't know if you mentioned the issue with binary form. The binary form isn't byte aligned, etc...

58

fo -> for

59

Do you have any experience for supporting ErrorRecovery mode?

lib/Bitcode/Reader/BitcodeRecordReader.cpp

1

Wonder if these various fils should be TextualBitcode...

18

semicolin -> semicolon in this file too

62

Don't need to reference "pnacl" here...

133

Clarify that if not found, it will not advance the cursor.

142

How about skipWhitespaceLines() as an alternate name? This doesn't skip whitespace in the middle of a line.

262

read -> Read

271

read -> Read

288

Could this be shared with the "other" bitcode reader? (binary to IR reader, which has two instances of this already?).

The refactoring can be a separate patch too...

369

Doesn't this already check isBitcodeWrapper ?

lib/Bitcode/Writer/BitcodeRecordWriter.cpp

1

BitcodeRecordWriter.cpp (capital W)

Wonder if this file should also be prefixed with Textual...

12

Capital T for Textual seems a bit inconsistent (binary doesn't get a capital B) in the docs. So, perhaps just lower case it.

243

If you are refactoring the reader to share code, in a separate patch, you could share this writeHeader also.

tools/Makefile

30

let's keep the P in PARALLEL

tools/llvm-bcconv/Makefile

12

BitReader BitWriter

tools/llvm-bcconv/llvm-bcconv.cpp

1

Update the header (it's not llvm-bcanalyzer)

23

semicolon

30

Is the motivation for making it optional, so that a fuzzer doesn't go off and start filling up the file with comments which don't affect anything?

I guess I would have hoped that a fuzzer would be smart enough to detect that such changes aren't useful (no increase in coverage), but maybe it's still helpful to make it optional...

[kcc]

Will this work with libFuzzer out of the box?
Do you need something form libFuzzer to make it work (better|at all)?

[kschimpf]

I believe so, but haven't tried it yet. I will be on vacation next week,
but will look into this further when I get back on the 20th.

Karl

Karl Schimpf

[kcc]

In D11072#202331, @kschimpf wrote:

I believe so, but haven't tried it yet. I will be on vacation next week,
but will look into this further when I get back on the 20th.

I don't want to block you on this, but my first question is whether we need this change to fuzz using libFuzzer at all.
If I were doing a mutator for llvm bit code, I'd probably do something different.
We even have an interface for custom mutators:
https://github.com/llvm-mirror/llvm/blob/master/lib/Fuzzer/FuzzerInterface.h#L51

Another story is if we also have to support afl-fuzz, w/o adding features to afl-fuzz.

[kschimpf]

I guess I'm confused. I thought you were talking about a custom mutator.
One of the main goals is to allow it to use this API. The fuzzer would fuzz
the textual version. The custom mutator would then modify the fuzzed
bitcode into bitcode records using function readTextualBitcode, and then
reformat it to the binary form by calling writeBinaryBitcode.

This would allow the LLVM bitcode reader to work out of the box, without
having to change the code.

The tool llvm-bcconv just makes it convenient to build unit test cases for
LLVM, and to convert (assembled) llvm fuzzing test cases into the textual
form.

Karl Schimpf

[• rafael]

If we are going to have this (not convinced we should), it should be
another library and not modify lib/Bitcode.

[kschimpf]

Apply fixes from review, and add "simplified" form of bitcode.

[kschimpf]

I have added the new form "simplified" bitcode to this, based on conversations with Kostya and libFuzzer. I also moved the code into a separate library as suggested by Rafael.

include/llvm/Bitcode/BitcodeConvert.h

1

I don't like TextualBitcodeConvert because it converts back and forth between the text, binary, and (new) simplified forms.

The simplified form is based on discussions with Kostya and the way that libFuzzer works. It is intended to improve the ability of that fuzzer to mutate simplified forms.

16

Changed the discussion to try and make this more clear.

59

The main purpose for supporting error recovery is to be able to convert fuzzed (i.e. mutated) bitcode files into something that is (bitstream) readable. It is not clear if they are needed for the other forms (i.e. textual and the new variant "simplified"). However, since all three forms use the same driver, it is easier to assume that we can recover when writing all forms.

lib/Bitcode/Reader/BitcodeRecordReader.cpp

1

Decided to separate out each of the reader/writers into separate files, and moved then to a separate subdirectory (and library).

288

I agree that this should be factored out, however, I will do it in a separate patch.

369

Yes. Forgot to remove TODO after fix.

lib/Bitcode/Writer/BitcodeRecordWriter.cpp

1

Refactored the code so that each bitcode writer is in a separate source file.

243

Agreed. Will create separate patch for this.

tools/llvm-bcconv/llvm-bcconv.cpp

30

Yes. I'm not sure that it will guarantee that the fuzzer will notice this, so I was being safe.

[• rafael]

Please move the library outside of Bitcode. This is just another
textual representation. This patch should not change anything in
lib/Bitcode.

[kschimpf]

I'm a bit confused on naming conventions. lib/Bitcode represents multiple libraries:

lib/Bitcode/Reader
lib/Bitcode/Writer

I assume that they are contained in lib/Bitcode because they represent Bitcode, bitcode records, and the corresponding bitstreams.

Similarly, the bitcode converter reads/writes bitcode records without converting to IR, or starting with IR. Rather, it only uses the (same) bitcode records that the bitcode reader and writer use. For this reason, I created a separate library lib/Bitcode/Convert.

Are you suggesting that I should (instead) create a separate directory lib/BitcodeConvert, even though lib/Bitcode defines bitcode records as well?

[kschimpf]

Rafael wrote:

I am simply not convinced of the need for this and want it to be as
out of the way as possible.

Given that this is just used by tools/llvm-bcconv, probably the best

i> s to just move *all* the code to tools/llvm-bcconv and not have a

library at all.

I did think of putting it all in tools/llvm-bcconv. However, I would rather have a library. Part of this work is to build fuzzers for LLVM bitcode files. I already have code that fuzzes LLVM bitcode files using lib/Bitcode/Convert and lib/Fuzzer. That is my motivation for having a library.

[kschimpf]

Rafael wrote:

Why can't the fuzzer write a file?

lib/Fuzzer runs the fuzzing in the same process as the test. It doesn't create an intermediate file. Even if it did, the conversion must still take place.

The reason for this is that the what the LLVM bitstream is modeled, it is not conducive to fuzzing. That is, values are variable-rate bit encoded, based on the value. This implies that mutating a couple of bits will (almost always) make the rest of the input bitstream unreadable. The point of the fuzzed mutations is to change small portions of the input, and leave the rest alone. This is not possible with the binary form of bitcode.

Hence (as mentioned in the comments for include/llvm/Bitcode/BitcodeConvert.h), this CL defines two alternative forms: simplified and textual. Both are essentially the same, except that the textual form is human readable, by using textual digits rather than binary bytes to define numbers. These alternative forms are specifically designed to all small mutations to only effect the bitcode record (and possibly the immediately surrounding records), when the contents of a bitcode record is mutated. This makes the mutations of bitcode tractable.

[• rafael]

If it doesn't create files, why do you need a text representation? If
you don't need the text representation, than it is llvm-bcconv that
should be deleted and this library merged into a tools/llvm-bc-fuzzer.

The summary is that this is a lot of code with unproven value. So far
filcab has found more bugs with just afl.

[kcc]

afl is great, but in my experience more fuzzers lead to more bugs.
Besides, libFuzzer being in-process makes it much faster.
(I am biased, of course)
Maybe if Karl can add the actual libFuzzer glue to this patch and demonstrate a couple of bugs found this way
it will be easier to make it through.

[kschimpf]

Files in llvm/test/Convert show how this code could be used.

Files in llvm/test/Convert are as follows:

File MyMain.cpp that shows how the bitcode coversion library of
http://reviews.llvm.org/D11072 can be used. The single input fed to
the generated fuzzer is a trivial program in foo.ll.

Within less than a minute I was able to generate the crashes in this
CL (files with prefix "crash"). Files with extension '.bc' are LLVM
bitcode files. Files with extension '.sbc' are the corresponding
bitcode files in simplified (binary) form. Files with extension '.err'
are the corresponding crashes caused by the '.bc' file.

[kschimpf]

Note: The code in test/Convert will be removed before committing. It was included to show how the bitcode conversion library/tool can be used.

[• rafael]

I am all for fuzzing stuff, but I don't think I will have the time to really review this much code right now.

Kostya is the fuzzer expert and Duncan the bitcode one. If you guys are OK with this, go for it.

I just have two passing requests:

• Please git-clang-format the patch.
• Please don't add unnecessary features. No additional text format if it is not need. No additional library if only one program will use it. Etc.

[kcc]

• Please don't add unnecessary features. No additional text format if it is not need. No additional library if only one program will use it. Etc.

Karl,
Within the Rafael's constraints, to which I tend to agree, you may want to back up to my initial proposal:
Implement a fuzzer with a custom mutator:
https://github.com/llvm-mirror/llvm/blob/master/lib/Fuzzer/FuzzerInterface.h
https://github.com/llvm-mirror/llvm/blob/master/lib/Fuzzer/test/UserSuppliedFuzzerTest.cpp

It can all be done simple and in a single file:

1. Read and parse the bit code
2. translate it into some simple binary form in-memory. The simpler the format is the better.
3. let the fuzzer mutate it
4. translate the mutated binary form back to bitcode. If the translation was successful -- run optiimzations. This step is the most important: how many of the mutated units will lead to a valid bitcode?
5. profit

[kschimpf]

Kostya,

I agree that we should keep it simple. The text format isn't necessary, but
it does make writing unit tests much easier to maintain. Since the records
are simple lists of (textual) numbers, it is easy to update a record in
this form, should the format change.

When the code is in binary form, this is much harder to do.

However, for a first step, I agree that we should not worry about the
textual form. That can be left to be introduced later, when more concrete
examples of its utility can be shown.

I will also look at your suggested list of flow for mutators, to see how it
effects things.

I also agree that we want to keep things as simple as possible. We might be
able to put it all in a custom mutator library. I will look into that.

Finally, if possible, I will split this patch into smaller patches. I
initially presented as a single patch mainly to make it clear how the
pieces fit together.

Karl

Karl Schimpf

[kcc]

When the code is in binary form, this is much harder to do.

Just to clarify:
My suggestion is that files on disk should be in one of the two standard formats: textual bit code format or binary bitcode format.
The "fuzzer-friendly" format should exist only in memory and never be written on disk.

[kschimpf]

Met with Chandler Carruth, JF Bastien , Kostya Serebryany, and myself (Karl Schimpf) to discuss how to proceed with helping the LLVM community using fuzzing. Briefly discussed patch D11072. Then discussed the overall goals of the LLVM community with respect to fuzzing.

We discussed that there really should be 3 levels of fuzzing:

1. Parsing .ll files to generate IR.
2. Optimization phases of the compiler
3. Using bitcode to represent other structured objects.

It was also noted that once these levels are more stable, one could move into more structural fuzzing (details omitted here).

As such, patch D11072 doesn’t really fit this strategy. Hence, this patch will be abandoned.

However, I will continue to work towards fuzzing LLVM to improve the code quality. My initial goals will be to apply afl-fuzz to a corpus of .ll files to find errors in parsing .ll files (i.e. run llvm-as).

I will also work with Kostya on building a fuzzer using libFuzzer to also test parsing .ll files to generate IR. To improve code coverage, the goal is to call functions that remove the bitcode writing step of llvm-as.

Once llvm-as is relatively stable, focus will then move forward to the optimization phases of the compiler.

Any help or comments from the general LLVM community to help with fuzzing is greatly appreciated.

include/llvm/Bitcode/BitcodeConvert.h

+//===- BitcodeConvert.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the conversion of Bitcode files from binary and textual forms.  The
+// textual form is modeled as a list of bitcode records, one record per line.
+// Each bitcode record is a list of 64-bit integers, separated by commas, and
+// terminated with a semicolin.
+//
+// The goal of textual bitcode records is to provide a simple API to the
+// contents of bitcode files that is human readable, easy to fuzz, and easy to
+// write test cases. To do this, the textual form removes all notions of
+// abbreviations, and thier corresponding bit-encoded forms. Rather, just the
+// raw data within the bitcode records is written.
+//
+// To model block enter/exits, special symbolic constants have been defined.
+// The enter block gets a single parameter, the block ID, and the block exits
+// gets no parameters.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_BITCODE_BITCODECONVERT_H
+#define LLVM_BITCODE_BITCODECONVERT_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+#include <vector>
+
+namespace llvm {
+
+namespace bitc {
+
+enum SpecialBlockCodes { BLK_CODE_ENTER = 65535, BLK_CODE_EXIT = 65534 };
+
+} // end of namespace bitc
+
+typedef std::vector<uint64_t> BitcodeRecord;
+
+/// Reads textual bitcode from Input, and updates Records with its contents.  If
+/// AllowComments is true, the rules are relaxed to allow empty lines and
+/// comment lines beginning with a semicolin.
+std::error_code
+readTextualBitcode(std::unique_ptr<MemoryBuffer> Input,
+                   std::vector<std::unique_ptr<BitcodeRecord>> &Records,
+                   bool AllowComments = false);
+
+/// Reads binary bitcode from Input, and updates Records with its contents.
+std::error_code
+readBinaryBitcode(std::unique_ptr<MemoryBuffer> Input,
+                  std::vector<std::unique_ptr<BitcodeRecord>> &Records);
+
+/// Writes the textual representation fo Records into the buffer. If
+/// ErrorRecover is true, it will apply repairs and continue when
+/// possible. Returns true when successful.
+bool writeTextualBitcode(SmallVectorImpl<char> &Buffer,
+                         std::vector<std::unique_ptr<BitcodeRecord>> &Records,
+                         bool ErrorRecover = false);
+
+/// Writes the binary representation fo Records into the byte Buffer. If
+/// ErrorRecover is true, it will apply repairs and continue when
+/// possible. Returns true when successful.
+bool writeBinaryBitcode(SmallVectorImpl<char> &Buffer,
+                        std::vector<std::unique_ptr<BitcodeRecord>> &Records,
+                        bool ErrorRecover = false);
+
+} // end of namespace llvm
+
+#endif //  LLVM_BITCODE_BITCODECONVERT_H

lib/Bitcode/Reader/BitcodeRecordReader.cpp

+//===- BitcodeRecordReader.cpp --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implements the binary and textual bitcode record readers.
+//
+// The textual bitcode reader takes a text buffer and creates the corresponding
+// sequence of bitcode records.  Each bitcode record is a sequence unsigned
+// integers. Each integer is a sequence of digits. Each integer is separated by
+// a comma, and terminated with a semicolin. Each record begins on a newline.
+//
+// If comments are allowed, the comment begins with a semicolin. Any text after
+// a semicolin, to the end of the line is considered a comment. Empty lines are
+// also allowed.
+//
+// The binary bitcode reader take a binary buffer, and generates the
+// corresponding sequence of bitcode records. While reading, it removes all
+// references to abbreviations, including the blockinfo block.
+// ===---------------------------------------------------------------------===//
+
+#include "llvm/Bitcode/BitcodeConvert.h"
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Bitcode/BitstreamReader.h"
+#include "llvm/Bitcode/ReaderWriter.h"
+
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+namespace {
+
+// Defines reader error codes.
+enum ReaderErrorType {
+  NoCodeForRecord = 1,
+  NoValueAfterSeparator,
+  NoSeparatorOrTerminator,
+  NoNewlineAfterTerminator,
+  MalformedBlock,
+  MalformedIRFile,
+  RecordAtTopLevel,
+  InvalidBitcodeSignature
+};
+
+// Defines the corresponding error messages.
+class ReaderErrorCategoryType : public std::error_category {
+  ReaderErrorCategoryType(const ReaderErrorCategoryType &) = delete;
+  void operator=(const ReaderErrorCategoryType &) = delete;
+
+public:
+  static const ReaderErrorCategoryType &get() { return Sentinel; }
+
+private:
+  static const ReaderErrorCategoryType Sentinel;
+  ReaderErrorCategoryType() = default;
+  const char *name() const LLVM_NOEXCEPT override {
+    return "pnacl.text_bitcode";
+  }
+  std::string message(int IndexError) const override {
+    switch (static_cast<ReaderErrorType>(IndexError)) {
+    case NoCodeForRecord:
+      return "Bitcode record doesn't begin with a record code";
+    case NoValueAfterSeparator:
+      return "Value expected after separator, but not found";
+    case NoSeparatorOrTerminator:
+      return "Separator/terminator expected after value";
+    case NoNewlineAfterTerminator:
+      return "Newline expecded after terminating semicolon";
+    case MalformedBlock:
+      return "Malformed block found in bitcode";
+    case MalformedIRFile:
+      return "Malformed IR file";
+    case RecordAtTopLevel:
+      return "Record not allowed outside block";
+    case InvalidBitcodeSignature:
+      return "Bitcode has invalid bitcode signature";
+    }
+    llvm_unreachable("Unknown error type!");
+  }
+  ~ReaderErrorCategoryType() override = default;
+};
+
+const ReaderErrorCategoryType ReaderErrorCategoryType::Sentinel;
+
+std::error_code error(ReaderErrorType Error) {
+  return std::error_code(Error, ReaderErrorCategoryType::get());
+}
+
+/// Parses text bitcode records, putting them in Records.
+class TextRecordParser {
+  TextRecordParser(const TextRecordParser &) = delete;
+  void operator=(const TextRecordParser &) = delete;
+
+public:
+  /// Creates a parser to parse records from the InputBuffer, and put them into
+  /// Records. If AllowComments is true, relax the input rules to allow
+  /// comments as well.
+  TextRecordParser(StringRef Buffer,
+                   std::vector<std::unique_ptr<BitcodeRecord>> &Records,
+                   bool AllowComments)
+      : Buffer(Buffer), Records(Records), AllowComments(AllowComments) {}
+
+  /// Reads in the list of bitcode records in the input buffer.
+  std::error_code read();
+
+private:
+  // The input buffer to parse.
+  StringRef Buffer;
+  // The list of bitcode records to generate.
+  std::vector<std::unique_ptr<BitcodeRecord>> &Records;
+  // Allow comments in bitcode file.
+  bool AllowComments;
+  // The current location within the input buffer.
+  size_t Cursor = 0;
+  // The separator character.
+  static const char *Separator;
+  // The terminator character.
+  static const char *Terminator;
+  // The newline character that must follow a terminator.
+  static const char *Newline;
+  // Valid digits that can be used to define numbers.
+  static const char *Digits;
+
+  // Returns true if we have reached the end of the input buffer.
+  bool atEof() const { return Cursor == Buffer.size(); }
+
+  // Tries to read a character in the given set of Characters. Returns
+  // the character found, or 0 if not found.
+  char readChar(const char *Characters);
+
+  // Tries to read a (integral) number. If successful, Value is set to
+  // the parsed number and returns true. Otherwise false is returned.
+  // Does not check for number overflow.
+  bool readNumber(uint64_t &Value);
+
+  // Skip empty lines, and lines beginning with a semicolin.
+  bool skipWhitespace();
+
+  // Skip rest of line.
+  void skipComment() {
+    while (!atEof()) {
+      char Ch = Buffer[Cursor++];
+      if (Ch == *Newline)
+        return;
+    }
+  }
+
+  // Reads a record from the input buffer.
+  std::error_code readRecord();
+};
+
+const char *TextRecordParser::Newline = "\n";
+const char *TextRecordParser::Separator = ",";
+const char *TextRecordParser::Terminator = ";";
+const char *TextRecordParser::Digits = "0123456789";
+
+std::error_code TextRecordParser::read() {
+  while (!atEof()) {
+    if (AllowComments)
+      while (skipWhitespace())
+        ;
+    if (std::error_code EC = readRecord())
+      return EC;
+  }
+  return std::error_code();
+}
+
+bool TextRecordParser::skipWhitespace() {
+  if (readChar(Newline))
+    return true;
+  if (readChar(Terminator)) {
+    skipComment();
+    return true;
+  }
+  return false;
+}
+
+char TextRecordParser::readChar(const char *Characters) {
+  if (atEof())
+    return 0;
+  char Ch = Buffer[Cursor];
+  if (std::strchr(Characters, Ch) == 0)
+    return 0;
+  ++Cursor;
+  return Ch;
+}
+
+bool TextRecordParser::readNumber(uint64_t &Value) {
+  Value = 0;
+  bool NumberFound = false;
+  while (1) {
+    char Ch = readChar(Digits);
+    if (!Ch)
+      return NumberFound;
+    Value = (Value * 10) + (Ch - '0');
+    NumberFound = true;
+  }
+}
+
+std::error_code TextRecordParser::readRecord() {
+  // States of parser used to parse bitcode records.
+  enum ParseState {
+    // Begin parsing a record.
+    StartParse,
+    // Before a value in the record.
+    BeforeValue,
+    // Immediately after a value in the record.
+    AfterValue
+  } State = StartParse;
+  std::vector<uint64_t> Values;
+  uint64_t Number = 0;
+  while (1) {
+    switch (State) {
+    case StartParse:
+      if (!readNumber(Number)) {
+        if (atEof())
+          return std::error_code();
+        return error(NoCodeForRecord);
+      }
+      Values.push_back(Number);
+      State = AfterValue;
+      continue;
+    case BeforeValue:
+      if (!readNumber(Number))
+        return error(NoValueAfterSeparator);
+      Values.push_back(Number);
+      State = AfterValue;
+      continue;
+    case AfterValue:
+      if (readChar(Separator)) {
+        State = BeforeValue;
+        continue;
+      }
+      if (readChar(Terminator)) {
+        if (AllowComments)
+          skipComment();
+        else if (!readChar(Newline))
+          return error(NoNewlineAfterTerminator);
+        Records.push_back(make_unique<BitcodeRecord>(Values));
+        return std::error_code();
+      }
+      return error(NoSeparatorOrTerminator);
+    }
+  }
+}
+
+// Parses binary bitcode records.
+class BinaryRecordParser {
+  BinaryRecordParser(const BinaryRecordParser &) = delete;
+  void operator=(const BinaryRecordParser &) = delete;
+
+public:
+  BinaryRecordParser(std::unique_ptr<MemoryBuffer> Buffer,
+                     std::vector<std::unique_ptr<BitcodeRecord>> &Records)
+      : Buffer(std::move(Buffer)), Records(Records) {}
+
+  /// read in a module block.
+  std::error_code readModule();
+
+private:
+  std::unique_ptr<MemoryBuffer> Buffer;
+  std::vector<std::unique_ptr<BitcodeRecord>> &Records;
+  std::unique_ptr<BitstreamReader> Reader;
+  std::unique_ptr<BitstreamCursor> Cursor;
+
+  // read block with ID.
+  std::error_code readBlock(unsigned ID);
+};
+
+std::error_code BinaryRecordParser::readModule() {
+  const unsigned char *BufBegin =
+      (const unsigned char *)Buffer->getBufferStart();
+  const unsigned char *BufEnd = (const unsigned char *)Buffer->getBufferEnd();
+  if (isBitcodeWrapper(BufBegin, BufEnd)) {
+    constexpr bool VerifyBufferSize = true;
+    if (SkipBitcodeWrapperHeader(BufBegin, BufEnd, VerifyBufferSize))
+      return error(MalformedIRFile);
+  }
+
+  Reader = make_unique<BitstreamReader>(BufBegin, BufEnd);
+  Cursor = make_unique<BitstreamCursor>(*Reader);
+
+  // Sniff for the signature.
+  if (Cursor->Read(8) != 'B' || Cursor->Read(8) != 'C' ||
+      Cursor->Read(4) != 0x0 || Cursor->Read(4) != 0xC ||
+      Cursor->Read(4) != 0xE || Cursor->Read(4) != 0xD)
+    return error(InvalidBitcodeSignature);
+
+  while (1) {
+    if (Cursor->AtEndOfStream())
+      return error(MalformedIRFile);
+
+    BitstreamEntry Entry =
+        Cursor->advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
+
+    if (Entry.Kind != BitstreamEntry::SubBlock)
+      return error(MalformedIRFile);
+    return readBlock(Entry.ID);
+  }
+}
+
+std::error_code BinaryRecordParser::readBlock(unsigned BlockID) {
+  std::unique_ptr<std::vector<uint64_t>> RecordValues =
+      make_unique<std::vector<uint64_t>>();
+  RecordValues->push_back(bitc::BLK_CODE_ENTER);
+  RecordValues->push_back(BlockID);
+  Records.push_back(std::move(RecordValues));
+  Cursor->EnterSubBlock(BlockID);
+
+  SmallVector<uint64_t, 32> Values;
+  while (1) {
+    BitstreamEntry Entry = Cursor->advance();
+    switch (Entry.Kind) {
+    case BitstreamEntry::Error:
+      return error(MalformedBlock);
+    case BitstreamEntry::EndBlock: {
+      std::unique_ptr<std::vector<uint64_t>> RecordValues =
+          make_unique<std::vector<uint64_t>>();
+      RecordValues->push_back(bitc::BLK_CODE_EXIT);
+      Records.push_back(std::move(RecordValues));
+      return std::error_code();
+    }
+    case BitstreamEntry::SubBlock: {
+      if (Entry.ID == bitc::BLOCKINFO_BLOCK_ID) {
+        if (Cursor->ReadBlockInfoBlock())
+          return error(MalformedBlock);
+        continue;
+      }
+      if (std::error_code EC = readBlock(Entry.ID))
+        return EC;
+      continue;
+    }
+    case BitstreamEntry::Record: {
+      unsigned Code = Cursor->readRecord(Entry.ID, Values);
+      std::unique_ptr<std::vector<uint64_t>> RecordValues =
+          make_unique<std::vector<uint64_t>>();
+      RecordValues->push_back(Code);
+      for (const auto Val : Values)
+        RecordValues->push_back(Val);
+      Records.push_back(std::move(RecordValues));
+      Values.clear();
+      continue;
+    }
+    }
+  }
+  llvm_unreachable("Should not reach here!");
+}
+
+} // end of anonymous namespace
+
+namespace llvm {
+
+std::error_code
+readTextualBitcode(std::unique_ptr<MemoryBuffer> Input,
+                   std::vector<std::unique_ptr<BitcodeRecord>> &Records,
+                   bool AllowComments) {
+  TextRecordParser Parser(Input->getBuffer(), Records, AllowComments);
+  return Parser.read();
+}
+
+std::error_code
+readBinaryBitcode(std::unique_ptr<MemoryBuffer> Input,
+                  std::vector<std::unique_ptr<BitcodeRecord>> &Records) {
+  // TODO(kschimpf) Handle bitcode wrappers.
+  BinaryRecordParser Parser(std::move(Input), Records);
+  return Parser.readModule();
+}
+
+} // end of namespace llvm

lib/Bitcode/Reader/CMakeLists.txt

 add_llvm_library(LLVMBitReader
   BitReader.cpp
   BitcodeReader.cpp
+  BitcodeRecordReader.cpp
   BitstreamReader.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Bitcode
   )
 
 add_dependencies(LLVMBitReader intrinsics_gen)

lib/Bitcode/Writer/BitcodeRecordWriter.cpp

+//===- BitcodeRecordwriter.cpp --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Implements the binary and textual bitcode record writers.
+//
+// The Textual bitcode writer takes a sequence of bitcode records, and writes
+// out textually to a buffer.  Each bitcode record is a sequence of 64-bit,
+// unsigned integers. Each integer is separated by a comma, and terminated with
+// a semicolin. Each record begins on a newline.
+//
+// The binary bitcode writer constructs the corresponding binary form in a
+// buffer.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Bitcode/BitcodeConvert.h"
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Bitcode/BitstreamWriter.h"
+#include "llvm/Support/raw_ostream.h"
+#include <climits>
+
+using namespace llvm;
+
+namespace {
+
+// Abstract bitcode record writer.
+class RecordWriter {
+  RecordWriter(const RecordWriter &) = delete;
+  void operator=(const RecordWriter &) = delete;
+
+public:
+  explicit RecordWriter(bool ErrorRecover) : ErrorRecover(ErrorRecover) {}
+  virtual ~RecordWriter() = default;
+
+  // Writes out Records.
+  bool
+  writeBitcodeRecords(std::vector<std::unique_ptr<BitcodeRecord>> &Records);
+
+protected:
+  // The block ID associated with records not in any block.
+  static const unsigned UnknownBlockID = std::numeric_limits<unsigned>::max();
+  // True if error recovery should be applied.
+  bool ErrorRecover;
+  // Nest level of blocks within bitcode being written.
+  size_t BlockDepth = 0;
+  // The number of errors found.
+  size_t NumErrors = 0;
+  // The number of error repairs applied.
+  size_t NumRepairs = 0;
+
+  // Records that an error has occurred, and returns stream to print the
+  // corresponding error message to.
+  raw_ostream &error() {
+    ++NumErrors;
+    return errs();
+  }
+
+  // Records that a recoverable error has occurred, and returns the stream to
+  // print error message to.
+  raw_ostream &recoverableError() {
+    if (ErrorRecover)
+      ++NumRepairs;
+    return error();
+  }
+
+  bool isSuccessful() const {
+    return NumErrors == 0 || (ErrorRecover && NumErrors == NumRepairs);
+  }
+
+  bool atOutermostScope() { return BlockDepth == 0; }
+
+  // Emit the contents of Record.
+  bool emitRecord(const BitcodeRecord &Record);
+
+  // Write out the enter record for block ID.
+  virtual void writeEnterBlock(uint64_t ID) {
+    (void)ID;
+    ++BlockDepth;
+  }
+
+  // Write out the contents of the Record in the current block.
+  virtual void writeRecord(const BitcodeRecord &Record) = 0;
+
+  // Write out the exit record for the current block.
+  virtual void writeExitBlock() { --BlockDepth; }
+
+  // Apply any necessary cleanups after writing bitcode.
+  virtual bool finish() {
+    if (atOutermostScope())
+      return true;
+
+    recoverableError() << "Missing " << BlockDepth << " close blocks.\n";
+    if (!ErrorRecover)
+      return false;
+
+    while (!atOutermostScope())
+      writeExitBlock();
+    return true;
+  }
+};
+
+bool RecordWriter::writeBitcodeRecords(
+    std::vector<std::unique_ptr<BitcodeRecord>> &Records) {
+  for (const std::unique_ptr<BitcodeRecord> &Rec : Records)
+    if (!emitRecord(*Rec))
+      return false;
+  if (!finish())
+    return false;
+  return isSuccessful();
+}
+
+bool RecordWriter::emitRecord(const std::vector<uint64_t> &Record) {
+  size_t NumValues = Record.size();
+  if (NumValues == 0) {
+    recoverableError() << "Empty records not allowed in bitcode\n";
+    return ErrorRecover;
+  }
+  switch (Record[0]) {
+  case bitc::BLK_CODE_ENTER: {
+    uint64_t WriteBlockID = UnknownBlockID;
+    if (NumValues != 2) {
+      recoverableError() << "Block enter record not size 2\n";
+      if (!ErrorRecover)
+        return false;
+    }
+    if (NumValues > 1)
+      WriteBlockID = Record[1];
+    if (WriteBlockID == bitc::BLOCKINFO_BLOCK_ID) {
+      recoverableError() << "BlockInfo block not allowed in bitcode records\n";
+      if (!ErrorRecover)
+        return false;
+      WriteBlockID = UnknownBlockID;
+    }
+    writeEnterBlock(WriteBlockID);
+    return true;
+  }
+  case bitc::BLK_CODE_EXIT: {
+    if (atOutermostScope()) {
+      recoverableError() << "Extraneous exit block\n";
+      return ErrorRecover;
+    }
+    writeExitBlock();
+    return true;
+  }
+  default: {
+    if (atOutermostScope()) {
+      recoverableError() << "Record not allowed outside block\n";
+      if (!ErrorRecover)
+        return false;
+      writeEnterBlock(UnknownBlockID);
+    }
+    writeRecord(Record);
+    return true;
+  }
+  }
+}
+
+// Writer of textual bitcode records to a byte buffer.
+class TextRecordWriter : public RecordWriter {
+  TextRecordWriter(const TextRecordWriter &) = delete;
+  void operator=(const TextRecordWriter &) = delete;
+
+public:
+  TextRecordWriter(SmallVectorImpl<char> &Buffer, bool ErrorRecover)
+      : RecordWriter(ErrorRecover), Buffer(Buffer), ValueStream(ValueBuffer) {}
+
+  ~TextRecordWriter() final = default;
+
+private:
+  // Buffer to write textual bitcode records into.
+  SmallVectorImpl<char> &Buffer;
+  // String stream to convert integers to strings.
+  std::string ValueBuffer;
+  raw_string_ostream ValueStream;
+
+  void writeValue(uint64_t Value);
+
+  void writeSeparator() { Buffer.push_back(','); }
+
+  void writeTerminator() {
+    Buffer.push_back(';');
+    Buffer.push_back('\n');
+  }
+
+  void writeEnterBlock(uint64_t ID) final {
+    RecordWriter::writeEnterBlock(ID);
+    writeValue(bitc::BLK_CODE_ENTER);
+    writeSeparator();
+    writeValue(ID);
+    writeTerminator();
+  }
+
+  void writeExitBlock() final {
+    RecordWriter::writeExitBlock();
+    writeValue(bitc::BLK_CODE_EXIT);
+    writeTerminator();
+  }
+
+  void writeRecord(const BitcodeRecord &Record) final {
+    bool IsFirst = true;
+    for (const auto Value : Record) {
+      if (IsFirst)
+        IsFirst = false;
+      else
+        writeSeparator();
+      writeValue(Value);
+    }
+    writeTerminator();
+  }
+};
+
+void TextRecordWriter::writeValue(uint64_t Value) {
+  ValueStream << Value;
+  ValueStream.flush();
+  for (auto ch : ValueBuffer)
+    Buffer.push_back(ch);
+  ValueBuffer.clear();
+}
+
+// Writer of binary bitcode records to a byte buffer.
+class BinaryRecordWriter : public RecordWriter {
+  BinaryRecordWriter(const BinaryRecordWriter &) = delete;
+  void operator=(const BinaryRecordWriter &) = delete;
+
+public:
+  BinaryRecordWriter(SmallVectorImpl<char> &Buffer, bool ErrorRecover)
+      : RecordWriter(ErrorRecover), Writer(Buffer) {
+    writeHeader();
+  }
+
+  ~BinaryRecordWriter() final = default;
+
+private:
+  BitstreamWriter Writer;
+
+  void writeHeader() {
+    Writer.Emit((unsigned)'B', 8);
+    Writer.Emit((unsigned)'C', 8);
+    Writer.Emit(0x0, 4);
+    Writer.Emit(0xC, 4);
+    Writer.Emit(0xE, 4);
+    Writer.Emit(0xD, 4);
+  }
+
+  void writeEnterBlock(uint64_t ID) final {
+    RecordWriter::writeEnterBlock(ID);
+    Writer.EnterSubblock(ID, 2);
+  }
+
+  void writeExitBlock() final {
+    RecordWriter::writeExitBlock();
+    Writer.ExitBlock();
+  }
+
+  void writeRecord(const BitcodeRecord &Record) final {
+    unsigned Code = Record[0];
+    SmallVector<uint64_t, 6> Values;
+    for (size_t i = 1; i < Record.size(); ++i)
+      Values.push_back(Record[i]);
+    Writer.EmitRecord(Code, Values);
+  }
+
+  bool finish() final;
+};
+
+bool BinaryRecordWriter::finish() {
+  bool Success = true;
+  // First try to finish gracefully.
+  if (!RecordWriter::finish())
+    Success = false;
+
+  // Force out exit blocks, if needed, to avoid the bitstream writer from assert
+  // failing.
+  while (!atOutermostScope())
+    writeExitBlock();
+
+  // Make sure file length divisible by 4.
+  uint64_t TrailingBits = Writer.GetCurrentBitNo() % 4 * CHAR_BIT;
+  if (TrailingBits) {
+    recoverableError() << "Generated bitstream not word aligned\n";
+    Writer.Emit(0, TrailingBits);
+    if (!ErrorRecover)
+      return false;
+  }
+
+  return Success;
+}
+
+} // end of anonymous namespace
+
+namespace llvm {
+
+bool writeTextualBitcode(SmallVectorImpl<char> &Buffer,
+                         std::vector<std::unique_ptr<BitcodeRecord>> &Records,
+                         bool ErrorRecover) {
+  TextRecordWriter RecordWriter(Buffer, ErrorRecover);
+  return RecordWriter.writeBitcodeRecords(Records);
+}
+
+bool writeBinaryBitcode(SmallVectorImpl<char> &Buffer,
+                        std::vector<std::unique_ptr<BitcodeRecord>> &Records,
+                        bool ErrorRecover) {
+  BinaryRecordWriter RecordWriter(Buffer, ErrorRecover);
+  return RecordWriter.writeBitcodeRecords(Records);
+}
+
+} // end of llvm namespace

lib/Bitcode/Writer/CMakeLists.txt

 add_llvm_library(LLVMBitWriter
   BitWriter.cpp
+  BitcodeRecordWriter.cpp
   BitcodeWriter.cpp
   BitcodeWriterPass.cpp
   ValueEnumerator.cpp
 
   DEPENDS
   intrinsics_gen
   )

test/Bitcode/text-bitcode.ll

+; Tests that we can convert LLVM bitcode to textual form, and back to binary.
+
+; RUN: llvm-as %s -o - | llvm-bcconv -to-text \
+; RUN:                 | FileCheck --check-prefix=TBC %s
+
+; RUN: llvm-as %s -o - | llvm-bcconv -to-text | llvm-bcconv -to-binary \
+; RUN:                 | llvm-dis | FileCheck %s
+
+define void @f() {
+  ret void
+}
+
+; CHECK:      define void @f() {
+; CHECK-NEXT:   ret void
+; CHECK-NEXT: }
+
+; TBC:      65535,8;
+; TBC-NEXT: 1,1;
+; TBC-NEXT: 65535,17;
+; TBC-NEXT: 1,4;
+; TBC-NEXT: 2;
+; TBC-NEXT: 21,0,0;
+; TBC-NEXT: 8,1,0;
+; TBC-NEXT: 16;          
+; TBC-NEXT: 65534;
+; TBC-NEXT: 8,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0;
+; TBC-NEXT: 65535,15;
+;           Intentionally skip contents of metadata block.
+; TBC:      65534;
+; TBC-NEXT: 65535,14;
+; TBC-NEXT: 1,0,102;
+; TBC-NEXT: 65534;
+; TBC-NEXT: 65535,12;
+; TBC-NEXT: 1,1;
+; TBC-NEXT: 10;
+; TBC-NEXT: 65534;
+; TBC-NEXT: 65534;

test/lit.cfg

 NOJUNK = r"(?<!\.|-|\^|/)"
 
 for pattern in [r"\bbugpoint\b(?!-)",
                 NOJUNK + r"\bllc\b",
                 r"\blli\b",
                 r"\bllvm-ar\b",
                 r"\bllvm-as\b",
                 r"\bllvm-bcanalyzer\b",
+                r"\bllvm-bcconv\b",
                 r"\bllvm-config\b",
                 r"\bllvm-cov\b",
                 r"\bllvm-cxxdump\b",
                 r"\bllvm-diff\b",
                 r"\bllvm-dis\b",
                 r"\bllvm-dsymutil\b",
                 r"\bllvm-dwarfdump\b",
                 r"\bllvm-extract\b",

tools/LLVMBuild.txt

 subdirectories =
  bugpoint
  dsymutil
  llc
  lli
  llvm-ar
  llvm-as
  llvm-bcanalyzer
+ llvm-bcconv
  llvm-cov
  llvm-diff
  llvm-dis
  llvm-dwarfdump
  llvm-extract
  llvm-jitlistener
  llvm-link
  llvm-lto

tools/Makefile

 # Build LLDB if present. Note LLDB must be built last as it depends on
 # the wider LLVM infrastructure (including Clang).
 OPTIONAL_DIRS := lldb
 
 # NOTE: The tools are organized into five groups of four consisting of one
 # large and three small executables. This is done to minimize memory load
 # in parallel builds.  Please retain this ordering.
 DIRS := llvm-config
-PARALLEL_DIRS := opt llvm-as llvm-dis llc llvm-ar llvm-nm llvm-link \
-                 lli llvm-extract llvm-mc bugpoint llvm-bcanalyzer llvm-diff \
-                 macho-dump llvm-objdump llvm-readobj llvm-rtdyld \
+ARALLEL_DIRS := opt llvm-as llvm-dis llc llvm-ar llvm-nm llvm-link \
+                 lli llvm-extract llvm-mc bugpoint llvm-bcanalyzer llvm-bcconv \
+                 llvm-diff macho-dump llvm-objdump llvm-readobj llvm-rtdyld \
                  llvm-dwarfdump llvm-cov llvm-size llvm-stress llvm-mcmarkup \
                  llvm-profdata llvm-symbolizer obj2yaml yaml2obj llvm-c-test \
                  llvm-cxxdump verify-uselistorder dsymutil llvm-pdbdump
 
 # If Intel JIT Events support is configured, build an extra tool to test it.
 ifeq ($(USE_INTEL_JITEVENTS), 1)
   PARALLEL_DIRS += llvm-jitlistener
 endif

tools/llvm-bcconv/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  BitReader
+  BitWriter
+  Support
+  )
+
+add_llvm_tool(llvm-bcconv
+  llvm-bcconv.cpp
+  )

tools/llvm-bcconv/LLVMBuild.txt

-;===- ./tools/LLVMBuild.txt ------------------------------------*- Conf -*--===;
+;===- ./tools/llvm-bcconv/LLVMBuild.txt ------------------------*- Conf -*--===;
 ;
 ;                     The LLVM Compiler Infrastructure
 ;
 ; This file is distributed under the University of Illinois Open Source
 ; License. See LICENSE.TXT for details.
 ;
 ;===------------------------------------------------------------------------===;
 ;
 ; This is an LLVMBuild description file for the components in this subdirectory.
 ;
 ; For more information on the LLVMBuild system, please see:
 ;
 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
-[common]
-subdirectories =
- bugpoint
- dsymutil
- llc
- lli
- llvm-ar
- llvm-as
- llvm-bcanalyzer
- llvm-cov
- llvm-diff
- llvm-dis
- llvm-dwarfdump
- llvm-extract
- llvm-jitlistener
- llvm-link
- llvm-lto
- llvm-mc
- llvm-mcmarkup
- llvm-nm
- llvm-objdump
- llvm-pdbdump
- llvm-profdata
- llvm-rtdyld
- llvm-size
- macho-dump
- opt
- verify-uselistorder
-
 [component_0]
-type = Group
-name = Tools
-parent = $ROOT
+type = Tool
+name = llvm-bcconv
+parent = Tools
+required_libraries = BitReader BitWriter Support

tools/llvm-bcconv/Makefile

+##===- tools/llvm-bcconv/Makefile -------------------------*- Makefile -*-====##
+# 
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+# 
+##===----------------------------------------------------------------------===##
+
+LEVEL := ../..
+TOOLNAME := llvm-bcconv
+LINK_COMPONENTS := bitreader bitwriter Support
+
+# This tool has no plugins, optimize startup time.
+TOOL_NO_EXPORTS := 1
+
+include $(LEVEL)/Makefile.common

tools/llvm-bcconv/llvm-bcconv.cpp

+//===-- llvm-bcanalyzer.cpp - Bitcode Analyzer --------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This tool converts bitcode files from binary form to its textual equivalent,
+// and from its textual equivalent back to the binary form.
+//
+// A textual bitcode file is NOT an assembly file (i.e. .ll file).  It is an
+// alternate format for bitcode files (i.e. .bc files). Its main purpose is for
+// testing and fuzzing. Typically, the extension .tbc is used for textual
+// bitcode files.
+//
+// The textual bitcode file is a simplified form of bitcode files. In
+// particular, it removes all user-specified abbreviations from the bitcode
+// file. Its form is a list of bitcode records.
+//
+// Each bitcode record is a sequence of (unsigned) integers, separated by
+// commas, and terminated with a semicolin (followed by a newline).
+//
+// When '-allow-comments' is provided as a command-line argument, the semicolin
+// not only acts as a terminator, but all remaining text on that line is
+// treated as a comment. Between lines, empty blank lines and comment lines
+// can be inserted. A comment line is a line beginning with a semicolin.
+//
+// Note that the '-allow-comments' feature allows one to use textual bitcode
+// files as input to FileCheck.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Bitcode/BitcodeConvert.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/PrettyStackTrace.h"
+#include "llvm/Support/Signals.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+static cl::opt<std::string>
+    InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
+
+static cl::opt<std::string> OutputFilename(
+    "o", cl::desc("Write output to specified filename (rather than stdout)"),
+    cl::init("-"));
+
+enum ConversionKind { BinaryToText, TextToBinary };
+
+cl::opt<ConversionKind> ConversionFlag(
+    cl::desc("Choose format conversion:"),
+    cl::values(clEnumValN(TextToBinary, "to-binary",
+                          "Convert from textual form to binary form"),
+               clEnumValN(BinaryToText, "to-text",
+                          "Convert from binary form to textual form"),
+               clEnumValEnd));
+
+static cl::opt<bool>
+    AllowTextComments("allow-comments",
+                      cl::desc("Allow comments in textual bitcode"),
+                      cl::init(false));
+
+static cl::opt<bool> ErrorRecover("error-recover",
+                                  cl::desc("Try to recover on errors"),
+                                  cl::init(false));
+
+static bool writeOutput(SmallVectorImpl<char> &Output,
+                        sys::fs::OpenFlags OpenFlags) {
+  std::error_code EC;
+  auto FDOut = make_unique<tool_output_file>(OutputFilename, EC, OpenFlags);
+  if (EC) {
+    errs() << EC.message() << '\n';
+    return false;
+  }
+  for (auto Val : Output)
+    FDOut->os() << Val;
+  FDOut->keep();
+  return true;
+}
+
+static bool applyBinaryConversion(std::unique_ptr<MemoryBuffer> Input) {
+  std::vector<std::unique_ptr<BitcodeRecord>> Records;
+  if (std::error_code EC =
+          readTextualBitcode(std::move(Input), Records, AllowTextComments)) {
+    errs() << "Error: " << EC.message() << "\n";
+    return false;
+  }
+  SmallVector<char, 1024> Output;
+  if (!writeBinaryBitcode(Output, Records, ErrorRecover)) {
+    errs() << "Error: Unable to write binary bitcode\n";
+    return false;
+  }
+  return writeOutput(Output, sys::fs::F_None);
+}
+
+static bool applyTextualConversion(std::unique_ptr<MemoryBuffer> Input) {
+  std::vector<std::unique_ptr<BitcodeRecord>> Records;
+  if (std::error_code EC = readBinaryBitcode(std::move(Input), Records)) {
+    errs() << "Error: " << EC.message() << "\n";
+    return false;
+  }
+  SmallVector<char, 1024> Output;
+  if (!writeTextualBitcode(Output, Records, ErrorRecover)) {
+    errs() << "Error: Unable to write textual bitcode\n";
+    return false;
+  }
+  return writeOutput(Output, sys::fs::F_Text);
+}
+
+inline static int convertToExitStatus(bool Value) { return !Value; }
+
+int main(int argc, char *argv[]) {
+  // Print a stack trace if we signal out.
+  sys::PrintStackTraceOnErrorSignal();
+  PrettyStackTraceProgram X(argc, argv);
+  llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
+  cl::ParseCommandLineOptions(argc, argv,
+                              "llvm-bcconv: Bitcode format converter\n");
+
+  ErrorOr<std::unique_ptr<MemoryBuffer>> ErrOrInput =
+      MemoryBuffer::getFileOrSTDIN(InputFilename);
+  if (std::error_code EC = ErrOrInput.getError()) {
+    errs() << "Error reading " << InputFilename << ": " << EC.message() << "\n";
+    return 1;
+  }
+
+  std::unique_ptr<MemoryBuffer> Input(ErrOrInput.get().release());
+  switch (ConversionFlag) {
+  case BinaryToText:
+    return convertToExitStatus(applyTextualConversion(std::move(Input)));
+  case TextToBinary:
+    return convertToExitStatus(applyBinaryConversion(std::move(Input)));
+  }
+}