Index: include/llvm/CodeGen/FaultMaps.h
===================================================================
--- include/llvm/CodeGen/FaultMaps.h
+++ include/llvm/CodeGen/FaultMaps.h
@@ -12,6 +12,8 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/MC/MCSymbol.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Format.h"
 
 #include <vector>
 #include <map>
@@ -68,6 +70,154 @@
 
   void emitFunctionInfo(const MCSymbol *FnLabel, const FunctionFaultInfos &FFI);
 };
+
+template <support::endianness Endianness> class FaultMapParser {
+  static const size_t FaultMapVersionOffset = 0;
+  static const size_t Reserved0Offset = FaultMapVersionOffset + sizeof(uint8_t);
+  static const size_t Reserved1Offset = Reserved0Offset + sizeof(uint8_t);
+  static const size_t NumFunctionsOffset = Reserved1Offset + sizeof(uint16_t);
+  static const size_t FunctionInfosOffset =
+      NumFunctionsOffset + sizeof(uint32_t);
+
+  const uint8_t *P;
+  const uint8_t *E;
+
+  template <typename T> static T read(const uint8_t *P, const uint8_t *E) {
+    assert(P + sizeof(T) <= E && "out of bounds read!");
+    return support::endian::read<T, Endianness, 1>(P);
+  }
+
+public:
+  class FunctionFaultInfoAccessor {
+    static const size_t FaultKindOffset = 0;
+    static const size_t FaultingPCOffsetOffset =
+        FaultKindOffset + sizeof(uint32_t);
+    static const size_t HandlerPCOffsetOffset =
+        FaultingPCOffsetOffset + sizeof(uint32_t);
+
+    const uint8_t *P;
+    const uint8_t *E;
+
+  public:
+    explicit FunctionFaultInfoAccessor(const uint8_t *P, const uint8_t *E)
+        : P(P), E(E) {}
+
+    uint32_t getFaultKind() const {
+      return read<uint32_t>(P + FaultKindOffset, E);
+    }
+
+    uint32_t getFaultingPCOffset() const {
+      return read<uint32_t>(P + FaultingPCOffsetOffset, E);
+    }
+
+    uint32_t getHandlerPCOffset() const {
+      return read<uint32_t>(P + HandlerPCOffsetOffset, E);
+    }
+  };
+
+  class FunctionInfoAccessor {
+    static const size_t FunctionAddrOffset = 0;
+    static const size_t NumFaultingPCsOffset =
+        FunctionAddrOffset + sizeof(uint64_t);
+    static const size_t ReservedOffset =
+        NumFaultingPCsOffset + sizeof(uint32_t);
+    static const size_t FunctionFaultInfosOffset =
+        ReservedOffset + sizeof(uint32_t);
+    static const size_t FunctionFaultInfoSize = sizeof(uint32_t) * 3;
+
+    const uint8_t *P;
+    const uint8_t *E;
+
+  public:
+    explicit FunctionInfoAccessor(const uint8_t *P, const uint8_t *E)
+        : P(P), E(E) {}
+
+    uint64_t getFunctionAddr() const {
+      return read<uint64_t>(P + FunctionAddrOffset, E);
+    }
+
+    uint32_t getNumFaultingPCs() const {
+      return read<uint32_t>(P + NumFaultingPCsOffset, E);
+    }
+
+    FunctionFaultInfoAccessor getFunctionFaultInfoAt(uint32_t idx) const {
+      assert(idx < getNumFaultingPCs() && "index out of bounds!");
+      const uint8_t *Begin =
+          P + FunctionFaultInfosOffset + FunctionFaultInfoSize * idx;
+      return FunctionFaultInfoAccessor(Begin, E);
+    }
+
+    FunctionInfoAccessor getNextFunctionInfo() const {
+      size_t MySize = sizeof(uint64_t) + // FunctionAddress
+                      sizeof(uint32_t) + // NumFaultingPCs
+                      sizeof(uint32_t) + // Reserved
+                      getNumFaultingPCs() * FunctionFaultInfoSize;
+
+      const uint8_t *Begin = P + MySize;
+      assert(Begin < E && "out of bounds!");
+      return FunctionInfoAccessor(Begin, E);
+    }
+  };
+
+  explicit FaultMapParser(const uint8_t *Begin, const uint8_t *End)
+      : P(Begin), E(End) {}
+
+  uint8_t getFaultMapVersion() const {
+    uint8_t Version = read<uint8_t>(P + FaultMapVersionOffset, E);
+    assert(Version == 1 && "only version 1 supported!");
+    return Version;
+  }
+
+  uint32_t getNumFunctions() const {
+    return read<uint32_t>(P + NumFunctionsOffset, E);
+  }
+
+  FunctionInfoAccessor getFirstFunctionInfo() const {
+    const uint8_t *Begin = P + FunctionInfosOffset;
+    return FunctionInfoAccessor(Begin, E);
+  }
+};
+
+template <support::endianness Endianness>
+raw_ostream &operator<<(
+    raw_ostream &OS,
+    const typename FaultMapParser<Endianness>::FunctionFaultInfoAccessor &FFI) {
+  OS << "Fault kind: "
+     << FaultMaps::faultTypeToString((FaultMaps::FaultKind)FFI.getFaultKind())
+     << ", faulting PC offset: " << FFI.getFaultingPCOffset()
+     << ", handling PC offset: " << FFI.getHandlerPCOffset();
+  return OS;
+}
+
+template <support::endianness Endianness>
+raw_ostream &operator<<(
+    raw_ostream &OS,
+    const typename FaultMapParser<Endianness>::FunctionInfoAccessor &FI) {
+  OS << "FunctionAddress: " << format_hex(FI.getFunctionAddr(), 8)
+     << ", NumFaultingPCs: " << FI.getNumFaultingPCs() << "\n";
+  for (unsigned i = 0, e = FI.getNumFaultingPCs(); i != e; ++i)
+    operator<<<Endianness>(OS, FI.getFunctionFaultInfoAt(i)) << "\n";
+  return OS;
+}
+
+template <support::endianness Endianness>
+raw_ostream &operator<<(raw_ostream &OS,
+                        const FaultMapParser<Endianness> &FMP) {
+  OS << "Version: " << format_hex(FMP.getFaultMapVersion(), 2) << "\n";
+  OS << "NumFunctions: " << FMP.getNumFunctions() << "\n";
+
+  if (FMP.getNumFunctions() == 0)
+    return OS;
+
+  auto FFI = FMP.getFirstFunctionInfo();
+  for (unsigned i = 1, e = FMP.getNumFunctions(); i != e; ++i) {
+    operator<<<Endianness>(OS, FFI);
+    FFI = FFI.getNextFunctionInfo();
+  }
+
+  operator<<<Endianness>(OS, FFI);
+  return OS;
+}
 }
 
 #endif
Index: test/CodeGen/X86/implicit-null-check.ll
===================================================================
--- test/CodeGen/X86/implicit-null-check.ll
+++ test/CodeGen/X86/implicit-null-check.ll
@@ -1,4 +1,5 @@
 ; RUN: llc -O3 -mtriple=x86_64-apple-macosx -enable-implicit-null-checks < %s | FileCheck %s
+; RUN: llc -O3 -mtriple=x86_64-apple-macosx -enable-implicit-null-checks < %s -filetype=obj -o - | llvm-objdump -print-fault-maps - | FileCheck %s -check-prefix=OBJDUMP
 
 define i32 @imp_null_check_load(i32* %x) {
 ; CHECK-LABEL: _imp_null_check_load:
@@ -116,3 +117,13 @@
 ; CHECK-NEXT: .long Ltmp1-_imp_null_check_load
 ; Fault[0].HandlerOffset:
 ; CHECK-NEXT: .long Ltmp0-_imp_null_check_load
+
+; OBJDUMP: FaultMap table:
+; OBJDUMP-NEXT: Version: 0x1
+; OBJDUMP-NEXT: NumFunctions: 3
+; OBJDUMP-NEXT: FunctionAddress: 0x000000, NumFaultingPCs: 1
+; OBJDUMP-NEXT: Fault kind: FaultingLoad, faulting PC offset: 0, handling PC offset: 5
+; OBJDUMP-NEXT: FunctionAddress: 0x000000, NumFaultingPCs: 1
+; OBJDUMP-NEXT: Fault kind: FaultingLoad, faulting PC offset: 0, handling PC offset: 7
+; OBJDUMP-NEXT: FunctionAddress: 0x000000, NumFaultingPCs: 1
+; OBJDUMP-NEXT: Fault kind: FaultingLoad, faulting PC offset: 0, handling PC offset: 3
Index: tools/llvm-objdump/llvm-objdump.cpp
===================================================================
--- tools/llvm-objdump/llvm-objdump.cpp
+++ tools/llvm-objdump/llvm-objdump.cpp
@@ -17,9 +17,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm-objdump.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/CodeGen/FaultMaps.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler.h"
@@ -153,6 +155,9 @@
     llvm::PrintImmHex("print-imm-hex",
                       cl::desc("Use hex format for immediate values"));
 
+cl::opt<bool> PrintFaultMaps("print-fault-maps",
+                             cl::desc("Print the faultmap section"));
+
 static StringRef ToolName;
 static int ReturnValue = EXIT_SUCCESS;
 
@@ -1226,6 +1231,32 @@
   }
 }
 
+static void printFaultMaps(const ObjectFile *Obj) {
+  outs() << "FaultMap table:\n";
+  Optional<object::SectionRef> FaultMapSection;
+  for (auto Sec : Obj->sections()) {
+    StringRef Name;
+    Sec.getName(Name);
+    if (Name == "__llvm_faultmaps") {
+      FaultMapSection = Sec;
+      break;
+    }
+  }
+
+  if (!FaultMapSection.hasValue())
+    return;
+
+  StringRef FaultMapContents;
+  FaultMapSection.getValue().getContents(FaultMapContents);
+  const uint8_t *Begin =
+      reinterpret_cast<const uint8_t *>(FaultMapContents.data());
+  const uint8_t *End = Begin + FaultMapContents.size();
+
+  FaultMapParser<support::little> FMP(Begin, End);
+
+  outs() << FMP;
+}
+
 static void printPrivateFileHeader(const ObjectFile *o) {
   if (o->isELF()) {
     printELFFileHeader(o);
@@ -1265,6 +1296,8 @@
     printLazyBindTable(o);
   if (WeakBind)
     printWeakBindTable(o);
+  if (PrintFaultMaps)
+    printFaultMaps(o);
 }
 
 /// @brief Dump each object file in \a a;
@@ -1362,7 +1395,8 @@
       && !(DylibsUsed && MachOOpt)
       && !(DylibId && MachOOpt)
       && !(ObjcMetaData && MachOOpt)
-      && !(DumpSections.size() != 0 && MachOOpt)) {
+      && !(DumpSections.size() != 0 && MachOOpt)
+      && !PrintFaultMaps) {
     cl::PrintHelpMessage();
     return 2;
   }