Rebased PNaCl localmods in LLVM to 223109

lib/Bitcode/NaCl/Analysis/NaClObjDump.cpp

+//===-- NaClObjDump.cpp - Dump PNaCl bitcode contents ---------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Analysis/NaCl/PNaClABIProps.h"
+#include "llvm/Analysis/NaCl/PNaClABITypeChecker.h"
+#include "llvm/Analysis/NaCl/PNaClAllowedIntrinsics.h"
+#include "llvm/Bitcode/NaCl/NaClBitcodeDecoders.h"
+#include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
+#include "llvm/Bitcode/NaCl/NaClBitcodeParser.h"
+#include "llvm/Bitcode/NaCl/NaClBitCodes.h"
+#include "llvm/Bitcode/NaCl/NaClObjDumpStream.h"
+#include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <map>
+
+namespace {
+
+using namespace llvm;
+
+static cl::opt<bool>
+ReportWarningsAsErrors(
+    "Werror",
+    cl::desc("Report warnings as errors."),
+    cl::init(false));
+
+static cl::opt<bool>
+IgnorePNaClABIChecks(
+    "ignore-pnaclabi-checks",
+    cl::desc("Ignore checking bitcode for PNaCl ABI violations"),
+    cl::init(false));
+
+/// Class to handle sign rotations in a human readable form. That is,
+/// the sign is in the low bit. The two special cases are:
+/// 1) -1 is true for i1.
+/// 2) The representation allows -0 (which is different than 0).
+class SignRotatedInt {
+public:
+  SignRotatedInt(uint64_t Value, Type* ValueType)
+      : SignedValue(Value >> 1),
+        IsNegated((Value & 0x1)
+                  && !(ValueType->isIntegerTy()
+                       && ValueType->getIntegerBitWidth() == 1)) {
+  }
+
+  SignRotatedInt()
+      : SignedValue(0), IsNegated(false) {}
+
+  explicit SignRotatedInt(const SignRotatedInt &V)
+      : SignedValue(V.SignedValue), IsNegated(V.IsNegated) {}
+
+  void operator=(const SignRotatedInt &V) {
+    SignedValue = V.SignedValue;
+    IsNegated = V.IsNegated;
+  }
+
+  void Print(raw_ostream &Strm) const {
+    if (IsNegated) Strm << "-";
+    Strm << SignedValue;
+  }
+
+private:
+  int64_t SignedValue;
+  bool IsNegated;
+};
+
+inline raw_ostream &operator<<(raw_ostream &Strm, const SignRotatedInt &V) {
+  V.Print(Strm);
+  return Strm;
+}
+
+/// Convenience class to be able to print value ids to raw_ostream's.
+/// Kinds of bitcode Ids:
+///    a : For abbreviations.
+///    b : For basic blocks.
+///    c : For local constants.
+///    f : For function addresses.
+///    g : For global variable addresses.
+///    p : For parameter arguments.
+///    t : For type values.
+///    v : For values generated by instructions.
+class BitcodeId {
+public:
+  BitcodeId(char Kind, uint32_t Index)
+      : Kind(Kind), Index(Index), IsGlobal(IsGlobalKind(Kind)) {
+  }
+
+  BitcodeId(const BitcodeId &Id)
+      : Kind(Id.Kind), Index(Id.Index), IsGlobal(Id.IsGlobal) {}
+
+  BitcodeId(char Kind, uint32_t Index, bool IsGlobal)
+      : Kind(Kind), Index(Index), IsGlobal(IsGlobal) {}
+
+  void operator=(const BitcodeId &Id) {
+    Kind = Id.Kind;
+    Index = Id.Index;
+    IsGlobal = Id.IsGlobal;
+  }
+
+  raw_ostream &Print(raw_ostream &Stream) const {
+    return Stream << Prefix() << Kind << Index;
+  }
+
+  char GetKind() const {
+    return Kind;
+  }
+
+  std::string GetName() const {
+    std::string Buffer;
+    raw_string_ostream StrBuf(Buffer);
+    Print(StrBuf);
+    return StrBuf.str();
+  }
+
+private:
+  char Kind;
+  uint32_t Index;
+  bool IsGlobal;
+
+  // Returns true if (default) assumption for kind implies global.
+  static bool IsGlobalKind(char Kind);
+
+  // Returns the bitcode prefix character that communicates if the
+  // bitcode Id is lcoal or global.
+  char Prefix() const { return IsGlobal ? '@' : '%'; }
+};
+
+bool BitcodeId::IsGlobalKind(char Kind) {
+  switch (Kind) {
+  case 'f':
+  case 'g':
+  case 't':
+    return true;
+  case 'b':
+  case 'c':
+  case 'p':
+  case 'v':
+    return false;
+  default:
+    errs() << "Bad bitcode id, can't determine (statically) if global: "
+           << Kind << "\n";
+    report_fatal_error("Unable to continue");
+  }
+}
+
+raw_ostream &operator<<(raw_ostream &Stream, const BitcodeId &Id) {
+  return Id.Print(Stream);
+}
+
+class NaClDisBlockParser;
+
+/// The text formatter for PNaClAsm instructions.
+class AssemblyTextFormatter : public naclbitc::TextFormatter {
+public:
+  // Special directive to tokenize type expressions. Used to convert
+  // type signatures into a sequence of tokens.
+  class TypeDirective : public naclbitc::TextFormatter::Directive {
+  public:
+    TypeDirective(TextFormatter *Formatter)
+        : naclbitc::TextFormatter::Directive(Formatter),
+          Typ(0),
+          FcnId(0),
+          AddParams(false) {}
+
+    ~TypeDirective() override {}
+
+  private:
+    /// Calls the corresponding method in AssemblyTextFormatter, with
+    /// the locally stored arguments.
+    void MyApply(bool Replay) const override;
+
+    void MaybeSaveForReplay() const override {}
+
+    // The type to tokenize.
+    Type *Typ;
+    // Pointer to function id, if not NULL.
+    BitcodeId *FcnId;
+    // true if parameter id's should be added to function signature.
+    bool AddParams;
+
+    friend class AssemblyTextFormatter;
+
+    // Internal routine to allow AssemblyTextFormatter::AllocateTypeDirective
+    // to initialize a type directive.
+    void Init(Type *NewTyp, BitcodeId *NewFcnId, bool NewAddParams) {
+      Typ = NewTyp;
+      FcnId = NewFcnId;
+      AddParams = NewAddParams;
+    }
+  };
+
+  // Special directive to tokenize an abbreviation. Used to convert
+  // an abbreviation (pointer) into a sequence of tokens.
+  class AbbreviationDirective : public naclbitc::TextFormatter::Directive {
+  public:
+    AbbreviationDirective(TextFormatter *Formatter)
+        : naclbitc::TextFormatter::Directive(Formatter),
+          Abbrev(0) {}
+
+    ~AbbreviationDirective() override {}
+
+  private:
+    void MyApply(bool Replay) const override;
+
+    void MaybeSaveForReplay() const override {}
+
+    // The abbreviation to tokenize.
+    NaClBitCodeAbbrev *Abbrev;
+
+    friend class AssemblyTextFormatter;
+  };
+
+  // Special directive to tokenize an abbreviation index, if the corresponding
+  // record in the block parser used a user-defined abbreviation.
+  class AbbrevIndexDirective : public naclbitc::TextFormatter::Directive {
+  public:
+    AbbrevIndexDirective(TextFormatter *Formatter)
+        : naclbitc::TextFormatter::Directive(Formatter),
+          Record(0), NumGlobalAbbreviations(0) {}
+
+    ~AbbrevIndexDirective() override {}
+
+  private:
+    void MyApply(bool Replay) const override;
+
+    void MaybeSaveForReplay() const override {}
+
+    // The record containing the associated abbreviation.
+    NaClBitcodeRecord *Record;
+
+    // The number of global abbreviations defined for the block the
+    // record appears in.
+    unsigned NumGlobalAbbreviations;
+
+    friend class AssemblyTextFormatter;
+  };
+
+public:
+
+  /// Creates an assembly text formatter for the given dump stream.
+  AssemblyTextFormatter(naclbitc::ObjDumpStream &ObjDump)
+      : TextFormatter(ObjDump.Assembly(),
+                      std::max(20U, GetAssemblyWidth(ObjDump)),
+                      "  "),
+        Comma(this, ","),
+        Semicolon(this, ";"),
+        Colon(this, ":"),
+        Space(this),
+        OpenParen(this, "("),
+        CloseParen(this, ")"),
+        OpenAngle(this, "<"),
+        CloseAngle(this, ">"),
+        OpenCurly(this, "{"),
+        CloseCurly(this, "}"),
+        OpenSquare(this, "["),
+        CloseSquare(this, "]"),
+        Endline(this),
+        StartCluster(this),
+        FinishCluster(this)
+  {
+    ContinuationIndent = GetIndent(2);
+  }
+
+  ~AssemblyTextFormatter() override {}
+
+  naclbitc::TokenTextDirective Comma;
+  naclbitc::TokenTextDirective Semicolon;
+  naclbitc::TokenTextDirective Colon;
+  naclbitc::SpaceTextDirective Space;
+  naclbitc::OpenTextDirective OpenParen;
+  naclbitc::CloseTextDirective CloseParen;
+  naclbitc::OpenTextDirective OpenAngle;
+  naclbitc::CloseTextDirective CloseAngle;
+  naclbitc::OpenTextDirective OpenCurly;
+  naclbitc::CloseTextDirective CloseCurly;
+  naclbitc::OpenTextDirective OpenSquare;
+  naclbitc::CloseTextDirective CloseSquare;
+  naclbitc::EndlineTextDirective Endline;
+  naclbitc::StartClusteringDirective StartCluster;
+  naclbitc::FinishClusteringDirective FinishCluster;
+
+  /// Prints the given type as a sequence of tokens.
+  TypeDirective &TokenizeType(Type *Typ) {
+    return AllocateTypeDirective(Typ, 0, false);
+  }
+
+  /// Prints the named function type as a sequence of tokens.
+  /// Typ is the type signature of the function, and FunctionName
+  /// points to the name of the function.
+  TypeDirective &TokenizeFunctionType(FunctionType *Typ,
+                                      BitcodeId *FunctionName) {
+    return AllocateTypeDirective(Typ, FunctionName, false);
+  }
+
+  /// Prints the function signature of the function type. Typ is
+  /// the type signature of the function. FunctionName points to the
+  /// name of the function. Note: Unlike TokenizeFunctionType, this
+  /// method also adds the parameter names to paramter argumements.
+  TypeDirective &TokenizeFunctionSignature(FunctionType *Typ,
+                                           BitcodeId *FunctionName) {
+    return AllocateTypeDirective(Typ, FunctionName, true);
+  }
+
+  /// Prints out the abbreviation defined by Abbrev.
+  AbbreviationDirective &TokenizeAbbreviation(NaClBitCodeAbbrev *Abbrev) {
+    AbbreviationDirective *Dir = AbbrevDirMemoryPool.Allocate(this);
+    Dir->Abbrev = Abbrev;
+    return *Dir;
+  }
+
+  /// If the record was read using a user-defined abbreviation,
+  /// generates assembly tokens describing the abbreviation index
+  /// used. Otherwise, no tokens are generated. NumGlobalAbbreviations
+  /// is used to determine if the user-defined abbreviation is local
+  /// or global.
+  AbbrevIndexDirective &TokenizeAbbrevIndex(NaClBitcodeRecord &Record,
+                                            unsigned NumGlobalAbbreviations) {
+    AbbrevIndexDirective *Dir = AbbrevIndexDirMemoryPool.Allocate(this);
+    Dir->Record = &Record;
+    Dir->NumGlobalAbbreviations = NumGlobalAbbreviations;
+    return *Dir;
+  }
+
+private:
+  // Converts the given type to tokens, based on the values passed in
+  // by TokenizeType, TokenizeFunctionType, or TokenizeFunctionSignature.
+  void TokenizeTypeInternal(Type *Typ, BitcodeId* FcnName, bool AddParams);
+
+  // The free list of type directives.
+  naclbitc::DirectiveMemoryPool<TypeDirective> TypeDirMemoryPool;
+
+  // Allocates an instance of TypeDirective with the following fields.
+  TypeDirective &AllocateTypeDirective(Type *Typ, BitcodeId *FcnId,
+                                       bool AddParams);
+
+  // Converts the given abbreviation to tokens.
+  void TokenizeAbbreviationInternal(const NaClBitCodeAbbrev *Abbrev);
+
+  // Helper function that prints out the abbreviation expression
+  // located at Index in the given abbreviation. Updates Index to
+  // next expression in the abbreviation.
+  void TokenizeAbbrevExpression(const NaClBitCodeAbbrev *Abbrev,
+                                unsigned &Index);
+
+  // Prints out the given abbreviation operator.
+  void TokenizeAbbrevOp(const NaClBitCodeAbbrevOp &Op);
+
+  // The free list for abbreviation directives.
+  naclbitc::DirectiveMemoryPool<AbbreviationDirective> AbbrevDirMemoryPool;
+
+  // The free list for abbreviation index directives.
+  naclbitc::DirectiveMemoryPool<AbbrevIndexDirective> AbbrevIndexDirMemoryPool;
+
+  // Computes how wide the assembly portion of the dump file should be.
+  static unsigned GetAssemblyWidth(naclbitc::ObjDumpStream &ObjDump) {
+    int Diff = 80 - (ObjDump.GetRecordWidth()+1);
+    // Make sure there is enough room to print out assembly.
+    return Diff < 20 ? 20 : Diff;
+  }
+};
+
+void AssemblyTextFormatter::TypeDirective::MyApply(bool Replay) const {
+  assert(!Replay && "Shouldn't have been saved for replay");
+  AssemblyTextFormatter *AssemblyFormatter =
+      reinterpret_cast<AssemblyTextFormatter*>(Formatter);
+  AssemblyFormatter->TokenizeTypeInternal(Typ, FcnId, AddParams);
+  AssemblyFormatter->TypeDirMemoryPool.Free(const_cast<TypeDirective*>(this));
+}
+
+void AssemblyTextFormatter::AbbreviationDirective::MyApply(bool Replay) const {
+  assert(!Replay && "Shouldn't have been saved for replay");
+  AssemblyTextFormatter *AssemblyFormatter =
+      reinterpret_cast<AssemblyTextFormatter*>(Formatter);
+  AssemblyFormatter->TokenizeAbbreviationInternal(Abbrev);
+  AssemblyFormatter->AbbrevDirMemoryPool.Free(
+      const_cast<AbbreviationDirective*>(this));
+}
+
+AssemblyTextFormatter::TypeDirective &AssemblyTextFormatter::
+AllocateTypeDirective(Type *Typ, BitcodeId *FcnId, bool AddParams) {
+  TypeDirective *Element = TypeDirMemoryPool.Allocate(this);
+  Element->Init(Typ, FcnId, AddParams);
+  return *Element;
+}
+
+void AssemblyTextFormatter::TokenizeTypeInternal(
+    Type *Typ, BitcodeId* FcnName, bool AddParams) {
+  switch (Typ->getTypeID()) {
+  case Type::VoidTyID:
+    TextStream << "void";
+    break;
+  case Type::FloatTyID:
+    TextStream << "float";
+    break;
+  case Type::DoubleTyID:
+    TextStream << "double";
+    break;
+  case Type::IntegerTyID:
+    TextStream << "i" << Typ->getIntegerBitWidth();
+    break;
+  case Type::VectorTyID: {
+    VectorType *VecType = cast<VectorType>(Typ);
+    TextStream << StartCluster << OpenAngle << VecType->getNumElements()
+               << Space << "x" << Space
+               << TokenizeType(VecType->getElementType())
+               << CloseAngle << FinishCluster;
+    break;
+  }
+  case Type::FunctionTyID: {
+    FunctionType *FcnType = cast<FunctionType>(Typ);
+    unsigned NumParams = FcnType->getFunctionNumParams();
+    TextStream << StartCluster
+               << TokenizeType(FcnType->getReturnType())
+               << Space
+               << StartCluster;
+    if (NumParams > 0) TextStream << StartCluster;
+    if (FcnName) TextStream << *FcnName;
+    TextStream << OpenParen << FinishCluster;
+    bool HasParamStartCluster = false;
+    for (unsigned i = 0, NumParams = FcnType->getFunctionNumParams();
+         i < NumParams; ++i) {
+      if (i > 0) {
+        TextStream << Comma << FinishCluster << Space;
+        HasParamStartCluster = false;
+      }
+      TextStream << StartCluster
+                 << TokenizeType(FcnType->getFunctionParamType(i));
+      if (AddParams) TextStream << Space << BitcodeId('p', i);
+      HasParamStartCluster = true;
+    }
+    if (FcnType->isFunctionVarArg()) {
+      if (HasParamStartCluster) {
+        TextStream << Comma << FinishCluster << Space;
+      }
+      TextStream << StartCluster << "...";
+      HasParamStartCluster = true;
+    }
+    if (HasParamStartCluster) TextStream << FinishCluster;
+    TextStream << CloseParen << FinishCluster;
+    if (NumParams > 0) TextStream << FinishCluster;
+    break;
+  }
+  default:
+    report_fatal_error("Unsupported PNaCl type found");
+    break;
+  }
+}
+
+void AssemblyTextFormatter::TokenizeAbbrevOp(const NaClBitCodeAbbrevOp &Op) {
+  // Note: Mimics NaClBitCodeAbbrevOp::Print in NaClBitCodes.cpp
+  switch (Op.getEncoding()) {
+  case NaClBitCodeAbbrevOp::Literal:
+    Tokens() << Op.getValue();
+    return;
+  case NaClBitCodeAbbrevOp::Fixed:
+    Tokens() << StartCluster << "fixed" << OpenParen << Op.getValue()
+             << CloseParen << FinishCluster;
+    return;
+  case NaClBitCodeAbbrevOp::VBR:
+    Tokens() << StartCluster << "vbr" << OpenParen << Op.getValue()
+             << CloseParen << FinishCluster;
+    return;
+  case NaClBitCodeAbbrevOp::Array:
+    Tokens() << "array";
+    return;
+  case NaClBitCodeAbbrevOp::Char6:
+    Tokens() << "char6";
+    return;
+  }
+}
+
+void AssemblyTextFormatter::
+TokenizeAbbrevExpression(const NaClBitCodeAbbrev *Abbrev, unsigned &Index) {
+  // Note: Mimics PrintExpression in NaClBitCodes.cpp
+  const NaClBitCodeAbbrevOp &Op = Abbrev->getOperandInfo(Index);
+  TokenizeAbbrevOp(Op);
+  if (unsigned NumArgs = Op.NumArguments()) {
+    Tokens() << StartCluster << OpenParen;
+    for (unsigned i = 0; i < NumArgs; ++i) {
+      ++Index;
+      if (i > 0) {
+        Tokens() << Comma << FinishCluster << Space << StartCluster;
+      }
+      TokenizeAbbrevExpression(Abbrev, Index);
+    }
+    Tokens() << CloseParen << FinishCluster;
+  }
+}
+
+void AssemblyTextFormatter::
+TokenizeAbbreviationInternal(const NaClBitCodeAbbrev *Abbrev) {
+  Tokens() << StartCluster << OpenAngle;
+  for (unsigned i = 0; i < Abbrev->getNumOperandInfos(); ++i) {
+    if (i > 0) {
+      Tokens() << Comma << FinishCluster << Space << StartCluster;
+    }
+    TokenizeAbbrevExpression(Abbrev, i);
+  }
+  Tokens() << CloseAngle << FinishCluster;
+}
+
+void AssemblyTextFormatter::AbbrevIndexDirective::MyApply(bool Replay) const {
+  assert(!Replay && "Shouldn't have been saved for replay");
+  if (!Record->UsedAnAbbreviation()) return;
+  unsigned Index = Record->GetAbbreviationIndex();
+  if (Index < naclbitc::FIRST_APPLICATION_ABBREV) return;
+  Index -= naclbitc::FIRST_APPLICATION_ABBREV;
+  bool IsGlobal = Index < NumGlobalAbbreviations;
+  if (!IsGlobal) Index -= NumGlobalAbbreviations;
+  BitcodeId AbbrevIndex('a', Index, IsGlobal);
+  AssemblyTextFormatter *Fmtr =
+      reinterpret_cast<AssemblyTextFormatter*>(Formatter);
+  Tokens() << Fmtr->Space << Fmtr->StartCluster << Fmtr->OpenAngle
+           << AbbrevIndex << Fmtr->CloseAngle << Fmtr->FinishCluster;
+  Fmtr->AbbrevIndexDirMemoryPool.Free(const_cast<AbbrevIndexDirective*>(this));
+}
+
+// Holds possible alignements for loads/stores etc. Used to extract
+// expected values.
+static unsigned NaClPossibleLoadStoreAlignments[] = {
+  1, 2, 4, 8
+};
+
+// Finds the expected alignments for the load/store, for type Ty.
+static void NaClGetExpectedLoadStoreAlignment(
+    const DataLayout &DL, Type *Ty, std::vector<unsigned> &ValidAlignments) {
+  for (size_t i = 0; i < array_lengthof(NaClPossibleLoadStoreAlignments); ++i) {
+    unsigned Alignment = NaClPossibleLoadStoreAlignments[i];
+    if (PNaClABIProps::isAllowedAlignment(&DL, Alignment, Ty)) {
+      ValidAlignments.push_back(Alignment);
+    }
+  }
+}
+
+/// Top-level class to parse bitcode file and transform to
+/// corresponding disassembled code.
+class NaClDisTopLevelParser : public NaClBitcodeParser {
+  NaClDisTopLevelParser(const NaClDisTopLevelParser&) LLVM_DELETED_FUNCTION;
+  void operator=(const NaClDisTopLevelParser&) LLVM_DELETED_FUNCTION;
+
+public:
+  NaClDisTopLevelParser(NaClBitcodeHeader &Header,
+                        const unsigned char *HeaderBuffer,
+                        NaClBitstreamCursor &Cursor,
+                        naclbitc::ObjDumpStream &ObjDump)
+      : NaClBitcodeParser(Cursor),
+        Mod("ObjDump", getGlobalContext()),
+        ObjDump(ObjDump),
+        AbbrevListener(this),
+        DL(&Mod),
+        AllowedIntrinsics(&Mod.getContext()),
+        AssemblyFormatter(ObjDump),
+        Header(Header),
+        HeaderBuffer(HeaderBuffer),
+        NumFunctions(0),
+        NumGlobals(0),
+        ExpectedNumGlobals(0),
+        NumParams(0),
+        NumConstants(0),
+        NumValuedInsts(0),
+        UnknownType(Type::getVoidTy(Mod.getContext())),
+        PointerType(Type::getInt32Ty(Mod.getContext())),
+        ComparisonType(Type::getInt1Ty(Mod.getContext())),
+        NumDefinedFunctions(0) {
+    SetListener(&AbbrevListener);
+  }
+
+  ~NaClDisTopLevelParser() override {
+    // Be sure to flush any remaining errors.
+    ObjDump.Flush();
+  }
+
+  // Returns the number of errors that were sent to the ObjDump.
+  unsigned GetNumErrors() {
+    return ObjDump.GetNumErrors();
+  }
+
+  /// Generates an error with the given message.
+  bool Error(const std::string &Message) override {
+    // Use local error routine so that all errors are treated uniformly.
+    ObjDump.Error() << Message << "\n";
+    return true;
+  }
+
+  /// Flushes out objdump and then exits with fatal error.
+  void Fatal() {
+    Fatal("");
+  }
+
+  /// Flushes out objdump and then exits with fatal error, using
+  /// the given message.
+  void Fatal(const std::string &Message) {
+    ObjDump.Fatal(Message);
+  }
+
+  /// Parses the top-level module block.
+  bool ParseBlock(unsigned BlockID) override;
+
+  /// Installs the given type to the next available type index.
+  void InstallType(Type *Ty) {
+    TypeIdType.push_back(Ty);
+  }
+
+  /// Returns the type associated with the given type index.
+  Type *GetType(uint32_t Index) {
+    if (Index >= TypeIdType.size()) {
+      BitcodeId Id('t', Index);
+      Errors() << "Can't find definition for " << Id << "\n";
+      // Recover so that additional errors can be found.
+      return UnknownType;
+    }
+    return TypeIdType[Index];
+  }
+
+  /// Returns the number of types (currently) defined in the bitcode
+  /// file.
+  uint32_t GetNumTypes() const {
+    return TypeIdType.size();
+  }
+
+  /// Returns true if Type represents a (non-zero sized) value.
+  bool isValidValueType(Type *Ty) const {
+    return Ty->isIntegerTy() || Ty->isFloatTy() || Ty->isDoubleTy()
+        || Ty->isVectorTy();
+  }
+
+  /// Installs the given type to the next available function index.
+  void InstallFunctionType(FunctionType *Ty, uint64_t BitAddress) {
+    assert(FunctionIdType.size() == NumFunctions);
+    ++NumFunctions;
+    FunctionIdType.push_back(Ty);
+    FunctionIdAddress.push_back(BitAddress);
+    // Let Valuesymtab change this to true if appropriate.
+    FunctionIdIsIntrinsic.push_back(false);
+  }
+
+  /// Returns the bit address where the function record appeared in
+  /// the bitcode file. Returns 0 if unknown.
+  uint64_t GetFunctionIdAddress(uint32_t Index) {
+    if (Index >= FunctionIdAddress.size()) return 0;
+    return FunctionIdAddress[Index];
+  }
+
+  /// Sets the record bit address to the function ID address (if known).
+  void SetRecordAddressToFunctionIdAddress(uint32_t Index) {
+    uint64_t Address = GetFunctionIdAddress(Index);
+    if (Address)
+      ObjDump.SetRecordBitAddress(Address);
+  }
+
+  //// Returns the type associated with the given function index.
+  FunctionType *GetFunctionType(uint32_t Index) {
+    if (Index >= FunctionIdType.size()) {
+      BitcodeId Id('f', Index);
+      Errors() << "Can't find definition for " << Id << "\n";
+      Fatal();
+    }
+    return FunctionIdType[Index];
+  }
+
+  /// Marks the function associated with the given Index as intrinsic.
+  void MarkFunctionAsIntrinsic(uint32_t Index) {
+    if (Index >= FunctionIdIsIntrinsic.size()) {
+      BitcodeId Id('f', Index);
+      Errors() << "Can't define " << Id << " as intrinsic, no definition";
+    }
+    FunctionIdIsIntrinsic[Index] = true;
+  }
+
+  /// Returns true if the given Index is for a function intrinsic.
+  bool IsFunctionIntrinsic(uint32_t Index) {
+    if (Index >= FunctionIdIsIntrinsic.size()) return false;
+    return FunctionIdIsIntrinsic[Index];
+  }
+
+  /// Returns true if the function is an intrinsic function.
+  bool IsIntrinsicAllowed(const std::string &FuncName,
+                          const FunctionType *FuncType) {
+    return AllowedIntrinsics.isAllowed(FuncName, FuncType);
+  }
+
+  /// Returns the type of the Name'd intrinsic, if defined as an
+  /// allowed intrinsic name. Otherwise returns 0.
+  FunctionType *GetIntrinsicType(const std::string &Name) {
+    return AllowedIntrinsics.getIntrinsicType(Name);
+  }
+
+  /// Returns the number of functions (currently) defined/declared in
+  /// the bitcode file.
+  uint32_t GetNumFunctions() const {
+    return NumFunctions;
+  }
+
+  /// Installs that the given function index as having a function body
+  /// (i.e. the function address uses the "define" keyword instead of
+  /// the "declare" keyword).
+  void InstallDefinedFunction(uint32_t Index) {
+    DefinedFunctions.push_back(Index);
+  }
+
+  /// Returns true if there is an Index defined function block.
+  bool HasDefinedFunctionIndex(uint32_t Index) const {
+    return Index < DefinedFunctions.size();
+  }
+
+  /// Returns the function index associated with the Index defined
+  /// function block.
+  uint32_t GetDefinedFunctionIndex(uint32_t Index) const {
+    assert(Index < DefinedFunctions.size());
+    return DefinedFunctions[NumDefinedFunctions];
+  }
+
+  /// Returns true if there is a next defined function index.
+  bool HasNextDefinedFunctionIndex() const {
+    return HasDefinedFunctionIndex(NumDefinedFunctions);
+  }
+
+  /// Returns the function index associated with the next defined function.
+  uint32_t GetNextDefinedFunctionIndex() const {
+    return GetDefinedFunctionIndex(NumDefinedFunctions);
+  }
+
+  /// Returns true if the given value ID corresponds to a declared (rather
+  /// than defined) function.
+  bool IsDeclaredFunction(uint32_t Index) {
+    if (Index >= NumFunctions) return false;
+    for (size_t i = 0, e = DefinedFunctions.size(); i < e; ++i) {
+      if (DefinedFunctions[i] == Index) return false;
+    }
+    return true;
+  }
+
+  /// Increments the number of (currently) defined functions in the
+  /// bitcode file by one.
+  void IncNumDefinedFunctions() {
+    ++NumDefinedFunctions;
+  }
+
+  void IncNumGlobals() {
+    NumGlobals++;
+  }
+
+  /// Returns the number of globals (currently) defined in the bitcode
+  /// file.
+  uint32_t GetNumGlobals() const {
+    return NumGlobals;
+  }
+
+  /// Returns the expected number of globals (as defined by the count
+  /// record of the globals block).
+  uint32_t GetExpectedNumGlobals() const {
+    return ExpectedNumGlobals;
+  }
+
+  /// Sets field ExpectedNumGlobals to the given value.
+  void SetExpectedNumGlobals(uint32_t NewValue) {
+    ExpectedNumGlobals = NewValue;
+  }
+
+  /// Installs the given type to the next available parameter index.
+  void InstallParamType(Type *Ty) {
+    while (ParamIdType.size() <= NumParams) {
+      ParamIdType.push_back(UnknownType);
+    }
+    ParamIdType[NumParams++] = Ty;
+  }
+
+  /// Returns the type associated with the given parameter index.
+  Type *GetParamType(uint32_t Index) {
+    if (Index >= ParamIdType.size()) {
+      BitcodeId Id('p', Index);
+      Errors() << "Can't find defintion for " << Id << "\n";
+      Fatal();
+    }
+    return ParamIdType[Index];
+  }
+
+  /// Returns the number of parameters (currently) defined in the
+  /// enclosing defined function.
+  uint32_t GetNumParams() const {
+    return NumParams;
+  }
+
+  /// Installs the given type to the next available constant index.
+  void InstallConstantType(Type *Ty) {
+    while (ConstantIdType.size() <= NumConstants) {
+      ConstantIdType.push_back(UnknownType);
+    }
+    ConstantIdType[NumConstants++] = Ty;
+  }
+
+  /// Returns the type associated with the given constant index.
+  Type *GetConstantType(uint32_t Index) {
+    if (Index >= ConstantIdType.size()) {
+      BitcodeId Id('c', Index);
+      Errors() << "Can't find definition for " << Id << "\n";
+      Fatal();
+    }
+    return ConstantIdType[Index];
+  }
+
+  /// Returns the number of constants (currently) defined in the
+  /// enclosing defined function.
+  uint32_t GetNumConstants() const {
+    return NumConstants;
+  }
+
+  /// Installs the given type to the given instruction index.  Note:
+  /// Instruction indices are only associated with instructions that
+  /// generate values.
+  void InstallInstType(Type *Ty, uint32_t Index) {
+    while (InstIdType.size() <= Index) {
+      InstIdType.push_back(UnknownType);
+    }
+    if (InstIdType[Index] != UnknownType && Ty != InstIdType[Index]) {
+      Errors() << BitcodeId('v', Index) << " defined with multiple types: "
+               << *Ty << " and " << *InstIdType[Index] << "\n";
+    }
+    InstIdType[Index] = Ty;
+  }
+
+  /// Installs the given type to the next available instruction index.
+  void InstallInstType(Type *Ty) {
+    InstallInstType(Ty, NumValuedInsts++);
+  }
+
+  /// Returns the type associated with the given instruction index.
+  /// Note: Instruction indices are only associated with instructions
+  /// that generate values.
+  Type *GetInstType(uint32_t Index) {
+    if (Index >= InstIdType.size()) {
+      Errors() << "Can't find type for " << BitcodeId('v', Index) << "\n";
+      return UnknownType;
+    }
+    return InstIdType[Index];
+  }
+
+  /// Returns the number of instructions (in the defined function)
+  /// that (currently) generate values.
+  uint32_t GetNumValuedInstructions() const {
+    return NumValuedInsts;
+  }
+
+  /// Resets index counters local to a defined function.
+  void ResetLocalCounters() {
+    ParamIdType.clear();
+    NumParams = 0;
+    NumConstants = 0;
+    InstIdType.clear();
+    NumValuedInsts = 0;
+  }
+
+  /// Returns the bitcode id associated with the absolute value index
+  BitcodeId GetBitcodeId(uint32_t Index);
+
+  /// Returns the type associated with the given absolute value index.
+  /// If UnderlyingType is false, function indices always return a
+  /// pointer type. Otherwise, function indices returns the declared
+  /// type of the function index.
+  Type *GetValueType(uint32_t Index, bool UnderlyingType = false);
+
+  /// Returns a type to use when the type is unknown.
+  Type *GetUnknownType() const {
+    return UnknownType;
+  }
+
+  /// Returns the type used to represent a pointer.
+  Type *GetPointerType() const {
+    return PointerType;
+  }
+
+  /// Returns the type used to represent comparison results.
+  Type *GetComparisonType() const {
+    return ComparisonType;
+  }
+
+  /// Returns the void type.
+  Type *GetVoidType() const {
+    return Type::getVoidTy(getGlobalContext());
+  }
+
+  /// Returns the float (32-bit) type.
+  Type *GetFloatType() const {
+    return Type::getFloatTy(getGlobalContext());
+  }
+
+  /// Returns the double (64-bit) type.
+  Type *GetDoubleType() const {
+    return Type::getDoubleTy(getGlobalContext());
+  }
+
+  /// Returns an integer type of N bits.
+  Type *GetIntegerType(unsigned N) const {
+    return Type::getIntNTy(getGlobalContext(), N);
+  }
+
+  /// Returns the number of defined global abbreviations (currently)
+  /// for the given block id.
+  unsigned GetNumGlobalAbbreviations(unsigned BlockID) {
+    return GlobalAbbrevsCountMap[BlockID];
+  }
+
+  /// Increments the current number of defined global abbreviations.
+  void IncNumGlobalAbbreviations(unsigned BlockID) {
+    ++GlobalAbbrevsCountMap[BlockID];
+  }
+
+  /// Verifies the given integer operator has the right type.  Returns
+  /// the operator.
+  const char *VerifyIntArithmeticOp(const char *Op, Type *OpTy) {
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidIntArithmeticType(OpTy)) {
+      Errors() << Op << ": Invalid integer arithmetic type: " << *OpTy;
+    }
+    return Op;
+  }
+
+  // Checks the Alignment for loading/storing a value of type Ty. If
+  // invalid, generates an appropriate error message.
+  void VerifyMemoryAccessAlignment(const char *Op, Type *Ty,
+                                   unsigned Alignment) {
+    if (IgnorePNaClABIChecks) return;
+    if (!PNaClABIProps::isAllowedAlignment(&DL, Alignment, Ty)) {
+      raw_ostream &Errs = Errors();
+      std::vector<unsigned> Alignments;
+      NaClGetExpectedLoadStoreAlignment(DL, Ty, Alignments);
+      if (!Alignments.empty()) {
+        Errs << Op << ": Illegal alignment for " << *Ty << ". Expects: ";
+        bool isFirst = true;
+        for (auto Align : Alignments) {
+          if (isFirst)
+            isFirst = false;
+          else
+            Errs << " or ";
+          Errs << Align;
+        }
+        Errs << "\n";
+      } else {
+        Errs << Op << ": Not allowed for type: " << *Ty << "\n";
+      }
+    }
+  }
+
+  // ******************************************************
+  // The following return the corresponding methods/fields
+  // from the the assembly formatter/objdumper.
+  // ******************************************************
+
+  naclbitc::TokenTextDirective &Semicolon() {
+    return AssemblyFormatter.Semicolon;
+  }
+
+  naclbitc::TokenTextDirective &Colon() {
+    return AssemblyFormatter.Colon;
+  }
+
+  naclbitc::SpaceTextDirective &Space() {
+    return AssemblyFormatter.Space;
+  }
+
+  naclbitc::TokenTextDirective &Comma() {
+    return AssemblyFormatter.Comma;
+  }
+
+  naclbitc::OpenTextDirective &OpenParen() {
+    return AssemblyFormatter.OpenParen;
+  }
+
+  naclbitc::CloseTextDirective &CloseParen() {
+    return AssemblyFormatter.CloseParen;
+  }
+
+  naclbitc::OpenTextDirective &OpenAngle() {
+    return AssemblyFormatter.OpenAngle;
+  }
+
+  naclbitc::CloseTextDirective &CloseAngle() {
+    return AssemblyFormatter.CloseAngle;
+  }
+
+  naclbitc::OpenTextDirective &OpenCurly() {
+    return AssemblyFormatter.OpenCurly;
+  }
+
+  naclbitc::CloseTextDirective &CloseCurly() {
+    return AssemblyFormatter.CloseCurly;
+  }
+
+  naclbitc::OpenTextDirective &OpenSquare() {
+    return AssemblyFormatter.OpenSquare;
+  }
+
+  naclbitc::CloseTextDirective &CloseSquare() {
+    return AssemblyFormatter.CloseSquare;
+  }
+
+  naclbitc::EndlineTextDirective &Endline() {
+    return AssemblyFormatter.Endline;
+  }
+
+  naclbitc::StartClusteringDirective &StartCluster() {
+    return AssemblyFormatter.StartCluster;
+  }
+
+  naclbitc::FinishClusteringDirective &FinishCluster() {
+    return AssemblyFormatter.FinishCluster;
+  }
+
+  raw_ostream &Tokens() {
+    return AssemblyFormatter.Tokens();
+  }
+
+  raw_ostream &Errors() {
+    return ObjDump.Error();
+  }
+
+  raw_ostream &Warnings() {
+    if (ReportWarningsAsErrors) return Errors();
+    return ObjDump.Warning();
+  }
+
+  const std::string &GetAssemblyIndent() const {
+    return AssemblyFormatter.GetIndent();
+  }
+
+  unsigned GetAssemblyNumTabs() const {
+    return AssemblyFormatter.GetNumTabs();
+  }
+
+  void IncAssemblyIndent() {
+    AssemblyFormatter.Inc();
+  }
+
+  void DecAssemblyIndent() {
+    AssemblyFormatter.Dec();
+  }
+
+  void IncRecordIndent() {
+    ObjDump.IncRecordIndent();
+  }
+
+  void DecRecordIndent() {
+    ObjDump.DecRecordIndent();
+  }
+
+  void ObjDumpFlush() {
+    ObjDump.Flush();
+  }
+
+  void ObjDumpSetRecordBitAddress(uint64_t Bit) {
+    ObjDump.SetRecordBitAddress(Bit);
+  }
+
+  void ObjDumpWrite(uint64_t Bit,
+                    const NaClBitcodeRecordData &Record,
+                    int32_t AbbrevIndex =
+                    naclbitc::ABBREV_INDEX_NOT_SPECIFIED) {
+    ObjDump.Write(Bit, Record, AbbrevIndex);
+  }
+
+  void ObjDumpWrite(uint64_t Bit,
+                    const NaClBitcodeRecord &Record) {
+    ObjDump.Write(Bit, Record.GetRecordData(), Record.GetAbbreviationIndex());
+  }
+
+  AssemblyTextFormatter::TypeDirective &
+  TokenizeType(Type *Typ) {
+    return AssemblyFormatter.TokenizeType(Typ);
+  }
+
+  AssemblyTextFormatter::TypeDirective &
+  TokenizeFunctionType(FunctionType *Type, BitcodeId *FcnId) {
+    return AssemblyFormatter.TokenizeFunctionType(Type, FcnId);
+  }
+
+  AssemblyTextFormatter::TypeDirective &
+  TokenizeFunctionSignature(FunctionType *Typ, BitcodeId *FcnId) {
+    return AssemblyFormatter.TokenizeFunctionSignature(Typ, FcnId);
+  }
+
+  AssemblyTextFormatter::AbbreviationDirective &
+  TokenizeAbbreviation(NaClBitCodeAbbrev *Abbrev) {
+    return AssemblyFormatter.TokenizeAbbreviation(Abbrev);
+  }
+
+  AssemblyTextFormatter::AbbrevIndexDirective &
+  TokenizeAbbrevIndex(NaClBitcodeRecord &Record,
+                      unsigned NumGlobalAbbreviations) {
+    return AssemblyFormatter.TokenizeAbbrevIndex(Record,
+                                                 NumGlobalAbbreviations);
+  }
+
+private:
+  // A placeholder module for associating context and data layout.
+  Module Mod;
+  // The output stream to generate disassembly into.
+  naclbitc::ObjDumpStream &ObjDump;
+  // Listener used to get abbreviations as they are read.
+  NaClBitcodeParserListener AbbrevListener;
+  // DataLayout to use.
+  const DataLayout DL;
+  // The set of allowed intrinsics.
+  PNaClAllowedIntrinsics AllowedIntrinsics;
+  // The formatter to use to format assembly code.
+  AssemblyTextFormatter AssemblyFormatter;
+  // The header appearing before the beginning of the input stream.
+  NaClBitcodeHeader &Header;
+  // Pointer to the buffer containing the header.
+  const unsigned char *HeaderBuffer;
+  // The list of known types (index i defines the type associated with
+  // type index i).
+  std::vector<Type*> TypeIdType;
+  // The list of known function signatures (index i defines the type
+  // signature associated with function index i).
+  std::vector<FunctionType*> FunctionIdType;
+  // boolean flag defining if function id is an intrinsic.
+  std::vector<bool> FunctionIdIsIntrinsic;
+  // The list of record bit addresses associated with corresponding
+  // declaration of function IDs.
+  std::vector<uint64_t> FunctionIdAddress;
+  // The number of function indices currently defined.
+  uint32_t NumFunctions;
+  // The number of global indices currently defined.
+  uint32_t NumGlobals;
+  // The expected number of global indices (i.e. value of count record
+  // in the globals block).
+  uint32_t ExpectedNumGlobals;
+  // The list of known parameter types (index i defines the type
+  // associated with parameter index i).
+  std::vector<Type*>ParamIdType;
+  // The number of parameter indices currently defined.
+  uint32_t NumParams;
+  std::vector<Type*>ConstantIdType;
+  // The number of constant indices currently defined.
+  uint32_t NumConstants;
+  // The list of known instruction types (index i defines the type
+  // associated with valued instruction index i).
+  std::vector<Type*> InstIdType;
+  // The number of valued instructions currently defined.
+  uint32_t NumValuedInsts;
+  // Models an unknown type.
+  Type *UnknownType;
+  // Models the pointer type.
+  Type *PointerType;
+  // Models a result of a comparison.
+  Type *ComparisonType;
+  // Keeps list of function indicies (in the order found in the bitcode)
+  // that correspond to defined functions.
+  std::vector<uint32_t> DefinedFunctions;
+  // The number of function indices currently known to be defined.
+  uint32_t NumDefinedFunctions;
+  // Holds the number of global abbreviations defined for each block.
+  std::map<unsigned, unsigned> GlobalAbbrevsCountMap;
+};
+
+BitcodeId NaClDisTopLevelParser::GetBitcodeId(uint32_t Index) {
+  if (Index < NumFunctions) {
+    return BitcodeId('f', Index);
+  }
+  Index -= NumFunctions;
+  if (Index < ExpectedNumGlobals) {
+    return BitcodeId('g', Index);
+  }
+  Index -= ExpectedNumGlobals;
+  if (Index < NumParams) {
+    return BitcodeId('p', Index);
+  }
+  Index -= NumParams;
+  if (Index < NumConstants) {
+    return BitcodeId('c', Index);
+  }
+  Index -= NumConstants;
+  return BitcodeId('v', Index);
+}
+
+Type *NaClDisTopLevelParser::GetValueType(uint32_t Index, bool UnderlyingType) {
+  uint32_t Idx = Index;
+  if (Idx < NumFunctions)
+    return UnderlyingType ? GetFunctionType(Idx) : PointerType;
+  Idx -= NumFunctions;
+  if (Idx < ExpectedNumGlobals)
+    return PointerType;
+  Idx -= ExpectedNumGlobals;
+  if (Idx < NumParams)
+    return GetParamType(Idx);
+  Idx -= NumParams;
+  if (Idx < NumConstants)
+    return GetConstantType(Idx);
+  Idx -= NumConstants;
+  return GetInstType(Idx);
+}
+
+// Base class of all block parsers for the bitcode file. Handles
+// common actions needed by derived blocks.
+//
+// Note: This class also handles blocks with unknown block ID's.
+class NaClDisBlockParser : public NaClBitcodeParser {
+protected:
+  /// Constructor for the top-level block parser.
+  NaClDisBlockParser(unsigned BlockID, NaClDisTopLevelParser *Context)
+      : NaClBitcodeParser(BlockID, Context),
+        Context(Context){
+    InitAbbreviations();
+  }
+
+  /// Constructor for nested block parsers.
+  NaClDisBlockParser(unsigned BlockID, NaClDisBlockParser *EnclosingParser)
+      : NaClBitcodeParser(BlockID, EnclosingParser),
+        Context(EnclosingParser->Context) {
+    InitAbbreviations();
+  }
+
+public:
+
+  ~NaClDisBlockParser() override {
+    // Be sure to flush any remaining errors reported at end of block.
+    ObjDumpFlush();
+  }
+
+  bool ParseBlock(unsigned BlockID) override;
+
+protected:
+  void EnterBlock(unsigned NumWords) override;
+
+  void ExitBlock() override;
+
+  void ProcessRecord() override;
+
+  void ProcessAbbreviation(unsigned BlockID, NaClBitCodeAbbrev *Abbrev,
+                           bool IsLocal) override;
+
+  void InitAbbreviations() {
+    NumGlobalAbbreviations = Context->GetNumGlobalAbbreviations(GetBlockID());
+    NumLocalAbbreviations = 0;
+  }
+
+  // Prints the block header instruction for the block. Called by EnterBlock.
+  virtual void PrintBlockHeader();
+
+  // Dumps the corresponding record for a block enter.
+  void DumpEnterBlockRecord();
+
+  // Returns the identifier for the next local abbreviation appearing in
+  // the block.
+  BitcodeId NextLocalAbbreviationId() {
+    return BitcodeId('a', NumLocalAbbreviations, false);
+  }
+
+  AssemblyTextFormatter::AbbrevIndexDirective &TokenizeAbbrevIndex() {
+    return Context->TokenizeAbbrevIndex(Record, NumGlobalAbbreviations);
+  }
+
+  // *****************************************************************
+  // The following are dispatching methods that call the corresponding
+  // method on the Context (i.e. NaClDisTopLevelParser).
+  // *****************************************************************
+
+  /// Returns a directive to tokenize the given type.
+  AssemblyTextFormatter::TypeDirective &TokenizeType(Type *Type) {
+    return Context->TokenizeType(Type);
+  }
+
+  /// Returns a directive to tokenize the given function type,
+  /// using the given function id.
+  AssemblyTextFormatter::TypeDirective
+  &TokenizeFunctionType(FunctionType *Type, BitcodeId *FcnId) {
+    return Context->TokenizeFunctionType(Type, FcnId);
+  }
+
+  /// Returns a directive to tokenize the function signature, given the
+  /// type of the function signature, and the given function id.
+  AssemblyTextFormatter::TypeDirective
+  &TokenizeFunctionSignature(FunctionType *Typ, BitcodeId *FcnId) {
+    return Context->TokenizeFunctionSignature(Typ, FcnId);
+  }
+
+  AssemblyTextFormatter::AbbreviationDirective &TokenizeAbbreviation(
+      NaClBitCodeAbbrev *Abbrev) {
+    return Context->TokenizeAbbreviation(Abbrev);
+  }
+
+  naclbitc::TokenTextDirective &Semicolon() {
+    return Context->Semicolon();
+  }
+
+  naclbitc::TokenTextDirective &Colon() {
+    return Context->Colon();
+  }
+
+  naclbitc::SpaceTextDirective &Space() {
+    return Context->Space();
+  }
+
+  naclbitc::TokenTextDirective &Comma() {
+    return Context->Comma();
+  }
+
+  naclbitc::OpenTextDirective &OpenParen() {
+    return Context->OpenParen();
+  }
+
+
+  naclbitc::CloseTextDirective &CloseParen() {
+    return Context->CloseParen();
+  }
+
+  naclbitc::OpenTextDirective &OpenAngle() {
+    return Context->OpenAngle();
+  }
+
+  naclbitc::CloseTextDirective &CloseAngle() {
+    return Context->CloseAngle();
+  }
+
+  naclbitc::OpenTextDirective &OpenCurly() {
+    return Context->OpenCurly();
+  }
+
+  naclbitc::CloseTextDirective &CloseCurly() {
+    return Context->CloseCurly();
+  }
+
+  naclbitc::OpenTextDirective &OpenSquare() {
+    return Context->OpenSquare();
+  }
+
+  naclbitc::CloseTextDirective &CloseSquare() {
+    return Context->CloseSquare();
+  }
+
+  naclbitc::EndlineTextDirective &Endline() {
+    return Context->Endline();
+  }
+
+  naclbitc::StartClusteringDirective &StartCluster() {
+    return Context->StartCluster();
+  }
+
+  naclbitc::FinishClusteringDirective &FinishCluster() {
+    return Context->FinishCluster();
+  }
+
+  raw_ostream &Tokens() {
+    return Context->Tokens();
+  }
+
+  raw_ostream &Errors() {
+    return Context->Errors();
+  }
+
+  raw_ostream &Warnings() {
+    return Context->Warnings();
+  }
+
+  void Fatal() {
+    return Context->Fatal();
+  }
+
+  void Fatal(const std::string &Message) {
+    return Context->Fatal(Message);
+  }
+
+  const std::string &GetAssemblyIndent() const {
+    return Context->GetAssemblyIndent();
+  }
+
+  unsigned GetAssemblyNumTabs() const {
+    return Context->GetAssemblyNumTabs();
+  }
+
+  void IncAssemblyIndent() {
+    Context->IncAssemblyIndent();
+  }
+
+  void DecAssemblyIndent() {
+    Context->DecAssemblyIndent();
+  }
+
+  void IncRecordIndent() {
+    Context->IncRecordIndent();
+  }
+
+  void DecRecordIndent() {
+    Context->DecRecordIndent();
+  }
+
+  void ObjDumpFlush() {
+    Context->ObjDumpFlush();
+  }
+
+  void ObjDumpWrite(uint64_t Bit,
+                    const NaClBitcodeRecordData &Record,
+                    int32_t AbbrevIndex =
+                    naclbitc::ABBREV_INDEX_NOT_SPECIFIED) {
+    Context->ObjDumpWrite(Bit, Record, AbbrevIndex);
+  }
+
+  void ObjDumpWrite(uint64_t Bit,
+                    const NaClBitcodeRecord &Record) {
+    Context->ObjDumpWrite(Bit, Record);
+  }
+
+  void ObjDumpSetRecordBitAddress(uint64_t Bit) {
+    Context->ObjDumpSetRecordBitAddress(Bit);
+  }
+
+  void InstallType(Type *Ty) {
+    Context->InstallType(Ty);
+  }
+
+  Type *GetType(uint32_t Index) {
+    return Context->GetType(Index);
+  }
+
+  uint32_t GetNumTypes() const {
+    return Context->GetNumTypes();
+  }
+
+  bool isValidValueType(Type *Ty) const {
+    return Context->isValidValueType(Ty);
+  }
+
+  FunctionType *GetFunctionType(uint32_t Index) {
+    return Context->GetFunctionType(Index);
+  }
+
+  uint32_t GetNumFunctions() const {
+    return Context->GetNumFunctions();
+  }
+
+  void IncNumGlobals() {
+    Context->IncNumGlobals();
+  }
+
+  uint32_t GetNumGlobals() const {
+    return Context->GetNumGlobals();
+  }
+
+  void InstallFunctionType(FunctionType *Ty) {
+    return Context->InstallFunctionType(Ty, Record.GetStartBit());
+  }
+
+  void InstallDefinedFunction(uint32_t Index) {
+    Context->InstallDefinedFunction(Index);
+  }
+
+  BitcodeId GetBitcodeId(uint32_t Id) {
+    return Context->GetBitcodeId(Id);
+  }
+
+  void InstallParamType(Type *Ty) {
+    Context->InstallParamType(Ty);
+  }
+
+  uint32_t GetNumParams() const {
+    return Context->GetNumParams();
+  }
+  void InstallConstantType(Type *ConstantType) {
+    Context->InstallConstantType(ConstantType);
+  }
+
+  Type *GetConstantType(uint32_t Index) {
+    return Context->GetConstantType(Index);
+  }
+
+  uint32_t GetNumConstants() const {
+    return Context->GetNumConstants();
+  }
+
+  void InstallInstType(Type *Ty, uint32_t Index) {
+    Context->InstallInstType(Ty, Index);
+  }
+
+  void InstallInstType(Type *Ty) {
+    Context->InstallInstType(Ty);
+  }
+
+  uint32_t GetNumValuedInstructions() const {
+    return Context->GetNumValuedInstructions();
+  }
+
+  Type *GetValueType(uint32_t Id, bool UnderlyingType = false) {
+    return Context->GetValueType(Id, UnderlyingType);
+  }
+
+  Type *GetFunctionValueType(uint32_t Id) {
+    return GetValueType(Id, /* UnderlyingType = */ true);
+  }
+
+  Type *GetUnknownType() const {
+    return Context->GetUnknownType();
+  }
+
+  Type *GetPointerType() const {
+    return Context->GetPointerType();
+  }
+
+  Type *GetComparisonType() const {
+    return Context->GetComparisonType();
+  }
+
+  Type *GetVoidType() const {
+    return Context->GetVoidType();
+  }
+
+  Type *GetFloatType() const {
+    return Context->GetFloatType();
+  }
+
+  Type *GetDoubleType() const {
+    return Context->GetDoubleType();
+  }
+
+  Type *GetIntegerType(unsigned Size) const {
+    return Context->GetIntegerType(Size);
+  }
+
+  const char *VerifyIntArithmeticOp(const char *Op, Type *OpTy) {
+    return Context->VerifyIntArithmeticOp(Op, OpTy);
+  }
+
+protected:
+  // The context parser that contains decoding state.
+  NaClDisTopLevelParser *Context;
+  // The number of global abbreviations defined for this block.
+  unsigned NumGlobalAbbreviations;
+  // The current number of local abbreviations defined for this block.
+  unsigned NumLocalAbbreviations;
+};
+
+bool NaClDisBlockParser::ParseBlock(unsigned BlockId) {
+  // Only called if we don't know the details about the block.
+  ObjDumpSetRecordBitAddress(GetBlock().GetStartBit());
+  Errors() << "Don't know how to parse block " << BlockId
+           << ", when in block " << GetBlockID() << "\n";
+  NaClDisBlockParser Parser(BlockId, this);
+  return Parser.ParseThisBlock();
+}
+
+void NaClDisBlockParser::PrintBlockHeader() {
+  Errors() << "Unknown block id found: " << GetBlockID() << "\n";
+  Tokens() << "unknown" << Space() << OpenCurly()
+           << Space() << Space() << "// BlockID = "
+           << GetBlockID() << Endline();
+}
+
+void NaClDisBlockParser::EnterBlock(unsigned NumWords) {
+  PrintBlockHeader();
+  DumpEnterBlockRecord();
+  IncRecordIndent();
+  IncAssemblyIndent();
+}
+
+void NaClDisBlockParser::ExitBlock() {
+  DecAssemblyIndent();
+  DecRecordIndent();
+  Tokens() << CloseCurly() << Endline();
+  NaClBitcodeRecordData Exit;
+  Exit.Code = naclbitc::BLK_CODE_EXIT;
+  ObjDumpWrite(Record.GetStartBit(), Exit, naclbitc::END_BLOCK);
+}
+
+void NaClDisBlockParser::DumpEnterBlockRecord() {
+  // TODO(kschimpf): Better integrate this with the bitstream reader
+  // (which currently doesn't build any records).
+  NaClBitcodeRecordData Enter;
+  Enter.Code = naclbitc::BLK_CODE_ENTER;
+  Enter.Values.push_back(GetBlockID());
+  Enter.Values.push_back(Record.GetCursor().getAbbrevIDWidth());
+  ObjDumpWrite(GetBlock().GetStartBit(), Enter, naclbitc::ENTER_SUBBLOCK);
+}
+
+void NaClDisBlockParser::ProcessAbbreviation(unsigned BlockID,
+                                             NaClBitCodeAbbrev *Abbrev,
+                                             bool IsLocal) {
+  Tokens() << NextLocalAbbreviationId() << Space() << "=" << Space()
+           << "abbrev" << Space() << TokenizeAbbreviation(Abbrev)
+           << Semicolon() << Endline();
+  ++NumLocalAbbreviations;
+  ObjDumpWrite(Record.GetStartBit(), Record);
+}
+
+void NaClDisBlockParser::ProcessRecord() {
+  // Note: Only called if block is not understood. Hence, we
+  // only report the records.
+  ObjDumpWrite(Record.GetStartBit(), Record);
+}
+
+/// Parses and disassembles the blockinfo block.
+class NaClDisBlockInfoParser : public NaClDisBlockParser {
+public:
+  NaClDisBlockInfoParser(unsigned BlockID,
+                         NaClDisBlockParser *EnclosingParser)
+      : NaClDisBlockParser(BlockID, EnclosingParser) {
+  }
+
+  ~NaClDisBlockInfoParser() override {}
+
+private:
+  void PrintBlockHeader() override;
+
+  void SetBID() override;
+
+  void ProcessAbbreviation(unsigned BlockID, NaClBitCodeAbbrev *Abbrev,
+                           bool IsLocal) override;
+
+  /// Returns the abbreviation id for the next global abbreviation
+  /// to be defined for the given block id.
+  BitcodeId NextGlobalAbbreviationId(unsigned BlockID) {
+    return BitcodeId('a', Context->GetNumGlobalAbbreviations(BlockID), true);
+  }
+};
+
+void NaClDisBlockInfoParser::PrintBlockHeader() {
+  Tokens() << "abbreviations" << Space() << OpenCurly()
+           << Space() << Space() << "// BlockID = "
+           << GetBlockID() << Endline();
+}
+
+void NaClDisBlockInfoParser::SetBID() {
+  std::string BlockName;
+  uint64_t BlockID = Record.GetValues()[0];
+  switch (BlockID) {
+  case naclbitc::MODULE_BLOCK_ID:
+    Tokens() << "module";
+    break;
+  case naclbitc::CONSTANTS_BLOCK_ID:
+    Tokens() << "constants";
+    break;
+  case naclbitc::FUNCTION_BLOCK_ID:
+    Tokens() << "function";
+    break;
+  case naclbitc::VALUE_SYMTAB_BLOCK_ID:
+    Tokens() << "valuesymtab";
+    break;
+  case naclbitc::TYPE_BLOCK_ID_NEW:
+    Tokens() << "types";
+    break;
+  case naclbitc::GLOBALVAR_BLOCK_ID:
+    Tokens() << "globals";
+    break;
+  default:
+    Tokens() << "block" << OpenParen() << BlockID << CloseParen();
+    Errors() << "Block id " << BlockID << " not understood.\n";
+    break;
+  }
+  Tokens() << Colon() << Endline();
+  ObjDumpWrite(Record.GetStartBit(), Record);
+}
+
+void NaClDisBlockInfoParser::ProcessAbbreviation(unsigned BlockID,
+                                                 NaClBitCodeAbbrev *Abbrev,
+                                                 bool IsLocal) {
+  IncAssemblyIndent();
+  Tokens() << NextGlobalAbbreviationId(BlockID) << Space() << "=" << Space()
+           << "abbrev" << Space() << TokenizeAbbreviation(Abbrev)
+           << Semicolon() << Endline();
+  Context->IncNumGlobalAbbreviations(BlockID);
+  DecAssemblyIndent();
+  ObjDumpWrite(Record.GetStartBit(), Record);
+}
+
+/// Parses and disassembles the types block.
+class NaClDisTypesParser : public NaClDisBlockParser {
+public:
+  NaClDisTypesParser(unsigned BlockID,
+                     NaClDisBlockParser *EnclosingParser)
+      : NaClDisBlockParser(BlockID, EnclosingParser),
+        ExpectedNumTypes(0),
+        IsFirstRecord(true)
+  {
+  }
+
+  ~NaClDisTypesParser() override;
+
+private:
+  void PrintBlockHeader() override;
+
+  void ProcessRecord() override;
+
+  /// Returns the value id for the next type to be defined.
+  BitcodeId NextTypeId() {
+    return BitcodeId('t', GetNumTypes());
+  }
+
+  // Installs unknown type as definition of next type.
+  void InstallUnknownTypeForNextId();
+
+
+  uint32_t ExpectedNumTypes;
+  bool IsFirstRecord;
+};
+
+NaClDisTypesParser::~NaClDisTypesParser() {
+  if (GetNumTypes() != ExpectedNumTypes) {
+    Errors() << "Expected " << ExpectedNumTypes << " types but found: "
+             << GetNumTypes() << "\n";
+  }
+}
+
+void NaClDisTypesParser::PrintBlockHeader() {
+  Tokens() << "types" << Space() << OpenCurly()
+           << Space() << Space() << "// BlockID = " << GetBlockID()
+           << Endline();
+}
+
+void NaClDisTypesParser::InstallUnknownTypeForNextId() {
+  Type *UnknownType = GetUnknownType();
+  Tokens() << NextTypeId() << Space() << "=" << Space()
+           << TokenizeType(UnknownType) << Semicolon()
+           << TokenizeAbbrevIndex() << Endline();
+  InstallType(UnknownType);
+}
+
+void NaClDisTypesParser::ProcessRecord() {
+  ObjDumpSetRecordBitAddress(Record.GetStartBit());
+  const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
+  switch (Record.GetCode()) {
+  case naclbitc::TYPE_CODE_NUMENTRY: {
+    // NUMENTRY: [numentries]
+    uint64_t Size = 0;
+    if (Values.size() == 1) {
+      Size = Values[0];
+    } else {
+      Errors() << "Count record should have 1 argument. Found: "
+               << Values.size() << "\n";
+    }
+    if (!IsFirstRecord) {
+      Errors() << "Count record not first record of types block\n";
+    }
+    Tokens() << "count" << Space() << Size << Semicolon()
+             << TokenizeAbbrevIndex() << Endline();
+    ExpectedNumTypes = Size;
+    break;
+  }
+  case naclbitc::TYPE_CODE_VOID: {
+    // VOID
+    if (!Values.empty())
+      Errors() << "Void record shouldn't have arguments. Found: "
+               << Values.size() << "\n";
+    Type *VoidType = GetVoidType();
+    Tokens() << NextTypeId() << Space() << "=" << Space()
+             << TokenizeType(VoidType) << Semicolon()
+             << TokenizeAbbrevIndex() << Endline();
+    InstallType(VoidType);
+    break;
+  }
+  case naclbitc::TYPE_CODE_FLOAT: {
+    // FLOAT
+    if (!Values.empty())
+      Errors() << "Float record shoudn't have arguments. Found: "
+               << Values.size() << "\n";
+    Type *FloatType = GetFloatType();
+    Tokens() << NextTypeId() << Space() << "=" << Space()
+             << TokenizeType(FloatType) << Semicolon()
+             << TokenizeAbbrevIndex() << Endline();
+    InstallType(FloatType);
+    break;
+  }
+  case naclbitc::TYPE_CODE_DOUBLE: {
+    // DOUBLE
+    if (!Values.empty())
+      Errors() << "Double record shound't have arguments. Found: "
+               << Values.size() << "\n";
+    Type *DoubleType = GetDoubleType();
+    Tokens() << NextTypeId() << Space() << "=" << Space()
+             << TokenizeType(DoubleType) << Semicolon()
+             << TokenizeAbbrevIndex() << Endline();
+    InstallType(DoubleType);
+    break;
+  }
+  case naclbitc::TYPE_CODE_INTEGER: {
+    // INTEGER: [width]
+    uint64_t Size;
+    if (Values.size() == 1) {
+      Size = Values[0];
+    } else {
+      Errors() << "Integer record should have one argument. Found: "
+               << Values.size() << "\n";
+      Size = 32;
+    }
+    switch (Size) {
+      case 1:
+      case 8:
+      case 16:
+      case 32:
+      case 64: {
+        break;
+      }
+      default:
+        if (!IgnorePNaClABIChecks) {
+          Errors() << "Integer record contains bad integer size: "
+                   << Size << "\n";
+          Size = 32;
+        }
+        break;
+    }
+    Type *IntType = GetIntegerType(Size);
+    Tokens() << NextTypeId() << Space() << "=" << Space()
+             << TokenizeType(IntType) << Semicolon()
+             << TokenizeAbbrevIndex() << Endline();
+    InstallType(IntType);
+    break;
+  }
+  case naclbitc::TYPE_CODE_VECTOR: {
+    // VECTOR: [numelts, eltty]
+    if (Values.size() != 2) {
+      Errors() << "Vector record should contain two arguments. Found: "
+               << Values.size() << "\n";
+      InstallUnknownTypeForNextId();
+      break;
+    }
+    Type *BaseType = GetType(Values[1]);
+    if (!(BaseType->isIntegerTy()
+          || BaseType->isFloatTy()
+          || BaseType->isDoubleTy())) {
+      Type *ErrorRecoveryTy = GetIntegerType(32);
+      Errors() << "Vectors can only be defined on primitive types. Found "
+               << *BaseType << ". Assuming " << *ErrorRecoveryTy
+               << " instead.\n";
+      BaseType = ErrorRecoveryTy;
+    }
+    uint64_t NumElements = Values[0];
+    Type *VecType = VectorType::get(BaseType, NumElements);
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidVectorType(VecType)) {
+      Errors() << "Vector type " << *VecType << " not allowed.\n";
+    }
+    Tokens() << NextTypeId() << Space() << "=" << Space()
+             << TokenizeType(VecType) << Semicolon()
+             << TokenizeAbbrevIndex() << Endline();
+    InstallType(VecType);
+    break;
+  }
+  case naclbitc::TYPE_CODE_FUNCTION: {
+    // FUNCTION: [vararg, retty, paramty x N]
+    if (Values.size() < 2) {
+      Errors()
+          << "Function record should contain at least 2 arguments. Found: "
+          << Values.size() << "\n";
+      InstallUnknownTypeForNextId();
+      break;
+    }
+    if (Values[0]) {
+      Errors() << "Functions with variable length arguments is not supported\n";
+    }
+    Type *ReturnType = GetType(Values[1]);
+    if (!(isValidValueType(ReturnType) || ReturnType->isVoidTy())) {
+      Type *ReplaceType = GetIntegerType(32);
+      Errors() << "Invalid return type. Found: " << *ReturnType
+               << ". Assuming: " << *ReplaceType << "\n";
+      ReturnType = ReplaceType;
+    }
+    SmallVector<Type*, 8> Signature;
+    for (size_t i = 2; i < Values.size(); ++i) {
+      Type *Ty = GetType(Values[i]);
+      if (!isValidValueType(Ty)) {
+        Type *ReplaceTy = GetIntegerType(32);
+        Errors() << "Invalid type for parameter " << (i - 1) << ". Found: "
+                 << *Ty << ". Assuming: " << *ReplaceTy << "\n";
+        Ty = ReplaceTy;
+      }
+      Signature.push_back(Ty);
+    }
+    Type *FcnType =  FunctionType::get(ReturnType, Signature, Values[0]);
+    Tokens() << NextTypeId() << Space() << "=" << Space()
+             << StartCluster() << TokenizeType(FcnType)
+             << Semicolon() << FinishCluster() << TokenizeAbbrevIndex()
+             << Endline();
+    InstallType(FcnType);
+    break;
+  }
+  default:
+    Errors() << "Unknown record code in types block. Found: "
+             << Record.GetCode() << "\n";
+    break;
+  }
+  ObjDumpWrite(Record.GetStartBit(), Record);
+  IsFirstRecord = false;
+}
+
+/// Parses and disassembles the globalvars block.
+class NaClDisGlobalsParser : public NaClDisBlockParser {
+public:
+  NaClDisGlobalsParser(unsigned BlockID,
+                       NaClDisBlockParser *EnclosingParser)
+      : NaClDisBlockParser(BlockID, EnclosingParser),
+        NumInitializers(0),
+        InsideCompound(false),
+        BaseTabs(GetAssemblyNumTabs()+1) {}
+
+  ~NaClDisGlobalsParser() override {}
+
+private:
+  void PrintBlockHeader() override;
+
+  void ProcessRecord() override;
+
+  void ExitBlock() override;
+
+  // Expected number of initializers associated with last globalvars
+  // record
+  uint32_t NumInitializers;
+  // True if last globalvars record was defined by a compound record.
+  bool InsideCompound;
+  // Number of tabs used to indent elements in the globals block.
+  unsigned BaseTabs;
+
+  // Returns the ID for the next defined global.
+  BitcodeId NextGlobalId() {
+    return BitcodeId('g', GetNumGlobals());
+  }
+
+  // Prints out the close initializer "}" if necessary, and fixes
+  // the indentation to match previous indentation.
+  void InsertCloseInitializer();
+
+  uint32_t GetExpectedNumGlobals() const {
+    return Context->GetExpectedNumGlobals();
+  }
+};
+
+void NaClDisGlobalsParser::PrintBlockHeader() {
+  Tokens() << "globals" << Space() << OpenCurly()
+           << Space() << Space() << "// BlockID = " << GetBlockID()
+           << Endline();
+}
+
+void NaClDisGlobalsParser::InsertCloseInitializer() {
+  if (InsideCompound) {
+    while (BaseTabs + 1 < GetAssemblyNumTabs()) DecAssemblyIndent();
+    Tokens() << CloseCurly() << Endline();
+  }
+  while (BaseTabs < GetAssemblyNumTabs()) DecAssemblyIndent();
+  ObjDumpFlush();
+  NumInitializers = 0;
+  InsideCompound = false;
+}
+
+void NaClDisGlobalsParser::ExitBlock() {
+  if (NumInitializers > 0) {
+    BitcodeId LastGlobal('g', (GetNumGlobals()-1));
+    Errors() << "More initializers for " << LastGlobal << " expected: "
+             << NumInitializers << "\n";
+  }
+  if (GetNumGlobals() != GetExpectedNumGlobals()) {
+    Errors() << "Expected " << GetExpectedNumGlobals()
+             << " globals but found: " << GetNumGlobals() << "\n";
+  }
+  NaClDisBlockParser::ExitBlock();
+}
+
+void NaClDisGlobalsParser::ProcessRecord() {
+  ObjDumpSetRecordBitAddress(Record.GetStartBit());
+  const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
+  switch (Record.GetCode()) {
+  case naclbitc::GLOBALVAR_VAR: {
+    // VAR: [align, isconst]
+    if (Values.size() != 2) {
+      Errors() << "Globalvar record expects two arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    if (GetNumGlobals() == GetExpectedNumGlobals()) {
+      Errors() << "Exceeded expected number of globals: "
+               << GetExpectedNumGlobals() << "\n";
+    }
+    if (NumInitializers > 0) {
+      Errors() << "Previous initializer list too short. Expects "
+               << NumInitializers << " more initializers\n";
+      InsertCloseInitializer();
+    }
+    uint32_t Alignment = (1 << Values[0]) >> 1;
+    Tokens() << StartCluster() << (Values[1] ? "const" : "var")
+             << Space() << NextGlobalId()
+             << Comma() << FinishCluster() << Space()
+             << StartCluster() << "align" << Space() << Alignment
+             << Comma() << FinishCluster() << TokenizeAbbrevIndex()
+             << Endline();
+    IncAssemblyIndent();
+    IncNumGlobals();
+    NumInitializers = 1;
+    break;
+  }
+  case naclbitc::GLOBALVAR_COMPOUND:
+    // COMPOUND: [size]
+    if (Values.size() != 1) {
+      Errors() << "Compound record expects one argument. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    if (NumInitializers == 1) {
+      if (InsideCompound) {
+        Errors() << "Nested initialization records not allowed\n";
+        InsertCloseInitializer();
+      }
+    } else {
+      Errors() << "Compound record must follow globalvars record\n";
+      InsertCloseInitializer();
+    }
+    Tokens() << StartCluster() << "initializers" << Space()
+             << Values[0] << FinishCluster() << Space()
+             << OpenCurly() << TokenizeAbbrevIndex() << Endline();
+    IncAssemblyIndent();
+    NumInitializers = Values[0];
+    InsideCompound = true;
+    break;
+  case naclbitc::GLOBALVAR_ZEROFILL:
+    // ZEROFILL: [size]
+    if (Values.size() != 1) {
+      Errors() << "Zerofill record expects one argument. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    if (NumInitializers == 0) {
+      Errors() << "Zerofill initializer not associated with globalvar record\n";
+    }
+    Tokens() << "zerofill" << Space() << Values[0] << Semicolon()
+             << TokenizeAbbrevIndex() << Endline();
+    --NumInitializers;
+    break;
+  case naclbitc::GLOBALVAR_DATA: {
+    // DATA: [b0, b1, ...]
+    if (Values.empty()) {
+      Errors() << "Globals data record must have arguments.\n";
+    }
+    if (NumInitializers == 0) {
+      Errors() << "Data initializer not associated with globalvar record\n";
+    }
+    Tokens() << StartCluster() << OpenCurly();
+    for (size_t i = 0; i < Values.size(); ++i) {
+      if (i > 0) Tokens() << Comma() << FinishCluster() << Space();
+      uint64_t Byte = Values[i];
+      if (Byte >= 256) {
+        Errors() << "Invalid byte value in data record: " << Byte << "\n";
+        Byte &= 0xFF;
+      }
+      if (i > 0) Tokens() << StartCluster();
+      Tokens() << format("%3u", static_cast<unsigned>(Byte));
+    }
+    Tokens() << CloseCurly() << FinishCluster() << TokenizeAbbrevIndex()
+             << Endline();
+    --NumInitializers;
+    break;
+  }
+  case naclbitc::GLOBALVAR_RELOC:
+    // RELOC: [val, [addend]]
+    if (Values.empty() || Values.size() > 2) {
+      Errors() << "Invalid reloc record size: " << Values.size() << "\n";
+      break;
+    }
+    if (NumInitializers == 0) {
+      Errors() <<
+          "Relocation initializer not associated with globalvar record\n";
+    }
+    Tokens() << "reloc" << Space() << StartCluster() << GetBitcodeId(Values[0]);
+    if (Values.size() == 2) {
+      int32_t Addend = static_cast<int32_t>(Values[1]);
+      char Operator = '+';
+      if (Addend < 0) {
+        Operator = '-';
+        Addend = -Addend;
+      }
+      Tokens() << Space()<< Operator << Space() << Addend;
+    }
+    Tokens() << Semicolon() << FinishCluster() << TokenizeAbbrevIndex()
+             << Endline();
+    --NumInitializers;
+    break;
+  case naclbitc::GLOBALVAR_COUNT: {
+    // COUNT: [n]
+    uint32_t Count = 0;
+    if (Values.size() == 1) {
+      Count = Values[0];
+    } else {
+      Errors() << "Globals count record expects one argument. Found: "
+               << Values.size() << "\n";
+    }
+    if (GetNumGlobals() != 0)
+      Errors() << "Count record not first record in block.\n";
+    Tokens() << "count" << Space() << Count << Semicolon()
+             << TokenizeAbbrevIndex() << Endline();
+    Context->SetExpectedNumGlobals(Count);
+    break;
+  }
+  default:
+    Errors() << "Unknown record found in globals block.\n";
+  }
+
+  ObjDumpWrite(Record.GetStartBit(), Record);
+
+  if (GetNumGlobals() > 0 && NumInitializers == 0)
+    InsertCloseInitializer();
+}
+
+/// Parsers and disassembles a valuesymtab block.
+class NaClDisValueSymtabParser : public NaClDisBlockParser {
+public:
+  NaClDisValueSymtabParser(unsigned BlockID,
+                           NaClDisBlockParser *EnclosingParser)
+      : NaClDisBlockParser(BlockID, EnclosingParser) {
+  }
+
+  ~NaClDisValueSymtabParser() override {}
+
+private:
+  void PrintBlockHeader() override;
+
+  void ProcessRecord() override;
+
+  // Displays the context of the name (in Values) for the given Id.
+  void DisplayEntry(BitcodeId &Id,
+                    const NaClBitcodeRecord::RecordVector &Values);
+};
+
+void NaClDisValueSymtabParser::PrintBlockHeader() {
+  Tokens() << "valuesymtab" << Space() << OpenCurly()
+           << Space() << Space() << "// BlockID = " << GetBlockID()
+           << Endline();
+}
+
+void NaClDisValueSymtabParser::
+DisplayEntry(BitcodeId &Id,
+             const NaClBitcodeRecord::RecordVector &Values) {
+  if (Values.size() <= 1) {
+    Errors() << "Valuesymtab entry record expects 2 arguments. Found: "
+             << Values.size() << "\n";
+    return;
+  }
+  Tokens() << Id << Space() << Colon() << Space();
+  // Check if the name of the symbol is alphanumeric. If so, print
+  // as a string. Otherwise, print a sequence of bytes.
+  // Note: The check isChar6 is a test for aphanumeric + {'.', '_'}.
+  bool IsChar6 = true;  // Until proven otherwise.
+  for (size_t i = 1; i < Values.size(); ++i) {
+    uint64_t Byte = Values[i];
+    if (Byte >= 256) {
+      Errors() << "Argument " << i << " of symbol entry not byte: "
+               << Byte << "\n";
+      IsChar6 = false;
+      break;
+    }
+    if (!NaClBitCodeAbbrevOp::isChar6(Byte))
+      IsChar6 = false;
+  }
+  if (IsChar6) {
+    Tokens() << StartCluster() << "\"";
+    for (size_t i = 1; i < Values.size(); ++i) {
+      Tokens() << static_cast<char>(Values[i]);
+    }
+    Tokens() << "\"" << Semicolon();
+  } else {
+    Tokens() << StartCluster() << OpenCurly();
+    for (size_t i = 1; i < Values.size(); ++i) {
+      if (i > 1) {
+        Tokens() << Comma() << FinishCluster() << Space()
+                 << StartCluster();
+      }
+      char ch = Values[i];
+      if (NaClBitCodeAbbrevOp::isChar6(ch)) {
+        Tokens() << "'" << ch << "'";
+      } else {
+        Tokens() << format("%3u", static_cast<unsigned>(ch));
+      }
+    }
+    Tokens() << CloseCurly();
+  }
+  Tokens() << FinishCluster() << TokenizeAbbrevIndex() << Endline();
+}
+
+void NaClDisValueSymtabParser::ProcessRecord() {
+  ObjDumpSetRecordBitAddress(Record.GetStartBit());
+  const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
+  switch (Record.GetCode()) {
+  case naclbitc::VST_CODE_ENTRY: {
+    // VST_ENTRY: [valueid, namechar x N]
+    uint32_t ValID = Values[0];
+    BitcodeId ID(GetBitcodeId(ValID));
+    DisplayEntry(ID, Values);
+    if (ValID < GetNumFunctions()) {
+      // Check if value is intrinsic name. If so, verify function signature.
+      std::string Name;
+      for (unsigned i = 1; i < Values.size(); ++i) {
+        Name.push_back(static_cast<char>(Values[i]));
+      }
+      FunctionType *IntrinTy = Context->GetIntrinsicType(Name);
+      if (IntrinTy == 0)
+        // TODO(kschimpf): Check for _start? Complain about other names?
+        break;
+      Context->MarkFunctionAsIntrinsic(ValID);
+      // Verify that expected intrinsic function type matches declared
+      // type signature.
+      FunctionType *FcnTy = GetFunctionType(ValID);
+      if (FcnTy->getNumParams() != IntrinTy->getNumParams()) {
+        Errors() << "Intrinsic " << Name
+                 << " expects " << IntrinTy->getNumParams()
+                 << " arguments. Found: " << FcnTy->getNumParams()
+                 << "\n";
+        break;
+      }
+      if (!IgnorePNaClABIChecks && !PNaClABITypeChecker::IsPointerEquivType(
+              IntrinTy->getReturnType(), FcnTy->getReturnType())) {
+        Errors() << "Intrinsic " << Name
+                 << " expects return type " << *IntrinTy->getReturnType()
+                 << ". Found: " << *FcnTy->getReturnType() << "\n";
+        break;
+      }
+      for (size_t i = 0; i < FcnTy->getNumParams(); ++i) {
+        if (!IgnorePNaClABIChecks && !PNaClABITypeChecker::IsPointerEquivType(
+                IntrinTy->getParamType(i),
+                FcnTy->getParamType(i))) {
+          Errors() << "Intrinsic " << Name
+                   << " expects " << *IntrinTy->getParamType(i)
+                   << " for argument " << (i+1) << ". Found: "
+                   << *FcnTy->getParamType(i) << "\n";
+          break;
+        }
+      }
+    }
+    break;
+  }
+  case naclbitc::VST_CODE_BBENTRY: {
+    // [bbid, namechar x N]
+    BitcodeId ID('b', Values[0]);
+    DisplayEntry(ID, Values);
+    break;
+  }
+  default:
+    Errors() << "Unknown record in valuesymtab block.\n";
+    break;
+  }
+  ObjDumpWrite(Record.GetStartBit(), Record);
+}
+
+/// Parses and disassembles a constants block.
+class NaClDisConstantsParser : public NaClDisBlockParser {
+public:
+  NaClDisConstantsParser(unsigned BlockID,
+                         NaClDisBlockParser *EnclosingParser)
+      : NaClDisBlockParser(BlockID, EnclosingParser),
+        ConstantType(0),
+        BlockTabs(GetAssemblyNumTabs()) {}
+
+  virtual ~NaClDisConstantsParser() {
+    while (BlockTabs < GetAssemblyNumTabs()) DecAssemblyIndent();
+  }
+
+private:
+  void PrintBlockHeader() override;
+
+  void ProcessRecord() override;
+
+  /// Generates the value id for the next generated constant.
+  BitcodeId NextConstId() {
+    return BitcodeId('c', GetNumConstants());
+  }
+
+  // The type associated with the constant.
+  Type *ConstantType;
+  // The number of tabs used to indent the globals block.
+  unsigned BlockTabs;
+};
+
+void NaClDisConstantsParser::PrintBlockHeader() {
+  Tokens() << "constants" << Space() << OpenCurly()
+           << Space() << Space() << "// BlockID = " << GetBlockID()
+           << Endline();
+}
+
+void NaClDisConstantsParser::ProcessRecord() {
+  ObjDumpSetRecordBitAddress(Record.GetStartBit());
+  const NaClBitcodeRecord::RecordVector Values = Record.GetValues();
+  switch (Record.GetCode()) {
+  case naclbitc::CST_CODE_SETTYPE:
+    // SETTYPE: [typeid]
+    while (BlockTabs + 1 < GetAssemblyNumTabs()) DecAssemblyIndent();
+    if (Values.size() == 1) {
+      ConstantType = GetType(Values[0]);
+      Tokens() << TokenizeType(ConstantType) << ":"
+               << TokenizeAbbrevIndex() << Endline();
+    } else {
+      Errors() << "Settype record should have 1 argument. Found: "
+               << Values.size() << "\n";
+      // Make up a type, so we can continue.
+      ConstantType = GetIntegerType(32);
+    }
+    IncAssemblyIndent();
+    break;
+  case naclbitc::CST_CODE_UNDEF:
+    // CST_CODE_UNDEF: []
+    if (!Values.empty()) {
+      Errors() << "Undefined record should not have arguments: Found: "
+               << Values.size() << "\n";
+    }
+    Tokens() << NextConstId() << Space() << "=" << Space()
+             << StartCluster() << TokenizeType(ConstantType)
+             << Space() << "undef"
+             << Semicolon() << FinishCluster()
+             << TokenizeAbbrevIndex() << Endline();
+    InstallConstantType(ConstantType);
+    break;
+  case naclbitc::CST_CODE_INTEGER: {
+    // INTEGER: [intval]
+    SignRotatedInt Value;
+    if (Values.size() == 1) {
+      const SignRotatedInt MyValue(Values[0], ConstantType);
+      Value = MyValue;
+    } else {
+      Errors() << "Integer record should have 1 argument. Found: "
+               << Values.size() << "\n";
+    }
+    Tokens() << NextConstId() << Space() << "=" << Space() << StartCluster()
+             << StartCluster() << TokenizeType(ConstantType) << Space()
+             << Value << Semicolon() << FinishCluster() << FinishCluster()
+             << TokenizeAbbrevIndex() << Endline();
+    InstallConstantType(ConstantType);
+    break;
+  }
+  case naclbitc::CST_CODE_FLOAT: {
+    // FLOAT: [fpval]
+    // Define initially with default value zero, in case of errors.
+    const fltSemantics &FloatRep =
+        ConstantType->isFloatTy() ? APFloat::IEEEsingle : APFloat::IEEEdouble;
+    APFloat Value(APFloat::getZero(FloatRep));
+    if (Values.size() == 1) {
+      if (ConstantType->isFloatTy()) {
+        Value = APFloat(FloatRep, APInt(32, static_cast<uint32_t>(Values[0])));
+      }
+      else if (ConstantType->isDoubleTy()) {
+        Value = APFloat(FloatRep, APInt(64, Values[0]));
+      } else {
+        Errors() << "Bad floating point constant argument: "
+                 << Values[0] << "\n";
+      }
+    } else {
+      Errors() << "Float record should have 1 argument. Found: "
+               << Values.size() << "\n";
+    }
+    Tokens() << NextConstId() << Space() << "=" << Space() << StartCluster()
+             << TokenizeType(ConstantType) << Space();
+    if (ConstantType->isFloatTy()) {
+      Tokens() << format("%g", Value.convertToFloat());
+    } else {
+      Tokens() << format("%g", Value.convertToDouble());
+    }
+    Tokens() << Semicolon() << FinishCluster()
+             << TokenizeAbbrevIndex() << Endline();
+    InstallConstantType(ConstantType);
+    break;
+  }
+  default:
+    Errors() << "Unknown record in valuesymtab block.\n";
+    break;
+  }
+  ObjDumpWrite(Record.GetStartBit(), Record);
+}
+
+/// Parses and disassembles function blocks.
+class NaClDisFunctionParser : public NaClDisBlockParser {
+public:
+  NaClDisFunctionParser(unsigned BlockID,
+                        NaClDisBlockParser *EnclosingParser);
+
+  ~NaClDisFunctionParser() override {}
+
+  void PrintBlockHeader() override;
+
+  bool ParseBlock(unsigned BlockID) override;
+
+  void ProcessRecord() override;
+
+  /// Returns the absolute value index of the first instruction that
+  /// generates a value in the defined function.
+  uint32_t FirstValuedInstructionId() const {
+    return GetNumFunctions() + GetNumGlobals() + GetNumParams()
+        + GetNumConstants();
+  }
+
+  /// Converts an instruction index to the corresponding absolute value
+  /// index.
+  uint32_t ValuedInstToAbsId(uint32_t Id) const {
+    return FirstValuedInstructionId() + Id;
+  }
+
+  /// Converts the (function) relative index to the corresponding
+  /// absolute value index.
+  uint32_t RelativeToAbsId(int32_t Id) {
+    uint32_t AbsNextId = ValuedInstToAbsId(GetNumValuedInstructions());
+    if (Id > 0 && AbsNextId < static_cast<uint32_t>(Id)) {
+      Errors() << "Invalid relative value id: " << Id
+               << " (Must be <= " << AbsNextId << ")\n";
+      AbsNextId = Id;
+    }
+    return AbsNextId - Id;
+  }
+
+  /// Converts the given absolute value index to a corresponding
+  /// valued instruction index.
+  uint32_t AbsToValuedInstId(uint32_t Id) const {
+    return Id - FirstValuedInstructionId();
+  }
+
+  /// Returns the text representation of the encoded binary operator,
+  /// assuming the binary operator is operating on the given type.
+  /// Generates appropriate error messages if the given type is not
+  // allowed for the given Opcode.
+  const char *GetBinop(uint32_t Opcode, Type *Type);
+
+  /// Returns the text representation of the encoded cast operator.
+  /// Generates appropriate error messages if the given Opcode is
+  /// not allowed for the given types.
+  const char *GetCastOp(uint32_t Opcode, Type *FromType, Type *ToType);
+
+  /// Returns the text representation of the encoded integer compare
+  /// predicate. Generates appropriate error message if the given
+  /// Opcode is not defined.
+  const char *GetIcmpPredicate(uint32_t Opcode);
+
+  /// Returns the text representation of the encoded floating point
+  /// compare predicate. Generates appropriate error message if the
+  /// given Opcode is not defined.
+  const char *GetFcmpPredicate(uint32_t Opcode);
+
+  /// Returns the value id for the next instruction to be defined.
+  BitcodeId NextInstId() const {
+    return BitcodeId('v', GetNumValuedInstructions());
+  }
+
+private:
+  // The function index of the function being defined.
+  uint32_t FcnId;
+  // The function type for the function being defined.
+  FunctionType *FcnTy;
+  // The current basic block being printed.
+  int32_t CurrentBbIndex;
+  // The expected number of basic blocks.
+  uint64_t ExpectedNumBbs;
+  // True if the previously printed instruction was a terminating
+  // instruction. Used to figure out where to insert block labels.
+  bool InstIsTerminating;
+
+  /// Returns scalar type of vector type Ty, if vector type. Otherwise
+  /// returns Ty.
+  Type *UnderlyingType(Type *Ty) {
+    return Ty->isVectorTy() ? Ty->getVectorElementType() : Ty;
+  }
+
+  bool isFloatingType(Type *Ty) {
+    return Ty->isFloatTy() || Ty->isDoubleTy();
+  }
+
+  /// Verifies that OpTy is an integer, or a vector of integers, for
+  /// operator Op. Generates error messages if appropriate. Returns Op.
+  const char *VerifyIntegerOrVectorOp(const char *Op, Type *OpTy) {
+    Type *BaseTy = OpTy;
+    if (OpTy->isVectorTy()) {
+      if (!IgnorePNaClABIChecks &&
+          !PNaClABITypeChecker::isValidVectorType(OpTy)) {
+        Errors() << Op << ": invalid vector type: " << *OpTy << "\n";
+        return Op;
+      }
+      BaseTy = OpTy->getVectorElementType();
+    }
+    if (BaseTy->isIntegerTy()) {
+      if (IgnorePNaClABIChecks ||
+          PNaClABITypeChecker::isValidScalarType(BaseTy)) {
+        return Op;
+      }
+      Errors() << Op << ": Invalid integer type: " << *OpTy << "\n";
+    } else {
+      Errors() << Op << ": Expects integer type. Found: " << *OpTy << "\n";
+    }
+    return Op;
+  }
+
+  /// Verifies that Opty is a floating point type, or a vector of a
+  /// floating points, for operator Op. Generates error messages if
+  /// appropriate. Returns Op.
+  const char *VerifyFloatingOrVectorOp(const char *Op, Type *OpTy) {
+    Type *BaseTy = OpTy;
+    if (OpTy->isVectorTy()) {
+      if (!IgnorePNaClABIChecks &&
+          !PNaClABITypeChecker::isValidVectorType(OpTy)) {
+        Errors() << Op << ": invalid vector type: " << *OpTy << "\n";
+        return Op;
+      }
+      BaseTy = OpTy->getVectorElementType();
+    }
+    if (!isFloatingType(BaseTy)) {
+      Errors() << Op << ": Expects floating point. Found "
+               << OpTy << "\n";
+      return Op;
+    }
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidScalarType(BaseTy)) {
+      Errors() << Op << ": type not allowed: " << OpTy << "\n";
+    }
+    return Op;
+  }
+
+  /// Op is the name of the operation that called this.  Checks if
+  /// OpTy is either a (non-void) scalar, or a vector of scalars. If
+  /// not, generates an appropriate error message. Always returns Op.
+  const char *VerifyScalarOrVectorOp(const char *Op, Type *OpTy) {
+    if (IgnorePNaClABIChecks) return Op;
+    if (PNaClABITypeChecker::isValidScalarType(OpTy)) {
+      if (OpTy->isVoidTy())
+        Errors() << Op << ": Type void not allowed\n";
+    } else if (!PNaClABITypeChecker::isValidVectorType(OpTy)) {
+      Errors() << Op << ": Expects scalar/vector type. Found: "
+               << OpTy << "\n";
+    }
+    return Op;
+  }
+
+  void VerifyIndexedVector(const char *Op, uint32_t VecValue,
+                           uint32_t IdxValue) {
+    Type *VecType = GetValueType(VecValue);
+    Type *IdxType = GetValueType(IdxValue);
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidVectorType(VecType)){
+      if (VecType->isVectorTy())
+        Errors() << Op << ": Vector type " << *VecType << " not allowed\n";
+      else
+        Errors() << Op << ": Vector type expected. Found: " << *VecType << "\n";
+    }
+    // Note: This restriction appears to be LLVM specific.
+    if (!IdxType->isIntegerTy(32)) {
+      Errors() << Op << ": Index not i32. Found: " << *IdxType << "\n";
+    }
+    BitcodeId IdxId(GetBitcodeId(IdxValue));
+    if (IdxId.GetKind() != 'c') {
+      Errors() << Op << ": Vector index not constant: " << IdxId << "\n";
+      // TODO(kschimpf): We should check that Idx is a constant with
+      // valid access. However, we currently don't store constant
+      // values, so it can't be tested.
+    }
+  }
+
+  /// Checks if block Value is a valid branch target for the current
+  /// function block. If not, generates an appropriate error message.
+  void VerifyBranchRange(uint64_t Value) {
+    if (0 == Value || Value >= ExpectedNumBbs) {
+      Errors() << "Branch " << BitcodeId('b', Value)
+               << " out of range. Not in [1," << ExpectedNumBbs << "]\n";
+    }
+  }
+
+  /// Convert alignment exponent (i.e. power of two (or zero)) to the
+  /// corresponding alignment to use. If alignment is too large, it generates
+  /// an error message and returns 0.
+  unsigned getAlignmentValue(uint64_t Exponent);
+};
+
+NaClDisFunctionParser::NaClDisFunctionParser(
+    unsigned BlockID,
+    NaClDisBlockParser *EnclosingParser)
+    : NaClDisBlockParser(BlockID, EnclosingParser),
+      CurrentBbIndex(-1),
+      ExpectedNumBbs(0),
+      InstIsTerminating(false) {
+  Context->ResetLocalCounters();
+  if (Context->HasNextDefinedFunctionIndex()) {
+    FcnId = Context->GetNextDefinedFunctionIndex();
+    FcnTy = GetFunctionType(FcnId);
+  } else {
+    FcnId = 0;
+    SmallVector<Type*, 8> Signature;
+    FcnTy = FunctionType::get(GetVoidType(), Signature, 0);
+    Errors() <<
+        "No corresponding defining function address for function block.\n";
+    return;
+  }
+  Context->IncNumDefinedFunctions();
+
+  // Now install parameters.
+  for (size_t Index = 0; Index < FcnTy->getFunctionNumParams(); ++Index) {
+    InstallParamType(FcnTy->getFunctionParamType(Index));
+  }
+}
+
+void NaClDisFunctionParser::PrintBlockHeader() {
+  Tokens() << "function" << Space();
+  BitcodeId FunctionId('f', FcnId);
+  bool InvalidSignature = true; // until proven otherwise.
+  if (Context->IsFunctionIntrinsic(FcnId))
+    InvalidSignature = false;
+  else if (IgnorePNaClABIChecks ||
+           PNaClABITypeChecker::isValidFunctionType(FcnTy)) {
+      InvalidSignature = false;
+  }
+  if (InvalidSignature) {
+    Errors() << "Invalid type signature for "
+             << BitcodeId('f', FcnId) << ": " << *FcnTy << "\n";
+  }
+  Tokens() << TokenizeFunctionSignature(FcnTy, &FunctionId)
+           << Space() << OpenCurly()
+           << Space() << Space() << "// BlockID = " << GetBlockID()
+           << Endline();
+}
+
+const char *NaClDisFunctionParser::GetBinop(uint32_t Opcode, Type *Ty) {
+  Instruction::BinaryOps LLVMOpcode;
+  if (!naclbitc::DecodeBinaryOpcode(Opcode, Ty, LLVMOpcode)) {
+    Errors() << "Binary opcode not understood: " << Opcode << "\n";
+    return "???";
+  }
+  switch (LLVMOpcode) {
+  default:
+    Errors() << "Binary opcode not understood: " << Opcode << "\n";
+    return "???";
+  case Instruction::Add:
+    return VerifyIntArithmeticOp("add", Ty);
+  case Instruction::FAdd:
+    return VerifyFloatingOrVectorOp("fadd", Ty);
+  case Instruction::Sub:
+    return VerifyIntArithmeticOp("sub", Ty);
+  case Instruction::FSub:
+    return VerifyFloatingOrVectorOp("fsub", Ty);
+  case Instruction::Mul:
+    return VerifyIntArithmeticOp("mul", Ty);
+  case Instruction::FMul:
+    return VerifyFloatingOrVectorOp("fmul", Ty);
+  case Instruction::UDiv:
+    return VerifyIntArithmeticOp("udiv", Ty);
+  case Instruction::SDiv:
+    return VerifyIntArithmeticOp("sdiv", Ty);
+  case Instruction::FDiv:
+    return VerifyFloatingOrVectorOp("fdiv", Ty);
+  case Instruction::URem:
+    return VerifyIntArithmeticOp("urem", Ty);
+  case Instruction::SRem:
+    return VerifyIntArithmeticOp("srem", Ty);
+  case Instruction::FRem:
+    return VerifyFloatingOrVectorOp("frem", Ty);
+  case Instruction::Shl:
+    return VerifyIntArithmeticOp("shl", Ty);
+  case Instruction::LShr:
+    return VerifyIntArithmeticOp("lshr", Ty);
+  case Instruction::AShr:
+    return VerifyIntArithmeticOp("ashr", Ty);
+  case Instruction::And:
+    return VerifyIntegerOrVectorOp("and", Ty);
+  case Instruction::Or:
+    return VerifyIntegerOrVectorOp("or", Ty);
+  case Instruction::Xor:
+    return VerifyIntegerOrVectorOp("xor", Ty);
+  }
+}
+
+const char *NaClDisFunctionParser::GetCastOp(uint32_t Opcode,
+                                             Type *FromType, Type *ToType) {
+  Instruction::CastOps Cast;
+  const char *CastName = "???";
+  if (!naclbitc::DecodeCastOpcode(Opcode, Cast)) {
+    Errors() << "Cast opcode not understood: " << Opcode << "\n";
+    return CastName;
+  }
+  switch (Cast) {
+  default:
+    Errors() << "Cast opcode not understood: " << Opcode << "\n";
+    return CastName;
+  case Instruction::BitCast:
+    CastName = "bitcast";
+    break;
+  case Instruction::Trunc:
+    CastName = "trunc";
+    break;
+  case Instruction::ZExt:
+    CastName = "zext";
+    break;
+  case Instruction::SExt:
+    CastName = "sext";
+    break;
+  case Instruction::FPToUI:
+    CastName = "fptoui";
+    break;
+  case Instruction::FPToSI:
+    CastName = "fptosi";
+    break;
+  case Instruction::UIToFP:
+    CastName = "uitofp";
+    break;
+  case Instruction::SIToFP:
+    CastName = "sitofp";
+    break;
+  case Instruction::FPTrunc:
+    CastName = "fptrunc";
+    break;
+  case Instruction::FPExt:
+    CastName = "fpext";
+    break;
+  }
+  if (!CastInst::castIsValid(Cast, FromType, ToType)) {
+    Errors() << "Invalid cast '" << CastName << "'. Not defined on "
+             << FromType << " to " << ToType << "\n";
+  }
+  return CastName;
+}
+
+const char *NaClDisFunctionParser::GetIcmpPredicate(uint32_t Opcode) {
+  CmpInst::Predicate Predicate;
+  if (!naclbitc::DecodeIcmpPredicate(Opcode, Predicate)) {
+    Errors() << "Icmp predicate not understood: " << Opcode << "\n";
+    return "???";
+  }
+  switch (Predicate) {
+  default:
+    Errors() << "Icmp predicate not understood: " << Opcode << "\n";
+    return "???";
+  case CmpInst::ICMP_EQ:
+    return "eq";
+  case CmpInst::ICMP_NE:
+    return "ne";
+ case CmpInst::ICMP_UGT:
+    return "ugt";
+  case CmpInst::ICMP_UGE:
+    return "uge";
+  case CmpInst::ICMP_ULT:
+    return "ult";
+  case CmpInst::ICMP_ULE:
+    return "ule";
+  case CmpInst::ICMP_SGT:
+    return "sgt";
+  case CmpInst::ICMP_SGE:
+    return "sge";
+  case CmpInst::ICMP_SLT:
+    return "slt";
+  case CmpInst::ICMP_SLE:
+    return "sle";
+  }
+}
+
+const char *NaClDisFunctionParser::GetFcmpPredicate(uint32_t Opcode) {
+  CmpInst::Predicate Predicate;
+  if (!naclbitc::DecodeFcmpPredicate(Opcode, Predicate)) {
+    Errors() << "Fcmp predicate not understood: " << Opcode << "\n";
+    return "???";
+  }
+  switch (Predicate) {
+  default:
+    Errors() << "Fcmp predicate not understood: " << Opcode << "\n";
+    return "???";
+  case CmpInst::FCMP_FALSE:
+    return "false";
+  case CmpInst::FCMP_OEQ:
+    return "oeq";
+  case CmpInst::FCMP_OGT:
+    return "ogt";
+  case CmpInst::FCMP_OGE:
+    return "oge";
+  case CmpInst::FCMP_OLT:
+    return "olt";
+  case CmpInst::FCMP_OLE:
+    return "ole";
+  case CmpInst::FCMP_ONE:
+    return "one";
+  case CmpInst::FCMP_ORD:
+    return "ord";
+  case CmpInst::FCMP_UNO:
+    return "uno";
+  case CmpInst::FCMP_UEQ:
+    return "ueq";
+  case CmpInst::FCMP_UGT:
+    return "ugt";
+  case CmpInst::FCMP_UGE:
+    return "uge";
+  case CmpInst::FCMP_ULT:
+    return "ult";
+  case CmpInst::FCMP_ULE:
+    return "ule";
+  case CmpInst::FCMP_UNE:
+    return "une";
+  case CmpInst::FCMP_TRUE:
+    return "true";
+  }
+}
+
+namespace {
+
+static const unsigned MaxAlignmentExponent = 29;
+static_assert(
+    (1u << MaxAlignmentExponent) == Value::MaximumAlignment,
+    "Inconsistency between Value.MaxAlignment and PNaCl alignment limit");
+}
+
+unsigned NaClDisFunctionParser::getAlignmentValue(uint64_t Exponent) {
+  if (Exponent > MaxAlignmentExponent + 1) {
+    Errors() << "Alignment can't be greater than 2**" << MaxAlignmentExponent
+             << ". Found: 2**" << (Exponent - 1) << "\n";
+    return 0;
+  }
+  return (1 << static_cast<unsigned>(Exponent)) >> 1;
+}
+
+bool NaClDisFunctionParser::ParseBlock(unsigned BlockID) {
+  ObjDumpSetRecordBitAddress(GetBlock().GetStartBit());
+  switch (BlockID) {
+  case naclbitc::CONSTANTS_BLOCK_ID: {
+    NaClDisConstantsParser Parser(BlockID, this);
+    return Parser.ParseThisBlock();
+  }
+  case naclbitc::VALUE_SYMTAB_BLOCK_ID: {
+    if (!PNaClAllowLocalSymbolTables) break;
+    NaClDisValueSymtabParser Parser(BlockID, this);
+    return Parser.ParseThisBlock();
+  }
+  default:
+    break;
+  }
+  return NaClDisBlockParser::ParseBlock(BlockID);
+}
+
+void NaClDisFunctionParser::ProcessRecord() {
+  ObjDumpSetRecordBitAddress(Record.GetStartBit());
+  const NaClBitcodeRecord::RecordVector Values = Record.GetValues();
+  // Start by adding block label if previous instruction is terminating.
+  if (InstIsTerminating) {
+    InstIsTerminating = false;
+    ++CurrentBbIndex;
+    DecAssemblyIndent();
+    Tokens() << BitcodeId('b', CurrentBbIndex) << ":" << Endline();
+    ObjDumpFlush();
+    IncAssemblyIndent();
+  }
+  switch (Record.GetCode()) {
+  case naclbitc::FUNC_CODE_DECLAREBLOCKS:
+    // DECLAREBLOCKS: [n]
+    InstIsTerminating = true;  // Force block label on first instruction.
+    if (Values.size() != 1) {
+      Errors() << "Function blocks record expects a size argument.\n";
+      break;
+    }
+    ExpectedNumBbs = Values[0];
+    if (ExpectedNumBbs == 0) {
+      Errors() << "Functions must contain at least one block.\n";
+    }
+    Tokens() << "blocks" << Space() << ExpectedNumBbs << Semicolon();
+    break;
+  case naclbitc::FUNC_CODE_INST_BINOP: {
+    // BINOP: [opval, opval, opcode]
+    if (Values.size() != 3) {
+      Errors() << "Binop record expects 3 arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    uint32_t Op1 = RelativeToAbsId(Values[0]);
+    uint32_t Op2 = RelativeToAbsId(Values[1]);
+    Type *Type1 = GetValueType(Op1);
+    Type *Type2 = GetValueType(Op2);
+    if (Type1 != Type2) {
+      Errors() << "Binop argument types differ: " << *Type1 << " and "
+               << *Type2 << "\n";
+    }
+    const char *Binop = GetBinop(Values[2], Type1);
+    Tokens() << NextInstId() << Space() << "=" << Space() << Binop << Space()
+             << TokenizeType(Type1) << Space() << GetBitcodeId(Op1) << Comma()
+             << Space() << GetBitcodeId(Op2) << Semicolon();
+    InstallInstType(Type1);
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_CAST: {
+    // CAST: [opval, destty, castopc]
+    if (Values.size() != 3) {
+      Errors() << "Cast record expects 3 argments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    uint32_t Op = RelativeToAbsId(Values[0]);
+    Type *FromType = GetValueType(Op);
+    Type *ToType = GetType(Values[1]);
+    const char *CastOp = GetCastOp(Values[2], FromType, ToType);
+    Tokens() << NextInstId() << Space() << "=" << Space() << CastOp << Space()
+             << TokenizeType(FromType) << Space() << GetBitcodeId(Op)
+             << Space() << "to" << Space() << TokenizeType(ToType)
+             << Semicolon();
+    InstallInstType(ToType);
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_RET: {
+    // RET: [opval?]
+    InstIsTerminating = true;
+    Tokens() << "ret" << Space();
+    switch (Values.size()) {
+    default:
+      Errors() << "Function return record expects an optional return argument. "
+               << "Found: " << Values.size() << " arguments\n";
+      break;
+    case 0:
+      Tokens() << "void";
+      break;
+    case 1: {
+      uint32_t Op = RelativeToAbsId(Values[0]);
+      Tokens() << TokenizeType(GetValueType(Op)) << Space()<< GetBitcodeId(Op);
+      break;
+    }
+    }
+    Tokens() << Semicolon();
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_BR: {
+    // BR: [bb#, bb#, opval] or [bb#]
+    InstIsTerminating = true;
+    if (Values.size() != 1 && Values.size() != 3) {
+      Errors() << "Function branch record expects 1 or 3 arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    Tokens() << "br" << Space();
+    if (Values.size() == 3) {
+      uint32_t OpIndex = RelativeToAbsId(Values[2]);
+      if (GetValueType(OpIndex) != GetComparisonType())
+        Errors() << "Branch condition not i1\n";
+      Tokens() << StartCluster() << "i1" << Space() << GetBitcodeId(OpIndex)
+               << Comma() << FinishCluster() << Space();
+    }
+    VerifyBranchRange(Values[0]);
+    Tokens() << StartCluster() << "label" << Space()
+             << BitcodeId('b', Values[0]);
+    if (Values.size() == 3) {
+      VerifyBranchRange(Values[1]);
+      Tokens() << Comma() << FinishCluster() << Space()
+               << StartCluster() << "label" << Space()
+               << BitcodeId('b', Values[1]);
+    }
+    Tokens() << Semicolon() << FinishCluster();
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_SWITCH: {
+    // SWITCH:  [opty, op, bb#, n, (1, 1, int, bb#)*]
+    InstIsTerminating = true;
+    if (Values.size() < 4) {
+      Errors()
+          << "Function switch record expects at least 4 arguments. Found: "
+          << Values.size() << "\n";
+      break;
+    }
+    Type *OpType = GetType(Values[0]);
+    uint32_t CondId = RelativeToAbsId(Values[1]);
+    Type *CondType = GetValueType(CondId);
+    if (OpType != CondType)
+      Errors() << "Specified select type " << *OpType << " but found: "
+               << *CondType << "\n";
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidSwitchConditionType(CondType)) {
+      Errors() << PNaClABITypeChecker::ExpectedSwitchConditionType(CondType)
+               << "\n";
+    }
+    uint32_t DefaultBb = Values[2];
+    unsigned NumCases = Values[3];
+    VerifyBranchRange(DefaultBb);
+    Tokens() << "switch" << Space() << StartCluster() << StartCluster()
+             << TokenizeType(OpType) << Space() <<  GetBitcodeId(CondId)
+             << FinishCluster() << Space() << "{" << FinishCluster()
+             << Endline();
+    IncAssemblyIndent();
+    Tokens() << StartCluster() << "default" << ":" << Space()
+             << FinishCluster() << StartCluster() << "br" << Space() << "label"
+             << Space() << BitcodeId('b', DefaultBb) << Semicolon()
+             << FinishCluster() << Endline();
+    unsigned CurIdx = 4;
+    for (unsigned i = 0; i < NumCases; ++i) {
+      unsigned NumItems = Values[CurIdx++];
+      bool IsSingleNumber = Values[CurIdx++];
+      if (NumItems != 1 || !IsSingleNumber) {
+        Errors() << "Case ranges are not supported in PNaCl\n";
+        break;
+      }
+      SignRotatedInt CaseValue(Values[CurIdx++], OpType);
+      // TODO(kschimpf) Check if CaseValue possible based on OpType.
+      uint64_t Label = Values[CurIdx++];
+      VerifyBranchRange(Label);
+      Tokens() << StartCluster() << TokenizeType(OpType) << Space()
+               << CaseValue << ":" << Space() << FinishCluster()
+               << StartCluster() << "br" << Space() << "label" << Space()
+               << BitcodeId('b', Label) << Semicolon() << FinishCluster()
+               << Endline();
+    }
+    DecAssemblyIndent();
+    Tokens() << "}";
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_UNREACHABLE:
+    // UNREACHABLE
+    InstIsTerminating = true;
+    if (!Values.empty()) {
+      Errors() << "Function unreachable record expects no arguments. Found: "
+               << Values.size() << "\n";
+    }
+    Tokens() << "unreachable" << Semicolon();
+    break;
+  case naclbitc::FUNC_CODE_INST_PHI: {
+    // PHI: [ty, (val0, bb0)*]
+    if (Values.size() < 3) {
+      Errors() << "Function phi record expects at least 3 arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    } else if (Values.size() % 2 == 0) {
+      Errors()
+          << "Function phi records should have an odd number of arguments. "
+          << "Found: " << Values.size() << "\n";
+    }
+    Type* OpType = GetType(Values[0]);
+    Tokens() << NextInstId() << Space() << "=" << StartCluster() << Space()
+             << "phi" << Space() << TokenizeType(OpType);
+    for (size_t i = 1; i < Values.size(); i += 2) {
+      if (i > 1) Tokens() << Comma();
+      uint32_t Index = RelativeToAbsId(NaClDecodeSignRotatedValue(Values[i]));
+      Tokens() << FinishCluster() << Space() << StartCluster() << OpenSquare()
+               << GetBitcodeId(Index) << Comma() << Space()
+               << BitcodeId('b', Values[i+1]) << CloseSquare();
+    }
+    Tokens() << Semicolon() << FinishCluster();
+    InstallInstType(OpType);
+    break;
+  };
+  case naclbitc::FUNC_CODE_INST_ALLOCA: {
+    // ALLOCA:     [size, align]
+    if (Values.size() != 2) {
+      Errors() << "Function alloca record expects 2 arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    uint32_t SizeOp = RelativeToAbsId(Values[0]);
+    Type* SizeType = GetValueType(SizeOp);
+    BitcodeId SizeId(GetBitcodeId(SizeOp));
+    unsigned Alignment = getAlignmentValue(Values[1]);
+    if (!IgnorePNaClABIChecks && !PNaClABIProps::isAllocaSizeType(SizeType))
+      Errors() << PNaClABIProps::ExpectedAllocaSizeType() << "\n";
+    // TODO(kschimpf) Are there any constraints on alignment?
+    Tokens() << NextInstId() << Space() << "=" << Space() << StartCluster()
+             << "alloca" << Space() << "i8" << Comma() << FinishCluster()
+             << Space() << StartCluster() << TokenizeType(SizeType) << Space()
+             << SizeId << Comma() << FinishCluster() << Space()
+             << StartCluster() <<"align" << Space() << Alignment << Semicolon()
+             << FinishCluster();
+    InstallInstType(GetPointerType());
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_LOAD: {
+    // LOAD: [op, align, ty]
+    if (Values.size() != 3) {
+      Errors() << "Function load record expects 3 arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    unsigned Alignment = getAlignmentValue(Values[1]);
+    Type *LoadType = GetType(Values[2]);
+    VerifyScalarOrVectorOp("load", LoadType);
+    Context->VerifyMemoryAccessAlignment("load", LoadType, Alignment);
+    Tokens() << NextInstId() << Space() << "=" << Space() << StartCluster()
+             << "load" << Space() << TokenizeType(LoadType) << "*" << Space()
+             << GetBitcodeId(RelativeToAbsId(Values[0])) << Comma()
+             << FinishCluster() << Space() << StartCluster()
+             << "align" << Space() << Alignment << Semicolon()
+             << FinishCluster();
+    InstallInstType(LoadType);
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_STORE: {
+    // STORE: [ptr, val, align]
+    if (Values.size() != 3) {
+      Errors() << "Function store record expects 3 arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    unsigned Alignment = getAlignmentValue(Values[2]);
+    uint32_t Val = RelativeToAbsId(Values[1]);
+    Type *ValType = GetValueType(Val);
+    VerifyScalarOrVectorOp("store", ValType);
+    Context->VerifyMemoryAccessAlignment("store", ValType, Alignment);
+    Tokens() << StartCluster() << "store" << Space() << TokenizeType(ValType)
+             << Space() << GetBitcodeId(Val) << Comma() << FinishCluster()
+             << Space() << StartCluster() << TokenizeType(ValType) << "*"
+             << Space() << GetBitcodeId(RelativeToAbsId(Values[0])) << Comma()
+             << FinishCluster() << Space() << StartCluster() << "align"
+             << Space() << Alignment << Semicolon() << FinishCluster();
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_CMP2: {
+    // CMP2: [opval, opval, pred]
+    if (Values.size() != 3) {
+      Errors() << "Function compare record expects 3 arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    uint32_t Arg1 = RelativeToAbsId(Values[0]);
+    uint32_t Arg2 = RelativeToAbsId(Values[1]);
+    Type *Arg1Type = GetValueType(Arg1);
+    Type *Arg2Type = GetValueType(Arg2);
+    if (Arg1Type != Arg2Type) {
+      Errors() << "Arguments not of same type: " << *Arg1Type << " and "
+               << *Arg2Type << "\n";
+    }
+    const char *Pred = "???";
+    Tokens() << NextInstId() << Space() << "=" << Space() << StartCluster();
+    Type* BaseType = UnderlyingType(Arg1Type);
+    if (BaseType->isIntegerTy()) {
+      Pred = GetIcmpPredicate(Values[2]);
+      Tokens() << "icmp" << Space() << Pred;
+    } else if (isFloatingType(BaseType)) {
+      Pred = GetFcmpPredicate(Values[2]);
+      Tokens() << "fcmp" << Space() << Pred;
+    } else {
+      Errors() << "Compare not on integer/float type. Found: "
+               << *Arg1Type << "\n";
+      Tokens() << "cmp" << Space() << "???" "(" << Values[2] << ")";
+    }
+    Tokens() << FinishCluster() << Space() << StartCluster()
+             << TokenizeType(Arg1Type) << Space () << GetBitcodeId(Arg1)
+             << Comma() << FinishCluster() << Space() << StartCluster()
+             << GetBitcodeId(Arg2) << Semicolon() << FinishCluster();
+    Type *ResultType = GetComparisonType();
+    if (Arg1Type->isVectorTy()) {
+      ResultType = VectorType::get(ResultType,
+                                   Arg1Type->getVectorNumElements());
+    }
+    InstallInstType(ResultType);
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_VSELECT: {
+    // VSELECT:    [opval, opval, pred]
+    if (Values.size() != 3) {
+      Errors() << "Select record expects 3 arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    uint32_t CondValue = RelativeToAbsId(Values[2]);
+    uint32_t ThenValue = RelativeToAbsId(Values[0]);
+    uint32_t ElseValue = RelativeToAbsId(Values[1]);
+    Type *CondType = GetValueType(CondValue);
+    Type *ThenType = GetValueType(ThenValue);
+    Type *ElseType = GetValueType(ElseValue);
+    if (ThenType != ElseType) {
+      Errors() << "Selected arguments not of same type: "
+               << *ThenType << " and " << *ElseType << "\n";
+    }
+    Type *BaseType = UnderlyingType(ThenType);
+    if (!(BaseType->isIntegerTy() || isFloatingType(BaseType))) {
+      Errors() << "Select arguments not integer/float. Found: " << *ThenType;
+    }
+    Tokens() << NextInstId() << Space() << "=" << Space() << StartCluster()
+             << "select" << Space() << TokenizeType(CondType) << Space()
+             << GetBitcodeId(CondValue) << Comma() << FinishCluster() << Space()
+             << StartCluster() << TokenizeType(ThenType) << Space()
+             << GetBitcodeId(ThenValue) << Comma() << FinishCluster() << Space()
+             << StartCluster() << TokenizeType(ElseType) << Space()
+             << GetBitcodeId(ElseValue) << Semicolon()
+             << FinishCluster();
+    InstallInstType(ThenType);
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_EXTRACTELT: {
+    // EXTRACTELT: [opval, opval]
+    if (Values.size() != 2) {
+      Errors() << "Extract element record expects 2 arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    uint32_t VecValue = RelativeToAbsId(Values[0]);
+    uint32_t IdxValue = RelativeToAbsId(Values[1]);
+    VerifyIndexedVector("extractelement", VecValue, IdxValue);
+    Type *VecType = GetValueType(VecValue);
+    Type *IdxType = GetValueType(IdxValue);
+    Tokens() << NextInstId() << Space() << " = " << Space() << StartCluster()
+             << "extractelement" << Space() << TokenizeType(VecType) << Space()
+             << GetBitcodeId(VecValue) << Comma() << FinishCluster() << Space()
+             << StartCluster() << TokenizeType(IdxType) << Space()
+             << GetBitcodeId(IdxValue) << Semicolon() << FinishCluster();
+    InstallInstType(UnderlyingType(VecType));
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_INSERTELT: {
+    // INSERTELT:  [opval, opval, opval]
+    uint32_t VecValue = RelativeToAbsId(Values[0]);
+    uint32_t EltValue = RelativeToAbsId(Values[1]);
+    uint32_t IdxValue = RelativeToAbsId(Values[2]);
+    VerifyIndexedVector("insertelement", VecValue, IdxValue);
+    Type *VecType = GetValueType(VecValue);
+    Type *EltType = GetValueType(EltValue);
+    Type *IdxType = GetValueType(IdxValue);
+    if (EltType != UnderlyingType(VecType)) {
+      Errors() << "insertelement: Illegal element type " << *EltType
+               << ". Expected: " << *UnderlyingType(VecType) << "\n";
+    }
+    Tokens() << NextInstId() << Space() << " = " << Space() << StartCluster()
+             << "insertelement" << Space() << TokenizeType(VecType) << Space()
+             << GetBitcodeId(VecValue) << Comma() << FinishCluster() << Space()
+             << StartCluster() << TokenizeType(EltType) << Space()
+             << GetBitcodeId(EltValue) << Comma() << FinishCluster() << Space()
+             << StartCluster() << TokenizeType(IdxType) << Space()
+             << GetBitcodeId(IdxValue) << Semicolon() << FinishCluster();
+    InstallInstType(VecType);
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_CALL:
+  case naclbitc::FUNC_CODE_INST_CALL_INDIRECT: {
+    // CALL: [cc, fnid, arg0, arg1...]
+    // CALL_INDIRECT: [cc, fnid, returnty, args...]
+    if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL) {
+      if (Values.size() < 2) {
+        Errors() << "Call record expects at least 2 arguments. Found: "
+                 << Values.size() << "\n";
+        break;
+      }
+    } else if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL_INDIRECT) {
+      if (Values.size() < 3) {
+        Errors() << "Call indirect record expects at least 3 arguments. Found: "
+                 << Values.size() << "\n";
+        break;
+      }
+    }
+    unsigned IsTailCall = (Values[0] & 0x1);
+    CallingConv::ID CallingConv;
+    uint32_t FcnId = RelativeToAbsId(Values[1]);
+    if (!naclbitc::DecodeCallingConv(Values[0]>>1, CallingConv))
+      Errors() << "Call unknown calling convention:" << (Values[0]>>1) << "\n";
+    if (!IgnorePNaClABIChecks &&
+        !PNaClABIProps::isValidCallingConv(CallingConv)) {
+      Errors() << "Call uses disallowed calling convention: "
+               << PNaClABIProps::CallingConvName(CallingConv) << "("
+               << CallingConv << ")\n";
+    }
+    FunctionType *FcnType = 0;
+    Type *ReturnType = 0;
+    size_t ArgIndex = 2;
+    // Flag defining if type checking should be done on argument/return
+    // types.
+    bool CheckArgRetTypes = true;
+    if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL) {
+      Type *FcnTy = GetFunctionValueType(FcnId);
+      if (FunctionType *FcnTyp = dyn_cast<FunctionType>(FcnTy)) {
+        // TODO(kschimpf) Add back signature checking once we know how
+        // to handle intrinsics (which can violate general signature
+        // rules).
+        CheckArgRetTypes = false;
+        FcnType = FcnTyp;
+        ReturnType = FcnType->getReturnType();
+      } else {
+        Errors() << "Invalid function signature: " << *FcnTy << "\n";
+        ReturnType = GetVoidType();
+      }
+    } else {
+      ReturnType = GetType(Values[2]);
+      ArgIndex = 3;
+    }
+    if (!ReturnType->isVoidTy()) {
+      Tokens() << NextInstId() << Space() << "=" << Space();
+    }
+    if (IsTailCall) {
+      Tokens() << "tail" << Space();
+    }
+    if (CheckArgRetTypes &&
+        !IgnorePNaClABIChecks &&
+        !PNaClABITypeChecker::isValidParamType(ReturnType)) {
+      Errors() << "Invalid return type: " << *ReturnType << "\n";
+    }
+    Tokens() << "call" << Space();
+    if (CallingConv != CallingConv::C) {
+      Tokens() << PNaClABIProps::CallingConvName(CallingConv) << Space();
+    }
+    Tokens() << TokenizeType(ReturnType) << Space()
+             << StartCluster() << GetBitcodeId(FcnId) << OpenParen()
+             << StartCluster();
+    unsigned ParamIndex = 0;
+    unsigned NumParams = Values.size() + 1 - ArgIndex;
+    for (size_t i = ArgIndex; i < Values.size(); ++i, ++ParamIndex) {
+      uint32_t ParamId = RelativeToAbsId(Values[i]);
+      Type *ParamType = GetValueType(ParamId);
+      if (CheckArgRetTypes &&
+          !IgnorePNaClABIChecks &&
+          !PNaClABITypeChecker::isValidParamType(ParamType)) {
+        Errors() << "invalid type for parameter " << i << ": "
+                 << *ParamType << "\n";
+      }
+      if (FcnType) {
+        if (ParamIndex < FcnType->getNumParams()) {
+          Type *ExpectedType = FcnType->getParamType(ParamIndex);
+          if (ParamType != ExpectedType) {
+            Warnings() << "Parameter " << (ParamIndex + 1) << " mismatch: "
+                       << *ParamType << " and " << *ExpectedType << "\n";
+          }
+        }
+        else if (ParamIndex == FcnType->getNumParams()) {
+          Warnings() << "Call expects " << FcnType->getNumParams()
+                     << " arguments. Got: " << NumParams << "\n";
+        }
+      }
+      if (i > ArgIndex) {
+        Tokens() << Comma() << FinishCluster() << Space() << StartCluster();
+      }
+      Tokens() << TokenizeType(ParamType) << Space() << GetBitcodeId(ParamId);
+    }
+    Tokens() << CloseParen() << Semicolon() << FinishCluster()
+             << FinishCluster();
+    if (!ReturnType->isVoidTy()) InstallInstType(ReturnType);
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_FORWARDTYPEREF: {
+    // TYPE: [opval, ty]
+    if (Values.size() != 2) {
+      Errors() << "Forward declare record expects 2 arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    Type *OpType = GetType(Values[1]);
+    Tokens() << "declare" << Space() << StartCluster()
+             << TokenizeType(OpType) << Space()
+             << GetBitcodeId(Values[0]) << Semicolon() << FinishCluster();
+    InstallInstType(OpType, AbsToValuedInstId(Values[0]));
+    break;
+  }
+  default:
+    Errors() << "Unknown record found in module block.\n";
+    break;
+  }
+  Tokens() << TokenizeAbbrevIndex() << Endline();
+  ObjDumpWrite(Record.GetStartBit(), Record);
+}
+
+/// Parses and disassembles the module block.
+class NaClDisModuleParser : public NaClDisBlockParser {
+public:
+  NaClDisModuleParser(unsigned BlockID, NaClDisTopLevelParser *Context)
+      : NaClDisBlockParser(BlockID, Context) {
+  }
+
+  ~NaClDisModuleParser() override;
+
+  bool ParseBlock(unsigned BlockID) override;
+
+  void PrintBlockHeader() override;
+
+  void ProcessRecord() override;
+};
+
+NaClDisModuleParser::~NaClDisModuleParser() {
+  // Note: Since we can't check type signatures of most functions till
+  // we know intrinsic names, and that isn't known until the (optional)
+  // valuesymtab block is parsed, the only reasonable spot to check
+  // function signatures is once the module block has been processed.
+  unsigned NextFcnDefinedId = 0;
+  for (unsigned i = 0, e = GetNumFunctions(); i < e; ++i) {
+    // Note: If the type of a function isn't a function type, that
+    // was checked in method ProcessRecord.
+    // Note: If the function was defined, the type was checked in
+    // NaClDisFunctionParser::PrintBlockHeader.
+    if (Context->HasDefinedFunctionIndex(NextFcnDefinedId)
+        && i == Context->GetDefinedFunctionIndex(NextFcnDefinedId)) {
+      ++NextFcnDefinedId;
+      continue;
+    }
+    if (FunctionType *FcnTy = dyn_cast<FunctionType>(GetFunctionValueType(i))) {
+      if (!Context->IsFunctionIntrinsic(i) &&
+          !IgnorePNaClABIChecks &&
+          !PNaClABITypeChecker::isValidFunctionType(FcnTy)) {
+        Context->SetRecordAddressToFunctionIdAddress(i);
+        Errors() << "Invalid type signature for "
+                 << BitcodeId('f', i) << ": " << *FcnTy << "\n";
+      }
+    }
+  }
+}
+
+bool NaClDisModuleParser::ParseBlock(unsigned BlockID) {
+  ObjDumpSetRecordBitAddress(GetBlock().GetStartBit());
+  switch (BlockID) {
+  case naclbitc::BLOCKINFO_BLOCK_ID: {
+    NaClDisBlockInfoParser Parser(BlockID, this);
+    return Parser.ParseThisBlock();
+  }
+  case naclbitc::TYPE_BLOCK_ID_NEW: {
+    NaClDisTypesParser Parser(BlockID, this);
+    return Parser.ParseThisBlock();
+  }
+  case naclbitc::GLOBALVAR_BLOCK_ID: {
+    NaClDisGlobalsParser Parser(BlockID, this);
+    return Parser.ParseThisBlock();
+  }
+  case naclbitc::VALUE_SYMTAB_BLOCK_ID: {
+    NaClDisValueSymtabParser Parser(BlockID, this);
+    return Parser.ParseThisBlock();
+  }
+  case naclbitc::FUNCTION_BLOCK_ID: {
+    NaClDisFunctionParser Parser(BlockID, this);
+    return Parser.ParseThisBlock();
+  }
+  default:
+    return NaClDisBlockParser::ParseBlock(BlockID);
+  }
+}
+
+void NaClDisModuleParser::PrintBlockHeader() {
+  Tokens() << "module" << Space() << OpenCurly()
+           << Space() << Space() << "// BlockID = " << GetBlockID()
+           << Endline();
+}
+
+void NaClDisModuleParser::ProcessRecord() {
+  ObjDumpSetRecordBitAddress(Record.GetStartBit());
+  const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
+  switch (Record.GetCode()) {
+  case naclbitc::MODULE_CODE_VERSION:
+    // [version#]
+    if (Values.size() != 1) {
+      Errors() << "Version record should have one argument. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    Tokens() << "version" << Space() << Values[0] << Semicolon()
+             << TokenizeAbbrevIndex() << Endline();
+    break;
+  case naclbitc::MODULE_CODE_FUNCTION: {
+    // [type, callingconv, isproto, linkage]
+    if (Values.size() != 4) {
+      Errors() << "Function record should have 4 arguments. Found: "
+               << Values.size() << "\n";
+      break;
+    }
+    bool IsProto = (Values[2] != 0);
+    Tokens() << StartCluster() << (IsProto ? "declare" : "define");
+    uint32_t FcnId = GetNumFunctions();
+    BitcodeId FcnName('f', FcnId);
+    std::string FcnStrName(FcnName.GetName());
+    GlobalValue::LinkageTypes Linkage;
+    if (!naclbitc::DecodeLinkage(Values[3], Linkage)) {
+      Errors() << "Unknown linkage value: " << Values[3] << "\n";
+    } else {
+      if (!IgnorePNaClABIChecks &&
+          !PNaClABIProps::isValidGlobalLinkage(Linkage)) {
+        Errors() << "Disallowed linkage type: "
+                 << PNaClABIProps::LinkageName(Linkage) << "\n";
+      }
+      Tokens() << Space() << PNaClABIProps::LinkageName(Linkage);
+    }
+    CallingConv::ID CallingConv;
+    if (!naclbitc::DecodeCallingConv(Values[1], CallingConv)) {
+      Errors() << "Unknown calling convention value: " << Values[1] << "\n";
+    } else if (PNaClABIProps::isValidCallingConv(CallingConv)) {
+      if (CallingConv != CallingConv::C) {
+        Tokens() << Space() << PNaClABIProps::CallingConvName(CallingConv);
+      }
+    } else {
+      Errors() << "Function " << FcnStrName
+               << " has disallowed calling convention: "
+               << PNaClABIProps::CallingConvName(CallingConv)
+               << " (" << CallingConv << ")\n";
+    }
+    Tokens() << FinishCluster() << Space() << StartCluster();
+    Type *FcnType = GetType(Values[0]);
+    FunctionType *FunctionTy = dyn_cast<FunctionType>(FcnType);
+    if (FunctionTy) {
+      Tokens() << TokenizeFunctionType(FunctionTy, &FcnName);
+    } else {
+      BitcodeId FcnTypeId('t', Values[0]);
+      Errors() << "Not function type: " << FcnTypeId << " = "
+               << *FcnType << "\n";
+      Tokens() << "???";
+      SmallVector<Type*, 1> Signature;
+      FunctionTy = FunctionType::get(GetVoidType(), Signature, 0);
+    }
+    Tokens() << Semicolon() << FinishCluster() << TokenizeAbbrevIndex()
+             << Endline();
+    InstallFunctionType(FunctionTy);
+    if (!IsProto) InstallDefinedFunction(FcnId);
+    break;
+  }
+  default:
+    Errors() << "Unknown record found in module block\n";
+    break;
+  }
+  ObjDumpWrite(Record.GetStartBit(), Record);
+}
+
+bool NaClDisTopLevelParser::ParseBlock(unsigned BlockID) {
+  // Before parsing top-level module block. Describe header.
+  NaClBitcodeRecordData Record;
+  size_t HeaderSize = Header.getHeaderSize();
+  Record.Code = naclbitc::BLK_CODE_HEADER;
+  for (size_t i = 0; i < HeaderSize; ++i) {
+    Record.Values.push_back(HeaderBuffer[i]);
+  }
+  if (ObjDump.GetDumpRecords() && ObjDump.GetDumpAssembly()) {
+    if (HeaderSize >= 4) {
+      const NaClRecordVector &Values = Record.Values;
+      Tokens() << "Magic" << Space() << "Number" << Colon()
+               << Space() << StartCluster() << StartCluster() << "'"
+               << (char) Values[0] << (char) Values[1]
+               << (char) Values[2] << (char) Values[3]
+               << "'" << FinishCluster() << Space()
+               << StartCluster() << OpenParen()
+               << Values[0] << Comma() << Space()
+               << Values[1] << Comma() << Space()
+               << Values[2] << Comma() << Space()
+               << Values[3] << CloseParen() << FinishCluster()
+               << FinishCluster() << Endline();
+    }
+    // Show interpretation of header as assembly.
+    for (size_t i = 0; i < Header.NumberFields(); ++i) {
+      Tokens() << Header.GetField(i)->Contents() << Endline();
+    }
+  }
+  ObjDump.Write(0, Record);
+  ObjDump.SetStartOffset(HeaderSize * 8);
+
+  if (BlockID != naclbitc::MODULE_BLOCK_ID)
+    return Error("Module block expected at top-level, but not found");
+
+  // Now parse a module block.
+  NaClDisModuleParser Parser(BlockID, this);
+  return Parser.ParseThisBlock();
+}
+
+}
+
+namespace llvm {
+
+bool NaClObjDump(MemoryBuffer *MemBuf, raw_ostream &Output,
+                 bool NoRecords, bool NoAssembly) {
+  // Create objects needed to run parser.
+  naclbitc::ObjDumpStream ObjDump(Output, !NoRecords, !NoAssembly);
+
+  if (MemBuf->getBufferSize() % 4 != 0) {
+    ObjDump.Error()
+        << "Bitcode stream should be a multiple of 4 bytes in length.\n";
+    return true;
+  }
+
+  const unsigned char *BufPtr = (const unsigned char *)MemBuf->getBufferStart();
+  const unsigned char *EndBufPtr = BufPtr+MemBuf->getBufferSize();
+  const unsigned char *HeaderPtr = BufPtr;
+
+  // Read header and verify it is good.
+  NaClBitcodeHeader Header;
+  if (Header.Read(BufPtr, EndBufPtr) || !Header.IsSupported()) {
+    ObjDump.Error() << "Invalid PNaCl bitcode header.\n";
+    return true;
+  }
+
+  // Create a bitstream reader to read the bitcode file.
+  NaClBitstreamReader InputStreamFile(BufPtr, EndBufPtr);
+  NaClBitstreamCursor InputStream(InputStreamFile);
+
+  // Parse the the bitcode file.
+  ::NaClDisTopLevelParser Parser(Header, HeaderPtr, InputStream, ObjDump);
+  int NumBlocksRead = 0;
+  bool ErrorsFound = false;
+  while (!InputStream.AtEndOfStream()) {
+    ++NumBlocksRead;
+    if (Parser.Parse()) ErrorsFound = true;
+  }
+
+  if (NumBlocksRead != 1) {
+    ObjDump.Error() << "Expected 1 top level block in bitcode: Found:"
+                    << NumBlocksRead << "\n";
+    ErrorsFound = true;
+  }
+
+  ObjDump.Flush();
+  return ErrorsFound || Parser.GetNumErrors() > 0;
+}
+
+}