Index: include/llvm/Bitcode/LLVMBitCodes.h
===================================================================
--- include/llvm/Bitcode/LLVMBitCodes.h
+++ include/llvm/Bitcode/LLVMBitCodes.h
@@ -34,7 +34,10 @@
     CONSTANTS_BLOCK_ID,
     FUNCTION_BLOCK_ID,
 
-    UNUSED_ID1,
+    // Block intended to contains information on the bitcode versioning.
+    // Can be used to provide better error messages when we fail to parse a
+    // bitcode file.
+    IDENTIFICATION_BLOCK_ID,
 
     VALUE_SYMTAB_BLOCK_ID,
     METADATA_BLOCK_ID,
@@ -50,6 +53,12 @@
     OPERAND_BUNDLE_TAGS_BLOCK_ID
   };
 
+  /// Idenfitication block contains a string that describes the producer
+  /// details, and the major.minor.patch version to enforce compatibility.
+  enum IdentificationCodes {
+    IDENTIFICATION_CODE_STRING = 1,  // IDENTIFICATION:    [strchr x N]
+    IDENTIFICATION_CODE_VERSION = 2, // VERSION:           [major,minor,patch]
+  };
 
   /// MODULE blocks have a number of optional fields and subblocks.
   enum ModuleCodes {
Index: lib/Bitcode/Reader/BitcodeReader.cpp
===================================================================
--- lib/Bitcode/Reader/BitcodeReader.cpp
+++ lib/Bitcode/Reader/BitcodeReader.cpp
@@ -152,6 +152,8 @@
   uint64_t LastFunctionBlockBit = 0;
   bool SeenValueSymbolTable = false;
   unsigned VSTOffset = 0;
+  // Contains an arbitrary and optional string identifying the bitcode producer
+  std::string ProducerIdentification;
 
   std::vector<Type*> TypeList;
   BitcodeReaderValueList ValueList;
@@ -273,6 +275,11 @@
   void setStripDebugInfo() override;
 
 private:
+  /// Parse the "IDENTIFICATION_BLOCK_ID" block, populate the
+  // ProducerIdentification data member, and do some basic enforcement on the
+  // "epoch" encoded in the bitcode.
+  std::error_code parseBitcodeVersion();
+
   std::vector<StructType *> IdentifiedStructTypes;
   StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name);
   StructType *createIdentifiedStructType(LLVMContext &Context);
@@ -518,10 +525,21 @@
 }
 
 std::error_code BitcodeReader::error(BitcodeError E, const Twine &Message) {
+  if (!ProducerIdentification.empty()) {
+    Twine MsgWithID = Message + " (Producer: '" + ProducerIdentification
+        + "' Reader: 'LLVM " + LLVM_VERSION_STRING "')";
+    return ::error(DiagnosticHandler, make_error_code(E), MsgWithID);
+  }
   return ::error(DiagnosticHandler, make_error_code(E), Message);
 }
 
 std::error_code BitcodeReader::error(const Twine &Message) {
+  if (!ProducerIdentification.empty()) {
+    Twine MsgWithID = Message + " (Producer: '" + ProducerIdentification
+        + "' Reader: 'LLVM " + LLVM_VERSION_STRING "')";
+    return ::error(DiagnosticHandler,
+                   make_error_code(BitcodeError::CorruptedBitcode), MsgWithID);
+  }
   return ::error(DiagnosticHandler,
                  make_error_code(BitcodeError::CorruptedBitcode), Message);
 }
@@ -3061,6 +3079,56 @@
   }
 }
 
+std::error_code BitcodeReader::parseBitcodeVersion() {
+  if (Stream.EnterSubBlock(bitc::IDENTIFICATION_BLOCK_ID))
+    return error("Invalid record");
+
+
+  // Read all the records.
+  SmallVector<uint64_t, 64> Record;
+  while (1) {
+    BitstreamEntry Entry = Stream.advance();
+
+    switch (Entry.Kind) {
+      default:
+      case BitstreamEntry::Error:
+        return error("Malformed block");
+      case BitstreamEntry::EndBlock:
+        return std::error_code();
+      case BitstreamEntry::Record:
+        // The interesting case.
+        break;
+    }
+
+    // Read a record.
+    Record.clear();
+    unsigned BitCode = Stream.readRecord(Entry.ID, Record);
+    switch (BitCode) {
+      default: // Default behavior: reject
+        return error("Invalid value");
+      case bitc::IDENTIFICATION_CODE_STRING: { // IDENTIFICATION:      [strchr x N]
+        convertToString(Record, 0, ProducerIdentification);
+        break;
+      }
+      case bitc::IDENTIFICATION_CODE_VERSION: { // EPOCH:      [epoch#]
+        unsigned Major = (unsigned)Record[0];
+        unsigned Minor = (unsigned)Record[1];
+        // Implement basic compatibility check
+        // LLVM X.y can only read bitcode generated by X.z with y<z, except for
+        // the first minor X.0 which can read any (X-1).w version.
+        if ((Major < LLVM_VERSION_MAJOR && LLVM_VERSION_MINOR != 0) ||
+            Major > LLVM_VERSION_MAJOR ||
+            (Major == LLVM_VERSION_MAJOR && Minor > LLVM_VERSION_MAJOR)) {
+          auto BitcodeMajor = std::to_string(Major);
+          auto BitcodeMinor = std::to_string(Minor);
+          return error(Twine("Incompatible Bitcode Version ") + BitcodeMajor +
+                       "." + BitcodeMinor);
+        }
+      }
+    }
+  }
+}
+
 std::error_code BitcodeReader::parseModule(uint64_t ResumeBit,
                                            bool ShouldLazyLoadMetadata) {
   if (ResumeBit)
@@ -3552,6 +3620,11 @@
     if (Entry.Kind != BitstreamEntry::SubBlock)
       return error("Malformed block");
 
+    if (Entry.ID == bitc::IDENTIFICATION_BLOCK_ID) {
+      parseBitcodeVersion();
+      continue;
+    }
+
     if (Entry.ID == bitc::MODULE_BLOCK_ID)
       return parseModule(0, ShouldLazyLoadMetadata);
 
Index: lib/Bitcode/Writer/BitcodeWriter.cpp
===================================================================
--- lib/Bitcode/Writer/BitcodeWriter.cpp
+++ lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -2830,6 +2830,33 @@
   Stream.ExitBlock();
 }
 
+// Create the "IDENTIFICATION_BLOCK_ID" containing a single string with the
+// current llvm version, and a record for the major.minor.patch version
+static void WriteIdentificationBlock(const Module *M, BitstreamWriter &Stream) {
+  Stream.EnterSubblock(bitc::IDENTIFICATION_BLOCK_ID, 5);
+
+  // Write the "user readable" string identifying the bitcode producer
+  BitCodeAbbrev *Abbv = new BitCodeAbbrev();
+  Abbv->Add(BitCodeAbbrevOp(bitc::IDENTIFICATION_CODE_STRING));
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
+  auto StringAbbrev = Stream.EmitAbbrev(Abbv);
+  WriteStringRecord(bitc::IDENTIFICATION_CODE_STRING,
+                    "LLVM" LLVM_VERSION_STRING, StringAbbrev, Stream);
+
+  // Write the major.minor.patch version
+  Abbv = new BitCodeAbbrev();
+  Abbv->Add(BitCodeAbbrevOp(bitc::IDENTIFICATION_CODE_VERSION));
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
+  auto VersionAbbrev = Stream.EmitAbbrev(Abbv);
+  SmallVector<unsigned, 1> Vals = {LLVM_VERSION_MAJOR, LLVM_VERSION_MINOR,
+                                   LLVM_VERSION_PATCH};
+  Stream.EmitRecord(bitc::IDENTIFICATION_CODE_VERSION, Vals, VersionAbbrev);
+  Stream.ExitBlock();
+}
+
 /// WriteModule - Emit the specified module to the bitstream.
 static void WriteModule(const Module *M, BitstreamWriter &Stream,
                         bool ShouldPreserveUseListOrder,
@@ -3001,6 +3028,8 @@
     // Emit the file header.
     WriteBitcodeHeader(Stream);
 
+    WriteIdentificationBlock(M, Stream);
+
     // Emit the module.
     WriteModule(M, Stream, ShouldPreserveUseListOrder, BitcodeStartBit,
                 EmitFunctionSummary);
Index: test/Bitcode/identification.ll
===================================================================
--- /dev/null
+++ test/Bitcode/identification.ll
@@ -0,0 +1,6 @@
+; Check that a block "IDENTIFICATION_BLOCK_ID" is emitted.
+;RUN: llvm-as < %s | llvm-bcanalyzer -dump | FileCheck %s
+;CHECK: <IDENTIFICATION_BLOCK_ID
+;CHECK-NEXT: <STRING
+;CHECK-NEXT: <EPOCH
+;CHECK-NEXT: </IDENTIFICATION_BLOCK_ID
Index: tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
===================================================================
--- tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
+++ tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
@@ -110,6 +110,8 @@
   case bitc::TYPE_BLOCK_ID_NEW:        return "TYPE_BLOCK_ID";
   case bitc::CONSTANTS_BLOCK_ID:       return "CONSTANTS_BLOCK";
   case bitc::FUNCTION_BLOCK_ID:        return "FUNCTION_BLOCK";
+  case bitc::IDENTIFICATION_BLOCK_ID:
+    return "IDENTIFICATION_BLOCK_ID";
   case bitc::VALUE_SYMTAB_BLOCK_ID:    return "VALUE_SYMTAB";
   case bitc::METADATA_BLOCK_ID:        return "METADATA_BLOCK";
   case bitc::METADATA_ATTACHMENT_ID:   return "METADATA_ATTACHMENT_BLOCK";
@@ -170,6 +172,12 @@
       STRINGIFY_CODE(MODULE_CODE, GCNAME)
       STRINGIFY_CODE(MODULE_CODE, VSTOFFSET)
     }
+  case bitc::IDENTIFICATION_BLOCK_ID:
+    switch (CodeID) {
+      default: return nullptr;
+        STRINGIFY_CODE(IDENTIFICATION_CODE, STRING)
+        STRINGIFY_CODE(IDENTIFICATION_CODE, VERSION)
+    }
   case bitc::PARAMATTR_BLOCK_ID:
     switch (CodeID) {
     default: return nullptr;