diff --git a/vndk/tools/header-checker/Android.bp b/vndk/tools/header-checker/Android.bp
index 71cf175..3f29d06 100644
--- a/vndk/tools/header-checker/Android.bp
+++ b/vndk/tools/header-checker/Android.bp
@@ -24,11 +24,14 @@
     cflags: [
         "-Wall",
         "-Werror",
-        "-std=c++11",
         "-DGOOGLE_PROTOBUF_NO_RTTI",
         "-UNDEBUG"
     ],
 
+    cppflags: [
+        "-std=c++14",
+    ],
+
     target: {
         windows: {
             enabled: false
@@ -40,8 +43,8 @@
     name: "header-checker-lib-defaults",
 
     static_libs: [
-        "libclangTooling",
         "libclangToolingCore",
+        "libclangTooling",
         "libclangFrontendTool",
         "libclangFrontend",
         "libclangDriver",
@@ -134,8 +137,8 @@
     ],
 
     static_libs: [
-        "libheader-checker-proto",
         "libheader-abi-util",
+        "libheader-checker-proto",
     ],
 
     target: {
@@ -269,8 +272,14 @@
         "libLLVMMCParser",
         "libLLVMCore",
         "libLLVMSupport",
+        "libheader-checker-proto",
     ],
 
+    shared_libs: [
+        "libprotobuf-cpp-full",
+    ],
+
+
     cflags: [
         "-Wcast-qual",
         "-Wno-long-long",
diff --git a/vndk/tools/header-checker/README.md b/vndk/tools/header-checker/README.md
index 9412f60..242786a 100644
--- a/vndk/tools/header-checker/README.md
+++ b/vndk/tools/header-checker/README.md
@@ -7,6 +7,7 @@
 ## Usage
  header-abi-dumper -o <dump-file> <source_file> -I <export-include-dir-1> -I
  <export-include-dir-2>.. -- <cflags>
+ For options : header-abi-dumper --help
 
 # VNDK Header Abi Linker
 
@@ -16,6 +17,7 @@
 
 ## Usage
  header-abi-linker -o <linked-abi-dump> <abi-dump1> <abi-dump2> <abi-dump3> ...
+ For options : header-abi-linker --help
 
 # VNDK Header Abi Diff
 
@@ -24,10 +26,13 @@
  abi's exposed by the two dumps.
 
 # Return Value
- 1: InCompatible
- 0: Compatible or Compatible Extension.
+ 0: Compatible
+ 1: Changes to APIs unreferenced by symbols in the .dynsym table
+ 4: Compatible Extension
+ 8: Incompatible
 
 
 ## Usage
  header-abi-diff -old <old-abi-dump> -new <new-abi-dump> -o <report>
+ For options : header-abi-diff --help
 
diff --git a/vndk/tools/header-checker/header-abi-diff/src/abi_diff.cpp b/vndk/tools/header-checker/header-abi-diff/src/abi_diff.cpp
index 45aac64..7d21566 100644
--- a/vndk/tools/header-checker/header-abi-diff/src/abi_diff.cpp
+++ b/vndk/tools/header-checker/header-abi-diff/src/abi_diff.cpp
@@ -14,169 +14,262 @@
 
 #include "abi_diff.h"
 
+#include <header_abi_util.h>
+
 #include <llvm/Support/raw_ostream.h>
 
 #include <google/protobuf/text_format.h>
 #include <google/protobuf/io/zero_copy_stream_impl.h>
 
 #include <memory>
-#include <fstream>
-#include <iostream>
 #include <string>
 #include <vector>
 
 #include <stdlib.h>
 
-CompatibilityStatus HeaderAbiDiff::GenerateCompatibilityReport() {
-  abi_dump::TranslationUnit old_tu;
-  abi_dump::TranslationUnit new_tu;
-  std::ifstream old_input(old_dump_);
-  std::ifstream new_input(new_dump_);
-  google::protobuf::io::IstreamInputStream text_iso(&old_input);
-  google::protobuf::io::IstreamInputStream text_isn(&new_input);
-
-  if (!google::protobuf::TextFormat::Parse(&text_iso, &old_tu) ||
-      !google::protobuf::TextFormat::Parse(&text_isn, &new_tu)) {
-    llvm::errs() << "Failed to generate compatibility report\n";
+abi_util::CompatibilityStatusIR HeaderAbiDiff::GenerateCompatibilityReport() {
+  using abi_util::TextFormatToIRReader;
+  std::unique_ptr<abi_util::TextFormatToIRReader> old_reader =
+      TextFormatToIRReader::CreateTextFormatToIRReader("protobuf", old_dump_);
+  std::unique_ptr<abi_util::TextFormatToIRReader> new_reader =
+      TextFormatToIRReader::CreateTextFormatToIRReader("protobuf", new_dump_);
+  if (!old_reader || !new_reader || !old_reader->ReadDump() ||
+      !new_reader->ReadDump()) {
+    llvm::errs() << "Could not create Text Format readers\n";
     ::exit(1);
   }
-  return CompareTUs(old_tu, new_tu);
+  std::unique_ptr<abi_util::IRDiffDumper> ir_diff_dumper =
+      abi_util::IRDiffDumper::CreateIRDiffDumper("protobuf", cr_);
+  abi_util::CompatibilityStatusIR status =
+      CompareTUs(old_reader.get(), new_reader.get(), ir_diff_dumper.get());
+  if (!ir_diff_dumper->Dump()) {
+    llvm::errs() << "Could not dump diff report\n";
+    ::exit(1);
+  }
+  return status;
 }
 
-CompatibilityStatus HeaderAbiDiff::CompareTUs(
-    const abi_dump::TranslationUnit &old_tu,
-    const abi_dump::TranslationUnit &new_tu) {
-  std::unique_ptr<abi_diff::TranslationUnitDiff> diff_tu(
-      new abi_diff::TranslationUnitDiff);
-  CompatibilityStatus record_status = Collect<abi_dump::RecordDecl>(
-      diff_tu->mutable_records_added(), diff_tu->mutable_records_removed(),
-      diff_tu->mutable_records_diff(), old_tu.records(), new_tu.records(),
-      ignored_symbols_);
+template <typename F>
+static void AddTypesToMap(std::map<std::string, const abi_util::TypeIR *> *dst,
+                          const abi_util::TextFormatToIRReader *tu, F func) {
+  AddToMap(dst, tu->GetRecordTypes(), func);
+  AddToMap(dst, tu->GetEnumTypes(), func);
+  AddToMap(dst, tu->GetPointerTypes(), func);
+  AddToMap(dst, tu->GetBuiltinTypes(), func);
+  AddToMap(dst, tu->GetArrayTypes(), func);
+  AddToMap(dst, tu->GetLvalueReferenceTypes(), func);
+  AddToMap(dst, tu->GetRvalueReferenceTypes(), func);
+  AddToMap(dst, tu->GetQualifiedTypes(), func);
+}
 
-  CompatibilityStatus function_status = Collect<abi_dump::FunctionDecl>(
-      diff_tu->mutable_functions_added(), diff_tu->mutable_functions_removed(),
-      diff_tu->mutable_functions_diff(), old_tu.functions(),
-      new_tu.functions(), ignored_symbols_);
+abi_util::CompatibilityStatusIR HeaderAbiDiff::CompareTUs(
+    const abi_util::TextFormatToIRReader *old_tu,
+    const abi_util::TextFormatToIRReader *new_tu,
+    abi_util::IRDiffDumper *ir_diff_dumper) {
+  // Collect all old and new types in maps, so that we can refer to them by
+  // type name / linker_set_key later.
+  std::map<std::string, const abi_util::TypeIR *> old_types;
+  std::map<std::string, const abi_util::TypeIR *> new_types;
+  AddTypesToMap(&old_types, old_tu,
+                [](const abi_util::TypeIR *e) {return e->GetLinkerSetKey();});
+  AddTypesToMap(&new_types, new_tu,
+                [](const abi_util::TypeIR *e) {return e->GetLinkerSetKey();});
 
-  CompatibilityStatus enum_status = Collect<abi_dump::EnumDecl>(
-      diff_tu->mutable_enums_added(), diff_tu->mutable_enums_removed(),
-      diff_tu->mutable_enums_diff(), old_tu.enums(), new_tu.enums(),
-      ignored_symbols_);
-
-  CompatibilityStatus global_var_status = Collect<abi_dump::GlobalVarDecl>(
-      diff_tu->mutable_global_vars_added(),
-      diff_tu->mutable_global_vars_removed(),
-      diff_tu->mutable_global_vars_diff(), old_tu.global_vars(),
-      new_tu.global_vars(), ignored_symbols_);
-
-  CompatibilityStatus combined_status =
-      record_status | function_status | enum_status | global_var_status;
-
-  if (combined_status & CompatibilityStatus::INCOMPATIBLE) {
-    combined_status = CompatibilityStatus::INCOMPATIBLE;
-  } else if (combined_status & CompatibilityStatus::EXTENSION) {
-    combined_status = CompatibilityStatus::EXTENSION;
-  } else {
-    combined_status = CompatibilityStatus::COMPATIBLE;
-  }
-  diff_tu->set_compatibility_status(combined_status);
-  diff_tu->set_lib_name(lib_name_);
-  diff_tu->set_arch(arch_);
-  std::ofstream text_output(cr_);
-  google::protobuf::io::OstreamOutputStream text_os(&text_output);
-
-  if(!google::protobuf::TextFormat::Print(*diff_tu, &text_os)) {
-    llvm::errs() << "Unable to dump report\n";
+  // Collect fills in added, removed ,unsafe and safe function diffs.
+  if (!CollectDynsymExportables(old_tu->GetFunctions(), new_tu->GetFunctions(),
+                                old_tu->GetElfFunctions(),
+                                new_tu->GetElfFunctions(),
+                                old_types, new_types,
+                                ir_diff_dumper) ||
+      !CollectDynsymExportables(old_tu->GetGlobalVariables(),
+                                new_tu->GetGlobalVariables(),
+                                old_tu->GetElfObjects(),
+                                new_tu->GetElfObjects(),
+                                old_types, new_types,
+                                ir_diff_dumper)) {
+    llvm::errs() << "Unable to collect dynsym exportables\n";
     ::exit(1);
   }
+
+  // By the time this call is reached, all referenced types have been diffed.
+  // So all additional calls on ir_diff_dumper get DiffKind::Unreferenced.
+  if (check_all_apis_ && !CollectUserDefinedTypes(old_tu, new_tu, old_types,
+                                                  new_types, ir_diff_dumper)) {
+    llvm::errs() << "Unable to collect user defined types\n";
+    ::exit(1);
+  }
+
+  abi_util::CompatibilityStatusIR combined_status =
+      ir_diff_dumper->GetCompatibilityStatusIR();
+
+  ir_diff_dumper->AddLibNameIR(lib_name_);
+  ir_diff_dumper->AddArchIR(arch_);
+  ir_diff_dumper->AddCompatibilityStatusIR(combined_status);
   return combined_status;
 }
 
-template <typename T, typename TDiff>
-abi_diff::CompatibilityStatus HeaderAbiDiff::Collect(
-    google::protobuf::RepeatedPtrField<T> *elements_added,
-    google::protobuf::RepeatedPtrField<T> *elements_removed,
-    google::protobuf::RepeatedPtrField<TDiff> *elements_diff,
-    const google::protobuf::RepeatedPtrField<T> &old_srcs,
-    const google::protobuf::RepeatedPtrField<T> &new_srcs,
-    const std::set<std::string> &ignored_symbols) {
-  assert(elements_added != nullptr);
-  assert(elements_removed != nullptr);
-  assert(elements_diff != nullptr);
+bool HeaderAbiDiff::CollectUserDefinedTypes(
+    const abi_util::TextFormatToIRReader *old_tu,
+    const abi_util::TextFormatToIRReader *new_tu,
+    const std::map<std::string, const abi_util::TypeIR *> &old_types_map,
+    const std::map<std::string, const abi_util::TypeIR *> &new_types_map,
+    abi_util::IRDiffDumper *ir_diff_dumper) {
+  return CollectUserDefinedTypesInternal(
+      old_tu->GetRecordTypes(), new_tu->GetRecordTypes(), old_types_map,
+      new_types_map, ir_diff_dumper) &&
+      CollectUserDefinedTypesInternal(old_tu->GetEnumTypes(),
+                                      new_tu->GetEnumTypes(), old_types_map,
+                                      new_types_map, ir_diff_dumper);
+}
 
-  std::map<std::string, const T*> old_elements_map;
-  std::map<std::string, const T*> new_elements_map;
-  AddToMap(&old_elements_map, old_srcs);
-  AddToMap(&new_elements_map, new_srcs);
+template <typename T>
+bool HeaderAbiDiff::CollectUserDefinedTypesInternal(
+    const std::vector<T> &old_ud_types,
+    const std::vector<T> &new_ud_types,
+    const std::map<std::string, const abi_util::TypeIR *> &old_types_map,
+    const std::map<std::string, const abi_util::TypeIR *> &new_types_map,
+    abi_util::IRDiffDumper *ir_diff_dumper) {
+  // No elf information for records and enums.
+  std::map<std::string, const T *> old_ud_types_map;
+  std::map<std::string, const T *> new_ud_types_map;
 
-  if (!PopulateRemovedElements(elements_removed, old_elements_map,
-                               new_elements_map, ignored_symbols) ||
-      !PopulateRemovedElements(elements_added, new_elements_map,
-                               old_elements_map, ignored_symbols) ||
-      !PopulateCommonElements(elements_diff, old_elements_map,
-                              new_elements_map, ignored_symbols)) {
+  abi_util::AddToMap(&old_ud_types_map, old_ud_types,
+                     [](const T *e)
+                     { return e->GetLinkerSetKey();});
+
+  abi_util::AddToMap(&new_ud_types_map, new_ud_types,
+                     [](const T *e)
+                     { return e->GetLinkerSetKey();});
+
+  return Collect(old_ud_types_map, new_ud_types_map, nullptr, nullptr,
+                 ir_diff_dumper) &&
+      PopulateCommonElements(old_ud_types_map, new_ud_types_map, old_types_map,
+                             new_types_map, ir_diff_dumper,
+                             abi_util::IRDiffDumper::Unreferenced);
+}
+
+template <typename T, typename ElfSymbolType>
+bool HeaderAbiDiff::CollectDynsymExportables(
+    const std::vector<T> &old_exportables,
+    const std::vector<T> &new_exportables,
+    const std::vector<ElfSymbolType> &old_elf_symbols,
+    const std::vector<ElfSymbolType> &new_elf_symbols,
+    const std::map<std::string, const abi_util::TypeIR *> &old_types_map,
+    const std::map<std::string, const abi_util::TypeIR *> &new_types_map,
+    abi_util::IRDiffDumper *ir_diff_dumper) {
+  std::map<std::string, const T *> old_exportables_map;
+  std::map<std::string, const T *> new_exportables_map;
+  std::map<std::string, const abi_util::ElfSymbolIR *> old_elf_symbol_map;
+  std::map<std::string, const abi_util::ElfSymbolIR *> new_elf_symbol_map;
+
+  abi_util::AddToMap(&old_exportables_map, old_exportables,
+                     [](const T *e)
+                     { return e->GetLinkerSetKey();});
+  abi_util::AddToMap(&new_exportables_map, new_exportables,
+                     [](const T *e)
+                     { return e->GetLinkerSetKey();});
+  abi_util::AddToMap(
+      &old_elf_symbol_map, old_elf_symbols,
+      [](const ElfSymbolType *symbol) { return symbol->GetName();});
+  abi_util::AddToMap(
+      &new_elf_symbol_map, new_elf_symbols,
+      [](const ElfSymbolType *symbol) { return symbol->GetName();});
+
+  if (!Collect(old_exportables_map,
+               new_exportables_map, &old_elf_symbol_map, &new_elf_symbol_map,
+               ir_diff_dumper) ||
+      !CollectElfSymbols(old_elf_symbol_map, new_elf_symbol_map,
+                         ir_diff_dumper) ||
+      !PopulateCommonElements(old_exportables_map, new_exportables_map,
+                              old_types_map, new_types_map, ir_diff_dumper,
+                              abi_util::IRDiffDumper::Referenced)) {
+    llvm::errs() << "Diffing dynsym exportables failed\n";
+    return false;
+  }
+  return true;
+}
+
+// Collect added and removed Elements. The elf set is needed since some symbols
+// might not have meta-data about them collected through the AST. For eg: if a
+// function Foo is defined in an assembly file on target A, but in a c/c++ file
+// on target B, foo does not have meta-data surrounding it when building target
+// A, this does not mean it is not in the ABI + API of the library.
+
+template <typename T>
+bool HeaderAbiDiff::Collect(
+    const std::map<std::string, const T*> &old_elements_map,
+    const std::map<std::string, const T*> &new_elements_map,
+    const std::map<std::string, const abi_util::ElfSymbolIR *> *old_elf_map,
+    const std::map<std::string, const abi_util::ElfSymbolIR *> *new_elf_map,
+    abi_util::IRDiffDumper *ir_diff_dumper) {
+  if (!PopulateRemovedElements(
+      old_elements_map, new_elements_map, new_elf_map, ir_diff_dumper,
+      abi_util::IRDiffDumper::Removed) ||
+      !PopulateRemovedElements(new_elements_map, old_elements_map, old_elf_map,
+                               ir_diff_dumper,
+                               abi_util::IRDiffDumper::DiffKind::Added)) {
     llvm::errs() << "Populating functions in report failed\n";
-    ::exit(1);
+    return false;
   }
-  if (elements_diff->size() || elements_removed->size()) {
-    return CompatibilityStatus::INCOMPATIBLE;
+  return true;
+}
+
+bool HeaderAbiDiff::CollectElfSymbols(
+    const std::map<std::string, const abi_util::ElfSymbolIR *> &old_symbols,
+    const std::map<std::string, const abi_util::ElfSymbolIR *> &new_symbols,
+    abi_util::IRDiffDumper *ir_diff_dumper) {
+  std::vector<const abi_util::ElfSymbolIR *> removed_elements =
+      abi_util::FindRemovedElements(old_symbols, new_symbols);
+
+  std::vector<const abi_util::ElfSymbolIR *> added_elements =
+      abi_util::FindRemovedElements(new_symbols, old_symbols);
+
+  return PopulateElfElements(removed_elements, ir_diff_dumper,
+                             abi_util::IRDiffDumper::DiffKind::Removed) &&
+         PopulateElfElements(added_elements, ir_diff_dumper,
+                             abi_util::IRDiffDumper::DiffKind::Added);
+}
+
+bool HeaderAbiDiff::PopulateElfElements(
+    std::vector<const abi_util::ElfSymbolIR *> &elf_elements,
+    abi_util::IRDiffDumper *ir_diff_dumper,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  for (auto &&elf_element : elf_elements) {
+    if (!ir_diff_dumper->AddElfSymbolMessageIR(elf_element, diff_kind)) {
+      return false;
+    }
   }
-  if (elements_added->size()) {
-    return CompatibilityStatus::EXTENSION;
-  }
-  return CompatibilityStatus::COMPATIBLE;
+  return true;
 }
 
 template <typename T>
 bool HeaderAbiDiff::PopulateRemovedElements(
-    google::protobuf::RepeatedPtrField<T> *dst,
     const std::map<std::string, const T*> &old_elements_map,
     const std::map<std::string, const T*> &new_elements_map,
-    const std::set<std::string> &ignored_symbols) {
-
-  std::vector<const T *> removed_elements;
-  for (auto &&map_element : old_elements_map) {
-      const T *element = map_element.second;
-      auto new_element =
-          new_elements_map.find(element->basic_abi().linker_set_key());
-      if (new_element == new_elements_map.end()) {
-        removed_elements.emplace_back(element);
-      }
-  }
-  if (!DumpLoneElements(dst, removed_elements, ignored_symbols)) {
+    const std::map<std::string, const abi_util::ElfSymbolIR *> *elf_map,
+    abi_util::IRDiffDumper *ir_diff_dumper,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  std::vector<const T *> removed_elements =
+      abi_util::FindRemovedElements(old_elements_map, new_elements_map);
+  if (!DumpLoneElements(removed_elements, elf_map, ir_diff_dumper, diff_kind)) {
     llvm::errs() << "Dumping added / removed element to report failed\n";
     return false;
   }
   return true;
 }
 
-template <typename T, typename TDiff>
+template <typename T>
 bool HeaderAbiDiff::PopulateCommonElements(
-    google::protobuf::RepeatedPtrField<TDiff> *dst,
     const std::map<std::string, const T *> &old_elements_map,
     const std::map<std::string, const T *> &new_elements_map,
-    const std::set<std::string> &ignored_symbols) {
-  std::vector<std::pair<const T *, const T *>> common_elements;
-  typename std::map<std::string, const T *>::const_iterator old_element =
-      old_elements_map.begin();
-  typename std::map<std::string, const T *>::const_iterator new_element =
-      new_elements_map.begin();
-  while (old_element != old_elements_map.end() &&
-         new_element != new_elements_map.end()) {
-    if (old_element->first == new_element->first) {
-      common_elements.emplace_back(std::make_pair(
-          old_element->second, new_element->second));
-      old_element++;
-      new_element++;
-      continue;
-    }
-    if (old_element->first < new_element->first) {
-      old_element++;
-    } else {
-      new_element++;
-    }
-  }
-  if (!DumpDiffElements(dst, common_elements, ignored_symbols)) {
+    const std::map<std::string, const abi_util::TypeIR *> &old_types,
+    const std::map<std::string, const abi_util::TypeIR *> &new_types,
+    abi_util::IRDiffDumper *ir_diff_dumper,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  std::vector<std::pair<const T *, const T *>> common_elements =
+      abi_util::FindCommonElements(old_elements_map, new_elements_map);
+  if (!DumpDiffElements(common_elements, old_types, new_types,
+                        ir_diff_dumper, diff_kind)) {
     llvm::errs() << "Dumping difference in common element to report failed\n";
     return false;
   }
@@ -185,48 +278,62 @@
 
 template <typename T>
 bool HeaderAbiDiff::DumpLoneElements(
-    google::protobuf::RepeatedPtrField<T> *dst,
     std::vector<const T *> &elements,
-    const std::set<std::string> &ignored_symbols) {
+    const std::map<std::string, const abi_util::ElfSymbolIR *> *elf_map,
+    abi_util::IRDiffDumper *ir_diff_dumper,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  // If the record / enum has source file information, skip it.
+  std::smatch source_file_match;
+  std::regex source_file_regex(" at ");
   for (auto &&element : elements) {
-    if (abi_diff_wrappers::IgnoreSymbol<T>(element, ignored_symbols)) {
+    if (abi_diff_wrappers::IgnoreSymbol<T>(
+        element, ignored_symbols_,
+        [](const T *e) {return e->GetLinkerSetKey();})) {
       continue;
     }
-    T *added_element = dst->Add();
-    if (!added_element) {
-      llvm::errs() << "Adding element diff failed\n";
+    // The element does exist in the .dynsym table, we do not have meta-data
+    // surrounding the element.
+    const std::string &element_linker_set_key = element->GetLinkerSetKey();
+    if ((elf_map != nullptr) &&
+        (elf_map->find(element_linker_set_key) != elf_map->end())) {
+      continue;
+    }
+    if (std::regex_search(element_linker_set_key, source_file_match,
+                          source_file_regex)) {
+      continue;
+    }
+    if (!ir_diff_dumper->AddLinkableMessageIR(element, diff_kind)) {
+      llvm::errs() << "Couldn't dump added /removed element\n";
       return false;
     }
-    *added_element = *element;
   }
   return true;
 }
 
-template <typename T, typename TDiff>
+
+template <typename T>
 bool HeaderAbiDiff::DumpDiffElements(
-    google::protobuf::RepeatedPtrField<TDiff>  *dst,
     std::vector<std::pair<const T *,const T *>> &pairs,
-    const std::set<std::string> &ignored_symbols) {
+    const std::map<std::string, const abi_util::TypeIR *> &old_types,
+    const std::map<std::string, const abi_util::TypeIR *> &new_types,
+    abi_util::IRDiffDumper *ir_diff_dumper,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
   for (auto &&pair : pairs) {
     const T *old_element = pair.first;
     const T *new_element = pair.second;
-    // Not having inheritance from protobuf messages makes this
-    // restrictive code.
-    if (abi_diff_wrappers::IgnoreSymbol<T>(old_element, ignored_symbols)) {
+
+    if (abi_diff_wrappers::IgnoreSymbol<T>(
+        old_element, ignored_symbols_,
+        [](const T *e) {return e->GetLinkerSetKey();})) {
       continue;
     }
-    abi_diff_wrappers::DiffWrapper<T, TDiff> diff_wrapper(old_element,
-                                                          new_element);
-    std::unique_ptr<TDiff> decl_diff_ptr = diff_wrapper.Get();
-    if (!decl_diff_ptr) {
-      continue;
-    }
-    TDiff *added_element_diff = dst->Add();
-    if (!added_element_diff) {
-      llvm::errs() << "Adding element diff failed\n";
+    abi_diff_wrappers::DiffWrapper<T> diff_wrapper(old_element, new_element,
+                                                   ir_diff_dumper, old_types,
+                                                   new_types, &type_cache_);
+    if (!diff_wrapper.DumpDiff(diff_kind)) {
+      llvm::errs() << "Failed to diff elements\n";
       return false;
     }
-    *added_element_diff = *decl_diff_ptr;
   }
   return true;
 }
diff --git a/vndk/tools/header-checker/header-abi-diff/src/abi_diff.h b/vndk/tools/header-checker/header-abi-diff/src/abi_diff.h
index df8a6d1..3cabc8b 100644
--- a/vndk/tools/header-checker/header-abi-diff/src/abi_diff.h
+++ b/vndk/tools/header-checker/header-abi-diff/src/abi_diff.h
@@ -14,6 +14,8 @@
 
 #include "abi_diff_wrappers.h"
 
+#include <ir_representation.h>
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
 #pragma clang diagnostic ignored "-Wnested-anon-types"
@@ -21,68 +23,102 @@
 #include "proto/abi_diff.pb.h"
 #pragma clang diagnostic pop
 
-#include <memory>
-#include <fstream>
-#include <iostream>
 #include <string>
 #include <vector>
 
-
-typedef abi_diff::CompatibilityStatus CompatibilityStatus;
-
 class HeaderAbiDiff {
  public:
   HeaderAbiDiff(const std::string &lib_name, const std::string &arch,
                 const std::string &old_dump, const std::string &new_dump,
                 const std::string &compatibility_report,
-                const std::set<std::string> &ignored_symbols)
+                const std::set<std::string> &ignored_symbols,
+                bool check_all_apis)
       : lib_name_(lib_name), arch_(arch), old_dump_(old_dump),
         new_dump_(new_dump), cr_(compatibility_report),
-      ignored_symbols_(ignored_symbols) { }
+        ignored_symbols_(ignored_symbols), check_all_apis_(check_all_apis) { }
 
-  CompatibilityStatus GenerateCompatibilityReport();
+  abi_util::CompatibilityStatusIR GenerateCompatibilityReport();
 
  private:
-  CompatibilityStatus CompareTUs(const abi_dump::TranslationUnit &old_tu,
-                                 const abi_dump::TranslationUnit &new_tu);
-  // Collect* methods fill in the diff_tu.
-  template <typename T, typename TDiff>
-  static CompatibilityStatus Collect(
-      google::protobuf::RepeatedPtrField<T> *elements_added,
-      google::protobuf::RepeatedPtrField<T> *elements_removed,
-      google::protobuf::RepeatedPtrField<TDiff> *elements_diff,
-      const google::protobuf::RepeatedPtrField<T> &old_srcs,
-      const google::protobuf::RepeatedPtrField<T> &new_srcs,
-      const std::set<std::string> &ignored_symbols);
+  abi_util::CompatibilityStatusIR CompareTUs(
+      const abi_util::TextFormatToIRReader *old_tu,
+      const abi_util::TextFormatToIRReader *new_tu,
+      abi_util::IRDiffDumper *ir_diff_dumper);
+
+  template <typename T, typename ElfSymbolType>
+  bool CollectDynsymExportables(
+    const std::vector<T> &old_exportables,
+    const std::vector<T> &new_exportables,
+    const std::vector<ElfSymbolType> &old_elf_symbols,
+    const std::vector<ElfSymbolType> &new_elf_symbols,
+    const std::map<std::string, const abi_util::TypeIR *> &old_types_map,
+    const std::map<std::string, const abi_util::TypeIR *> &new_types_map,
+    abi_util::IRDiffDumper *ir_diff_dumper);
 
   template <typename T>
-  static inline void AddToMap(std::map<std::string, const T *> *dst,
-                              const google::protobuf::RepeatedPtrField<T> &src);
+  bool Collect(
+      const std::map<std::string, const T *> &old_elements_map,
+      const std::map<std::string, const T *> &new_elements_map,
+      const std::map<std::string, const abi_util::ElfSymbolIR *> *old_elf_map,
+      const std::map<std::string, const abi_util::ElfSymbolIR *> *new_elf_map,
+      abi_util::IRDiffDumper *ir_diff_dumper);
+
+  bool CollectElfSymbols(
+      const std::map<std::string, const abi_util::ElfSymbolIR *> &old_symbols,
+      const std::map<std::string, const abi_util::ElfSymbolIR *> &new_symbols,
+      abi_util::IRDiffDumper *ir_diff_dumper);
+
+  bool PopulateElfElements(
+      std::vector<const abi_util::ElfSymbolIR *> &elf_elements,
+      abi_util::IRDiffDumper *ir_diff_dumper,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
 
   template <typename T>
-  static bool PopulateRemovedElements(
-      google::protobuf::RepeatedPtrField<T> *dst,
+  bool PopulateRemovedElements(
       const std::map<std::string, const T *> &old_elements_map,
       const std::map<std::string, const T *> &new_elements_map,
-      const std::set<std::string> &ignored_symbols);
+      const std::map<std::string, const abi_util::ElfSymbolIR *> *elf_map,
+      abi_util::IRDiffDumper *ir_diff_dumper,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
 
-  template <typename T, typename TDiff>
-  static bool PopulateCommonElements(
-      google::protobuf::RepeatedPtrField<TDiff> *dst,
+  template <typename T>
+  bool PopulateCommonElements(
       const std::map<std::string, const T *> &old_elements_map,
       const std::map<std::string, const T *> &new_elements_map,
-      const std::set<std::string> &ignored_symbols);
+      const std::map<std::string, const abi_util::TypeIR *> &old_types,
+      const std::map<std::string, const abi_util::TypeIR *> &new_types,
+      abi_util::IRDiffDumper *ir_diff_dumper,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
 
-  template <typename T, typename TDiff>
-  static bool DumpDiffElements(
-      google::protobuf::RepeatedPtrField<TDiff> *dst,
+  template <typename T>
+  bool DumpDiffElements(
       std::vector<std::pair<const T *, const T *>> &pairs,
-      const std::set<std::string> &ignored_symbols);
+      const std::map<std::string, const abi_util::TypeIR *> &old_types,
+      const std::map<std::string, const abi_util::TypeIR *> &new_types,
+      abi_util::IRDiffDumper *ir_diff_dumper,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
 
   template <typename T>
-  static bool DumpLoneElements(google::protobuf::RepeatedPtrField<T> *dst,
-                               std::vector<const T *> &elements,
-                               const std::set<std::string> &ignored_symbols);
+  bool DumpLoneElements(
+      std::vector<const T *> &elements,
+      const std::map<std::string, const abi_util::ElfSymbolIR *> *elf_map,
+      abi_util::IRDiffDumper *ir_diff_dumper,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
+
+  bool CollectUserDefinedTypes(
+      const abi_util::TextFormatToIRReader *old_tu,
+      const abi_util::TextFormatToIRReader *new_tu,
+      const std::map<std::string, const abi_util::TypeIR *> &old_types_map,
+      const std::map<std::string, const abi_util::TypeIR *> &new_types_map,
+      abi_util::IRDiffDumper *ir_diff_dumper);
+
+  template <typename T>
+  bool CollectUserDefinedTypesInternal(
+      const std::vector<T> &old_ud_types,
+      const std::vector<T> &new_ud_types,
+      const std::map<std::string, const abi_util::TypeIR *> &old_types_map,
+      const std::map<std::string, const abi_util::TypeIR *> &new_types_map,
+      abi_util::IRDiffDumper *ir_diff_dumper);
 
  private:
   const std::string &lib_name_;
@@ -91,27 +127,6 @@
   const std::string &new_dump_;
   const std::string &cr_;
   const std::set<std::string> &ignored_symbols_;
+  bool check_all_apis_;
+  std::set<std::string> type_cache_;
 };
-
-template <typename T>
-inline void HeaderAbiDiff::AddToMap(
-    std::map<std::string, const T *> *dst,
-    const google::protobuf::RepeatedPtrField<T> &src) {
-  for (auto &&element : src) {
-    dst->insert(std::make_pair(element.basic_abi().linker_set_key(), &element));
-  }
-}
-
-static inline CompatibilityStatus operator|(CompatibilityStatus f,
-                                            CompatibilityStatus s) {
-  return static_cast<CompatibilityStatus>(
-      static_cast<std::underlying_type<CompatibilityStatus>::type>(f) |
-      static_cast<std::underlying_type<CompatibilityStatus>::type>(s));
-}
-
-static inline CompatibilityStatus operator&(
-    CompatibilityStatus f, CompatibilityStatus s) {
-  return static_cast<CompatibilityStatus>(
-      static_cast<std::underlying_type<CompatibilityStatus>::type>(f) &
-      static_cast<std::underlying_type<CompatibilityStatus>::type>(s));
-}
diff --git a/vndk/tools/header-checker/header-abi-diff/src/abi_diff_wrappers.cpp b/vndk/tools/header-checker/header-abi-diff/src/abi_diff_wrappers.cpp
index e75d4ce..e9a0047 100644
--- a/vndk/tools/header-checker/header-abi-diff/src/abi_diff_wrappers.cpp
+++ b/vndk/tools/header-checker/header-abi-diff/src/abi_diff_wrappers.cpp
@@ -14,52 +14,23 @@
 
 #include "abi_diff_wrappers.h"
 
-#include<header_abi_util.h>
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunused-parameter"
-#pragma clang diagnostic ignored "-Wnested-anon-types"
-#include "proto/abi_dump.pb.h"
-#include "proto/abi_diff.pb.h"
-#pragma clang diagnostic pop
+#include <header_abi_util.h>
 
 #include <llvm/Support/raw_ostream.h>
 
-using abi_diff::RecordDeclDiff;
-using abi_diff::RecordFieldDeclDiff;
-using abi_diff::CXXBaseSpecifierDiff;
-using abi_diff::CXXVTableDiff;
-using abi_diff::EnumDeclDiff;
-using abi_diff::ReturnTypeDiff;
-using abi_diff::ParamDeclDiff;
-using abi_diff::FunctionDeclDiff;
-using abi_diff::EnumDeclDiff;
-using abi_diff::EnumFieldDeclDiff;
-using abi_diff::GlobalVarDeclDiff;
-using abi_dump::RecordDecl;
-using abi_dump::RecordFieldDecl;
-using abi_dump::EnumDecl;
-using abi_dump::EnumFieldDecl;
-using abi_dump::FunctionDecl;
-using abi_dump::ParamDecl;
-using abi_dump::VTableComponent;
-using abi_dump::CXXBaseSpecifier;
-using abi_dump::GlobalVarDecl;
-using abi_dump::BasicNamedAndTypedDecl;
-
 namespace abi_diff_wrappers {
 
-static bool IsAccessDownGraded(abi_dump::AccessSpecifier old_access,
-                               abi_dump::AccessSpecifier new_access) {
+static bool IsAccessDownGraded(abi_util::AccessSpecifierIR old_access,
+                               abi_util::AccessSpecifierIR new_access) {
   bool access_downgraded = false;
   switch (old_access) {
-    case abi_dump::AccessSpecifier::protected_access:
-      if (new_access == abi_dump::AccessSpecifier::private_access) {
+    case abi_util::AccessSpecifierIR::ProtectedAccess:
+      if (new_access == abi_util::AccessSpecifierIR::PrivateAccess) {
         access_downgraded = true;
       }
       break;
-    case abi_dump::AccessSpecifier::public_access:
-      if (new_access != abi_dump::AccessSpecifier::public_access) {
+    case abi_util::AccessSpecifierIR::PublicAccess:
+      if (new_access != abi_util::AccessSpecifierIR::PublicAccess) {
         access_downgraded = true;
       }
       break;
@@ -69,255 +40,590 @@
   return access_downgraded;
 }
 
-static std::string CpptoCAdjustment(const std::string &type) {
-  std::string adjusted_type_name =
-      abi_util::FindAndReplace(type, "\\bstruct ", "");
-
-  return adjusted_type_name;
+static std::string Unwind(const std::deque<std::string> *type_queue) {
+  if (!type_queue) {
+    return "";
+  }
+  std::string stack_str;
+  std::deque<std::string> type_queue_copy = *type_queue;
+  while (!type_queue_copy.empty()) {
+    stack_str += type_queue_copy.front() + "-> ";
+    type_queue_copy.pop_front();
+  }
+  return stack_str;
 }
 
-static bool CompareTypeNames(const abi_dump::BasicTypeAbi &old_abi,
-                             const abi_dump::BasicTypeAbi &new_abi) {
-  // Strip of leading 'struct' keyword from type names
-  std::string old_type = old_abi.name();
-  std::string new_type = new_abi.name();
-  old_type = CpptoCAdjustment(old_type);
-  new_type = CpptoCAdjustment(new_type);
-  // TODO: Add checks for C++ built-in types vs C corresponding types.
-  return old_type != new_type;
+void DiffWrapperBase::CompareEnumFields(
+    const std::vector<abi_util::EnumFieldIR> &old_fields,
+    const std::vector<abi_util::EnumFieldIR> &new_fields,
+    abi_util::EnumTypeDiffIR *enum_type_diff_ir) {
+  std::map<std::string, const abi_util::EnumFieldIR *> old_fields_map;
+  std::map<std::string, const abi_util::EnumFieldIR *> new_fields_map;
+  abi_util::AddToMap(&old_fields_map, old_fields,
+                     [](const abi_util::EnumFieldIR *f)
+                     {return f->GetName();});
+  abi_util::AddToMap(&new_fields_map, new_fields,
+                     [](const abi_util::EnumFieldIR *f)
+                     {return f->GetName();});
+  std::vector<const abi_util::EnumFieldIR *> removed_fields =
+      abi_util::FindRemovedElements(old_fields_map, new_fields_map);
+
+  std::vector<const abi_util::EnumFieldIR *> added_fields =
+      abi_util::FindRemovedElements(new_fields_map, old_fields_map);
+
+  enum_type_diff_ir->SetFieldsAdded(std::move(added_fields));
+
+  enum_type_diff_ir->SetFieldsRemoved(std::move(removed_fields));
+
+  std::vector<std::pair<
+      const abi_util::EnumFieldIR *, const abi_util::EnumFieldIR *>> cf =
+      abi_util::FindCommonElements(old_fields_map, new_fields_map);
+  std::vector<abi_util::EnumFieldDiffIR> enum_field_diffs;
+  for (auto &&common_fields : cf) {
+    if (common_fields.first->GetValue() != common_fields.second->GetValue()) {
+      abi_util::EnumFieldDiffIR enum_field_diff_ir(common_fields.first,
+                                                   common_fields.second);
+      enum_field_diffs.emplace_back(std::move(enum_field_diff_ir));
+    }
+  }
+  enum_type_diff_ir->SetFieldsDiff(std::move(enum_field_diffs));
 }
 
-static bool DiffBasicTypeAbi(const abi_dump::BasicTypeAbi &old_abi,
-                             const abi_dump::BasicTypeAbi &new_abi) {
-  // We need to add a layer of indirection to account for issues when C and C++
-  // are mixed. For example some types like wchar_t are in-built types for C++
-  // but not for C. Another example would be clang reporting C structures
-  // without the leading "struct" keyword when headers defining them are
-  // included in C++ files.
-  bool name_comparison = CompareTypeNames(old_abi, new_abi);
-  bool size_comparison = (old_abi.size() != new_abi.size());
-  bool alignment_comparison = (old_abi.alignment() != new_abi.alignment());
-  return name_comparison || size_comparison || alignment_comparison;
+DiffStatus DiffWrapperBase::CompareEnumTypes(
+    const abi_util::EnumTypeIR *old_type, const abi_util::EnumTypeIR *new_type,
+     std::deque<std::string> *type_queue,
+     abi_util::IRDiffDumper::DiffKind diff_kind) {
+  if (old_type->GetName() != new_type->GetName()) {
+    return DiffStatus::direct_diff;
+  }
+  auto enum_type_diff_ir = std::make_unique<abi_util::EnumTypeDiffIR>();
+  enum_type_diff_ir->SetName(old_type->GetName());
+  const std::string &old_underlying_type = old_type->GetUnderlyingType();
+  const std::string &new_underlying_type = new_type->GetUnderlyingType();
+  if (old_underlying_type != new_underlying_type) {
+    enum_type_diff_ir->SetUnderlyingTypeDiff(
+        std::make_unique<std::pair<std::string, std::string>>(
+            old_underlying_type, new_underlying_type));
+  }
+  CompareEnumFields(old_type->GetFields(), new_type->GetFields(),
+                    enum_type_diff_ir.get());
+  if ((enum_type_diff_ir->IsExtended() ||
+       enum_type_diff_ir->IsIncompatible()) &&
+      !ir_diff_dumper_->AddDiffMessageIR(enum_type_diff_ir.get(),
+                                         Unwind(type_queue), diff_kind)) {
+    llvm::errs() << "AddDiffMessage on EnumTypeDiffIR failed\n";
+    ::exit(1);
+  }
+  return DiffStatus::no_diff;
 }
 
-template <typename T>
-static bool Diff(const T &old_element, const T &new_element) {
-  // Can be specialized for future changes in the format.
-  return DiffBasicTypeAbi(old_element.basic_abi().type_abi(),
-                          new_element.basic_abi().type_abi()) ||
-      (old_element.basic_abi().name() != new_element.basic_abi().name()) ||
-      IsAccessDownGraded(old_element.basic_abi().access(),
-                         new_element.basic_abi().access());
+bool DiffWrapperBase::CompareVTableComponents(
+    const abi_util::VTableComponentIR &old_component,
+    const abi_util::VTableComponentIR &new_component) {
+  return old_component.GetName() == new_component.GetName() &&
+      old_component.GetValue() == new_component.GetValue() &&
+      old_component.GetKind() == new_component.GetKind();
 }
 
-template <>
-bool Diff<EnumFieldDecl>(const EnumFieldDecl &old_element,
-                         const EnumFieldDecl &new_element) {
-  // Can be specialized for future changes in the format.
-  return DiffBasicTypeAbi(old_element.basic_abi().type_abi(),
-                          new_element.basic_abi().type_abi()) ||
-      (old_element.enum_field_value() != new_element.enum_field_value()) ||
-      (old_element.basic_abi().name() != new_element.basic_abi().name());
+bool DiffWrapperBase::CompareVTables(
+    const abi_util::RecordTypeIR *old_record,
+    const abi_util::RecordTypeIR *new_record) {
+
+  const std::vector<abi_util::VTableComponentIR> &old_components =
+      old_record->GetVTableLayout().GetVTableComponents();
+  const std::vector<abi_util::VTableComponentIR> &new_components =
+      new_record->GetVTableLayout().GetVTableComponents();
+  if (old_components.size() > new_components.size()) {
+    // Something in the vtable got deleted.
+    return false;
+  }
+  uint32_t i = 0;
+  while (i < old_components.size()) {
+    auto &old_element = old_components.at(i);
+    auto &new_element = new_components.at(i);
+    if (!CompareVTableComponents(old_element, new_element)) {
+      return false;
+    }
+    i++;
+  }
+  return true;
 }
 
-template <>
-bool Diff<ParamDecl>(const ParamDecl &old_element,
-                     const ParamDecl &new_element) {
-  // Can be specialized for future changes in the format.
-  return DiffBasicTypeAbi(old_element.basic_abi().type_abi(),
-                          new_element.basic_abi().type_abi());
+bool DiffWrapperBase::CompareSizeAndAlignment(
+    const abi_util::TypeIR *old_type,
+    const abi_util::TypeIR *new_type) {
+  return old_type->GetSize() == new_type->GetSize() &&
+      old_type->GetAlignment() == new_type->GetAlignment();
 }
 
-template <>
-bool Diff<CXXBaseSpecifier>(const CXXBaseSpecifier &old_element,
-                            const CXXBaseSpecifier &new_element) {
-  // Can be specialized for future changes in the format.
-  return (DiffBasicTypeAbi(old_element.basic_abi().type_abi(),
-                           new_element.basic_abi().type_abi()) ||
-      old_element.basic_abi().access() != new_element.basic_abi().access() ||
-      old_element.is_virtual() != new_element.is_virtual());
+std::unique_ptr<abi_util::RecordFieldDiffIR>
+DiffWrapperBase::CompareCommonRecordFields(
+    const abi_util::RecordFieldIR *old_field,
+    const abi_util::RecordFieldIR *new_field,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  if (old_field->GetOffset() != new_field->GetOffset() ||
+      // TODO: Should this be an inquality check instead ? Some compilers can
+      // make signatures dependant on absolute values of access specifiers.
+      IsAccessDownGraded(old_field->GetAccess(), new_field->GetAccess()) ||
+      CompareAndDumpTypeDiff(old_field->GetReferencedType(),
+                             new_field->GetReferencedType(),
+                             type_queue, diff_kind) ==
+      DiffStatus::direct_diff) {
+    return std::make_unique<abi_util::RecordFieldDiffIR>(old_field, new_field);
+  }
+  return nullptr;
 }
 
-template <>
-bool Diff<VTableComponent>(const VTableComponent &old_element,
-                           const VTableComponent &new_element) {
-  bool kind_comparison = old_element.kind() != new_element.kind();
-  bool mangled_name_comparison = old_element.mangled_component_name() !=
-      new_element.mangled_component_name();
-  bool value_comparison =
-      old_element.component_value() != new_element.component_value();
-  return kind_comparison || mangled_name_comparison || value_comparison;
+std::pair<std::vector<abi_util::RecordFieldDiffIR>,
+    std::vector<const abi_util::RecordFieldIR *>>
+DiffWrapperBase::CompareRecordFields(
+    const std::vector<abi_util::RecordFieldIR> &old_fields,
+    const std::vector<abi_util::RecordFieldIR> &new_fields,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  std::pair<std::vector<abi_util::RecordFieldDiffIR>,
+  std::vector<const abi_util::RecordFieldIR *>> diffed_and_removed_fields;
+  std::map<std::string, const abi_util::RecordFieldIR *> old_fields_map;
+  std::map<std::string, const abi_util::RecordFieldIR *> new_fields_map;
+  std::map<uint64_t, const abi_util::RecordFieldIR *> old_fields_offset_map;
+  std::map<uint64_t, const abi_util::RecordFieldIR *> new_fields_offset_map;
+
+  abi_util::AddToMap(&old_fields_map, old_fields,
+                     [](const abi_util::RecordFieldIR *f)
+                     {return f->GetName();});
+  abi_util::AddToMap(&new_fields_map, new_fields,
+                     [](const abi_util::RecordFieldIR *f)
+                     {return f->GetName();});
+  abi_util::AddToMap(&old_fields_offset_map, old_fields,
+                     [](const abi_util::RecordFieldIR *f)
+                     {return f->GetOffset();});
+  abi_util::AddToMap(&new_fields_offset_map, new_fields,
+                     [](const abi_util::RecordFieldIR *f)
+                     {return f->GetOffset();});
+  // If a field is removed from the map field_name -> offset see if another
+  // field is present at the same offset and compare the size and type etc,
+  // remove it from the removed fields if they're compatible.
+  std::vector<const abi_util::RecordFieldIR *> removed_fields =
+      abi_util::FindRemovedElements(old_fields_map, new_fields_map);
+  uint32_t i = 0;
+  for (auto &&removed_field : removed_fields) {
+    // For the removed field, get the corresponding offset from the old map.
+    // Compare the fields from old map and new map if there's a direct diff,
+    // continue, otherwise remove that field from the removed fields map.
+    uint64_t old_field_offset = removed_field->GetOffset();
+    auto corresponding_field_at_same_offset =
+        new_fields_offset_map.find(old_field_offset);
+    // Correctly reported as removed.
+    if (corresponding_field_at_same_offset == new_fields_offset_map.end()) {
+      continue;
+    }
+    auto comparison_result = CompareCommonRecordFields(
+        removed_field, corresponding_field_at_same_offset->second,
+        type_queue, diff_kind);
+    if (comparison_result != nullptr) {
+      continue;
+    }
+    removed_fields.erase(removed_fields.begin() + i);
+    i++;
+  }
+  diffed_and_removed_fields.second = std::move(removed_fields);
+  std::vector<std::pair<
+      const abi_util::RecordFieldIR *, const abi_util::RecordFieldIR *>> cf =
+      abi_util::FindCommonElements(old_fields_map, new_fields_map);
+  for (auto &&common_fields : cf) {
+    std::unique_ptr<abi_util::RecordFieldDiffIR> diffed_field_ptr =
+        CompareCommonRecordFields(common_fields.first, common_fields.second,
+                                  type_queue, diff_kind);
+    if (diffed_field_ptr != nullptr) {
+      diffed_and_removed_fields.first.emplace_back(
+          std::move(*(diffed_field_ptr.release())));
+    }
+  }
+  return diffed_and_removed_fields;
 }
 
-// This function fills in a *Diff Message's repeated field. For eg:
-// RecordDeclDiff's CXXBaseSpecifierDiff fields and well as FieldDeclDiff
-// fields.
-template <typename T, typename TDiff>
-template <typename Element, typename ElementDiff>
-bool DiffWrapperBase<T, TDiff>::GetElementDiffs(
-    google::protobuf::RepeatedPtrField<ElementDiff> *dst,
-    const google::protobuf::RepeatedPtrField<Element> &old_elements,
-    const google::protobuf::RepeatedPtrField<Element> &new_elements) {
-  bool differs = false;
-  assert(dst != nullptr);
+bool DiffWrapperBase::CompareBaseSpecifiers(
+    const std::vector<abi_util::CXXBaseSpecifierIR> &old_base_specifiers,
+    const std::vector<abi_util::CXXBaseSpecifierIR> &new_base_specifiers,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  if (old_base_specifiers.size() != new_base_specifiers.size()) {
+    return false;
+  }
   int i = 0;
-  int j = 0;
-  while (i < old_elements.size() && j < new_elements.size()) {
-    const Element &old_element = old_elements.Get(i);
-    const Element &new_element = new_elements.Get(i);
-
-    if (Diff(old_element, new_element)) {
-      ElementDiff *diff = dst->Add();
-      Element *old_elementp = nullptr;
-      Element *new_elementp = nullptr;
-      if (!diff || !(old_elementp = diff->mutable_old()) ||
-          !(new_elementp = diff->mutable_new_())) {
-        llvm::errs() << "Failed to add diff element\n";
-        ::exit(1);
-      }
-      *old_elementp = old_element;
-      *new_elementp = new_element;
-      diff->set_index(i);
-      differs = true;
+  while (i < old_base_specifiers.size()) {
+    if (CompareAndDumpTypeDiff(old_base_specifiers.at(i).GetReferencedType(),
+                               new_base_specifiers.at(i).GetReferencedType(),
+                               type_queue, diff_kind) ==
+        DiffStatus::direct_diff ||
+        (old_base_specifiers.at(i).GetAccess() !=
+         new_base_specifiers.at(i).GetAccess())) {
+      return false;
     }
     i++;
-    j++;
   }
-  if (old_elements.size() != new_elements.size()) {
-    GetExtraElementDiffs(dst, i, j, old_elements, new_elements);
-    differs = true;
-  }
-  return differs;
+  return true;
 }
 
-template <typename T, typename TDiff>
-template <typename Element, typename ElementDiff>
-void DiffWrapperBase<T, TDiff>::GetExtraElementDiffs(
-    google::protobuf::RepeatedPtrField<ElementDiff> *dst, int i, int j,
-    const google::protobuf::RepeatedPtrField<Element> &old_elements,
-    const google::protobuf::RepeatedPtrField<Element> &new_elements) {
- assert(dst != nullptr);
- while (i < old_elements.size()) {
-    const Element &old_element = old_elements.Get(i);
-    ElementDiff *diff = dst->Add();
-    Element *old_elementp = nullptr;
-    if (!diff || !(old_elementp = diff->mutable_old())) {
-      llvm::errs() << "Failed to add diff element\n";
-      ::exit(1);
-    }
-    *old_elementp = old_element;
-    diff->set_index(i);
+void DiffWrapperBase::CompareTemplateInfo(
+    const std::vector<abi_util::TemplateElementIR> &old_template_elements,
+    const std::vector<abi_util::TemplateElementIR> &new_template_elements,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  uint32_t old_template_size = old_template_elements.size();
+  assert(old_template_size == new_template_elements.size());
+  uint32_t i = 0;
+  while (i < old_template_size) {
+    const abi_util::TemplateElementIR &old_template_element =
+        old_template_elements[i];
+    const abi_util::TemplateElementIR &new_template_element =
+        new_template_elements[i];
+    CompareAndDumpTypeDiff(old_template_element.GetReferencedType(),
+                           new_template_element.GetReferencedType(),
+                           type_queue, diff_kind);
     i++;
- }
- while (j < new_elements.size()) {
-    const Element &new_element = new_elements.Get(j);
-    ElementDiff *diff = dst->Add();
-    Element *new_elementp = nullptr;
-    if (!diff || !(new_elementp = diff->mutable_new_())) {
-      llvm::errs() << "Failed to add diff element\n";
-      ::exit(1);
-    }
-    *new_elementp = new_element;
-    diff->set_index(j);
-    j++;
- }
+  }
 }
 
-static bool DiffBasicNamedAndTypedDecl(BasicNamedAndTypedDecl *type_diff_old,
-                                       BasicNamedAndTypedDecl *type_diff_new,
-                                       const BasicNamedAndTypedDecl &old,
-                                       const BasicNamedAndTypedDecl &new_) {
-  assert(type_diff_old != nullptr);
-  assert(type_diff_new != nullptr);
-  if (DiffBasicTypeAbi(old.type_abi(), new_.type_abi()) ||
-      IsAccessDownGraded(old.access(), new_.access())) {
-    *(type_diff_old) = old;
-    *(type_diff_new) = new_;
+DiffStatus DiffWrapperBase::CompareRecordTypes(
+    const abi_util::RecordTypeIR *old_type,
+    const abi_util::RecordTypeIR *new_type,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  auto record_type_diff_ir = std::make_unique<abi_util::RecordTypeDiffIR>();
+  // Compare names.
+  if (old_type->GetName() != new_type->GetName()) {
+    // Do not dump anything since the record types themselves are fundamentally
+    // different.
+    return DiffStatus::direct_diff;
+  }
+  record_type_diff_ir->SetName(old_type->GetName());
+  if (old_type->GetAccess() != new_type->GetAccess()) {
+    record_type_diff_ir->SetAccessDiff(
+        std::make_unique<abi_util::AccessSpecifierDiffIR>(
+            old_type->GetAccess(), new_type->GetAccess()));
+  }
+
+  if (!CompareSizeAndAlignment(old_type, new_type)) {
+    record_type_diff_ir->SetTypeDiff(
+        std::make_unique<abi_util::TypeDiffIR>(
+            std::make_pair(old_type->GetSize(), new_type->GetSize()),
+            std::make_pair(old_type->GetAlignment(),
+                           new_type->GetAlignment())));
+  }
+  if (!CompareVTables(old_type, new_type)) {
+    record_type_diff_ir->SetVTableLayoutDiff(
+        std::make_unique<abi_util::VTableLayoutDiffIR>(
+            old_type->GetVTableLayout(), new_type->GetVTableLayout()));
+  }
+  std::pair<std::vector<abi_util::RecordFieldDiffIR>,
+      std::vector<const abi_util::RecordFieldIR *>> field_diffs;
+  field_diffs = CompareRecordFields(old_type->GetFields(),
+                                    new_type->GetFields(), type_queue,
+                                    diff_kind);
+  record_type_diff_ir->SetFieldDiffs(std::move(field_diffs.first));
+  record_type_diff_ir->SetFieldsRemoved(std::move(field_diffs.second));
+  const std::vector<abi_util::CXXBaseSpecifierIR> &old_bases =
+      old_type->GetBases();
+  const std::vector<abi_util::CXXBaseSpecifierIR> &new_bases =
+      new_type->GetBases();
+
+  if (!CompareBaseSpecifiers(old_bases, new_bases, type_queue, diff_kind)) {
+    record_type_diff_ir->SetBaseSpecifierDiffs(
+        std::make_unique<abi_util::CXXBaseSpecifierDiffIR>(old_bases,
+                                                           new_bases));
+  }
+  if (record_type_diff_ir->DiffExists() &&
+      !ir_diff_dumper_->AddDiffMessageIR(record_type_diff_ir.get(),
+                                         Unwind(type_queue), diff_kind)) {
+    llvm::errs() << "AddDiffMessage on record type failed\n";
+    ::exit(1);
+  } // No need to add a dump for an extension since records can't be "extended".
+
+  CompareTemplateInfo(old_type->GetTemplateElements(),
+                      new_type->GetTemplateElements(),
+                      type_queue, diff_kind);
+
+  return DiffStatus::no_diff;
+}
+
+DiffStatus DiffWrapperBase::CompareLvalueReferenceTypes(
+    const abi_util::LvalueReferenceTypeIR *old_type,
+    const abi_util::LvalueReferenceTypeIR *new_type,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  return CompareAndDumpTypeDiff(old_type->GetReferencedType(),
+                                new_type->GetReferencedType(),
+                                type_queue, diff_kind);
+}
+
+DiffStatus DiffWrapperBase::CompareRvalueReferenceTypes(
+    const abi_util::RvalueReferenceTypeIR *old_type,
+    const abi_util::RvalueReferenceTypeIR *new_type,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  return CompareAndDumpTypeDiff(old_type->GetReferencedType(),
+                                new_type->GetReferencedType(),
+                                type_queue, diff_kind);
+}
+
+DiffStatus DiffWrapperBase::CompareQualifiedTypes(
+    const abi_util::QualifiedTypeIR *old_type,
+    const abi_util::QualifiedTypeIR *new_type,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  // If all the qualifiers are not the same, return direct_diff, else
+  // recursively compare the unqualified types.
+  if (old_type->IsConst() != new_type->IsConst() ||
+      old_type->IsVolatile() != new_type->IsVolatile() ||
+      old_type->IsRestricted() != new_type->IsRestricted()) {
+    return DiffStatus::direct_diff;
+  }
+  return CompareAndDumpTypeDiff(old_type->GetReferencedType(),
+                                new_type->GetReferencedType(),
+                                type_queue, diff_kind);
+}
+
+DiffStatus DiffWrapperBase::ComparePointerTypes(
+    const abi_util::PointerTypeIR *old_type,
+    const abi_util::PointerTypeIR *new_type,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  // The following need to be the same for two pointer types to be considered
+  // equivalent:
+  // 1) Number of pointer indirections are the same.
+  // 2) The ultimate pointee is the same.
+  assert(CompareSizeAndAlignment(old_type, new_type));
+  return CompareAndDumpTypeDiff(old_type->GetReferencedType(),
+                                new_type->GetReferencedType(),
+                                type_queue, diff_kind);
+}
+
+DiffStatus DiffWrapperBase::CompareBuiltinTypes(
+    const abi_util::BuiltinTypeIR *old_type,
+    const abi_util::BuiltinTypeIR *new_type) {
+  // If the size, alignment and is_unsigned are the same, return no_diff
+  // else return direct_diff.
+  uint64_t old_signedness = old_type->IsUnsigned();
+  uint64_t new_signedness = new_type->IsUnsigned();
+
+  if (!CompareSizeAndAlignment(old_type, new_type) ||
+      old_signedness != new_signedness ||
+      old_type->IsIntegralType() != new_type->IsIntegralType()) {
+    return DiffStatus::direct_diff;
+  }
+  return DiffStatus::no_diff;
+}
+
+DiffStatus DiffWrapperBase::CompareFunctionParameters(
+    const std::vector<abi_util::ParamIR> &old_parameters,
+    const std::vector<abi_util::ParamIR> &new_parameters,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  size_t old_parameters_size = old_parameters.size();
+  if (old_parameters_size != new_parameters.size()) {
+    return DiffStatus::direct_diff;
+  }
+  uint64_t i = 0;
+  while (i < old_parameters_size) {
+    const abi_util::ParamIR &old_parameter = old_parameters.at(i);
+    const abi_util::ParamIR &new_parameter = new_parameters.at(i);
+    if ((CompareAndDumpTypeDiff(old_parameter.GetReferencedType(),
+                               new_parameter.GetReferencedType(),
+                               type_queue, diff_kind) ==
+        DiffStatus::direct_diff) ||
+        (old_parameter.GetIsDefault() != new_parameter.GetIsDefault())) {
+      return DiffStatus::direct_diff;
+    }
+    i++;
+  }
+  return DiffStatus::no_diff;
+}
+
+DiffStatus DiffWrapperBase::CompareAndDumpTypeDiff(
+    const abi_util::TypeIR *old_type, const abi_util::TypeIR *new_type,
+    abi_util::LinkableMessageKind kind, std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  if (kind == abi_util::LinkableMessageKind::BuiltinTypeKind) {
+    return CompareBuiltinTypes(
+        static_cast<const abi_util::BuiltinTypeIR *>(old_type),
+        static_cast<const abi_util::BuiltinTypeIR *>(new_type));
+  }
+
+  if (kind == abi_util::LinkableMessageKind::QualifiedTypeKind) {
+    return CompareQualifiedTypes(
+        static_cast<const abi_util::QualifiedTypeIR *>(old_type),
+        static_cast<const abi_util::QualifiedTypeIR *>(new_type),
+        type_queue, diff_kind);
+  }
+
+  if (kind == abi_util::LinkableMessageKind::EnumTypeKind) {
+      return CompareEnumTypes(
+          static_cast<const abi_util::EnumTypeIR *>(old_type),
+          static_cast<const abi_util::EnumTypeIR *>(new_type),
+          type_queue, diff_kind);
+
+  }
+
+  if (kind == abi_util::LinkableMessageKind::LvalueReferenceTypeKind) {
+    return CompareLvalueReferenceTypes(
+        static_cast<const abi_util::LvalueReferenceTypeIR *>(old_type),
+        static_cast<const abi_util::LvalueReferenceTypeIR *>(new_type),
+        type_queue, diff_kind);
+
+  }
+
+  if (kind == abi_util::LinkableMessageKind::RvalueReferenceTypeKind) {
+    return CompareRvalueReferenceTypes(
+        static_cast<const abi_util::RvalueReferenceTypeIR *>(old_type),
+        static_cast<const abi_util::RvalueReferenceTypeIR *>(new_type),
+        type_queue, diff_kind);
+  }
+
+  if (kind == abi_util::LinkableMessageKind::PointerTypeKind) {
+    return ComparePointerTypes(
+        static_cast<const abi_util::PointerTypeIR *>(old_type),
+        static_cast<const abi_util::PointerTypeIR *>(new_type),
+        type_queue, diff_kind);
+  }
+
+  if (kind == abi_util::LinkableMessageKind::RecordTypeKind) {
+    return CompareRecordTypes(
+        static_cast<const abi_util::RecordTypeIR *>(old_type),
+        static_cast<const abi_util::RecordTypeIR *>(new_type),
+        type_queue, diff_kind);
+  }
+  return DiffStatus::no_diff;
+}
+
+static DiffStatus CompareDistinctKindMessages(
+    const abi_util::TypeIR *old_type, const abi_util::TypeIR *new_type) {
+  // For these types to be considered ABI compatible, the very least requirement
+  // is that their sizes and alignments should be equal.
+  // TODO: Fill in
+  return DiffStatus::direct_diff;
+}
+
+DiffStatus DiffWrapperBase::CompareAndDumpTypeDiff(
+    const std::string &old_type_str, const std::string &new_type_str,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  // If either of the types are not found in their respective maps, the type
+  // was not exposed in a public header and we do a simple string comparison.
+  // Any diff found using a simple string comparison will be a direct diff.
+
+  // Check the map for types which have already been compared
+  bool same_type_str = (old_type_str == new_type_str);
+  if (same_type_str) {
+    // These types have already been diffed, return without further comparison.
+    if (!type_cache_->insert(old_type_str).second) {
+      return DiffStatus::no_diff;
+    }
+    type_queue->push_back(old_type_str);
+  }
+  std::map<std::string, const abi_util::TypeIR *>::const_iterator old_it =
+      old_types_.find(old_type_str);
+  std::map<std::string, const abi_util::TypeIR *>::const_iterator new_it =
+      new_types_.find(new_type_str);
+  if (old_it == old_types_.end() || new_it == new_types_.end()) {
+    // Do a simple string comparison.
+    if (!type_queue->empty()) {
+      type_queue->pop_back();
+    }
+    return (old_type_str == new_type_str) ?
+        DiffStatus::no_diff : DiffStatus::direct_diff;
+  }
+  abi_util::LinkableMessageKind old_kind =
+      old_it->second->GetKind();
+  abi_util::LinkableMessageKind new_kind =
+      new_it->second->GetKind();
+  DiffStatus diff_status = DiffStatus::no_diff;
+  if (old_kind != new_kind) {
+    diff_status = CompareDistinctKindMessages(old_it->second, new_it->second);
+  } else {
+    diff_status = CompareAndDumpTypeDiff(old_it->second , new_it->second ,
+                                         old_kind, type_queue, diff_kind);
+  }
+  if (!type_queue->empty()) {
+    type_queue->pop_back();
+  }
+  return diff_status;
+}
+
+template <>
+bool DiffWrapper<abi_util::RecordTypeIR>::DumpDiff(
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  std::deque<std::string> type_queue;
+  if (oldp_->GetName() != newp_->GetName()) {
+    llvm::errs() << "Comparing two different unreferenced records\n";
+    return false;
+  }
+  if (!type_cache_->insert(oldp_->GetName()).second) {
     return true;
   }
-  return false;
+  CompareRecordTypes(oldp_, newp_, &type_queue, diff_kind);
+  return true;
 }
 
 template <>
-std::unique_ptr<RecordDeclDiff>
-DiffWrapper<RecordDecl, RecordDeclDiff>::Get() {
-  std::unique_ptr<RecordDeclDiff> record_diff(new RecordDeclDiff());
-  assert(oldp_->basic_abi().linker_set_key() ==
-         newp_->basic_abi().linker_set_key());
-  record_diff->set_name(oldp_->basic_abi().name());
-  google::protobuf::RepeatedPtrField<RecordFieldDeclDiff> *fdiffs =
-      record_diff->mutable_field_diffs();
-  google::protobuf::RepeatedPtrField<CXXBaseSpecifierDiff> *bdiffs =
-      record_diff->mutable_base_diffs();
-  google::protobuf::RepeatedPtrField<CXXVTableDiff> *vtdiffs =
-      record_diff->mutable_vtable_diffs();
-  assert(fdiffs != nullptr && bdiffs != nullptr);
-  // Template Information isn't diffed since the linker_set_key includes the
-  // mangled name which includes template information.
-  if (GetElementDiffs(fdiffs, oldp_->fields(), newp_->fields()) ||
-      GetElementDiffs(bdiffs, oldp_->base_specifiers(),
-                      newp_->base_specifiers()) ||
-      GetElementDiffs(vtdiffs, oldp_->vtable_layout().vtable_components(),
-                      newp_->vtable_layout().vtable_components()) ||
-      DiffBasicNamedAndTypedDecl(
-          record_diff->mutable_type_diff()->mutable_old(),
-          record_diff->mutable_type_diff()->mutable_new_(),
-          oldp_->basic_abi(), newp_->basic_abi())) {
-    return record_diff;
+bool DiffWrapper<abi_util::EnumTypeIR>::DumpDiff(
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  std::deque<std::string> type_queue;
+  if (oldp_->GetName() != newp_->GetName()) {
+    llvm::errs() << "Comparing two different unreferenced enums\n";
+    return false;
   }
-  return nullptr;
+  if (!type_cache_->insert(oldp_->GetName()).second) {
+    return true;
+  }
+  CompareEnumTypes(oldp_, newp_, &type_queue, diff_kind);
+  return true;
 }
 
 template <>
-std::unique_ptr<EnumDeclDiff>
-DiffWrapper<EnumDecl, EnumDeclDiff>::Get() {
-  std::unique_ptr<EnumDeclDiff> enum_diff(new EnumDeclDiff());
-  assert(oldp_->basic_abi().linker_set_key() ==
-         newp_->basic_abi().linker_set_key());
-  google::protobuf::RepeatedPtrField<EnumFieldDeclDiff> *fdiffs =
-      enum_diff->mutable_field_diffs();
-  assert(fdiffs != nullptr);
-  enum_diff->set_name(oldp_->basic_abi().name());
-  if (GetElementDiffs(fdiffs, oldp_->enum_fields(), newp_->enum_fields()) ||
-      DiffBasicNamedAndTypedDecl(
-          enum_diff->mutable_type_diff()->mutable_old(),
-          enum_diff->mutable_type_diff()->mutable_new_(),
-          oldp_->basic_abi(), newp_->basic_abi())) {
-    return enum_diff;
+bool DiffWrapper<abi_util::GlobalVarIR>::DumpDiff(
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  std::deque<std::string> type_queue;
+  type_queue.push_back(oldp_->GetName());
+  DiffStatus type_diff = CompareAndDumpTypeDiff(oldp_->GetReferencedType(),
+                                                newp_->GetReferencedType(),
+                                                &type_queue, diff_kind);
+  DiffStatus access_diff = (oldp_->GetAccess() == newp_->GetAccess()) ?
+      DiffStatus::no_diff : DiffStatus::direct_diff;
+  if ((type_diff | access_diff) & DiffStatus::direct_diff) {
+    abi_util::GlobalVarDiffIR global_var_diff_ir(oldp_, newp_);
+    global_var_diff_ir.SetName(oldp_->GetName());
+    return ir_diff_dumper_->AddDiffMessageIR(&global_var_diff_ir,
+                                             Unwind(&type_queue), diff_kind);
   }
-  return nullptr;
+  return true;
 }
 
 template <>
-std::unique_ptr<FunctionDeclDiff>
-DiffWrapper<FunctionDecl, FunctionDeclDiff>::Get() {
-  std::unique_ptr<FunctionDeclDiff> func_diff(new FunctionDeclDiff());
-  google::protobuf::RepeatedPtrField<ParamDeclDiff> *pdiffs =
-      func_diff->mutable_param_diffs();
-  assert(func_diff->mutable_return_type_diffs() != nullptr);
-  func_diff->set_name(oldp_->basic_abi().linker_set_key());
-  if (DiffBasicNamedAndTypedDecl(
-          func_diff->mutable_return_type_diffs()->mutable_old(),
-          func_diff->mutable_return_type_diffs()->mutable_new_(),
-          oldp_->basic_abi(), newp_->basic_abi()) ||
-      GetElementDiffs(pdiffs, oldp_->parameters(), newp_->parameters())) {
-    return func_diff;
-  }
-  return nullptr;
-}
+bool DiffWrapper<abi_util::FunctionIR>::DumpDiff(
+    abi_util::IRDiffDumper::DiffKind diff_kind) {
+  std::deque<std::string> type_queue;
+  type_queue.push_back(oldp_->GetName());
+  DiffStatus param_diffs = CompareFunctionParameters(oldp_->GetParameters(),
+                                                     newp_->GetParameters(),
+                                                     &type_queue, diff_kind);
+  DiffStatus return_type_diff =
+      CompareAndDumpTypeDiff(oldp_->GetReturnType(),
+                             newp_->GetReturnType(),
+                             &type_queue, diff_kind);
+  CompareTemplateInfo(oldp_->GetTemplateElements(),
+                      newp_->GetTemplateElements(),
+                      &type_queue, diff_kind);
 
-template <>
-std::unique_ptr<GlobalVarDeclDiff>
-DiffWrapper<GlobalVarDecl, GlobalVarDeclDiff>::Get() {
-  std::unique_ptr<GlobalVarDeclDiff> global_var_diff(new GlobalVarDeclDiff());
-  assert(global_var_diff->mutable_type_diff() != nullptr);
-  if (DiffBasicNamedAndTypedDecl(
-          global_var_diff->mutable_type_diff()->mutable_old(),
-          global_var_diff->mutable_type_diff()->mutable_new_(),
-          oldp_->basic_abi(), newp_->basic_abi())) {
-    return global_var_diff;
+  if ((param_diffs == DiffStatus::direct_diff ||
+       return_type_diff == DiffStatus::direct_diff) ||
+      (oldp_->GetAccess() != newp_->GetAccess())) {
+    abi_util::FunctionDiffIR function_diff_ir(oldp_, newp_);
+    function_diff_ir.SetName(oldp_->GetName());
+    return ir_diff_dumper_->AddDiffMessageIR(&function_diff_ir,
+                                             Unwind(&type_queue), diff_kind);
   }
-  return nullptr;
+  return true;
 }
-
 } // abi_diff_wrappers
diff --git a/vndk/tools/header-checker/header-abi-diff/src/abi_diff_wrappers.h b/vndk/tools/header-checker/header-abi-diff/src/abi_diff_wrappers.h
index 8cf4699..9b0a7f5 100644
--- a/vndk/tools/header-checker/header-abi-diff/src/abi_diff_wrappers.h
+++ b/vndk/tools/header-checker/header-abi-diff/src/abi_diff_wrappers.h
@@ -22,45 +22,160 @@
 #include "proto/abi_diff.pb.h"
 #pragma clang diagnostic pop
 
+#include <ir_representation.h>
+
+#include <deque>
+
 namespace abi_diff_wrappers {
 
-template <typename T>
+template <typename T, typename F>
 static bool IgnoreSymbol(const T *element,
-                         const std::set<std::string> &ignored_symbols) {
-  return ignored_symbols.find(element->basic_abi().linker_set_key()) !=
+                         const std::set<std::string> &ignored_symbols,
+                         F func) {
+  return ignored_symbols.find(func(element)) !=
       ignored_symbols.end();
 }
 
-template <typename T, typename TDiff>
-class DiffWrapperBase {
- public:
-  virtual std::unique_ptr<TDiff> Get() = 0 ;
- protected:
-  DiffWrapperBase(const T *oldp, const T *newp) : oldp_(oldp), newp_(newp) { }
-  template <typename Element, typename ElementDiff>
-  bool GetElementDiffs(
-      google::protobuf::RepeatedPtrField<ElementDiff> *dst,
-      const google::protobuf::RepeatedPtrField<Element> &old_elements,
-      const google::protobuf::RepeatedPtrField<Element> &new_elements);
-
- private:
-  template <typename Element, typename ElementDiff>
-  void GetExtraElementDiffs(
-      google::protobuf::RepeatedPtrField<ElementDiff> *dst, int i, int j,
-      const google::protobuf::RepeatedPtrField<Element> &old_elements,
-      const google::protobuf::RepeatedPtrField<Element> &new_elements);
-
- protected:
-  const T *oldp_;
-  const T *newp_;
+enum DiffStatus {
+  // Previous stages of CompareAndTypeDiff should not dump the diff.
+  no_diff = 0,
+  // Previous stages of CompareAndTypeDiff should dump the diff if required.
+  direct_diff = 1,
 };
 
-template <typename T, typename TDiff>
-class DiffWrapper : public DiffWrapperBase<T, TDiff> {
+class DiffWrapperBase {
  public:
-  DiffWrapper(const T *oldp, const T *newp)
-      : DiffWrapperBase<T, TDiff>(oldp, newp) { }
-  std::unique_ptr<TDiff> Get() override;
+  virtual bool DumpDiff(abi_util::IRDiffDumper::DiffKind diff_kind) = 0;
+  virtual ~DiffWrapperBase() { }
+ protected:
+  DiffWrapperBase(
+      abi_util::IRDiffDumper *ir_diff_dumper,
+      const std::map<std::string, const abi_util::TypeIR *> &old_types,
+      const std::map<std::string, const abi_util::TypeIR *> &new_types,
+      std::set<std::string> *type_cache)
+      : ir_diff_dumper_(ir_diff_dumper),
+        old_types_(old_types), new_types_(new_types),
+        type_cache_(type_cache) { }
+
+  DiffStatus CompareAndDumpTypeDiff(const std::string &old_type_str,
+                                    const std::string &new_type_str,
+                                    std::deque<std::string> *type_queue,
+                                    abi_util::IRDiffDumper::DiffKind diff_kind);
+
+  DiffStatus CompareAndDumpTypeDiff(
+      const abi_util::TypeIR *old_type, const abi_util::TypeIR *new_type,
+      abi_util::LinkableMessageKind kind, std::deque<std::string> *type_queue,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
+
+
+  DiffStatus CompareRecordTypes(const abi_util::RecordTypeIR *old_type,
+                                const abi_util::RecordTypeIR *new_type,
+                                std::deque<std::string> *type_queue,
+                                abi_util::IRDiffDumper::DiffKind diff_kind);
+
+  DiffStatus CompareQualifiedTypes(const abi_util::QualifiedTypeIR *old_type,
+                                   const abi_util::QualifiedTypeIR *new_type,
+                                   std::deque<std::string> *type_queue,
+                                   abi_util::IRDiffDumper::DiffKind diff_kind);
+
+  DiffStatus ComparePointerTypes(const abi_util::PointerTypeIR *old_type,
+                                 const abi_util::PointerTypeIR *new_type,
+                                 std::deque<std::string> *type_queue,
+                                 abi_util::IRDiffDumper::DiffKind diff_kind);
+
+  DiffStatus CompareLvalueReferenceTypes(
+      const abi_util::LvalueReferenceTypeIR *old_type,
+      const abi_util::LvalueReferenceTypeIR *new_type,
+      std::deque<std::string> *type_queue,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
+
+  DiffStatus CompareRvalueReferenceTypes(
+      const abi_util::RvalueReferenceTypeIR *old_type,
+      const abi_util::RvalueReferenceTypeIR *new_type,
+      std::deque<std::string> *type_queue,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
+
+
+  DiffStatus CompareBuiltinTypes(const abi_util::BuiltinTypeIR *old_type,
+                                 const abi_util::BuiltinTypeIR *new_type);
+  static void CompareEnumFields(
+    const std::vector<abi_util::EnumFieldIR> &old_fields,
+    const std::vector<abi_util::EnumFieldIR> &new_fields,
+    abi_util::EnumTypeDiffIR *enum_type_diff_ir);
+
+  DiffStatus CompareEnumTypes(const abi_util::EnumTypeIR *old_type,
+                              const abi_util::EnumTypeIR *new_type,
+                              std::deque<std::string> *type_queue,
+                              abi_util::IRDiffDumper::DiffKind diff_kind);
+
+  std::unique_ptr<abi_util::RecordFieldDiffIR> CompareCommonRecordFields(
+    const abi_util::RecordFieldIR *old_field,
+    const abi_util::RecordFieldIR *new_field,
+    std::deque<std::string> *type_queue,
+    abi_util::IRDiffDumper::DiffKind diff_kind);
+
+  std::pair<std::vector<abi_util::RecordFieldDiffIR>,
+      std::vector<const abi_util::RecordFieldIR *>>
+  CompareRecordFields(
+      const std::vector<abi_util::RecordFieldIR> &old_fields,
+      const std::vector<abi_util::RecordFieldIR> &new_fields,
+      std::deque<std::string> *type_queue,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
+
+  DiffStatus CompareFunctionParameters(
+      const std::vector<abi_util::ParamIR> &old_parameters,
+      const std::vector<abi_util::ParamIR> &new_parameters,
+      std::deque<std::string> *type_queue,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
+
+  bool CompareBaseSpecifiers(
+      const std::vector<abi_util::CXXBaseSpecifierIR> &old_base_specifiers,
+      const std::vector<abi_util::CXXBaseSpecifierIR> &new_base_specifiers,
+      std::deque<std::string> *type_queue,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
+
+  bool CompareVTables(const abi_util::RecordTypeIR *old_record,
+                      const abi_util::RecordTypeIR *new_record);
+
+  bool CompareVTableComponents(
+      const abi_util::VTableComponentIR &old_component,
+      const abi_util::VTableComponentIR &new_component);
+
+  void CompareTemplateInfo(
+      const std::vector<abi_util::TemplateElementIR> &old_template_elements,
+      const std::vector<abi_util::TemplateElementIR> &new_template_elements,
+      std::deque<std::string> *type_queue,
+      abi_util::IRDiffDumper::DiffKind diff_kind);
+
+
+  bool CompareSizeAndAlignment(const abi_util::TypeIR *old_ti,
+                               const abi_util::TypeIR *new_ti);
+
+  template <typename DiffType, typename DiffElement>
+  bool AddToDiff(DiffType *mutable_diff, const DiffElement *oldp,
+                 const DiffElement *newp,
+                 std::deque<std::string> *type_queue = nullptr);
+ protected:
+  abi_util::IRDiffDumper *ir_diff_dumper_;
+  const std::map<std::string, const abi_util::TypeIR *> &old_types_;
+  const std::map<std::string, const abi_util::TypeIR *> &new_types_;
+  std::set<std::string> *type_cache_;
+};
+
+template <typename T>
+class DiffWrapper : public DiffWrapperBase {
+ public:
+  DiffWrapper(const T *oldp, const T *newp,
+              abi_util::IRDiffDumper *ir_diff_dumper,
+              const std::map<std::string, const abi_util::TypeIR *> &old_types,
+              const std::map<std::string, const abi_util::TypeIR *> &new_types,
+              std::set<std::string> *type_cache)
+      : DiffWrapperBase(ir_diff_dumper, old_types, new_types, type_cache),
+        oldp_(oldp), newp_(newp) { }
+  bool DumpDiff(abi_util::IRDiffDumper::DiffKind diff_kind) override;
+ private:
+  const T *oldp_;
+  const T *newp_;
 };
 
 } // abi_diff_wrappers
diff --git a/vndk/tools/header-checker/header-abi-diff/src/header_abi_diff.cpp b/vndk/tools/header-checker/header-abi-diff/src/header_abi_diff.cpp
index 7281c09..813ea75 100644
--- a/vndk/tools/header-checker/header-abi-diff/src/header_abi_diff.cpp
+++ b/vndk/tools/header-checker/header-abi-diff/src/header_abi_diff.cpp
@@ -14,6 +14,8 @@
 
 #include "abi_diff.h"
 
+#include <fstream>
+
 #include <llvm/Support/CommandLine.h>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/raw_ostream.h>
@@ -49,6 +51,12 @@
     "advice-only", llvm::cl::desc("Advisory mode only"), llvm::cl::Optional,
     llvm::cl::cat(header_checker_category));
 
+static llvm::cl::opt<bool> check_all_apis(
+    "check-all-apis",
+    llvm::cl::desc("All apis, whether referenced or not, by exported symbols in"
+                   " the dynsym table of a shared library are checked"),
+    llvm::cl::Optional, llvm::cl::cat(header_checker_category));
+
 static llvm::cl::opt<bool> suppress_local_warnings(
     "suppress_local_warnings", llvm::cl::desc("suppress local warnings"),
     llvm::cl::Optional, llvm::cl::cat(header_checker_category));
@@ -58,6 +66,13 @@
     llvm::cl::desc("Do not return a non zero status on extensions"),
     llvm::cl::Optional, llvm::cl::cat(header_checker_category));
 
+static llvm::cl::opt<bool> allow_unreferenced_changes(
+    "allow-unreferenced-changes",
+    llvm::cl::desc("Do not return a non zero status on changes to data"
+                   " structures which are not directly referenced by exported"
+                   " APIs."),
+    llvm::cl::Optional, llvm::cl::cat(header_checker_category));
+
 static std::set<std::string> LoadIgnoredSymbols(std::string &symbol_list_path) {
   std::ifstream symbol_ifstream(symbol_list_path);
   std::set<std::string> ignored_symbols;
@@ -80,38 +95,50 @@
     ignored_symbols = LoadIgnoredSymbols(ignore_symbol_list);
   }
   HeaderAbiDiff judge(lib_name, arch, old_dump, new_dump, compatibility_report,
-                      ignored_symbols);
+                      ignored_symbols, check_all_apis);
 
-  CompatibilityStatus status  = judge.GenerateCompatibilityReport();
+  abi_util::CompatibilityStatusIR status = judge.GenerateCompatibilityReport();
 
   std::string status_str = "";
-  switch (status) {
-    case CompatibilityStatus::INCOMPATIBLE:
-      status_str = "broken";
-      break;
-    case CompatibilityStatus::EXTENSION:
-      status_str = "extended";
-      break;
-    default:
-      break;
-  }
+  std::string unreferenced_change_str = "";
+  std::string error_or_warning_str = "\033[36;1mwarning: \033[0m";
 
+  if (status == abi_util::CompatibilityStatusIR::Incompatible) {
+    error_or_warning_str = "\033[31;1merror: \033[0m";
+    status_str = " INCOMPATIBLE CHANGES";
+  } else if (status & abi_util::CompatibilityStatusIR::Extension) {
+    status_str = "EXTENDING CHANGES";
+  }
+  if (status & abi_util::CompatibilityStatusIR::UnreferencedChanges) {
+    unreferenced_change_str = ", changes in exported headers, which are";
+    unreferenced_change_str += " not directly referenced by exported symbols.";
+    unreferenced_change_str += " This MIGHT be an ABI breaking change due to";
+    unreferenced_change_str += " internal typecasts.";
+
+  }
   if (!suppress_local_warnings && status) {
     llvm::errs() << "******************************************************\n"
-                 << "VNDK Abi "
+                 << error_or_warning_str
+                 << "VNDK library: "
+                 << lib_name
+                 << "'s ABI has "
                  << status_str
-                 << ":"
+                 << unreferenced_change_str
                  << " Please check compatiblity report at : "
                  << compatibility_report << "\n"
-                 << "*****************************************************\n";
+                 << "******************************************************\n";
+  }
+
+  if ((allow_extensions &&
+      (status & abi_util::CompatibilityStatusIR::Extension)) ||
+      (allow_unreferenced_changes &&
+      (status & abi_util::CompatibilityStatusIR::UnreferencedChanges))) {
+    return abi_util::CompatibilityStatusIR::Compatible;
   }
 
   if (advice_only) {
-    return CompatibilityStatus::COMPATIBLE;
+    return abi_util::CompatibilityStatusIR::Compatible;
   }
 
-  if (allow_extensions && status == CompatibilityStatus::EXTENSION) {
-    return CompatibilityStatus::COMPATIBLE;
-  }
   return status;
 }
diff --git a/vndk/tools/header-checker/header-abi-dumper/src/abi_wrappers.cpp b/vndk/tools/header-checker/header-abi-dumper/src/abi_wrappers.cpp
index 32bb3c7..b0d4e23 100644
--- a/vndk/tools/header-checker/header-abi-dumper/src/abi_wrappers.cpp
+++ b/vndk/tools/header-checker/header-abi-dumper/src/abi_wrappers.cpp
@@ -28,10 +28,26 @@
 ABIWrapper::ABIWrapper(
     clang::MangleContext *mangle_contextp,
     clang::ASTContext *ast_contextp,
-    const clang::CompilerInstance *cip)
+    const clang::CompilerInstance *cip,
+    std::set<std::string> *type_cache,
+    abi_util::IRDumper *ir_dumper,
+    std::map<const clang::Decl *, std::string> &decl_to_source_cache)
   : cip_(cip),
     mangle_contextp_(mangle_contextp),
-    ast_contextp_(ast_contextp) { }
+    ast_contextp_(ast_contextp),
+    type_cache_(type_cache),
+    ir_dumper_(ir_dumper),
+    decl_to_source_file_cache_(decl_to_source_cache) { }
+
+std::string ABIWrapper::GetCachedDeclSourceFile(
+    const clang::Decl *decl, const clang::CompilerInstance *cip) {
+  assert(decl != nullptr);
+  auto result = decl_to_source_file_cache_.find(decl);
+  if (result == decl_to_source_file_cache_.end()) {
+    return GetDeclSourceFile(decl, cip);
+  }
+  return result->second;
+}
 
 std::string ABIWrapper::GetDeclSourceFile(const clang::Decl *decl,
                                           const clang::CompilerInstance *cip) {
@@ -53,85 +69,174 @@
   return file_abs_path;
 }
 
-abi_dump::AccessSpecifier ABIWrapper::AccessClangToDump(
-    const clang::AccessSpecifier sp) const {
+static abi_util::AccessSpecifierIR AccessClangToIR(
+    const clang::AccessSpecifier sp)  {
   switch (sp) {
     case clang::AS_private: {
-      return abi_dump::AccessSpecifier::private_access;
+      return abi_util::AccessSpecifierIR::PrivateAccess;
       break;
     }
     case clang::AS_protected: {
-      return abi_dump::AccessSpecifier::protected_access;
+      return abi_util::AccessSpecifierIR::ProtectedAccess;
       break;
     }
     default: {
-      return abi_dump::AccessSpecifier::public_access;
+      return abi_util::AccessSpecifierIR::PublicAccess;
       break;
     }
   }
 }
 
-// Dumping the size and alignment is optional. This is since clang can lazily
-// instantiate records as incomplete and therefore their sizes 'may' not be
-// computable. b/62307940
-bool ABIWrapper::SetupBasicTypeAbi(abi_dump::BasicTypeAbi *type_abi,
-                                   const clang::QualType type,
-                                   bool dump_size) const {
-  if (!type_abi) {
+// Get type 'referenced' by qual_type. Referenced type implies, in order:
+// 1) Strip off all qualifiers if qual_type has CVR qualifiers.
+// 2) Strip off a pointer level if qual_type is a pointer.
+// 3) Strip off the reference if qual_type is a reference.
+// Note: qual_type is expected to be a canonical type.
+clang::QualType ABIWrapper::GetReferencedType(const clang::QualType qual_type) {
+  const clang::Type *type_ptr = qual_type.getTypePtr();
+  if (qual_type.hasLocalQualifiers()) {
+    return qual_type.getLocalUnqualifiedType();
+  }
+  if (type_ptr->isPointerType()) {
+    return type_ptr->getPointeeType();
+  }
+  if (type_ptr->isArrayType()) {
+    return
+        type_ptr->getArrayElementTypeNoTypeQual()->getCanonicalTypeInternal();
+  }
+  return qual_type.getNonReferenceType();
+}
+
+bool ABIWrapper::CreateExtendedType(
+    clang::QualType qual_type,
+    abi_util::TypeIR *typep) {
+  std::string type_name = QualTypeToString(qual_type);
+  if (!type_cache_->insert(type_name).second) {
+    return true;
+  }
+  const clang::QualType canonical_type = qual_type.getCanonicalType();
+  return CreateBasicNamedAndTypedDecl(canonical_type, typep, "");
+}
+
+//This overload takes in a qualtype and adds its information to the abi-dump on
+//its own.
+bool ABIWrapper::CreateBasicNamedAndTypedDecl(clang::QualType qual_type,
+                                              const std::string &source_file) {
+  std::string type_name = QualTypeToString(qual_type);
+  const clang::QualType canonical_type = qual_type.getCanonicalType();
+  const clang::Type *base_type = canonical_type.getTypePtr();
+  bool is_ptr = base_type->isPointerType();
+  bool is_reference = base_type->isReferenceType();
+  bool is_array = base_type->isArrayType();
+  bool is_builtin = base_type->isBuiltinType();
+  bool has_referenced_type =
+      is_ptr || is_reference || is_array ||
+      canonical_type.hasLocalQualifiers() || is_builtin;
+  if (!has_referenced_type || !type_cache_->insert(type_name).second) {
+    return true;
+  }
+  // Do something similar to what is being done right now. Create an object
+  // extending Type and return a pointer to that and pass it to CreateBasic...
+  // CreateBasic...(qualtype, Type *) fills in size, alignemnt etc.
+  std::unique_ptr<abi_util::TypeIR> typep = SetTypeKind(canonical_type,
+                                                        source_file);
+  if (!base_type->isVoidType() && !typep) {
     return false;
   }
-  const clang::QualType canonical_type = type.getCanonicalType();
-  type_abi->set_name(QualTypeToString(canonical_type));
+  return CreateBasicNamedAndTypedDecl(canonical_type, typep.get(),
+                                      source_file) &&
+      ir_dumper_->AddLinkableMessageIR(typep.get());
+}
+
+// CreateBasicNamedAndTypedDecl creates a BasicNamedAndTypedDecl : that'll
+// include all the generic information a basic type will have:
+// abi_dump::BasicNamedAndTypedDecl. Other methods fill in more specific
+// information, eg: RecordDecl, EnumDecl.
+bool ABIWrapper::CreateBasicNamedAndTypedDecl(
+    clang::QualType canonical_type,
+    abi_util::TypeIR *typep, const std::string &source_file) {
   // Cannot determine the size and alignment for template parameter dependent
   // types as well as incomplete types.
   const clang::Type *base_type = canonical_type.getTypePtr();
+  assert(base_type != nullptr);
   clang::Type::TypeClass type_class = base_type->getTypeClass();
   // Temporary Hack for auto type sizes. Not determinable.
-  if (dump_size && base_type && !(base_type->isDependentType()) &&
-      !(base_type->isIncompleteType()) && (type_class != clang::Type::Auto)) {
+  if ((type_class != clang::Type::Auto) && !base_type->isIncompleteType() &&
+      !(base_type->isDependentType())) {
     std::pair<clang::CharUnits, clang::CharUnits> size_and_alignment =
     ast_contextp_->getTypeInfoInChars(canonical_type);
-    int64_t size = size_and_alignment.first.getQuantity();
-    int64_t alignment = size_and_alignment.second.getQuantity();
-    type_abi->set_size(size);
-    type_abi->set_alignment(alignment);
+    size_t size = size_and_alignment.first.getQuantity();
+    size_t alignment = size_and_alignment.second.getQuantity();
+    typep->SetSize(size);
+    typep->SetAlignment(alignment);
   }
-  return true;
+  typep->SetName(QualTypeToString(canonical_type));
+  typep->SetLinkerSetKey(QualTypeToString(canonical_type));
+  // default values are false, we don't set them since explicitly doing that
+  // makes the abi dumps more verbose.
+  // This type has a reference type if its a pointer / reference OR it has CVR
+  // qualifiers.
+  clang::QualType referenced_type = GetReferencedType(canonical_type);
+  typep->SetReferencedType(QualTypeToString(referenced_type));
+  // Create the type for referenced type.
+  return CreateBasicNamedAndTypedDecl(referenced_type, source_file);
 }
 
-bool ABIWrapper::SetupBasicNamedAndTypedDecl(
-    abi_dump::BasicNamedAndTypedDecl *basic_named_and_typed_decl,
-    const clang::QualType type, const std::string &name,
-    const clang::AccessSpecifier &access, std::string key,
-    bool dump_size) const {
-  if (!basic_named_and_typed_decl) {
-    return false;
-  }
-  abi_dump::AccessSpecifier access_dump = AccessClangToDump(access);
-  basic_named_and_typed_decl->set_name(name);
-  basic_named_and_typed_decl->set_access(access_dump);
-  if (key != "") {
-    basic_named_and_typed_decl->set_linker_set_key(key);
-  }
-  return SetupBasicTypeAbi(basic_named_and_typed_decl->mutable_type_abi(),
-                           type, dump_size);
-}
-
-static bool ShouldDumpSize(clang::QualType qt) {
-  const clang::Type *type_ptr = qt.getTypePtr();
-  assert(type_ptr != nullptr);
-  if (type_ptr->isBuiltinType() || type_ptr->isPointerType()) {
-    return true;
-  }
-  return false;
-}
-
-std::string ABIWrapper::GetTypeLinkageName(const clang::Type *typep) const {
+std::string ABIWrapper::GetTypeLinkageName(const clang::Type *typep)  {
   assert(typep != nullptr);
   clang::QualType qt = typep->getCanonicalTypeInternal();
   return QualTypeToString(qt);
 }
 
+std::unique_ptr<abi_util::TypeIR> ABIWrapper::SetTypeKind(
+    const clang::QualType canonical_type, const std::string &source_file) {
+  if (canonical_type.hasLocalQualifiers()) {
+    auto qual_type_ir =
+        std::make_unique<abi_util::QualifiedTypeIR>();
+    qual_type_ir->SetConstness(canonical_type.isConstQualified());
+    qual_type_ir->SetRestrictedness(canonical_type.isRestrictQualified());
+    qual_type_ir->SetVolatility(canonical_type.isVolatileQualified());
+    qual_type_ir->SetSourceFile(source_file);
+    return qual_type_ir;
+  }
+  const clang::Type *type_ptr = canonical_type.getTypePtr();
+  if (type_ptr->isPointerType()) {
+    auto pointer_type_ir = std::make_unique<abi_util::PointerTypeIR>();
+    pointer_type_ir->SetSourceFile(source_file);
+    return pointer_type_ir;
+  }
+  if (type_ptr->isLValueReferenceType()) {
+    auto lvalue_reference_type_ir =
+        std::make_unique<abi_util::LvalueReferenceTypeIR>();
+    lvalue_reference_type_ir->SetSourceFile(source_file);
+    return lvalue_reference_type_ir;
+  }
+  if (type_ptr->isRValueReferenceType()) {
+   auto rvalue_reference_type_ir =
+       std::make_unique<abi_util::RvalueReferenceTypeIR>();
+   rvalue_reference_type_ir->SetSourceFile(source_file);
+   return rvalue_reference_type_ir;
+  }
+  if (type_ptr->isArrayType()) {
+    auto array_type_ir = std::make_unique<abi_util::ArrayTypeIR>();
+    array_type_ir->SetSourceFile(source_file);
+    return array_type_ir;
+  }
+  if (type_ptr->isEnumeralType()) {
+    return std::make_unique<abi_util::EnumTypeIR>();
+  }
+  if (type_ptr->isRecordType()) {
+    return std::make_unique<abi_util::RecordTypeIR>();
+  }
+  if (type_ptr->isBuiltinType()) {
+    auto builtin_type_ir = std::make_unique<abi_util::BuiltinTypeIR>();
+    builtin_type_ir->SetSignedness(type_ptr->isUnsignedIntegerType());
+    builtin_type_ir->SetIntegralType(type_ptr->isIntegralType(*ast_contextp_));
+    return builtin_type_ir;
+  }
+  return nullptr;
+}
+
 std::string ABIWrapper::GetMangledNameDecl(
     const clang::NamedDecl *decl, clang::MangleContext *mangle_contextp) {
   if (!mangle_contextp->shouldMangleDeclName(decl)) {
@@ -145,36 +250,8 @@
   return mangled_name;
 }
 
-bool ABIWrapper::SetupTemplateParamNames(
-    abi_dump::TemplateInfo *tinfo,
-    clang::TemplateParameterList *pl) const {
-  if (tinfo->elements_size() > 0) {
-    return true;
-  }
-
-  clang::TemplateParameterList::iterator template_it = pl->begin();
-  while (template_it != pl->end()) {
-    abi_dump::TemplateElement *template_parameterp =
-        tinfo->add_elements();
-    if (!template_parameterp) {
-      return false;
-    }
-    abi_dump::TemplateElement::BasicTemplateElementAbi *basic_abi =
-        template_parameterp->mutable_basic_abi();
-    if (!basic_abi) {
-      return false;
-    }
-    std::string name = (*template_it)->getName();
-    basic_abi->set_name(name);
-    // TODO : Default arg ?
-    basic_abi->set_linker_set_key(name);
-    template_it++;
-  }
-  return true;
-}
-
 std::string ABIWrapper::GetTagDeclQualifiedName(
-    const clang::TagDecl *decl) const {
+    const clang::TagDecl *decl) {
   if (decl->getTypedefNameForAnonDecl()) {
     return decl->getTypedefNameForAnonDecl()->getQualifiedNameAsString();
   }
@@ -182,8 +259,10 @@
 }
 
 bool ABIWrapper::SetupTemplateArguments(
-    abi_dump::TemplateInfo *tinfo,
-    const clang::TemplateArgumentList *tl) const {
+    const clang::TemplateArgumentList *tl,
+    abi_util::TemplatedArtifactIR *ta,
+    const std::string &source_file) {
+  abi_util::TemplateInfoIR template_info;
   for (int i = 0; i < tl->size(); i++) {
     const clang::TemplateArgument &arg = (*tl)[i];
     //TODO: More comprehensive checking needed.
@@ -191,25 +270,33 @@
       continue;
     }
     clang::QualType type = arg.getAsType();
-    abi_dump::TemplateElement *template_parameterp =
-        tinfo->add_elements();
-    if (!template_parameterp) {
+    template_info.AddTemplateElement(
+        abi_util::TemplateElementIR(QualTypeToString(type)));
+    if (!CreateBasicNamedAndTypedDecl(type, source_file)) {
       return false;
     }
-    abi_dump::TemplateElement::BasicTemplateElementAbi *basic_abi =
-        template_parameterp->mutable_basic_abi();
-    if (!basic_abi || !SetupBasicTypeAbi(basic_abi->mutable_type_abi(), type,
-                                         false)) {
-      return false;
-    }
-    // TODO : default arg
-    basic_abi->set_linker_set_key(QualTypeToString(type));
   }
+  ta->SetTemplateInfo(std::move(template_info));
   return true;
 }
 
+static const clang::EnumDecl *GetAnonymousEnum(
+    const clang::QualType qual_type) {
+  const clang::Type *type_ptr = qual_type.getTypePtr();
+  assert(type_ptr != nullptr);
+  const clang::TagDecl *tag_decl = type_ptr->getAsTagDecl();
+  if (!tag_decl) {
+    return nullptr;
+  }
+  const clang::EnumDecl *enum_decl = llvm::dyn_cast<clang::EnumDecl>(tag_decl);
+  if (!enum_decl || enum_decl->hasNameForLinkage()) {
+    return nullptr;
+  }
+  return enum_decl;
+}
+
 std::string ABIWrapper::QualTypeToString(
-    const clang::QualType &sweet_qt) const {
+    const clang::QualType &sweet_qt) {
   const clang::QualType salty_qt = sweet_qt.getCanonicalType();
   // clang::TypeName::getFullyQualifiedName removes the part of the type related
   // to it being a template parameter. Don't use it for dependent types.
@@ -223,75 +310,84 @@
     clang::MangleContext *mangle_contextp,
     clang::ASTContext *ast_contextp,
     const clang::CompilerInstance *compiler_instance_p,
-    const clang::FunctionDecl *decl)
-  : ABIWrapper(mangle_contextp, ast_contextp, compiler_instance_p),
+    const clang::FunctionDecl *decl,
+    std::set<std::string> *type_cache,
+    abi_util::IRDumper *ir_dumper,
+    std::map<const clang::Decl *, std::string> &decl_to_source_cache)
+  : ABIWrapper(mangle_contextp, ast_contextp, compiler_instance_p,
+               type_cache, ir_dumper, decl_to_source_cache),
     function_decl_(decl) { }
 
+bool FunctionDeclWrapper::SetupThisParameter(abi_util::FunctionIR *functionp,
+                                             const std::string &source_file) {
+  const clang::CXXMethodDecl *cxx_method_decl =
+      llvm::dyn_cast<clang::CXXMethodDecl>(function_decl_);
+  // No this pointer for static methods.
+  if (!cxx_method_decl || cxx_method_decl->isStatic()) {
+    return true;
+  }
+  clang::QualType this_type = cxx_method_decl->getThisType(*ast_contextp_);
+  return SetupFunctionParameter(functionp, this_type, false, source_file);
+}
+
+bool FunctionDeclWrapper::SetupFunctionParameter(
+    abi_util::FunctionIR *functionp, const clang::QualType qual_type,
+    bool has_default_arg, const std::string &source_file) {
+  if (!CreateBasicNamedAndTypedDecl(qual_type, source_file)) {
+    return false;
+  }
+  functionp->AddParameter(abi_util::ParamIR(QualTypeToString(qual_type),
+                                            has_default_arg));
+  return true;
+}
+
 bool FunctionDeclWrapper::SetupFunctionParameters(
-    abi_dump::FunctionDecl *functionp) const {
+    abi_util::FunctionIR *functionp,
+    const std::string &source_file) {
   clang::FunctionDecl::param_const_iterator param_it =
       function_decl_->param_begin();
+  // If this is a CXXMethodDecl, we need to add the "this" pointer.
+  if (!SetupThisParameter(functionp, source_file)) {
+    return false;
+  }
+
   while (param_it != function_decl_->param_end()) {
-    abi_dump::ParamDecl *function_fieldp = functionp->add_parameters();
-    if (!function_fieldp) {
-      llvm::errs() << "Couldn't add parameter to method. Aborting\n";
-      return false;
-    }
     // The linker set key is blank since that shows up in the mangled name.
     bool has_default_arg = (*param_it)->hasDefaultArg();
     clang::QualType param_qt = (*param_it)->getType();
-    bool should_dump_size = ShouldDumpSize(param_qt);
-    if (!SetupBasicNamedAndTypedDecl(
-        function_fieldp->mutable_basic_abi(),
-        (*param_it)->getType(), (*param_it)->getName(),
-        (*param_it)->getAccess(), has_default_arg ? "true" : "false",
-        should_dump_size)) {
+    if (!SetupFunctionParameter(functionp, param_qt, has_default_arg,
+                                source_file)) {
       return false;
     }
-    function_fieldp->set_default_arg(has_default_arg);
     param_it++;
   }
   return true;
 }
 
-bool FunctionDeclWrapper::SetupFunction(abi_dump::FunctionDecl *functionp,
-                                        const std::string &source_file) const {
+bool FunctionDeclWrapper::SetupFunction(abi_util::FunctionIR *functionp,
+                                        const std::string &source_file)  {
   // Go through all the parameters in the method and add them to the fields.
   // Also get the fully qualfied name.
-  functionp->set_source_file(source_file);
-  // Combine the function name and return type to form a NamedAndTypedDecl
+  functionp->SetSourceFile(source_file);
+  functionp->SetName(function_decl_->getQualifiedNameAsString());
   clang::QualType return_type = function_decl_->getReturnType();
-  bool should_dump_size = ShouldDumpSize(return_type);
-  return SetupBasicNamedAndTypedDecl(
-      functionp->mutable_basic_abi(),
-      return_type, function_decl_->getQualifiedNameAsString(),
-      function_decl_->getAccess(), "", should_dump_size) &&
-      SetupTemplateInfo(functionp) && SetupFunctionParameters(functionp);
+
+  functionp->SetReturnType(QualTypeToString(return_type));
+  functionp->SetAccess(AccessClangToIR(function_decl_->getAccess()));
+  return CreateBasicNamedAndTypedDecl(return_type, source_file) &&
+      SetupFunctionParameters(functionp, source_file) &&
+      SetupTemplateInfo(functionp, source_file);
 }
 
 bool FunctionDeclWrapper::SetupTemplateInfo(
-    abi_dump::FunctionDecl *functionp) const {
+    abi_util::FunctionIR *functionp,
+    const std::string &source_file)  {
   switch (function_decl_->getTemplatedKind()) {
-    case clang::FunctionDecl::TK_FunctionTemplate: {
-      clang::FunctionTemplateDecl *template_decl =
-          function_decl_->getDescribedFunctionTemplate();
-      if (template_decl) {
-        clang::TemplateParameterList *template_parameter_list =
-            template_decl->getTemplateParameters();
-        if (template_parameter_list &&
-            !SetupTemplateParamNames(functionp->mutable_template_info(),
-                                     template_parameter_list)) {
-          return false;
-        }
-      }
-      break;
-    }
     case clang::FunctionDecl::TK_FunctionTemplateSpecialization: {
       const clang::TemplateArgumentList *arg_list =
           function_decl_->getTemplateSpecializationArgs();
-      if (arg_list &&
-          !SetupTemplateArguments(functionp->mutable_template_info(),
-                                  arg_list)) {
+      if (arg_list && !SetupTemplateArguments(arg_list, functionp,
+                                              source_file)) {
         return false;
       }
       break;
@@ -303,11 +399,9 @@
   return true;
 }
 
-std::unique_ptr<abi_dump::FunctionDecl>
-FunctionDeclWrapper::GetFunctionDecl() const {
-  std::unique_ptr<abi_dump::FunctionDecl> abi_decl(
-      new abi_dump::FunctionDecl());
-  std::string source_file = GetDeclSourceFile(function_decl_, cip_);
+std::unique_ptr<abi_util::FunctionIR> FunctionDeclWrapper::GetFunctionDecl() {
+  auto abi_decl = std::make_unique<abi_util::FunctionIR>();
+  std::string source_file = GetCachedDeclSourceFile(function_decl_, cip_);
   if (!SetupFunction(abi_decl.get(), source_file)) {
     return nullptr;
   }
@@ -318,59 +412,110 @@
     clang::MangleContext *mangle_contextp,
     clang::ASTContext *ast_contextp,
     const clang::CompilerInstance *compiler_instance_p,
-    const clang::RecordDecl *decl)
-  : ABIWrapper(mangle_contextp, ast_contextp, compiler_instance_p),
-    record_decl_(decl) { }
+    const clang::RecordDecl *decl,
+    std::set<std::string> *type_cache,
+    abi_util::IRDumper *ir_dumper,
+    std::map<const clang::Decl *, std::string> &decl_to_source_cache,
+    const std::string &previous_record_stages)
+  : ABIWrapper(mangle_contextp, ast_contextp, compiler_instance_p,
+               type_cache, ir_dumper, decl_to_source_cache),
+    record_decl_(decl), previous_record_stages_(previous_record_stages) { }
 
-bool RecordDeclWrapper::SetupRecordFields(abi_dump::RecordDecl *recordp) const {
+bool RecordDeclWrapper::CreateAnonymousRecord(
+    const clang::RecordDecl *record_decl, const std::string &linker_set_key) {
+  RecordDeclWrapper record_decl_wrapper(mangle_contextp_, ast_contextp_, cip_,
+                                        record_decl, type_cache_, ir_dumper_,
+                                        decl_to_source_file_cache_,
+                                        linker_set_key);
+  return record_decl_wrapper.GetRecordDecl();
+}
+
+static const clang::RecordDecl *GetAnonymousRecord(clang::QualType type) {
+  const clang::Type *type_ptr = type.getTypePtr();
+  assert(type_ptr != nullptr);
+  if (!type_ptr->isRecordType()) {
+    return nullptr;
+  }
+  const clang::TagDecl *tag_decl = type_ptr->getAsTagDecl();
+  if (!tag_decl) {
+    return nullptr;
+  }
+  const clang::RecordDecl *record_decl =
+      llvm::dyn_cast<clang::RecordDecl>(tag_decl);
+
+  if (record_decl != nullptr && (!record_decl->hasNameForLinkage() ||
+      record_decl->isAnonymousStructOrUnion())) {
+    return record_decl;
+  }
+  return nullptr;
+}
+
+bool RecordDeclWrapper::SetupRecordFields(abi_util::RecordTypeIR *recordp,
+                                          const std::string &source_file) {
   clang::RecordDecl::field_iterator field = record_decl_->field_begin();
+  uint32_t field_index = 0;
+  const clang::ASTRecordLayout &record_layout =
+      ast_contextp_->getASTRecordLayout(record_decl_);
   while (field != record_decl_->field_end()) {
-    abi_dump::RecordFieldDecl *record_fieldp = recordp->add_fields();
-    if (!record_fieldp) {
-      llvm::errs() << " Couldn't add record field: " << field->getName()
-                   << " to reference dump\n";
+    clang::QualType field_type = field->getType();
+    if (!CreateBasicNamedAndTypedDecl(field_type, source_file)) {
+      llvm::errs() << "Creation of Type failed\n";
       return false;
     }
-    if (!SetupBasicNamedAndTypedDecl(record_fieldp->mutable_basic_abi(),
-                                     field->getType(), field->getName(),
-                                     field->getAccess(), "", true)) {
+    std::string field_type_str = QualTypeToString(field_type);
+    std::string field_name = field->getName();
+    // Handle anoymous structs / unions as fields.
+    if (const clang::RecordDecl *anon_record_decl =
+        GetAnonymousRecord(field_type)) {
+      // We need to create a unique linker set key for anonymous structs / enums
+      // since clang just names them with fully_qualified_scope::anonymous.
+      field_type_str =
+          previous_record_stages_ + "::(anonymous)" +
+          std::to_string(field_index);
+      if (!CreateAnonymousRecord(anon_record_decl, field_type_str)) {
       return false;
+      }
+    } else if (const clang::EnumDecl *enum_decl =
+               GetAnonymousEnum(field_type)) {
+      // Handle anonymous enums.
+      field_type_str = QualTypeToString(enum_decl->getIntegerType());
     }
+    uint64_t field_offset = record_layout.getFieldOffset(field_index);
+    recordp->AddRecordField(abi_util::RecordFieldIR(
+        field_name, field_type_str, field_offset,
+        AccessClangToIR(field->getAccess())));
     field++;
+    field_index++;
   }
   return true;
 }
 
 bool RecordDeclWrapper::SetupCXXBases(
-    abi_dump::RecordDecl *cxxp,
-    const clang::CXXRecordDecl *cxx_record_decl) const {
-  assert(cxx_record_decl != nullptr);
+    abi_util::RecordTypeIR *cxxp,
+    const clang::CXXRecordDecl *cxx_record_decl) {
+  if (!cxx_record_decl || !cxxp) {
+    return false;
+  }
   clang::CXXRecordDecl::base_class_const_iterator base_class =
       cxx_record_decl->bases_begin();
   while (base_class != cxx_record_decl->bases_end()) {
-    abi_dump::CXXBaseSpecifier *base_specifierp = cxxp->add_base_specifiers();
-    if (!base_specifierp) {
-      llvm::errs() << " Couldn't add base specifier to reference dump\n";
-      return false;
-    }
     std::string name = QualTypeToString(base_class->getType());
     bool is_virtual = base_class->isVirtual();
-    if (!SetupBasicNamedAndTypedDecl(base_specifierp->mutable_basic_abi(),
-                                     base_class->getType(),
-                                     "", base_class->getAccessSpecifier(),
-                                     "", false)) {
-      return false;
-    }
-    base_specifierp->set_is_virtual(is_virtual);
+    abi_util::AccessSpecifierIR access =
+        AccessClangToIR(base_class->getAccessSpecifier());
+    cxxp->AddCXXBaseSpecifier(abi_util::CXXBaseSpecifierIR(name, is_virtual,
+                                                           access));
     base_class++;
   }
   return true;
 }
 
 bool RecordDeclWrapper::SetupRecordVTable(
-    abi_dump::RecordDecl *record_declp,
-    const clang::CXXRecordDecl *cxx_record_decl) const {
-  assert(cxx_record_decl != nullptr);
+    abi_util::RecordTypeIR *record_declp,
+    const clang::CXXRecordDecl *cxx_record_decl) {
+  if (!cxx_record_decl || !record_declp) {
+    return false;
+  }
   clang::VTableContextBase *base_vtable_contextp =
       ast_contextp_->getVTableContext();
   const clang::Type *typep = cxx_record_decl->getTypeForDecl();
@@ -386,263 +531,254 @@
   }
   const clang::VTableLayout &vtable_layout =
       itanium_vtable_contextp->getVTableLayout(cxx_record_decl);
-  abi_dump::VTableLayout *vtablep = record_declp->mutable_vtable_layout();
-  if (!vtablep) {
-    return false;
-  }
+  abi_util::VTableLayoutIR vtable_ir_layout;
   for (const auto &vtable_component : vtable_layout.vtable_components()) {
-    abi_dump::VTableComponent *added_vtable_component =
-        vtablep->add_vtable_components();
-    if (!added_vtable_component ||
-        !SetupRecordVTableComponent(added_vtable_component, vtable_component)) {
+    abi_util::VTableComponentIR added_component=
+        SetupRecordVTableComponent(vtable_component);
+    vtable_ir_layout.AddVTableComponent(std::move(added_component));
+  }
+  record_declp->SetVTableLayout(std::move(vtable_ir_layout));
+  return true;
+}
+
+abi_util::VTableComponentIR RecordDeclWrapper::SetupRecordVTableComponent(
+    const clang::VTableComponent &vtable_component) {
+  abi_util::VTableComponentIR::Kind kind =
+      abi_util::VTableComponentIR::Kind::RTTI;
+  std::string mangled_component_name = "";
+  llvm::raw_string_ostream ostream(mangled_component_name);
+  int64_t value = 0;
+  clang::VTableComponent::Kind clang_component_kind =
+      vtable_component.getKind();
+  switch (clang_component_kind) {
+    case clang::VTableComponent::CK_VCallOffset:
+      kind = abi_util::VTableComponentIR::Kind::VCallOffset;
+      value = vtable_component.getVCallOffset().getQuantity();
+      break;
+    case clang::VTableComponent::CK_VBaseOffset:
+      kind = abi_util::VTableComponentIR::Kind::VBaseOffset;
+      value = vtable_component.getVBaseOffset().getQuantity();
+      break;
+    case clang::VTableComponent::CK_OffsetToTop:
+      kind = abi_util::VTableComponentIR::Kind::OffsetToTop;
+      value = vtable_component.getOffsetToTop().getQuantity();
+      break;
+    case clang::VTableComponent::CK_RTTI:
+      {
+        kind = abi_util::VTableComponentIR::Kind::RTTI;
+        const clang::CXXRecordDecl *rtti_decl =
+            vtable_component.getRTTIDecl();
+        assert(rtti_decl != nullptr);
+        mangled_component_name =
+            ABIWrapper::GetTypeLinkageName(rtti_decl->getTypeForDecl());
+      }
+      break;
+    case clang::VTableComponent::CK_FunctionPointer:
+    case clang::VTableComponent::CK_CompleteDtorPointer:
+    case clang::VTableComponent::CK_DeletingDtorPointer:
+    case clang::VTableComponent::CK_UnusedFunctionPointer:
+      {
+        const clang::CXXMethodDecl *method_decl =
+            vtable_component.getFunctionDecl();
+        assert(method_decl != nullptr);
+        switch (clang_component_kind) {
+          case clang::VTableComponent::CK_FunctionPointer:
+            kind = abi_util::VTableComponentIR::Kind::FunctionPointer;
+            mangled_component_name = GetMangledNameDecl(method_decl,
+                                                        mangle_contextp_);
+              break;
+          case clang::VTableComponent::CK_CompleteDtorPointer:
+            kind = abi_util::VTableComponentIR::Kind::CompleteDtorPointer;
+            mangle_contextp_->mangleCXXDtor(
+                vtable_component.getDestructorDecl(),
+                clang::CXXDtorType::Dtor_Complete, ostream);
+            ostream.flush();
+            break;
+          case clang::VTableComponent::CK_DeletingDtorPointer:
+            kind = abi_util::VTableComponentIR::Kind::DeletingDtorPointer;
+            mangle_contextp_->mangleCXXDtor(
+                vtable_component.getDestructorDecl(),
+                clang::CXXDtorType::Dtor_Deleting, ostream);
+            ostream.flush();
+            break;
+          case clang::VTableComponent::CK_UnusedFunctionPointer:
+            kind = abi_util::VTableComponentIR::Kind::UnusedFunctionPointer;
+            break;
+          default:
+            break;
+        }
+      }
+      break;
+    default:
+      break;
+  }
+  return abi_util::VTableComponentIR(mangled_component_name, kind, value);
+}
+
+bool RecordDeclWrapper::SetupTemplateInfo(
+    abi_util::RecordTypeIR *record_declp,
+    const clang::CXXRecordDecl *cxx_record_decl,
+    const std::string &source_file) {
+  assert(cxx_record_decl != nullptr);
+  const clang::ClassTemplateSpecializationDecl *specialization_decl =
+      clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(cxx_record_decl);
+  if (specialization_decl) {
+    const clang::TemplateArgumentList *arg_list =
+        &specialization_decl->getTemplateArgs();
+    if (arg_list &&
+        !SetupTemplateArguments(arg_list, record_declp, source_file)) {
       return false;
     }
   }
   return true;
 }
 
-bool RecordDeclWrapper::SetupRecordVTableComponent(
-    abi_dump::VTableComponent *added_vtable_component,
-    const clang::VTableComponent &vtable_component) const {
-  assert(added_vtable_component != nullptr);
-  abi_dump::VTableComponent_Kind kind = abi_dump::VTableComponent_Kind_RTTI;
-  std::string mangled_component_name = "";
-  llvm::raw_string_ostream ostream(mangled_component_name);
-  int64_t value = 0;
-  clang::VTableComponent::Kind clang_component_kind =
-      vtable_component.getKind();
-    switch (clang_component_kind) {
-      case clang::VTableComponent::CK_VCallOffset:
-        kind =  abi_dump::VTableComponent_Kind_VCallOffset;
-        value = vtable_component.getVCallOffset().getQuantity();
-        break;
-      case clang::VTableComponent::CK_VBaseOffset:
-        kind =  abi_dump::VTableComponent_Kind_VBaseOffset;
-        value = vtable_component.getVBaseOffset().getQuantity();
-        break;
-      case clang::VTableComponent::CK_OffsetToTop:
-        kind =  abi_dump::VTableComponent_Kind_OffsetToTop;
-        value = vtable_component.getOffsetToTop().getQuantity();
-        break;
-      case clang::VTableComponent::CK_RTTI:
-        {
-          kind =  abi_dump::VTableComponent_Kind_RTTI;
-          const clang::CXXRecordDecl *rtti_decl =
-              vtable_component.getRTTIDecl();
-          assert(rtti_decl != nullptr);
-          mangled_component_name =
-              ABIWrapper::GetTypeLinkageName(rtti_decl->getTypeForDecl());
-        }
-        break;
-      case clang::VTableComponent::CK_FunctionPointer:
-      case clang::VTableComponent::CK_CompleteDtorPointer:
-      case clang::VTableComponent::CK_DeletingDtorPointer:
-      case clang::VTableComponent::CK_UnusedFunctionPointer:
-        {
-          const clang::CXXMethodDecl *method_decl =
-              vtable_component.getFunctionDecl();
-          assert(method_decl != nullptr);
-          switch (clang_component_kind) {
-            case clang::VTableComponent::CK_FunctionPointer:
-              kind =  abi_dump::VTableComponent_Kind_FunctionPointer;
-              mangled_component_name = GetMangledNameDecl(method_decl,
-                                                          mangle_contextp_);
-              break;
-            case clang::VTableComponent::CK_CompleteDtorPointer:
-              kind =  abi_dump::VTableComponent_Kind_CompleteDtorPointer;
-              mangle_contextp_->mangleCXXDtor(
-                  vtable_component.getDestructorDecl(),
-                  clang::CXXDtorType::Dtor_Complete, ostream);
-              ostream.flush();
-
-              break;
-            case clang::VTableComponent::CK_DeletingDtorPointer:
-              kind =  abi_dump::VTableComponent_Kind_DeletingDtorPointer;
-              mangle_contextp_->mangleCXXDtor(
-                  vtable_component.getDestructorDecl(),
-                  clang::CXXDtorType::Dtor_Deleting, ostream);
-              ostream.flush();
-              break;
-            case clang::VTableComponent::CK_UnusedFunctionPointer:
-              kind =  abi_dump::VTableComponent_Kind_UnusedFunctionPointer;
-            default:
-              break;
-          }
-        }
-        break;
-      default:
-        return false;
-    }
-  added_vtable_component->set_kind(kind);
-  added_vtable_component->set_component_value(value);
-  added_vtable_component->set_mangled_component_name(mangled_component_name);
-  return true;
-}
-
-bool RecordDeclWrapper::SetupTemplateInfo(
-    abi_dump::RecordDecl *record_declp,
-    const clang::CXXRecordDecl *cxx_record_decl) const {
-  assert(cxx_record_decl != nullptr);
-  if (cxx_record_decl->isTemplateDecl()) {
-    clang::ClassTemplateDecl *template_decl =
-        cxx_record_decl->getDescribedClassTemplate();
-    if (template_decl) {
-      clang::TemplateParameterList *template_parameter_list =
-          template_decl->getTemplateParameters();
-      if (template_parameter_list &&
-          !SetupTemplateParamNames(record_declp->mutable_template_info(),
-                                   template_parameter_list)) {
-        return false;
-      }
-    }
-  } else {
-    const clang::ClassTemplateSpecializationDecl *specialization_decl =
-        clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(
-            cxx_record_decl);
-    if(specialization_decl) {
-      const clang::TemplateArgumentList *arg_list =
-          &specialization_decl->getTemplateArgs();
-      if (arg_list &&
-          !SetupTemplateArguments(record_declp->mutable_template_info(),
-                                  arg_list)) {
-        return false;
-      }
-    }
+bool RecordDeclWrapper::SetupRecordInfo(abi_util::RecordTypeIR *record_declp,
+                                        const std::string &source_file) {
+  if (!record_declp) {
+    return false;
   }
-  return true;
-}
 
-bool RecordDeclWrapper::SetupRecordInfo(abi_dump::RecordDecl *record_declp,
-                                        const std::string &source_file) const {
-  std::string qualified_name = GetTagDeclQualifiedName(record_decl_);
+  if (record_decl_->isStruct()) {
+    record_declp->SetRecordKind(
+        abi_util::RecordTypeIR::RecordKind::struct_kind);
+  } else if (record_decl_->isClass()) {
+    record_declp->SetRecordKind(
+        abi_util::RecordTypeIR::RecordKind::class_kind);
+  } else {
+    record_declp->SetRecordKind(
+        abi_util::RecordTypeIR::RecordKind::union_kind);
+  }
+
   const clang::Type *basic_type = nullptr;
   if (!(basic_type = record_decl_->getTypeForDecl())) {
     return false;
   }
-  std::string mangled_name = ABIWrapper::GetTypeLinkageName(basic_type);
-  clang::QualType type = basic_type->getCanonicalTypeInternal();
-  std::string linker_key = (mangled_name == "") ? qualified_name : mangled_name;
-  if (!SetupBasicNamedAndTypedDecl(record_declp->mutable_basic_abi(),
-                                   type, qualified_name,
-                                   record_decl_->getAccess(), linker_key,
-                                   true)) {
+  clang::QualType qual_type = basic_type->getCanonicalTypeInternal();
+  if (!CreateExtendedType(qual_type, record_declp)) {
     return false;
   }
-  record_declp->set_mangled_record_name(mangled_name);
-  record_declp->set_source_file(source_file);
-  return true;
+  std::string record_qual_type_str = QualTypeToString(qual_type);
+  record_declp->SetSourceFile(source_file);
+  if (!record_decl_->hasNameForLinkage() ||
+      record_decl_->isAnonymousStructOrUnion()) {
+    record_declp->SetLinkerSetKey(previous_record_stages_);
+    record_declp->SetAnonymity(true);
+  } else {
+    previous_record_stages_ = record_qual_type_str;
+    record_declp->SetLinkerSetKey(record_qual_type_str);
+  }
+  record_declp->SetAccess(AccessClangToIR(record_decl_->getAccess()));
+  return SetupRecordFields(record_declp, source_file) &&
+      SetupCXXRecordInfo(record_declp, source_file);
 }
 
 bool RecordDeclWrapper::SetupCXXRecordInfo(
-    abi_dump::RecordDecl *record_declp) const {
+    abi_util::RecordTypeIR *record_declp, const std::string &source_file) {
   const clang::CXXRecordDecl *cxx_record_decl =
       clang::dyn_cast<clang::CXXRecordDecl>(record_decl_);
   if (!cxx_record_decl) {
     return true;
   }
-  return SetupTemplateInfo(record_declp, cxx_record_decl) &&
+  return SetupTemplateInfo(record_declp, cxx_record_decl, source_file) &&
       SetupCXXBases(record_declp, cxx_record_decl) &&
       SetupRecordVTable(record_declp, cxx_record_decl);
 }
 
-std::unique_ptr<abi_dump::RecordDecl> RecordDeclWrapper::GetRecordDecl() const {
-  std::unique_ptr<abi_dump::RecordDecl> abi_decl(new abi_dump::RecordDecl());
-  std::string source_file = GetDeclSourceFile(record_decl_, cip_);
-  abi_dump::RecordDecl *record_declp = abi_decl.get();
-  if (!SetupRecordInfo(record_declp, source_file) ||
-      !SetupRecordFields(record_declp) ||
-      !SetupCXXRecordInfo(abi_decl.get())) {
+bool RecordDeclWrapper::GetRecordDecl() {
+  auto abi_decl = std::make_unique<abi_util::RecordTypeIR>();
+  std::string source_file = GetCachedDeclSourceFile(record_decl_, cip_);
+  if (!SetupRecordInfo(abi_decl.get(), source_file)) {
     llvm::errs() << "Setting up CXX Bases / Template Info failed\n";
-    return nullptr;
+    return false;
   }
-  return abi_decl;
+  return ir_dumper_->AddLinkableMessageIR(abi_decl.get());
 }
 
 EnumDeclWrapper::EnumDeclWrapper(
     clang::MangleContext *mangle_contextp,
     clang::ASTContext *ast_contextp,
     const clang::CompilerInstance *compiler_instance_p,
-    const clang::EnumDecl *decl)
-  : ABIWrapper(mangle_contextp, ast_contextp, compiler_instance_p),
+    const clang::EnumDecl *decl,
+    std::set<std::string> *type_cache,
+    abi_util::IRDumper *ir_dumper,
+    std::map<const clang::Decl *, std::string> &decl_to_source_cache)
+  : ABIWrapper(mangle_contextp, ast_contextp, compiler_instance_p,
+               type_cache, ir_dumper, decl_to_source_cache),
     enum_decl_(decl) { }
 
-bool EnumDeclWrapper::SetupEnumFields(abi_dump::EnumDecl *enump) const {
+bool EnumDeclWrapper::SetupEnumFields(abi_util::EnumTypeIR *enump) {
+  if (!enump) {
+    return false;
+  }
   clang::EnumDecl::enumerator_iterator enum_it = enum_decl_->enumerator_begin();
   while (enum_it != enum_decl_->enumerator_end()) {
-    abi_dump::EnumFieldDecl *enum_fieldp = enump->add_enum_fields();
     std::string name = enum_it->getQualifiedNameAsString();
     uint64_t field_value = enum_it->getInitVal().getExtValue();
-    if (!enum_fieldp ||
-        !SetupBasicNamedAndTypedDecl(enum_fieldp->mutable_basic_abi(),
-                                     enum_it->getType(), name,
-                                     enum_it->getAccess(),
-                                     std::to_string(field_value), true)) {
-      return false;
-    }
-    enum_fieldp->set_enum_field_value(field_value);
+    enump->AddEnumField(abi_util::EnumFieldIR(name, field_value));
     enum_it++;
   }
   return true;
 }
 
-bool EnumDeclWrapper::SetupEnum(abi_dump::EnumDecl *enump,
-                                const std::string &source_file) const {
+bool EnumDeclWrapper::SetupEnum(abi_util::EnumTypeIR *enum_type,
+                                const std::string &source_file) {
   std::string enum_name = GetTagDeclQualifiedName(enum_decl_);
-  clang::QualType enum_type = enum_decl_->getIntegerType();
-  if (!SetupBasicNamedAndTypedDecl(enump->mutable_basic_abi(), enum_type,
-                                   enum_name, enum_decl_->getAccess(),
-                                   enum_name, true) ||
-      !SetupEnumFields(enump)) {
+  clang::QualType enum_qual_type =
+      enum_decl_->getTypeForDecl()->getCanonicalTypeInternal();
+  if (!CreateExtendedType(enum_qual_type, enum_type)) {
     return false;
   }
-  enump->set_source_file(source_file);
-  return true;
+  enum_type->SetSourceFile(source_file);
+  enum_type->SetUnderlyingType(QualTypeToString(enum_decl_->getIntegerType()));
+  enum_type->SetAccess(AccessClangToIR(enum_decl_->getAccess()));
+  return SetupEnumFields(enum_type) &&
+      CreateBasicNamedAndTypedDecl(enum_decl_->getIntegerType(), "");
 }
 
-std::unique_ptr<abi_dump::EnumDecl> EnumDeclWrapper::GetEnumDecl() const {
-  std::unique_ptr<abi_dump::EnumDecl> abi_decl(new abi_dump::EnumDecl());
-  std::string source_file = GetDeclSourceFile(enum_decl_, cip_);
+bool EnumDeclWrapper::GetEnumDecl() {
+  auto abi_decl = std::make_unique<abi_util::EnumTypeIR>();
+  std::string source_file = GetCachedDeclSourceFile(enum_decl_, cip_);
 
   if (!SetupEnum(abi_decl.get(), source_file)) {
-    llvm::errs() << "Setting up Enum fields failed\n";
-    return nullptr;
+    llvm::errs() << "Setting up Enum failed\n";
+    return false;
   }
-  return abi_decl;
+  return ir_dumper_->AddLinkableMessageIR(abi_decl.get());
 }
 
 GlobalVarDeclWrapper::GlobalVarDeclWrapper(
     clang::MangleContext *mangle_contextp,
     clang::ASTContext *ast_contextp,
     const clang::CompilerInstance *compiler_instance_p,
-    const clang::VarDecl *decl)
-  : ABIWrapper(mangle_contextp, ast_contextp, compiler_instance_p),
+    const clang::VarDecl *decl,std::set<std::string> *type_cache,
+    abi_util::IRDumper *ir_dumper,
+    std::map<const clang::Decl *, std::string> &decl_to_source_cache)
+  : ABIWrapper(mangle_contextp, ast_contextp, compiler_instance_p, type_cache,
+               ir_dumper, decl_to_source_cache),
     global_var_decl_(decl) { }
 
 bool GlobalVarDeclWrapper::SetupGlobalVar(
-    abi_dump::GlobalVarDecl *global_varp,
-    const std::string &source_file) const {
+    abi_util::GlobalVarIR *global_varp,
+    const std::string &source_file) {
   // Temporary fix : clang segfaults on trying to mangle global variable which
   // is a dependent sized array type.
-  std::string qualified_name = global_var_decl_->getQualifiedNameAsString();
   std::string mangled_name =
       GetMangledNameDecl(global_var_decl_, mangle_contextp_);
-  if (!SetupBasicNamedAndTypedDecl(
-      global_varp->mutable_basic_abi(),global_var_decl_->getType(),
-      qualified_name, global_var_decl_->getAccess(),
-      mangled_name, true)) {
+  if (!CreateBasicNamedAndTypedDecl(global_var_decl_->getType(), source_file)) {
     return false;
   }
-  global_varp->set_source_file(source_file);
+  global_varp->SetSourceFile(source_file);
+  global_varp->SetName(global_var_decl_->getQualifiedNameAsString());
+  global_varp->SetLinkerSetKey(mangled_name);
+  global_varp->SetReferencedType(
+      QualTypeToString(global_var_decl_->getType()));
   return true;
 }
 
-std::unique_ptr<abi_dump::GlobalVarDecl>
-GlobalVarDeclWrapper::GetGlobalVarDecl() const {
-  std::unique_ptr<abi_dump::GlobalVarDecl>
-      abi_decl(new abi_dump::GlobalVarDecl);
-  std::string source_file = GetDeclSourceFile(global_var_decl_, cip_);
-  if (!SetupGlobalVar(abi_decl.get(), source_file)) {
-    return nullptr;
-  }
-  return abi_decl;
+bool GlobalVarDeclWrapper::GetGlobalVarDecl() {
+  auto abi_decl = std::make_unique<abi_util::GlobalVarIR>();
+  std::string source_file = GetCachedDeclSourceFile(global_var_decl_, cip_);
+  return SetupGlobalVar(abi_decl.get(), source_file) &&
+      ir_dumper_->AddLinkableMessageIR(abi_decl.get());
 }
diff --git a/vndk/tools/header-checker/header-abi-dumper/src/abi_wrappers.h b/vndk/tools/header-checker/header-abi-dumper/src/abi_wrappers.h
index 262c9cf..af222b0 100644
--- a/vndk/tools/header-checker/header-abi-dumper/src/abi_wrappers.h
+++ b/vndk/tools/header-checker/header-abi-dumper/src/abi_wrappers.h
@@ -15,6 +15,8 @@
 #ifndef ABI_WRAPPERS_H_
 #define ABI_WRAPPERS_H_
 
+#include <ir_representation.h>
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
 #pragma clang diagnostic ignored "-Wnested-anon-types"
@@ -32,7 +34,10 @@
  public:
   ABIWrapper(clang::MangleContext *mangle_contextp,
              clang::ASTContext *ast_contextp,
-             const clang::CompilerInstance *cip);
+             const clang::CompilerInstance *cip,
+             std::set<std::string> *type_cache,
+             abi_util::IRDumper *ir_dumper,
+             std::map<const clang::Decl *, std::string> &decl_to_source_cache);
 
   static std::string GetDeclSourceFile(const clang::Decl *decl,
                                        const clang::CompilerInstance *cip);
@@ -41,123 +46,161 @@
                                         clang::MangleContext *mangle_context);
  protected:
   abi_dump::AccessSpecifier AccessClangToDump(
-      const clang::AccessSpecifier sp) const;
+      const clang::AccessSpecifier sp);
+  std::string GetCachedDeclSourceFile(const clang::Decl *decl,
+                                      const clang::CompilerInstance *cip);
 
-  bool SetupTemplateParamNames(abi_dump::TemplateInfo *tinfo,
-                               clang::TemplateParameterList *pl) const;
+  bool SetupTemplateArguments(const clang::TemplateArgumentList *tl,
+                              abi_util::TemplatedArtifactIR *ta,
+                              const std::string &source_file);
 
-  bool SetupTemplateArguments(abi_dump::TemplateInfo *tinfo,
-                              const clang::TemplateArgumentList *tl) const;
+  std::string QualTypeToString(const clang::QualType &sweet_qt);
 
-  std::string QualTypeToString(const clang::QualType &sweet_qt) const;
+  std::string GetTagDeclQualifiedName(const clang::TagDecl *decl);
 
-  std::string GetTagDeclQualifiedName(const clang::TagDecl *decl) const;
+  bool CreateBasicNamedAndTypedDecl(clang::QualType,
+                                    const std::string &source_file);
+  bool CreateBasicNamedAndTypedDecl(
+      clang::QualType canonical_type,
+      abi_util::TypeIR *typep,
+      const std::string &source_file);
 
-  bool SetupBasicTypeAbi(abi_dump::BasicTypeAbi *type_abi,
-                         const clang::QualType type, bool dump_size) const;
+  bool CreateExtendedType(
+      clang::QualType canonical_type,
+      abi_util::TypeIR *typep);
 
-  bool SetupBasicNamedAndTypedDecl(
-      abi_dump::BasicNamedAndTypedDecl *basic_named_and_typed_decl,
-      const clang::QualType type, const std::string &name,
-      const clang::AccessSpecifier &access, std::string key,
-      bool dump_size) const;
+  clang::QualType GetReferencedType(const clang::QualType qual_type);
 
-  std::string GetTypeLinkageName(const clang::Type *typep) const;
+  std::string GetTypeLinkageName(const clang::Type *typep);
 
-protected:
+  std::unique_ptr<abi_util::TypeIR> SetTypeKind(const clang::QualType qtype,
+                                                const std::string &source_file);
+
+
+ protected:
   const clang::CompilerInstance *cip_;
   clang::MangleContext *mangle_contextp_;
   clang::ASTContext *ast_contextp_;
+  std::set<std::string> *type_cache_;
+  abi_util::IRDumper *ir_dumper_;
+  std::map<const clang::Decl *, std::string> &decl_to_source_file_cache_;
 };
 
 class RecordDeclWrapper : public ABIWrapper {
  public:
-  RecordDeclWrapper(clang::MangleContext *mangle_contextp,
-                    clang::ASTContext *ast_contextp,
-                    const clang::CompilerInstance *compiler_instance_p,
-                    const clang::RecordDecl *decl);
+  RecordDeclWrapper(
+      clang::MangleContext *mangle_contextp, clang::ASTContext *ast_contextp,
+      const clang::CompilerInstance *compiler_instance_p,
+      const clang::RecordDecl *decl, std::set<std::string> *type_cache,
+      abi_util::IRDumper *ir_dumper,
+      std::map<const clang::Decl *, std::string> &decl_to_source_cache_,
+      const std::string &previous_record_stages);
 
-  std::unique_ptr<abi_dump::RecordDecl> GetRecordDecl() const;
+  bool GetRecordDecl();
 
  private:
   const clang::RecordDecl *record_decl_;
+  std::string previous_record_stages_;
 
  private:
-  bool SetupRecordInfo(abi_dump::RecordDecl *record_declp,
-                       const std::string &source_file) const;
+  bool SetupRecordInfo(abi_util::RecordTypeIR *type,
+                       const std::string &source_file);
 
-  bool SetupRecordFields(abi_dump::RecordDecl *record_declp) const;
+  bool SetupRecordFields(abi_util::RecordTypeIR *record_declp,
+                         const std::string &source_file);
 
-  bool SetupCXXBases(abi_dump::RecordDecl *cxxp,
-                     const clang::CXXRecordDecl *cxx_record_decl) const;
+  bool SetupCXXBases(abi_util::RecordTypeIR *cxxp,
+                     const clang::CXXRecordDecl *cxx_record_decl);
 
-  bool SetupTemplateInfo(abi_dump::RecordDecl *record_declp,
-                         const clang::CXXRecordDecl *cxx_record_decl) const;
+  bool SetupTemplateInfo(abi_util::RecordTypeIR *record_declp,
+                         const clang::CXXRecordDecl *cxx_record_decl,
+                         const std::string &source_file);
 
-  bool SetupRecordVTable(abi_dump::RecordDecl *record_declp,
-                         const clang::CXXRecordDecl *cxx_record_decl) const;
-  bool SetupRecordVTableComponent(
-      abi_dump::VTableComponent *added_vtable_component,
-      const clang::VTableComponent &vtable_component) const;
+  bool SetupRecordVTable(abi_util::RecordTypeIR *record_declp,
+                         const clang::CXXRecordDecl *cxx_record_decl);
+  abi_util::VTableComponentIR SetupRecordVTableComponent(
+      const clang::VTableComponent &vtable_component);
 
-  bool SetupCXXRecordInfo(abi_dump::RecordDecl *record_declp) const;
+  bool SetupCXXRecordInfo(abi_util::RecordTypeIR *record_declp,
+                          const std::string &source_file);
+
+  bool CreateAnonymousRecord(
+      const clang::RecordDecl *decl, const std::string &linker_set_key);
 };
 
 class FunctionDeclWrapper : public ABIWrapper {
  public:
-  FunctionDeclWrapper(clang::MangleContext *mangle_contextp,
-                      clang::ASTContext *ast_contextp,
-                      const clang::CompilerInstance *compiler_instance_p,
-                      const clang::FunctionDecl *decl);
+  FunctionDeclWrapper(
+      clang::MangleContext *mangle_contextp, clang::ASTContext *ast_contextp,
+      const clang::CompilerInstance *compiler_instance_p,
+      const clang::FunctionDecl *decl, std::set<std::string> *type_cache,
+      abi_util::IRDumper *ir_dumper,
+      std::map<const clang::Decl *, std::string> &decl_to_source_cache_);
 
-  std::unique_ptr<abi_dump::FunctionDecl> GetFunctionDecl() const;
+  std::unique_ptr<abi_util::FunctionIR> GetFunctionDecl();
 
  private:
   const clang::FunctionDecl *function_decl_;
 
  private:
-  bool SetupFunction(abi_dump::FunctionDecl *methodp,
-                     const std::string &source_file) const;
+  bool SetupFunction(abi_util::FunctionIR *methodp,
+                     const std::string &source_file);
 
-  bool SetupTemplateInfo(abi_dump::FunctionDecl *functionp) const;
+  bool SetupTemplateInfo(abi_util::FunctionIR *functionp,
+                         const std::string &source_file);
 
-  bool SetupFunctionParameters(abi_dump::FunctionDecl *functionp) const;
+  bool SetupFunctionParameters(abi_util::FunctionIR *functionp,
+                               const std::string &source_file);
+
+  bool SetupFunctionParameter(abi_util::FunctionIR *functionp,
+                              const clang::QualType qual_type,
+                              bool has_default_arg,
+                              const std::string &source_file);
+
+  bool SetupThisParameter(abi_util::FunctionIR *functionp,
+                          const std::string &source_file);
+
 };
 
 class EnumDeclWrapper : public ABIWrapper {
  public:
-  EnumDeclWrapper(clang::MangleContext *mangle_contextp,
-                  clang::ASTContext *ast_contextp,
-                  const clang::CompilerInstance *compiler_instance_p,
-                  const clang::EnumDecl *decl);
+  EnumDeclWrapper(
+      clang::MangleContext *mangle_contextp, clang::ASTContext *ast_contextp,
+      const clang::CompilerInstance *compiler_instance_p,
+      const clang::EnumDecl *decl,
+      std::set<std::string> *type_cache, abi_util::IRDumper *ir_dumper,
+      std::map<const clang::Decl *, std::string> &decl_to_source_cache_);
 
-  std::unique_ptr<abi_dump::EnumDecl> GetEnumDecl() const;
+  bool GetEnumDecl();
 
  private:
   const clang::EnumDecl *enum_decl_;
 
  private:
-  bool SetupEnum(abi_dump::EnumDecl *enump,
-                 const std::string &source_file) const;
-  bool SetupEnumFields(abi_dump::EnumDecl *enump) const;
+  bool SetupEnum(abi_util::EnumTypeIR *type,
+                 const std::string &source_file);
+
+  bool SetupEnumFields(abi_util::EnumTypeIR *enump);
 };
 
 class GlobalVarDeclWrapper : public ABIWrapper {
  public:
-  GlobalVarDeclWrapper(clang::MangleContext *mangle_contextp,
-                  clang::ASTContext *ast_contextp,
-                  const clang::CompilerInstance *compiler_instance_p,
-                  const clang::VarDecl *decl);
+  GlobalVarDeclWrapper(
+      clang::MangleContext *mangle_contextp, clang::ASTContext *ast_contextp,
+      const clang::CompilerInstance *compiler_instance_p,
+      const clang::VarDecl *decl,
+      std::set<std::string> *type_cache, abi_util::IRDumper *ir_dumper,
+      std::map<const clang::Decl *, std::string> &decl_to_source_cache_);
 
-  std::unique_ptr<abi_dump::GlobalVarDecl> GetGlobalVarDecl() const;
+  bool GetGlobalVarDecl();
 
  private:
   const clang::VarDecl *global_var_decl_;
  private:
-  bool SetupGlobalVar(abi_dump::GlobalVarDecl *global_varp,
-                      const std::string &source_file) const;
+  bool SetupGlobalVar(abi_util::GlobalVarIR *global_varp,
+                      const std::string &source_file);
 };
 
 } //end namespace abi_wrapper
 
-#endif  // ABI_WRAPPERS_H_
+#endif // ABI_WRAPPERS_H_
diff --git a/vndk/tools/header-checker/header-abi-dumper/src/ast_processing.cpp b/vndk/tools/header-checker/header-abi-dumper/src/ast_processing.cpp
index 66b3e9d..abf58ed 100644
--- a/vndk/tools/header-checker/header-abi-dumper/src/ast_processing.cpp
+++ b/vndk/tools/header-checker/header-abi-dumper/src/ast_processing.cpp
@@ -19,9 +19,6 @@
 #include <clang/Tooling/Core/QualTypeNames.h>
 #include <clang/Index/CodegenNameGenerator.h>
 
-#include <google/protobuf/text_format.h>
-#include <google/protobuf/io/zero_copy_stream_impl.h>
-
 #include <fstream>
 #include <iostream>
 #include <string>
@@ -33,83 +30,64 @@
 using abi_wrapper::GlobalVarDeclWrapper;
 
 HeaderASTVisitor::HeaderASTVisitor(
-    abi_dump::TranslationUnit *tu_ptr,
     clang::MangleContext *mangle_contextp,
     clang::ASTContext *ast_contextp,
     const clang::CompilerInstance *compiler_instance_p,
     const std::string &current_file_name,
     const std::set<std::string> &exported_headers,
-    const clang::Decl *tu_decl)
-  : tu_ptr_(tu_ptr),
-    mangle_contextp_(mangle_contextp),
+    const clang::Decl *tu_decl,
+    std::set<std::string> *type_cache,
+    abi_util::IRDumper *ir_dumper)
+  : mangle_contextp_(mangle_contextp),
     ast_contextp_(ast_contextp),
     cip_(compiler_instance_p),
     current_file_name_(current_file_name),
     exported_headers_(exported_headers),
-    tu_decl_(tu_decl) { }
+    tu_decl_(tu_decl),
+    type_cache_(type_cache),
+    ir_dumper_(ir_dumper) { }
 
 bool HeaderASTVisitor::VisitRecordDecl(const clang::RecordDecl *decl) {
-  // Skip forward declaration.
+  // Skip forward declarations, dependent records. Also skip anonymous records
+  // as they will be traversed through record fields.
   if (!decl->isThisDeclarationADefinition() ||
-      decl->getTypeForDecl()->isDependentType()) {
+      decl->getTypeForDecl()->isDependentType() ||
+      decl->isAnonymousStructOrUnion() ||
+      !decl->hasNameForLinkage()) {
     return true;
   }
   RecordDeclWrapper record_decl_wrapper(
-      mangle_contextp_, ast_contextp_, cip_, decl);
-  std::unique_ptr<abi_dump::RecordDecl> wrapped_record_decl =
-      record_decl_wrapper.GetRecordDecl();
-  if (!wrapped_record_decl) {
-    llvm::errs() << "Getting Record Decl failed\n";
-    return false;
-  }
-  abi_dump::RecordDecl *added_record_declp = tu_ptr_->add_records();
-  if (!added_record_declp) {
-    return false;
-  }
-  *added_record_declp = *wrapped_record_decl;
-  return true;
+      mangle_contextp_, ast_contextp_, cip_, decl, type_cache_,
+      ir_dumper_, decl_to_source_file_cache_, "");
+  return record_decl_wrapper.GetRecordDecl();
 }
 
 bool HeaderASTVisitor::VisitEnumDecl(const clang::EnumDecl *decl) {
   if (!decl->isThisDeclarationADefinition() ||
-      decl->getTypeForDecl()->isDependentType()) {
+      decl->getTypeForDecl()->isDependentType() ||
+      !decl->hasNameForLinkage()) {
     return true;
   }
   EnumDeclWrapper enum_decl_wrapper(
-      mangle_contextp_, ast_contextp_, cip_, decl);
-  std::unique_ptr<abi_dump::EnumDecl> wrapped_enum_decl =
-      enum_decl_wrapper.GetEnumDecl();
-  if (!wrapped_enum_decl) {
-    llvm::errs() << "Getting Enum Decl failed\n";
-    return false;
-  }
-  abi_dump::EnumDecl *added_enum_declp = tu_ptr_->add_enums();
-  if (!added_enum_declp) {
-    return false;
-  }
-  *added_enum_declp = *wrapped_enum_decl;
-  return true;
-}
+      mangle_contextp_, ast_contextp_, cip_, decl, type_cache_,
+      ir_dumper_, decl_to_source_file_cache_);
+  return enum_decl_wrapper.GetEnumDecl();
+ }
 
-static bool MutateFunctionWithLinkageName(abi_dump::TranslationUnit *tu_ptr,
-                                          const abi_dump::FunctionDecl *fd,
+static bool MutateFunctionWithLinkageName(const abi_util::FunctionIR *function,
+                                          abi_util::IRDumper *ir_dumper,
                                           std::string &linkage_name) {
-  abi_dump::FunctionDecl *added_function_declp = tu_ptr->add_functions();
-  if (!added_function_declp) {
-    return false;
-  }
-  *added_function_declp = *fd;
-  added_function_declp->set_mangled_function_name(linkage_name);
-  assert(added_function_declp->mutable_basic_abi() != nullptr);
-  added_function_declp->mutable_basic_abi()->set_linker_set_key(linkage_name);
-  return true;
+  auto added_function = std::make_unique<abi_util::FunctionIR>();
+  *added_function = *function;
+  added_function->SetLinkerSetKey(linkage_name);
+  return ir_dumper->AddLinkableMessageIR(added_function.get());
 }
 
-static bool AddMangledFunctions(abi_dump::TranslationUnit *tu_ptr,
-                                const abi_dump::FunctionDecl *fd,
+static bool AddMangledFunctions(const abi_util::FunctionIR *function,
+                                abi_util:: IRDumper *ir_dumper,
                                 std::vector<std::string> &manglings) {
   for (auto &&mangling : manglings) {
-    if (!MutateFunctionWithLinkageName(tu_ptr, fd, mangling)) {
+    if (!MutateFunctionWithLinkageName(function, ir_dumper, mangling)) {
       return false;
     }
   }
@@ -139,23 +117,20 @@
     return true;
   }
   FunctionDeclWrapper function_decl_wrapper(mangle_contextp_, ast_contextp_,
-                                            cip_, decl);
-  std::unique_ptr<abi_dump::FunctionDecl> wrapped_function_decl =
-      function_decl_wrapper.GetFunctionDecl();
-  if (!wrapped_function_decl) {
-    llvm::errs() << "Getting Function Decl failed\n";
-    return false;
-  }
+                                            cip_, decl, type_cache_,
+                                            ir_dumper_,
+                                            decl_to_source_file_cache_);
+  auto function_wrapper = function_decl_wrapper.GetFunctionDecl();
   // Destructors and Constructors can have more than 1 symbol generated from the
   // same Decl.
   clang::index::CodegenNameGenerator cg(*ast_contextp_);
   std::vector<std::string> manglings = cg.getAllManglings(decl);
   if (!manglings.empty()) {
-    return AddMangledFunctions(tu_ptr_, wrapped_function_decl.get(), manglings);
+    return AddMangledFunctions(function_wrapper.get(), ir_dumper_, manglings);
   }
   std::string linkage_name =
       ABIWrapper::GetMangledNameDecl(decl, mangle_contextp_);
-  return MutateFunctionWithLinkageName(tu_ptr_, wrapped_function_decl.get(),
+  return MutateFunctionWithLinkageName(function_wrapper.get(), ir_dumper_,
                                        linkage_name);
 }
 
@@ -166,19 +141,10 @@
     return true;
   }
   GlobalVarDeclWrapper global_var_decl_wrapper(mangle_contextp_, ast_contextp_,
-                                               cip_, decl);
-  std::unique_ptr<abi_dump::GlobalVarDecl> wrapped_global_var_decl =
-      global_var_decl_wrapper.GetGlobalVarDecl();
-  if (!wrapped_global_var_decl) {
-    llvm::errs() << "Getting Global Var Decl failed\n";
-    return false;
-  }
-  abi_dump::GlobalVarDecl *added_global_var_declp = tu_ptr_->add_global_vars();
-  if (!added_global_var_declp) {
-    return false;
-  }
-  *added_global_var_declp = *wrapped_global_var_decl;
-  return true;
+                                               cip_, decl, type_cache_,
+                                               ir_dumper_,
+                                               decl_to_source_file_cache_);
+  return  global_var_decl_wrapper.GetGlobalVarDecl();
 }
 
 static bool AreHeadersExported(const std::set<std::string> &exported_headers) {
@@ -191,6 +157,7 @@
     return true;
   }
   std::string source_file = ABIWrapper::GetDeclSourceFile(decl, cip_);
+  decl_to_source_file_cache_.insert(std::make_pair(decl, source_file));
   // If no exported headers are specified we assume the whole AST is exported.
   if ((decl != tu_decl_) && AreHeadersExported(exported_headers_) &&
       (exported_headers_.find(source_file) == exported_headers_.end())) {
@@ -210,18 +177,19 @@
     exported_headers_(exported_headers) { }
 
 void HeaderASTConsumer::HandleTranslationUnit(clang::ASTContext &ctx) {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-  std::ofstream text_output(out_dump_name_);
-  google::protobuf::io::OstreamOutputStream text_os(&text_output);
+  clang::PrintingPolicy policy(ctx.getPrintingPolicy());
+  policy.SuppressTagKeyword = true;
+  ctx.setPrintingPolicy(policy);
   clang::TranslationUnitDecl *translation_unit = ctx.getTranslationUnitDecl();
   std::unique_ptr<clang::MangleContext> mangle_contextp(
       ctx.createMangleContext());
-  abi_dump::TranslationUnit tu;
-  std::string str_out;
-  HeaderASTVisitor v(&tu, mangle_contextp.get(), &ctx, cip_, file_name_,
-                     exported_headers_, translation_unit);
-  if (!v.TraverseDecl(translation_unit) ||
-      !google::protobuf::TextFormat::Print(tu, &text_os)) {
+  std::set<std::string> type_cache;
+  std::unique_ptr<abi_util::IRDumper> ir_dumper =
+      abi_util::IRDumper::CreateIRDumper("protobuf", out_dump_name_);
+  HeaderASTVisitor v(mangle_contextp.get(), &ctx, cip_, file_name_,
+                     exported_headers_, translation_unit, &type_cache,
+                     ir_dumper.get());
+  if (!v.TraverseDecl(translation_unit) || !ir_dumper->Dump()) {
     llvm::errs() << "Serialization to ostream failed\n";
     ::exit(1);
   }
diff --git a/vndk/tools/header-checker/header-abi-dumper/src/ast_processing.h b/vndk/tools/header-checker/header-abi-dumper/src/ast_processing.h
index f3e6f8c..569936b 100644
--- a/vndk/tools/header-checker/header-abi-dumper/src/ast_processing.h
+++ b/vndk/tools/header-checker/header-abi-dumper/src/ast_processing.h
@@ -21,6 +21,8 @@
 #include "proto/abi_dump.pb.h"
 #pragma clang diagnostic pop
 
+#include <ir_representation.h>
+
 #include <clang/AST/AST.h>
 #include <clang/AST/ASTConsumer.h>
 #include <clang/AST/Mangle.h>
@@ -33,13 +35,14 @@
 class HeaderASTVisitor
     : public clang::RecursiveASTVisitor<HeaderASTVisitor> {
  public:
-  HeaderASTVisitor(abi_dump::TranslationUnit *tu_ptr,
-                   clang::MangleContext *mangle_contextp,
+  HeaderASTVisitor(clang::MangleContext *mangle_contextp,
                    clang::ASTContext *ast_contextp,
                    const clang::CompilerInstance *compiler_instance_p,
                    const std::string &current_file_name,
                    const std::set<std::string> &exported_headers,
-                   const clang::Decl *tu_decl);
+                   const clang::Decl *tu_decl,
+                   std::set<std::string> *type_cache,
+                   abi_util::IRDumper *ir_dumper);
 
   bool VisitRecordDecl(const clang::RecordDecl *decl);
 
@@ -57,7 +60,6 @@
   }
 
  private:
-  abi_dump::TranslationUnit *tu_ptr_;
   clang::MangleContext *mangle_contextp_;
   clang::ASTContext *ast_contextp_;
   const clang::CompilerInstance *cip_;
@@ -65,6 +67,11 @@
   const std::set<std::string> &exported_headers_;
   // To optimize recursion into only exported abi.
   const clang::Decl *tu_decl_;
+  std::set<std::string> *type_cache_;
+  abi_util::IRDumper *ir_dumper_;
+  // We cache the source file an AST node corresponds to, to avoid repeated
+  // calls to "realpath".
+  std::map<const clang::Decl *, std::string> decl_to_source_file_cache_;
 };
 
 class HeaderASTConsumer : public clang::ASTConsumer {
@@ -83,4 +90,4 @@
   std::set<std::string> exported_headers_;
 };
 
-#endif  // AST_PROCESSING_H_
+#endif // AST_PROCESSING_H_
diff --git a/vndk/tools/header-checker/header-abi-linker/src/header_abi_linker.cpp b/vndk/tools/header-checker/header-abi-linker/src/header_abi_linker.cpp
index 96616d1..b02092d 100644
--- a/vndk/tools/header-checker/header-abi-linker/src/header_abi_linker.cpp
+++ b/vndk/tools/header-checker/header-abi-linker/src/header_abi_linker.cpp
@@ -85,16 +85,20 @@
 
   bool LinkAndDump();
 
+  template <typename T>
+  static std::string GetLinkageName(T &element) {
+    return element.type_info().linker_set_key();
+  }
+  template <typename T>
+  static std::string GetSourceFile(T &element) {
+    return element.type_info().source_file();
+  }
  private:
-  bool LinkRecords(const abi_dump::TranslationUnit &dump_tu,
-                   abi_dump::TranslationUnit *linked_tu);
-
+  bool LinkTypes(const abi_dump::TranslationUnit &dump_tu,
+                 abi_dump::TranslationUnit *linked_tu);
   bool LinkFunctions(const abi_dump::TranslationUnit &dump_tu,
                      abi_dump::TranslationUnit *linked_tu);
 
-  bool LinkEnums(const abi_dump::TranslationUnit &dump_tu,
-                 abi_dump::TranslationUnit *linked_tu);
-
   bool LinkGlobalVars(const abi_dump::TranslationUnit &dump_tu,
                       abi_dump::TranslationUnit *linked_tu);
 
@@ -110,6 +114,8 @@
 
   bool ParseSoFile();
 
+  bool AddElfSymbols(abi_dump::TranslationUnit *linked_tu);
+
  private:
   const std::vector<std::string> &dump_files_;
   const std::vector<std::string> &exported_header_dirs_;
@@ -120,9 +126,8 @@
   const std::string &api_;
   // TODO: Add to a map of std::sets instead.
   std::set<std::string> exported_headers_;
-  std::set<std::string> record_decl_set_;
+  std::set<std::string> types_set_;
   std::set<std::string> function_decl_set_;
-  std::set<std::string> enum_decl_set_;
   std::set<std::string> globvar_decl_set_;
   // Version Script Regex Matching.
   std::set<std::string> functions_regex_matched_set;
@@ -132,12 +137,32 @@
   std::regex globvars_vs_regex_;
 };
 
+template <typename T, typename Iterable>
+static bool AddElfSymbols(google::protobuf::RepeatedPtrField<T> *dst,
+                          Iterable symbols) {
+  for (auto &&symbol : symbols) {
+    auto *added_symbol = dst->Add();
+    if (added_symbol == nullptr) {
+      return false;
+    }
+    added_symbol->set_name(symbol);
+  }
+  return true;
+}
+
+// To be called right after parsing the .so file / version script.
+bool HeaderAbiLinker::AddElfSymbols(abi_dump::TranslationUnit *linked_tu) {
+
+  return ::AddElfSymbols(linked_tu->mutable_elf_functions(), function_decl_set_)
+      && ::AddElfSymbols(linked_tu->mutable_elf_objects(), globvar_decl_set_);
+}
+
 bool HeaderAbiLinker::LinkAndDump() {
   abi_dump::TranslationUnit linked_tu;
   std::ofstream text_output(out_dump_name_);
   google::protobuf::io::OstreamOutputStream text_os(&text_output);
-  // If a version script is available, we use that as a filter.
-  if (version_script.empty()) {
+  // If the user specifies that a version script should be used, use that.
+  if (!so_file_.empty()) {
     exported_headers_ =
         abi_util::CollectAllExportedHeaders(exported_header_dirs_);
     if (!ParseSoFile()) {
@@ -149,20 +174,20 @@
     return false;
   }
 
+  AddElfSymbols(&linked_tu);
+
   for (auto &&i : dump_files_) {
     abi_dump::TranslationUnit dump_tu;
     std::ifstream input(i);
     google::protobuf::io::IstreamInputStream text_is(&input);
     if (!google::protobuf::TextFormat::Parse(&text_is, &dump_tu) ||
-        !LinkRecords(dump_tu, &linked_tu) ||
+        !LinkTypes(dump_tu, &linked_tu) ||
         !LinkFunctions(dump_tu, &linked_tu) ||
-        !LinkEnums(dump_tu, &linked_tu) ||
         !LinkGlobalVars(dump_tu, &linked_tu)) {
       llvm::errs() << "Failed to link elements\n";
       return false;
     }
   }
-
   if (!google::protobuf::TextFormat::Print(linked_tu, &text_os)) {
     llvm::errs() << "Serialization to ostream failed\n";
     return false;
@@ -170,22 +195,6 @@
   return true;
 }
 
-static std::string GetSymbol(const abi_dump::RecordDecl &element) {
-  return element.mangled_record_name();
-}
-
-static std::string GetSymbol(const abi_dump::FunctionDecl &element) {
-  return element.mangled_function_name();
-}
-
-static std::string GetSymbol(const abi_dump::EnumDecl &element) {
-  return element.basic_abi().linker_set_key();
-}
-
-static std::string GetSymbol(const abi_dump::GlobalVarDecl &element) {
-  return element.basic_abi().linker_set_key();
-}
-
 static bool QueryRegexMatches(std::set<std::string> *regex_matched_link_set,
                               const std::regex *vs_regex,
                               const std::string &symbol) {
@@ -219,10 +228,10 @@
   return std::regex(all_regex_match_str);
 }
 
+//TODO: make linking decls multi-threaded b/63590537.
 template <typename T>
 inline bool HeaderAbiLinker::LinkDecl(
-    google::protobuf::RepeatedPtrField<T> *dst,
-    std::set<std::string> *link_set,
+    google::protobuf::RepeatedPtrField<T> *dst, std::set<std::string> *link_set,
     std::set<std::string> *regex_matched_link_set, const std::regex *vs_regex,
     const google::protobuf::RepeatedPtrField<T> &src, bool use_version_script) {
   assert(dst != nullptr);
@@ -230,18 +239,20 @@
   for (auto &&element : src) {
     // If we are not using a version script and exported headers are available,
     // filter out unexported abi.
-    if (!exported_headers_.empty() &&
-        exported_headers_.find(element.source_file()) ==
+    std::string source_file = GetSourceFile(element);
+    // Builtin types will not have source file information.
+    if (!exported_headers_.empty() && !source_file.empty() &&
+        exported_headers_.find(source_file) ==
         exported_headers_.end()) {
       continue;
     }
+    std::string element_str = GetLinkageName(element);
     // Check for the existence of the element in linked dump / symbol file.
     if (!use_version_script) {
-        if (!link_set->insert(element.basic_abi().linker_set_key()).second) {
+      if (!link_set->insert(element_str).second) {
         continue;
-        }
+      }
     } else {
-      std::string element_str = GetSymbol(element);
       std::set<std::string>::iterator it =
           link_set->find(element_str);
       if (it == link_set->end()) {
@@ -263,13 +274,52 @@
   return true;
 }
 
-bool HeaderAbiLinker::LinkRecords(const abi_dump::TranslationUnit &dump_tu,
-                                  abi_dump::TranslationUnit *linked_tu) {
+
+template<>
+std::string HeaderAbiLinker::GetLinkageName<const abi_dump::FunctionDecl> (
+    const abi_dump::FunctionDecl &element) {
+  return element.linker_set_key();
+}
+
+template<>
+std::string HeaderAbiLinker::GetSourceFile<const abi_dump::FunctionDecl> (
+    const abi_dump::FunctionDecl &element) {
+  return element.source_file();
+}
+
+template<>
+std::string HeaderAbiLinker::GetLinkageName<const abi_dump::GlobalVarDecl> (
+    const abi_dump::GlobalVarDecl &element) {
+  return element.linker_set_key();
+}
+
+template<>
+std::string HeaderAbiLinker::GetSourceFile<const abi_dump::GlobalVarDecl> (
+    const abi_dump::GlobalVarDecl &element) {
+  return element.source_file();
+}
+
+bool HeaderAbiLinker::LinkTypes(const abi_dump::TranslationUnit &dump_tu,
+                                abi_dump::TranslationUnit *linked_tu) {
   assert(linked_tu != nullptr);
-  // Even if version scripts are available we take in records, since the symbols
-  // in the version script might reference a record exposed by the library.
-  return LinkDecl(linked_tu->mutable_records(), &record_decl_set_, nullptr,
-                  nullptr, dump_tu.records(), false);
+  // Even if version scripts are available we take in types, since the symbols
+  // in the version script might reference a type exposed by the library.
+  return LinkDecl(linked_tu->mutable_record_types(), &types_set_, nullptr,
+                  nullptr, dump_tu.record_types(), false) &&
+      LinkDecl(linked_tu->mutable_enum_types(), &types_set_, nullptr,
+               nullptr, dump_tu.enum_types(), false) &&
+      LinkDecl(linked_tu->mutable_builtin_types(), &types_set_, nullptr,
+               nullptr, dump_tu.builtin_types(), false) &&
+      LinkDecl(linked_tu->mutable_pointer_types(), &types_set_, nullptr,
+               nullptr, dump_tu.pointer_types(), false) &&
+      LinkDecl(linked_tu->mutable_rvalue_reference_types(), &types_set_, nullptr,
+               nullptr, dump_tu.rvalue_reference_types(), false) &&
+      LinkDecl(linked_tu->mutable_lvalue_reference_types(), &types_set_, nullptr,
+               nullptr, dump_tu.lvalue_reference_types(), false) &&
+      LinkDecl(linked_tu->mutable_array_types(), &types_set_, nullptr,
+               nullptr, dump_tu.array_types(), false) &&
+      LinkDecl(linked_tu->mutable_qualified_types(), &types_set_, nullptr,
+               nullptr, dump_tu.qualified_types(), false);
 }
 
 bool HeaderAbiLinker::LinkFunctions(const abi_dump::TranslationUnit &dump_tu,
@@ -281,15 +331,6 @@
                   (!version_script_.empty() || !so_file_.empty()));
 }
 
-bool HeaderAbiLinker::LinkEnums(const abi_dump::TranslationUnit &dump_tu,
-                                abi_dump::TranslationUnit *linked_tu) {
-  assert(linked_tu != nullptr);
-  // Even if version scripts are available we take in records, since the symbols
-  // in the version script might reference an enum exposed by the library.
-  return LinkDecl(linked_tu->mutable_enums(), &enum_decl_set_, nullptr,
-                  nullptr, dump_tu.enums(), false);
-}
-
 bool HeaderAbiLinker::LinkGlobalVars(const abi_dump::TranslationUnit &dump_tu,
                                      abi_dump::TranslationUnit *linked_tu) {
   assert(linked_tu != nullptr);
@@ -345,6 +386,10 @@
 int main(int argc, const char **argv) {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
   llvm::cl::ParseCommandLineOptions(argc, argv, "header-linker");
+  if (so_file.empty() && version_script.empty()) {
+    llvm::errs() << "One of -so or -v needs to be specified\n";
+    return -1;
+  }
   if (no_filter) {
     static_cast<std::vector<std::string> &>(exported_header_dirs).clear();
   }
diff --git a/vndk/tools/header-checker/header-abi-util/include/header_abi_util.h b/vndk/tools/header-checker/header-abi-util/include/header_abi_util.h
index b335cdd..5f18ab7 100644
--- a/vndk/tools/header-checker/header-abi-util/include/header_abi_util.h
+++ b/vndk/tools/header-checker/header-abi-util/include/header_abi_util.h
@@ -18,6 +18,7 @@
 #include <llvm/Support/Endian.h>
 #include <llvm/Support/raw_ostream.h>
 
+#include <map>
 #include <regex>
 #include <set>
 #include <string>
@@ -128,4 +129,60 @@
   bool IsSymbolExported(const Elf_Sym *elf_sym) const;
 };
 
+template <typename T, typename K>
+std::vector<T> FindRemovedElements(
+    const std::map<K, T> &old_elements_map,
+    const std::map<K, T> &new_elements_map) {
+  std::vector<T> removed_elements;
+  for (auto &&map_element : old_elements_map) {
+      auto element_key = map_element.first;
+      auto new_element = new_elements_map.find(element_key);
+      if (new_element == new_elements_map.end()) {
+        removed_elements.emplace_back(map_element.second);
+      }
+  }
+  return removed_elements;
+}
+
+template <typename T, typename F, typename K, typename Iterable>
+inline void AddToMap(std::map<K, T> *dst, Iterable &src, F get_key) {
+  for (auto &&element : src) {
+    dst->insert(std::make_pair(get_key(&element), &element));
+  }
+}
+
+template <typename F, typename K, typename Iterable>
+inline void AddToSet(std::set<K> *dst, Iterable &src, F get_key) {
+  for (auto &&element : src) {
+    dst->insert(get_key(element));
+  }
+}
+
+template <typename K, typename T>
+std::vector<std::pair<T, T>> FindCommonElements(
+    const std::map<K, T> &old_elements_map,
+    const std::map<K, T> &new_elements_map) {
+  std::vector<std::pair<T, T>> common_elements;
+  typename std::map<K, T>::const_iterator old_element =
+      old_elements_map.begin();
+  typename std::map<K, T>::const_iterator new_element =
+      new_elements_map.begin();
+  while (old_element != old_elements_map.end() &&
+         new_element != new_elements_map.end()) {
+    if (old_element->first == new_element->first) {
+      common_elements.emplace_back(std::make_pair(
+          old_element->second, new_element->second));
+      old_element++;
+      new_element++;
+      continue;
+    }
+    if (old_element->first < new_element->first) {
+      old_element++;
+    } else {
+      new_element++;
+    }
+  }
+  return common_elements;
+}
+
 } // namespace abi_util
diff --git a/vndk/tools/header-checker/header-abi-util/include/ir_representation.h b/vndk/tools/header-checker/header-abi-util/include/ir_representation.h
new file mode 100644
index 0000000..0567d0e
--- /dev/null
+++ b/vndk/tools/header-checker/header-abi-util/include/ir_representation.h
@@ -0,0 +1,1126 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef IR_
+#define IR_
+
+#include <map>
+#include <regex>
+#include <set>
+#include <string>
+#include <vector>
+#include <memory>
+
+// Classes which act as middle-men between clang AST parsing routines and
+// message format specific dumpers.
+namespace abi_util {
+
+enum CompatibilityStatusIR {
+  Compatible = 0,
+  UnreferencedChanges = 1,
+  Extension = 4,
+  Incompatible = 8
+};
+
+static inline CompatibilityStatusIR operator|(CompatibilityStatusIR f,
+                                              CompatibilityStatusIR s) {
+  return static_cast<CompatibilityStatusIR>(
+      static_cast<std::underlying_type<CompatibilityStatusIR>::type>(f) |
+      static_cast<std::underlying_type<CompatibilityStatusIR>::type>(s));
+}
+
+static inline CompatibilityStatusIR operator&(
+    CompatibilityStatusIR f, CompatibilityStatusIR s) {
+  return static_cast<CompatibilityStatusIR>(
+      static_cast<std::underlying_type<CompatibilityStatusIR>::type>(f) &
+      static_cast<std::underlying_type<CompatibilityStatusIR>::type>(s));
+}
+
+enum AccessSpecifierIR {
+  PublicAccess = 1,
+  ProtectedAccess = 2,
+  PrivateAccess = 3
+};
+
+enum LinkableMessageKind {
+  RecordTypeKind,
+  EnumTypeKind,
+  PointerTypeKind,
+  QualifiedTypeKind,
+  ArrayTypeKind,
+  LvalueReferenceTypeKind,
+  RvalueReferenceTypeKind,
+  BuiltinTypeKind,
+  FunctionKind,
+  GlobalVarKind
+};
+
+class LinkableMessageIR {
+ public:
+  const std::string &GetLinkerSetKey() const {
+    return linker_set_key_;
+  }
+
+  void SetSourceFile(const std::string &source_file) {
+    source_file_ = source_file;
+  }
+
+  void SetLinkerSetKey(const std::string &linker_set_key) {
+    linker_set_key_ = linker_set_key;
+  }
+
+  const std::string &GetSourceFile() const {
+    return source_file_;
+  }
+
+  virtual LinkableMessageKind GetKind() const = 0;
+
+  virtual ~LinkableMessageIR() {}
+
+ protected:
+  // The source file where this message comes from. This will be an empty string
+  // for built-in types
+  std::string source_file_;
+  std::string linker_set_key_;
+};
+
+class BasicTypeInfoIR {
+ public:
+  BasicTypeInfoIR(const std::string &name, const std::string &type,
+                  const std::string linker_set_key, uint64_t size,
+                  uint32_t alignment)
+      : name_(name), referenced_type_(type), linker_set_key_(linker_set_key) ,
+        size_(size), alignment_(alignment) { }
+
+  BasicTypeInfoIR() { }
+
+  std::string GetLinkerSetKey() {
+    return linker_set_key_;
+  }
+
+ protected:
+  std::string name_;
+  std::string referenced_type_;
+  std::string linker_set_key_;
+  uint64_t size_;
+  uint32_t alignment_;
+};
+
+// TODO: Break this up into types with sizes and those without types ?
+class TypeIR : public LinkableMessageIR {
+ public:
+  void SetName(const std::string &name) {
+    name_ = name;
+  }
+
+  const std::string &GetName() const {
+    return name_;
+  }
+
+  void SetReferencedType(const std::string &type) {
+    referenced_type_ = type;
+  }
+
+  const std::string &GetReferencedType() const {
+    return referenced_type_;
+  }
+
+  void SetSize(uint64_t size) {
+    size_ = size;
+  }
+  uint64_t GetSize() const {
+   return size_;
+  }
+  void SetAlignment(uint32_t alignment) {
+    alignment_ = alignment;
+  }
+  uint32_t GetAlignment() const {
+    return alignment_;
+  }
+  ~TypeIR() override { }
+
+ protected:
+  std::string name_;
+  std::string referenced_type_;
+  uint64_t size_;
+  uint32_t alignment_;
+};
+
+class VTableComponentIR {
+ public:
+  enum Kind {
+    VCallOffset = 0,
+    VBaseOffset = 1,
+    OffsetToTop = 2,
+    RTTI = 3,
+    FunctionPointer = 4,
+    CompleteDtorPointer = 5,
+    DeletingDtorPointer = 6,
+    UnusedFunctionPointer = 7
+  };
+
+  VTableComponentIR(const std::string &name, Kind kind, int64_t value)
+      : component_name_(name), kind_(kind), value_(value) { }
+
+  VTableComponentIR() { }
+
+  Kind GetKind() const {
+    return kind_;
+  }
+
+  int64_t GetValue() const {
+    return value_;
+  }
+
+  const std::string &GetName() const {
+    return component_name_;
+  }
+
+ protected:
+  std::string component_name_;
+  Kind kind_;
+  int64_t value_;
+};
+
+class VTableLayoutIR {
+ public:
+  void AddVTableComponent(VTableComponentIR &&vtable_component) {
+    vtable_components_.emplace_back(std::move(vtable_component));
+  }
+
+  const std::vector<VTableComponentIR> &GetVTableComponents() const {
+    return vtable_components_;
+  }
+
+  uint64_t GetVTableNumEntries() const {
+    return vtable_components_.size();
+  }
+
+ protected:
+  std::vector<VTableComponentIR> vtable_components_;
+};
+
+class CXXBaseSpecifierIR {
+ public:
+  CXXBaseSpecifierIR(const std::string &type, bool is_virtual,
+                     AccessSpecifierIR access) :
+    referenced_type_(type), is_virtual_(is_virtual), access_(access) { }
+
+  CXXBaseSpecifierIR() { }
+
+  const std::string &GetReferencedType() const {
+    return referenced_type_;
+  }
+
+  bool IsVirtual() const {
+    return is_virtual_;
+  }
+
+  AccessSpecifierIR GetAccess() const {
+    return access_;
+  }
+
+ protected:
+  std::string referenced_type_;
+  bool is_virtual_;
+  AccessSpecifierIR access_;
+};
+
+class TemplateElementIR {
+ public:
+  TemplateElementIR(std::string &&type)
+      : referenced_type_(std::move(type)) { }
+
+  TemplateElementIR(const std::string &type)
+      : referenced_type_(type) { }
+
+  TemplateElementIR() { }
+
+  const std::string &GetReferencedType() const {
+    return referenced_type_;
+  }
+
+ protected:
+  std::string referenced_type_;
+};
+
+class TemplateInfoIR {
+ public:
+  void AddTemplateElement(TemplateElementIR &&element) {
+    template_elements_.emplace_back(element);
+  }
+
+  const std::vector<TemplateElementIR> &GetTemplateElements() const {
+    return template_elements_;
+  }
+
+ protected:
+  std::vector<TemplateElementIR> template_elements_;
+};
+
+class TemplatedArtifactIR {
+ public:
+  void SetTemplateInfo(TemplateInfoIR &&template_info) {
+    template_info_ = std::move(template_info);
+  }
+
+  const std::vector<TemplateElementIR> &GetTemplateElements() const {
+    return template_info_.GetTemplateElements();
+  }
+
+ protected:
+  TemplateInfoIR template_info_;
+};
+
+class RecordFieldIR {
+ public:
+  RecordFieldIR(const std::string &name, const std::string &type,
+                uint64_t offset, AccessSpecifierIR access)
+      : name_(name), referenced_type_(type), offset_(offset),
+        access_(access) { }
+
+  RecordFieldIR() { }
+
+  const std::string &GetName() const {
+    return name_;
+  }
+
+  const std::string &GetReferencedType() const {
+    return referenced_type_;
+  }
+
+  uint64_t GetOffset() const {
+    return offset_;
+  }
+
+  AccessSpecifierIR GetAccess() const {
+    return access_;
+  }
+
+ protected:
+  std::string name_;
+  std::string referenced_type_;
+  uint64_t offset_;
+  AccessSpecifierIR access_;
+};
+
+class RecordTypeIR: public TypeIR, public TemplatedArtifactIR {
+ public:
+  enum RecordKind {
+    struct_kind,
+    class_kind,
+    union_kind
+  };
+
+  void AddRecordField(RecordFieldIR &&field) {
+    fields_.emplace_back(std::move(field));
+  }
+
+  void SetRecordFields(std::vector<RecordFieldIR> &&fields) {
+    fields_ = std::move(fields);
+  }
+
+  void SetVTableLayout(VTableLayoutIR &&vtable_layout) {
+    vtable_layout_ = std::move(vtable_layout);
+  }
+
+  const VTableLayoutIR &GetVTableLayout() const {
+    return vtable_layout_;
+  }
+
+  void AddCXXBaseSpecifier(CXXBaseSpecifierIR &&base_specifier) {
+    bases_.emplace_back(std::move(base_specifier));
+  }
+
+  void SetCXXBaseSpecifiers(std::vector<CXXBaseSpecifierIR> &&bases) {
+    bases_ = std::move(bases);
+  }
+
+  const std::vector<CXXBaseSpecifierIR> &GetBases() const {
+    return bases_;
+  }
+
+  void SetAccess(AccessSpecifierIR access) { access_ = access;}
+
+  AccessSpecifierIR GetAccess() const {
+    return access_;
+  }
+
+  const std::vector<RecordFieldIR> &GetFields() const {
+    return fields_;
+  }
+
+  LinkableMessageKind GetKind() const override {
+    return LinkableMessageKind::RecordTypeKind;
+  }
+
+  uint64_t GetVTableNumEntries() const {
+    return vtable_layout_.GetVTableNumEntries();
+  }
+
+  void SetRecordKind(RecordKind record_kind) {
+    record_kind_ = record_kind;
+  }
+
+  RecordKind GetRecordKind() const {
+    return record_kind_;
+  }
+
+  void SetAnonymity(bool is_anonymous) {
+    is_anonymous_ = is_anonymous;
+  }
+
+  bool IsAnonymous() const {
+    return is_anonymous_;
+  }
+
+ protected:
+  std::vector<RecordFieldIR> fields_;
+  VTableLayoutIR vtable_layout_;
+  std::vector<CXXBaseSpecifierIR> bases_;
+  AccessSpecifierIR access_;
+  bool is_anonymous_;
+  RecordKind record_kind_;
+};
+
+class EnumFieldIR {
+ public:
+  EnumFieldIR(const std::string &name, int value)
+      : name_(name), value_(value) { }
+  const std::string &GetName() const {
+    return name_;
+  }
+
+  int GetValue() const {
+    return value_;
+  }
+
+ protected:
+  std::string name_;
+  int value_;
+};
+
+class EnumTypeIR : public TypeIR {
+ public:
+  // Add Methods to get information from the IR.
+  void AddEnumField(EnumFieldIR &&field) {
+    fields_.emplace_back(std::move(field));
+  }
+
+  void SetAccess(AccessSpecifierIR access) { access_ = access;}
+
+  LinkableMessageKind GetKind() const override {
+    return LinkableMessageKind::EnumTypeKind;
+  }
+
+  AccessSpecifierIR GetAccess() const {
+    return access_;
+  }
+
+  void SetUnderlyingType(std::string &&underlying_type) {
+    underlying_type_ = std::move(underlying_type);
+  }
+
+  void SetUnderlyingType(const std::string &underlying_type) {
+    underlying_type_ = underlying_type;
+  }
+
+  const std::string &GetUnderlyingType() const {
+    return underlying_type_;
+  }
+
+  void SetFields(std::vector<EnumFieldIR> &&fields) {
+    fields_ = std::move(fields);
+  }
+
+  const std::vector<EnumFieldIR> &GetFields() const {
+    return fields_;
+  }
+
+ protected:
+  std::vector<EnumFieldIR> fields_;
+  std::string underlying_type_;
+  AccessSpecifierIR access_;
+};
+
+class ArrayTypeIR : public TypeIR {
+ public:
+  LinkableMessageKind GetKind() const override {
+    return LinkableMessageKind::ArrayTypeKind;
+  }
+};
+
+class PointerTypeIR : public TypeIR {
+ public:
+  LinkableMessageKind GetKind() const override {
+    return LinkableMessageKind::PointerTypeKind;
+  }
+};
+
+class BuiltinTypeIR : public TypeIR {
+ public:
+  void SetSignedness(bool is_unsigned) {
+    is_unsigned_ = is_unsigned;
+  }
+
+  bool IsUnsigned() const {
+    return is_unsigned_;
+  }
+
+  void SetIntegralType(bool is_integral_type) {
+    is_integral_type_ = is_integral_type;
+  }
+
+  bool IsIntegralType() const {
+    return is_integral_type_;
+  }
+
+ public:
+  LinkableMessageKind GetKind() const override {
+    return LinkableMessageKind::BuiltinTypeKind;
+  }
+
+ protected:
+  bool is_unsigned_;
+  bool is_integral_type_;
+};
+
+class LvalueReferenceTypeIR : public TypeIR {
+ public:
+  LinkableMessageKind GetKind() const override {
+    return LinkableMessageKind::LvalueReferenceTypeKind;
+  }
+};
+
+class RvalueReferenceTypeIR : public TypeIR {
+ public:
+  LinkableMessageKind GetKind() const override {
+    return LinkableMessageKind::RvalueReferenceTypeKind;
+  }
+};
+
+class QualifiedTypeIR : public TypeIR {
+ public:
+  void SetConstness(bool is_const) {
+    is_const_ = is_const;
+  }
+
+  bool IsConst() const {
+    return is_const_;
+  }
+
+  void SetRestrictedness(bool is_restricted) {
+    is_restricted_ = is_restricted;
+  }
+
+  bool IsRestricted() const {
+    return is_restricted_;
+  }
+
+  void SetVolatility(bool is_volatile) {
+    is_volatile_ = is_volatile;
+  }
+
+  bool IsVolatile() const {
+    return is_volatile_;
+  }
+
+ public:
+  LinkableMessageKind GetKind() const override {
+    return LinkableMessageKind::QualifiedTypeKind;
+  }
+
+ protected:
+  bool is_const_;
+  bool is_restricted_;
+  bool is_volatile_;
+};
+
+class GlobalVarIR: public LinkableMessageIR {
+ public:
+  // Add Methods to get information from the IR.
+  void SetReferencedType(const std::string &type) {
+    referenced_type_ = type;
+  }
+
+  const std::string &GetReferencedType() const {
+    return referenced_type_;
+  }
+
+  void SetName(std::string &&name) {
+    name_ = std::move(name);
+  }
+
+  void SetName(const std::string &name) {
+    name_ = name;
+  }
+
+  const std::string &GetName() const {
+    return name_;
+  }
+
+  AccessSpecifierIR GetAccess() const {
+    return access_;
+  }
+
+  LinkableMessageKind GetKind() const override {
+    return LinkableMessageKind::GlobalVarKind;
+  }
+
+ protected:
+  std::string referenced_type_; // underlying type
+  std::string name_;
+  AccessSpecifierIR access_;
+};
+
+class ParamIR {
+ public:
+  ParamIR(const std::string &type, bool is_default) :
+    referenced_type_(type) , is_default_(is_default) {}
+
+  const std::string &GetReferencedType() const {
+    return referenced_type_;
+  }
+
+  bool GetIsDefault() const {
+    return is_default_;
+  }
+
+ protected:
+  std::string referenced_type_;
+  bool is_default_;
+};
+
+class FunctionIR : public LinkableMessageIR, public TemplatedArtifactIR {
+ public:
+  void SetReturnType(const std::string &type) {
+    return_type_ = type;
+  }
+
+  const std::string &GetReturnType() const {
+    return return_type_;
+  }
+
+  void AddParameter(ParamIR &&parameter) {
+    parameters_.emplace_back(std::move(parameter));
+  }
+
+  void SetAccess(AccessSpecifierIR access) {
+    access_ = access;
+  }
+
+  AccessSpecifierIR GetAccess() const {
+    return access_;
+  }
+
+  LinkableMessageKind GetKind() const override {
+    return LinkableMessageKind::FunctionKind;
+  }
+
+  const std::vector<ParamIR> &GetParameters() const {
+    return parameters_;
+  }
+
+  void SetName(const std::string &name) {
+    name_ = name;
+  }
+
+  const std::string &GetName() const {
+    return name_;
+  }
+
+ protected:
+    std::string return_type_; // return type reference
+    std::string linkage_name_;
+    std::string name_;
+    std::vector<ParamIR> parameters_;
+    AccessSpecifierIR access_;
+};
+
+class ElfSymbolIR {
+ public:
+  enum ElfSymbolKind {
+    ElfFunctionKind,
+    ElfObjectKind
+  };
+
+  const std::string GetName() const {
+    return name_;
+  }
+
+  ElfSymbolIR(const std::string &name) : name_(name) { }
+
+  virtual ElfSymbolKind GetKind() const = 0;
+
+  virtual ~ElfSymbolIR() { }
+
+ protected:
+  std::string name_;
+};
+
+class ElfFunctionIR : public ElfSymbolIR{
+ public:
+  ElfSymbolKind GetKind() const override {
+    return ElfFunctionKind;
+  }
+
+  ElfFunctionIR(const std::string &name) : ElfSymbolIR(name) { }
+};
+
+class ElfObjectIR : public ElfSymbolIR {
+ public:
+  ElfSymbolKind GetKind() const override {
+    return ElfObjectKind;
+  }
+
+  ElfObjectIR(const std::string &name) : ElfSymbolIR(name) { }
+};
+
+class IRDumper {
+ public:
+  IRDumper(const std::string &dump_path) : dump_path_(dump_path) { }
+
+  static std::unique_ptr<IRDumper> CreateIRDumper(const std::string &type,
+                                                  const std::string &dump_path);
+
+  virtual bool AddLinkableMessageIR(const LinkableMessageIR *) = 0;
+
+  virtual bool Dump() = 0;
+
+  virtual ~IRDumper() {}
+
+ protected:
+  const std::string &dump_path_;
+};
+
+class TextFormatToIRReader {
+ public:
+  TextFormatToIRReader(const std::string &dump_path) : dump_path_(dump_path) { }
+
+  const std::vector<FunctionIR> &GetFunctions() const {
+    return functions_;
+  }
+
+  const std::vector<GlobalVarIR> &GetGlobalVariables() const {
+    return global_variables_;
+  }
+
+  const std::vector<RecordTypeIR> &GetRecordTypes() const {
+    return record_types_;
+  }
+
+  const std::vector<EnumTypeIR> &GetEnumTypes() const {
+    return enum_types_;
+  }
+
+  const std::vector<LvalueReferenceTypeIR> &GetLvalueReferenceTypes() const {
+    return lvalue_reference_types_;
+  }
+
+  const std::vector<RvalueReferenceTypeIR> &GetRvalueReferenceTypes() const {
+    return rvalue_reference_types_;
+  }
+
+  const std::vector<QualifiedTypeIR> &GetQualifiedTypes() const {
+    return qualified_types_;
+  }
+
+  const std::vector<ArrayTypeIR> &GetArrayTypes() const {
+    return array_types_;
+  }
+
+  const std::vector<PointerTypeIR> &GetPointerTypes() const {
+    return pointer_types_;
+  }
+
+  const std::vector<BuiltinTypeIR> &GetBuiltinTypes() const {
+    return builtin_types_;
+  }
+
+  const std::vector<ElfFunctionIR> &GetElfFunctions() const {
+    return elf_functions_;
+  }
+
+  const std::vector<ElfObjectIR> &GetElfObjects() const {
+    return elf_objects_;
+  }
+
+  virtual bool ReadDump() = 0;
+
+  virtual ~TextFormatToIRReader() { }
+
+  static std::unique_ptr<TextFormatToIRReader> CreateTextFormatToIRReader(
+      const std::string &text_format, const std::string &dump_path);
+
+ protected:
+  const std::string &dump_path_;
+  std::vector<FunctionIR> functions_;
+  std::vector<GlobalVarIR> global_variables_;
+  std::vector<RecordTypeIR> record_types_;
+  std::vector<EnumTypeIR> enum_types_;
+  std::vector<PointerTypeIR> pointer_types_;
+  std::vector<LvalueReferenceTypeIR> lvalue_reference_types_;
+  std::vector<RvalueReferenceTypeIR> rvalue_reference_types_;
+  std::vector<ArrayTypeIR> array_types_;
+  std::vector<BuiltinTypeIR> builtin_types_;
+  std::vector<QualifiedTypeIR> qualified_types_;
+  std::vector<ElfFunctionIR> elf_functions_;
+  std::vector<ElfObjectIR> elf_objects_;
+};
+
+class DiffMessageIR {
+ public:
+  virtual LinkableMessageKind Kind() const = 0;
+  void SetName(const std::string &name) {
+    name_ = name;
+  }
+
+  const std::string &GetName() const {
+    return name_;
+  }
+
+  virtual ~DiffMessageIR() { }
+
+ protected:
+  std::string name_;
+};
+
+class AccessSpecifierDiffIR {
+ public:
+  AccessSpecifierDiffIR(AccessSpecifierIR old_access,
+                        AccessSpecifierIR new_access)
+      : old_access_(old_access), new_access_(new_access) { }
+
+ protected:
+  AccessSpecifierIR old_access_;
+  AccessSpecifierIR new_access_;
+};
+
+class TypeDiffIR {
+ public:
+  TypeDiffIR(std::pair<uint64_t, uint64_t> &&sizes,
+             std::pair<uint32_t, uint32_t> &&alignment)
+      : sizes_(std::move(sizes)), alignments_(std::move(alignment)) { }
+
+  const std::pair<uint64_t, uint64_t> &GetSizes() const {
+    return sizes_;
+  }
+
+  const std::pair<uint32_t, uint32_t> &GetAlignments() const {
+    return alignments_;
+  }
+
+ protected:
+  std::pair<uint64_t, uint64_t> sizes_;
+  std::pair<uint32_t, uint32_t> alignments_;
+};
+
+class VTableLayoutDiffIR {
+ public:
+  VTableLayoutDiffIR(const VTableLayoutIR &old_layout,
+                     const VTableLayoutIR &new_layout)
+      : old_layout_(old_layout), new_layout_(new_layout) { }
+
+  const VTableLayoutIR &GetOldVTable() const {
+    return old_layout_;
+  }
+
+  const VTableLayoutIR &GetNewVTable() const {
+    return new_layout_;
+  }
+
+ protected:
+  const VTableLayoutIR &old_layout_;
+  const VTableLayoutIR &new_layout_;
+};
+
+class RecordFieldDiffIR {
+ public:
+  RecordFieldDiffIR(const RecordFieldIR *old_field,
+                    const RecordFieldIR *new_field)
+      : old_field_(old_field), new_field_(new_field) { }
+  const RecordFieldIR *GetOldField() const {
+    return old_field_;
+  }
+
+  const RecordFieldIR *GetNewField() const {
+    return new_field_;
+  }
+
+ protected:
+  const RecordFieldIR *old_field_;
+  const RecordFieldIR *new_field_;
+};
+
+class CXXBaseSpecifierDiffIR {
+ public:
+  CXXBaseSpecifierDiffIR(
+      const std::vector<CXXBaseSpecifierIR> &old_base_specifiers,
+      const std::vector<CXXBaseSpecifierIR> &new_base_specifiers)
+      : old_base_specifiers_(old_base_specifiers),
+        new_base_specifiers_(new_base_specifiers) { }
+  const std::vector<CXXBaseSpecifierIR> &GetOldBases() const {
+    return old_base_specifiers_;
+  }
+
+  const std::vector<CXXBaseSpecifierIR> &GetNewBases() const {
+    return new_base_specifiers_;
+  }
+
+ protected:
+  const std::vector<CXXBaseSpecifierIR> &old_base_specifiers_;
+  const std::vector<CXXBaseSpecifierIR> &new_base_specifiers_;
+};
+
+class RecordTypeDiffIR : public DiffMessageIR {
+ public:
+  LinkableMessageKind Kind() const override {
+    return LinkableMessageKind::RecordTypeKind;
+  }
+
+  void SetFieldDiffs(std::vector<RecordFieldDiffIR> &&field_diffs) {
+    field_diffs_ = std::move(field_diffs);
+  }
+
+  const std::vector<RecordFieldDiffIR> &GetFieldDiffs() const {
+    return field_diffs_;
+  }
+
+  void SetFieldsRemoved(std::vector<const RecordFieldIR *> &&fields_removed) {
+    fields_removed_ = std::move(fields_removed);
+  }
+
+  const std::vector<const RecordFieldIR *> &GetFieldsRemoved() const {
+    return fields_removed_;
+  }
+
+  void SetVTableLayoutDiff(std::unique_ptr<VTableLayoutDiffIR> &&vtable_diffs) {
+    vtable_diffs_ = std::move(vtable_diffs);
+  }
+
+  void SetTypeDiff(std::unique_ptr<TypeDiffIR> &&type_diff) {
+    type_diff_ = std::move(type_diff);
+  }
+
+  void SetAccessDiff(std::unique_ptr<AccessSpecifierDiffIR> &&access_diff) {
+    access_diff_ = std::move(access_diff);
+  }
+
+  void SetBaseSpecifierDiffs(
+      std::unique_ptr<CXXBaseSpecifierDiffIR> &&base_diffs) {
+    base_specifier_diffs_ = std::move(base_diffs);
+  }
+
+  bool DiffExists() const {
+    return (type_diff_ != nullptr) || (vtable_diffs_ != nullptr) ||
+        (fields_removed_.size() != 0) || (field_diffs_.size() != 0) ||
+        (access_diff_ != nullptr) || (base_specifier_diffs_ != nullptr);
+  }
+
+  const TypeDiffIR *GetTypeDiff() const {
+    return type_diff_.get();
+  }
+
+  const VTableLayoutDiffIR *GetVTableLayoutDiff() const {
+    return vtable_diffs_.get();
+  }
+
+  const CXXBaseSpecifierDiffIR *GetBaseSpecifiers() const {
+    return base_specifier_diffs_.get();
+  }
+
+ protected:
+  // optional implemented with vector / std::unique_ptr.
+  std::unique_ptr<TypeDiffIR> type_diff_;
+  std::unique_ptr<VTableLayoutDiffIR> vtable_diffs_;
+  std::vector<RecordFieldDiffIR> field_diffs_;
+  std::vector<const RecordFieldIR *> fields_removed_;
+  std::unique_ptr<AccessSpecifierDiffIR> access_diff_;
+  std::unique_ptr<CXXBaseSpecifierDiffIR> base_specifier_diffs_;
+  // Template Diffs are not needed since they will show up in the linker set
+  // key.
+};
+
+class EnumFieldDiffIR {
+ public:
+  EnumFieldDiffIR(const EnumFieldIR *old_field, const EnumFieldIR *new_field)
+      : old_field_(old_field), new_field_(new_field) { }
+
+  const EnumFieldIR *GetOldField() const {
+    return old_field_;
+  }
+
+  const EnumFieldIR *GetNewField() const {
+    return new_field_;
+  }
+
+ protected:
+  const EnumFieldIR *old_field_;
+  const EnumFieldIR *new_field_;
+};
+
+class EnumTypeDiffIR : public DiffMessageIR {
+ public:
+  void SetFieldsRemoved(std::vector<const EnumFieldIR *> &&fields_removed) {
+    fields_removed_ = std::move(fields_removed);
+  }
+
+  const std::vector<const EnumFieldIR *> &GetFieldsRemoved() const {
+    return fields_removed_;
+  }
+
+  void SetFieldsAdded(std::vector<const EnumFieldIR *> &&fields_added) {
+    fields_added_ = std::move(fields_added);
+  }
+
+  const std::vector<const EnumFieldIR *> &GetFieldsAdded() const {
+    return fields_added_;
+  }
+
+  void SetFieldsDiff(std::vector<EnumFieldDiffIR> &&fields_diff) {
+    fields_diff_ = std::move(fields_diff);
+  }
+
+  const std::vector<EnumFieldDiffIR> &GetFieldsDiff() const {
+    return fields_diff_;
+  }
+
+  void SetUnderlyingTypeDiff(
+      std::unique_ptr<std::pair<std::string, std::string>> &&utype_diff) {
+    underlying_type_diff_ = std::move(utype_diff);
+  }
+
+  const std::pair<std::string, std::string> *GetUnderlyingTypeDiff() const {
+    return underlying_type_diff_.get();
+  }
+
+  bool IsExtended() const {
+    if (fields_removed_.size() == 0 && fields_diff_.size() == 0 &&
+        fields_added_.size() != 0) {
+        return true;
+    }
+
+    return false;
+  }
+
+  bool IsIncompatible() const {
+    if (fields_removed_.size() != 0 || fields_diff_.size() != 0) {
+        return true;
+    }
+
+    return false;
+  }
+
+  LinkableMessageKind Kind() const override {
+    return LinkableMessageKind::EnumTypeKind;
+  }
+
+ protected:
+  // The underlying type can only be integral, so we just need to check for
+  // referenced type.
+  std::unique_ptr<std::pair<std::string, std::string>> underlying_type_diff_;
+  std::vector<const EnumFieldIR *> fields_removed_;
+  std::vector<const EnumFieldIR *> fields_added_;
+  std::vector<EnumFieldDiffIR> fields_diff_;
+  // Modifiable to allow implicit construction.
+  std::string name_;
+};
+
+class GlobalVarDiffIR : public DiffMessageIR {
+ public:
+  LinkableMessageKind Kind() const override {
+    return LinkableMessageKind::GlobalVarKind;
+  }
+
+ GlobalVarDiffIR(const GlobalVarIR *old_global_var,
+                 const GlobalVarIR *new_global_var)
+      : old_global_var_(old_global_var), new_global_var_(new_global_var) { }
+
+ const GlobalVarIR *GetOldGlobalVar() const {
+   return old_global_var_;
+ }
+
+ const GlobalVarIR *GetNewGlobalVar() const {
+   return new_global_var_;
+ }
+
+ protected:
+  const GlobalVarIR *old_global_var_;
+  const GlobalVarIR *new_global_var_;
+};
+
+class FunctionDiffIR : public DiffMessageIR {
+ public:
+  LinkableMessageKind Kind() const override {
+    return LinkableMessageKind::FunctionKind;
+  }
+
+  FunctionDiffIR(const FunctionIR *old_function,
+                 const FunctionIR *new_function)
+      : old_function_(old_function), new_function_(new_function) { }
+
+  const FunctionIR *GetOldFunction() const {
+    return old_function_;
+  }
+
+  const FunctionIR *GetNewFunction() const {
+    return new_function_;
+  }
+
+ protected:
+  const FunctionIR *old_function_;
+  const FunctionIR *new_function_;
+};
+
+class IRDiffDumper {
+ public:
+  enum DiffKind {
+    Extension, // Applicable for enums.
+    Added,
+    Removed,
+    Referenced,
+    Unreferenced
+  };
+
+  IRDiffDumper(const std::string &dump_path) : dump_path_(dump_path) { }
+
+  virtual bool AddDiffMessageIR(const DiffMessageIR *,
+                                const std::string &type_stack,
+                                DiffKind diff_kind) = 0;
+
+  virtual bool AddLinkableMessageIR(const LinkableMessageIR *,
+                                    DiffKind diff_kind) = 0;
+
+  virtual bool AddElfSymbolMessageIR(const ElfSymbolIR *,
+                                     DiffKind diff_kind) = 0;
+
+  virtual void AddLibNameIR(const std::string &name) = 0;
+
+  virtual void AddArchIR(const std::string &arch) = 0;
+
+  virtual void AddCompatibilityStatusIR(CompatibilityStatusIR status) = 0;
+
+  virtual bool Dump() = 0;
+
+  virtual CompatibilityStatusIR GetCompatibilityStatusIR() = 0;
+
+  virtual ~IRDiffDumper() {}
+  static std::unique_ptr<IRDiffDumper> CreateIRDiffDumper(
+      const std::string &type, const std::string &dump_path);
+ protected:
+  const std::string &dump_path_;
+};
+
+} // namespace abi_util
+
+#endif // IR_
diff --git a/vndk/tools/header-checker/header-abi-util/include/ir_representation_protobuf.h b/vndk/tools/header-checker/header-abi-util/include/ir_representation_protobuf.h
new file mode 100644
index 0000000..e5cf61e
--- /dev/null
+++ b/vndk/tools/header-checker/header-abi-util/include/ir_representation_protobuf.h
@@ -0,0 +1,418 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef IR_PROTOBUF_
+#define IR_PROTOBUF_
+
+#include <ir_representation.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wnested-anon-types"
+#include "proto/abi_dump.pb.h"
+#include "proto/abi_diff.pb.h"
+#pragma clang diagnostic pop
+
+#include <google/protobuf/text_format.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+
+
+// Classes which act as middle-men between clang AST parsing routines and
+// message format specific dumpers.
+namespace abi_util {
+
+inline abi_diff::CompatibilityStatus CompatibilityStatusIRToProtobuf(
+    CompatibilityStatusIR status) {
+  switch(status) {
+    case CompatibilityStatusIR::Incompatible:
+      return abi_diff::CompatibilityStatus::INCOMPATIBLE;
+    case CompatibilityStatusIR::Extension:
+      return abi_diff::CompatibilityStatus::EXTENSION;
+    default:
+      break;
+  }
+  return abi_diff::CompatibilityStatus::COMPATIBLE;
+}
+
+inline abi_dump::AccessSpecifier AccessIRToProtobuf(AccessSpecifierIR access) {
+  switch (access) {
+    case AccessSpecifierIR::ProtectedAccess:
+      return abi_dump::AccessSpecifier::protected_access;
+    case AccessSpecifierIR::PrivateAccess:
+      return abi_dump::AccessSpecifier::private_access;
+    default:
+      return abi_dump::AccessSpecifier::public_access;
+  }
+  return abi_dump::AccessSpecifier::public_access;
+}
+
+inline AccessSpecifierIR AccessProtobufToIR(
+    abi_dump::AccessSpecifier access) {
+  switch (access) {
+    case abi_dump::AccessSpecifier::protected_access:
+      return AccessSpecifierIR::ProtectedAccess;
+    case abi_dump::AccessSpecifier::private_access:
+      return AccessSpecifierIR::PrivateAccess;
+    default:
+      return AccessSpecifierIR::PublicAccess;
+  }
+  return AccessSpecifierIR::PublicAccess;
+}
+
+inline abi_dump::RecordKind RecordKindIRToProtobuf(
+    RecordTypeIR::RecordKind kind) {
+  switch (kind) {
+    case RecordTypeIR::RecordKind::struct_kind:
+      return abi_dump::RecordKind::struct_kind;
+
+    case RecordTypeIR::RecordKind::class_kind:
+      return abi_dump::RecordKind::class_kind;
+
+    case RecordTypeIR::RecordKind::union_kind:
+      return abi_dump::RecordKind::union_kind;
+
+    default:
+      return abi_dump::RecordKind::struct_kind;
+  }
+  // Should not be reached
+  assert(false);
+}
+
+inline abi_dump::VTableComponent::Kind VTableComponentKindIRToProtobuf(
+    VTableComponentIR::Kind kind) {
+  switch (kind) {
+    case VTableComponentIR::Kind::VCallOffset:
+      return abi_dump::VTableComponent_Kind_VCallOffset;
+
+    case VTableComponentIR::Kind::VBaseOffset:
+      return abi_dump::VTableComponent_Kind_VBaseOffset;
+
+    case VTableComponentIR::Kind::OffsetToTop:
+      return abi_dump::VTableComponent_Kind_OffsetToTop;
+
+    case VTableComponentIR::Kind::RTTI:
+      return abi_dump::VTableComponent_Kind_RTTI;
+
+    case VTableComponentIR::Kind::FunctionPointer:
+      return abi_dump::VTableComponent_Kind_FunctionPointer;
+
+    case VTableComponentIR::Kind::CompleteDtorPointer:
+      return abi_dump::VTableComponent_Kind_CompleteDtorPointer;
+
+    case VTableComponentIR::Kind::DeletingDtorPointer:
+      return abi_dump::VTableComponent_Kind_DeletingDtorPointer;
+
+    default:
+      return abi_dump::VTableComponent_Kind_UnusedFunctionPointer;
+  }
+  // Should not be reached
+  assert(false);
+}
+
+inline VTableComponentIR::Kind VTableComponentKindProtobufToIR(
+    abi_dump::VTableComponent_Kind kind) {
+  switch (kind) {
+    case abi_dump::VTableComponent_Kind_VCallOffset:
+      return VTableComponentIR::Kind::VCallOffset;
+
+    case abi_dump::VTableComponent_Kind_VBaseOffset:
+      return VTableComponentIR::Kind::VBaseOffset;
+
+    case abi_dump::VTableComponent_Kind_OffsetToTop:
+      return VTableComponentIR::Kind::OffsetToTop;
+
+    case abi_dump::VTableComponent_Kind_RTTI:
+      return VTableComponentIR::Kind::RTTI;
+
+    case abi_dump::VTableComponent_Kind_FunctionPointer:
+      return VTableComponentIR::Kind::FunctionPointer;
+
+    case abi_dump::VTableComponent_Kind_CompleteDtorPointer:
+      return VTableComponentIR::Kind::CompleteDtorPointer;
+
+    case abi_dump::VTableComponent_Kind_DeletingDtorPointer:
+      return VTableComponentIR::Kind::DeletingDtorPointer;
+
+    default:
+      return VTableComponentIR::Kind::UnusedFunctionPointer;
+  }
+  // Should not be reached
+  assert(false);
+}
+
+class IRToProtobufConverter {
+ private:
+  static bool AddTemplateInformation(
+    abi_dump::TemplateInfo *ti, const abi_util::TemplatedArtifactIR *ta);
+
+  static bool AddTypeInfo(
+      abi_dump::BasicNamedAndTypedDecl *type_info, const TypeIR *typep);
+
+  static bool AddRecordFields(
+      abi_dump::RecordType *record_protobuf, const RecordTypeIR *record_ir);
+
+  static bool AddBaseSpecifiers(
+      abi_dump::RecordType *record_protobuf, const RecordTypeIR *record_ir);
+
+  static bool AddVTableLayout(
+      abi_dump::RecordType *record_protobuf, const RecordTypeIR *record_ir);
+
+  static bool AddEnumFields(abi_dump::EnumType *enum_protobuf,
+                            const EnumTypeIR *enum_ir);
+ public:
+  static abi_dump::EnumType ConvertEnumTypeIR(const EnumTypeIR *enump);
+
+  static abi_dump::RecordType ConvertRecordTypeIR(const RecordTypeIR *recordp);
+
+  static bool AddFunctionParameters(abi_dump::FunctionDecl *function_protobuf,
+                                    const FunctionIR *function_ir);
+
+  static abi_dump::FunctionDecl ConvertFunctionIR(const FunctionIR *functionp);
+
+  static abi_dump::GlobalVarDecl ConvertGlobalVarIR(
+      const GlobalVarIR *global_varp);
+
+  static abi_dump::PointerType ConvertPointerTypeIR(
+      const PointerTypeIR *pointerp);
+
+  static abi_dump::QualifiedType ConvertQualifiedTypeIR(
+      const QualifiedTypeIR *qualtypep);
+
+  static abi_dump::BuiltinType ConvertBuiltinTypeIR(
+      const BuiltinTypeIR *builtin_typep);
+
+  static abi_dump::ArrayType ConvertArrayTypeIR(
+      const ArrayTypeIR *array_typep);
+
+  static abi_dump::LvalueReferenceType ConvertLvalueReferenceTypeIR(
+      const LvalueReferenceTypeIR *lvalue_reference_typep);
+
+  static abi_dump::RvalueReferenceType ConvertRvalueReferenceTypeIR(
+      const RvalueReferenceTypeIR *rvalue_reference_typep);
+
+  static abi_dump::ElfFunction ConvertElfFunctionIR(
+      const ElfFunctionIR *elf_function_ir);
+
+  static abi_dump::ElfObject ConvertElfObjectIR(
+      const ElfObjectIR *elf_object_ir);
+};
+
+class IRDiffToProtobufConverter {
+ private:
+  static bool AddTypeInfoDiff(abi_diff::TypeInfoDiff *type_info_diff_protobuf,
+                              const TypeDiffIR *type_diff_ir);
+
+  static bool AddVTableLayoutDiff(
+    abi_diff::VTableLayoutDiff *vtable_layout_diff_protobuf,
+    const VTableLayoutDiffIR *vtable_layout_diff_ir);
+
+  static bool AddBaseSpecifierDiffs(
+    abi_diff::CXXBaseSpecifierDiff *base_specifier_diff_protobuf,
+    const CXXBaseSpecifierDiffIR *base_specifier_diff_ir);
+
+  static bool AddRecordFieldsRemoved(
+    abi_diff::RecordTypeDiff *record_diff_protobuf,
+    const std::vector<const RecordFieldIR *> &record_fields_removed_ir);
+
+  static bool AddRecordFieldDiffs(
+    abi_diff::RecordTypeDiff *record_diff_protobuf,
+    const std::vector<RecordFieldDiffIR> &record_field_diff_ir);
+
+  static bool AddEnumUnderlyingTypeDiff(
+    abi_diff::UnderlyingTypeDiff *underlying_type_diff_protobuf,
+    const std::pair<std::string, std::string> *underlying_type_diff_ir);
+
+ public:
+  static abi_diff::RecordTypeDiff ConvertRecordTypeDiffIR(
+      const RecordTypeDiffIR *record_type_diffp);
+
+  static abi_diff::EnumTypeDiff ConvertEnumTypeDiffIR(
+      const EnumTypeDiffIR *enum_type_diffp);
+
+  static abi_diff::FunctionDeclDiff ConvertFunctionDiffIR(
+      const FunctionDiffIR *function_diffp);
+
+  static abi_diff::GlobalVarDeclDiff ConvertGlobalVarDiffIR(
+      const GlobalVarDiffIR *global_var_diffp);
+};
+
+class ProtobufIRDumper : public IRDumper, public IRToProtobufConverter {
+ private:
+  // Types
+  bool AddRecordTypeIR(const RecordTypeIR *);
+
+  bool AddEnumTypeIR(const EnumTypeIR *);
+
+  bool AddPointerTypeIR(const PointerTypeIR *);
+
+  bool AddQualifiedTypeIR(const QualifiedTypeIR *);
+
+  bool AddLvalueReferenceTypeIR(const LvalueReferenceTypeIR *);
+
+  bool AddRvalueReferenceTypeIR(const RvalueReferenceTypeIR *);
+
+  bool AddArrayTypeIR(const ArrayTypeIR *);
+
+  bool AddBuiltinTypeIR(const BuiltinTypeIR *);
+
+  // Functions and global variables.
+  bool AddFunctionIR(const FunctionIR *);
+
+  bool AddGlobalVarIR(const GlobalVarIR *);
+
+ public:
+  ProtobufIRDumper(const std::string &dump_path)
+      : IRDumper(dump_path), tu_ptr_(new abi_dump::TranslationUnit()) { }
+
+  bool AddLinkableMessageIR(const LinkableMessageIR *);
+
+  bool Dump() override;
+
+  ~ProtobufIRDumper() override { }
+
+ private:
+  std::unique_ptr<abi_dump::TranslationUnit> tu_ptr_;
+};
+
+
+class ProtobufTextFormatToIRReader : public TextFormatToIRReader {
+ public:
+
+  virtual bool ReadDump() override;
+
+  ProtobufTextFormatToIRReader(const std::string &dump_path)
+      : TextFormatToIRReader(dump_path) { }
+
+ private:
+  std::vector<FunctionIR> ReadFunctions(
+       const abi_dump::TranslationUnit &tu);
+
+  std::vector<GlobalVarIR> ReadGlobalVariables(
+       const abi_dump::TranslationUnit &tu);
+
+  std::vector<EnumTypeIR> ReadEnumTypes(const abi_dump::TranslationUnit &tu);
+
+  std::vector<RecordTypeIR> ReadRecordTypes(
+      const abi_dump::TranslationUnit &tu);
+
+  std::vector<PointerTypeIR> ReadPointerTypes(
+       const abi_dump::TranslationUnit &tu);
+
+  std::vector<BuiltinTypeIR> ReadBuiltinTypes(
+       const abi_dump::TranslationUnit &tu);
+
+  std::vector<QualifiedTypeIR> ReadQualifiedTypes(
+       const abi_dump::TranslationUnit &tu);
+
+  std::vector<ArrayTypeIR> ReadArrayTypes(const abi_dump::TranslationUnit &tu);
+
+  std::vector<LvalueReferenceTypeIR> ReadLvalueReferenceTypes(
+       const abi_dump::TranslationUnit &tu);
+
+  std::vector<RvalueReferenceTypeIR> ReadRvalueReferenceTypes(
+       const abi_dump::TranslationUnit &tu);
+
+  std::vector<ElfFunctionIR> ReadElfFunctions (
+      const abi_dump::TranslationUnit &tu);
+
+  std::vector<ElfObjectIR> ReadElfObjects (const abi_dump::TranslationUnit &tu);
+
+  void ReadTypeInfo(const abi_dump::BasicNamedAndTypedDecl &type_info,
+                    TypeIR *typep);
+
+  FunctionIR FunctionProtobufToIR(const abi_dump::FunctionDecl &);
+
+  RecordTypeIR RecordTypeProtobufToIR(
+       const abi_dump::RecordType &record_type_protobuf);
+
+  std::vector<RecordFieldIR> RecordFieldsProtobufToIR(
+    const google::protobuf::RepeatedPtrField<abi_dump::RecordFieldDecl> &rfp);
+
+  std::vector<CXXBaseSpecifierIR> RecordCXXBaseSpecifiersProtobufToIR(
+    const google::protobuf::RepeatedPtrField<abi_dump::CXXBaseSpecifier> &rbs);
+
+  std::vector<EnumFieldIR> EnumFieldsProtobufToIR(
+       const google::protobuf::RepeatedPtrField<abi_dump::EnumFieldDecl> &efp);
+
+  EnumTypeIR EnumTypeProtobufToIR(
+       const abi_dump::EnumType &enum_type_protobuf);
+
+  VTableLayoutIR VTableLayoutProtobufToIR(
+    const abi_dump::VTableLayout &vtable_layout_protobuf);
+
+  TemplateInfoIR TemplateInfoProtobufToIR(
+       const abi_dump::TemplateInfo &template_info_protobuf);
+};
+
+class ProtobufIRDiffDumper : public IRDiffDumper {
+ public:
+  ProtobufIRDiffDumper(const std::string &dump_path)
+      : IRDiffDumper(dump_path),
+        diff_tu_(new abi_diff::TranslationUnitDiff()) { }
+
+  bool AddDiffMessageIR(const DiffMessageIR *, const std::string &type_stack,
+                        DiffKind diff_kind) override;
+
+  bool AddLinkableMessageIR(const LinkableMessageIR *,
+                            DiffKind diff_kind) override;
+
+  bool AddElfSymbolMessageIR(const ElfSymbolIR *, DiffKind diff_kind) override;
+
+  void AddLibNameIR(const std::string &name) override;
+
+  void AddArchIR(const std::string &arch) override;
+
+  void AddCompatibilityStatusIR(CompatibilityStatusIR status) override;
+
+  bool Dump() override;
+
+   CompatibilityStatusIR GetCompatibilityStatusIR() override;
+
+   ~ProtobufIRDiffDumper() override { }
+
+ private:
+  // User defined types.
+  bool AddRecordTypeDiffIR(const RecordTypeDiffIR *,
+                           const std::string &type_stack, DiffKind diff_kind);
+
+  bool AddEnumTypeDiffIR(const EnumTypeDiffIR *,
+                         const std::string &type_stack, DiffKind diff_kind);
+
+  // Functions and global variables.
+  bool AddFunctionDiffIR(const FunctionDiffIR *,
+                         const std::string &type_stack, DiffKind diff_kind);
+
+  bool AddGlobalVarDiffIR(const GlobalVarDiffIR *,
+                          const std::string &type_stack, DiffKind diff_kind);
+
+  bool AddLoneRecordTypeDiffIR(const RecordTypeIR *, DiffKind diff_kind);
+
+  bool AddLoneEnumTypeDiffIR(const EnumTypeIR *, DiffKind diff_kind);
+
+  // Functions and global variables.
+  bool AddLoneFunctionDiffIR(const FunctionIR *, DiffKind diff_kind);
+
+  bool AddLoneGlobalVarDiffIR(const GlobalVarIR *, DiffKind diff_kind);
+
+  bool AddElfObjectIR(const ElfObjectIR *elf_object_ir, DiffKind diff_kind);
+
+  bool AddElfFunctionIR(const ElfFunctionIR *elf_function_ir,
+                        DiffKind diff_kind);
+
+ protected:
+  std::unique_ptr<abi_diff::TranslationUnitDiff> diff_tu_;
+};
+
+} // abi_util
+
+#endif // IR_PROTOBUF_
diff --git a/vndk/tools/header-checker/header-abi-util/src/ir_representation.cpp b/vndk/tools/header-checker/header-abi-util/src/ir_representation.cpp
new file mode 100644
index 0000000..0cf58e1
--- /dev/null
+++ b/vndk/tools/header-checker/header-abi-util/src/ir_representation.cpp
@@ -0,0 +1,67 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <ir_representation.h>
+#include <ir_representation_protobuf.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wnested-anon-types"
+#include "proto/abi_dump.pb.h"
+#pragma clang diagnostic pop
+
+#include <google/protobuf/text_format.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+
+#include <llvm/Support/raw_ostream.h>
+
+#include <string>
+#include <memory>
+
+
+namespace abi_util {
+
+std::unique_ptr<IRDumper> IRDumper::CreateIRDumper(
+    const std::string &type, const std::string &dump_path) {
+  if (type == "protobuf") {
+    return std::make_unique<ProtobufIRDumper>(dump_path);
+  }
+  // Nothing else is supported yet.
+  llvm::errs() << type << " message format is not supported yet!\n";
+  return nullptr;
+}
+
+std::unique_ptr<IRDiffDumper> IRDiffDumper::CreateIRDiffDumper(
+    const std::string &type, const std::string &dump_path) {
+  if (type == "protobuf") {
+    return std::make_unique<ProtobufIRDiffDumper>(dump_path);
+  }
+  // Nothing else is supported yet.
+  llvm::errs() << type << " message format is not supported yet!\n";
+  return nullptr;
+}
+
+std::unique_ptr<TextFormatToIRReader>
+TextFormatToIRReader::CreateTextFormatToIRReader(
+    const std::string &type, const std::string &dump_path) {
+  if (type == "protobuf") {
+    return std::make_unique<ProtobufTextFormatToIRReader>(dump_path);
+  }
+  // Nothing else is supported yet.
+  llvm::errs() << type << " message format is not supported yet!\n";
+  return nullptr;
+}
+
+} // namespace abi_util
+
diff --git a/vndk/tools/header-checker/header-abi-util/src/ir_representation_protobuf.cpp b/vndk/tools/header-checker/header-abi-util/src/ir_representation_protobuf.cpp
new file mode 100644
index 0000000..f3958d8
--- /dev/null
+++ b/vndk/tools/header-checker/header-abi-util/src/ir_representation_protobuf.cpp
@@ -0,0 +1,1353 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <ir_representation_protobuf.h>
+
+#include <llvm/Support/raw_ostream.h>
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <memory>
+
+namespace abi_util {
+
+void ProtobufTextFormatToIRReader::ReadTypeInfo(
+    const abi_dump::BasicNamedAndTypedDecl &type_info,
+    TypeIR *typep) {
+  typep->SetLinkerSetKey(type_info.linker_set_key());
+  typep->SetName(type_info.linker_set_key());
+  typep->SetSourceFile(type_info.source_file());
+  typep->SetReferencedType(type_info.referenced_type());
+  typep->SetSize(type_info.size());
+  typep->SetAlignment(type_info.alignment());
+}
+
+bool ProtobufTextFormatToIRReader::ReadDump() {
+  abi_dump::TranslationUnit tu;
+  std::ifstream input(dump_path_);
+  google::protobuf::io::IstreamInputStream text_is(&input);
+
+  if (!google::protobuf::TextFormat::Parse(&text_is, &tu)) {
+    llvm::errs() << "Failed to parse protobuf TextFormat file\n";
+    return false;
+  }
+
+  functions_ = ReadFunctions(tu);
+  global_variables_ = ReadGlobalVariables(tu);
+
+  enum_types_ = ReadEnumTypes(tu);
+  record_types_ = ReadRecordTypes(tu);
+  array_types_ = ReadArrayTypes(tu);
+  pointer_types_ = ReadPointerTypes(tu);
+  qualified_types_ = ReadQualifiedTypes(tu);
+  builtin_types_ = ReadBuiltinTypes(tu);
+  lvalue_reference_types_ = ReadLvalueReferenceTypes(tu);
+  rvalue_reference_types_ = ReadRvalueReferenceTypes(tu);
+
+  elf_functions_ = ReadElfFunctions(tu);
+  elf_objects_ = ReadElfObjects(tu);
+
+  return true;
+}
+
+TemplateInfoIR ProtobufTextFormatToIRReader::TemplateInfoProtobufToIR(
+    const abi_dump::TemplateInfo &template_info_protobuf) {
+  TemplateInfoIR template_info_ir;
+  for (auto &&template_element : template_info_protobuf.elements()) {
+    TemplateElementIR template_element_ir(template_element.referenced_type());
+    template_info_ir.AddTemplateElement(std::move(template_element_ir));
+  }
+  return template_info_ir;
+}
+
+FunctionIR ProtobufTextFormatToIRReader::FunctionProtobufToIR(
+    const abi_dump::FunctionDecl &function_protobuf) {
+  FunctionIR function_ir;
+  function_ir.SetReturnType(function_protobuf.return_type());
+  function_ir.SetLinkerSetKey(function_protobuf.linker_set_key());
+  function_ir.SetName(function_protobuf.function_name());
+  function_ir.SetAccess(AccessProtobufToIR(function_protobuf.access()));
+  function_ir.SetSourceFile(function_protobuf.source_file());
+  // Set parameters
+  for (auto &&parameter: function_protobuf.parameters()) {
+    ParamIR param_ir(parameter.referenced_type(), parameter.default_arg());
+    function_ir.AddParameter(std::move(param_ir));
+  }
+  // Set Template info
+  function_ir.SetTemplateInfo(
+      TemplateInfoProtobufToIR(function_protobuf.template_info()));
+  return function_ir;
+}
+
+VTableLayoutIR ProtobufTextFormatToIRReader::VTableLayoutProtobufToIR(
+    const abi_dump::VTableLayout &vtable_layout_protobuf) {
+  VTableLayoutIR vtable_layout_ir;
+  for (auto &&vtable_component : vtable_layout_protobuf.vtable_components()) {
+    VTableComponentIR vtable_component_ir(
+        vtable_component.mangled_component_name(),
+        VTableComponentKindProtobufToIR(vtable_component.kind()),
+        vtable_component.component_value());
+    vtable_layout_ir.AddVTableComponent(std::move(vtable_component_ir));
+  }
+  return vtable_layout_ir;
+}
+
+std::vector<RecordFieldIR>
+ProtobufTextFormatToIRReader::RecordFieldsProtobufToIR(
+    const google::protobuf::RepeatedPtrField<abi_dump::RecordFieldDecl> &rfp) {
+  std::vector<RecordFieldIR> record_type_fields_ir;
+  for (auto &&field : rfp) {
+    RecordFieldIR record_field_ir(field.field_name(), field.referenced_type(),
+                                  field.field_offset(),
+                                  AccessProtobufToIR(field.access()));
+    record_type_fields_ir.emplace_back(std::move(record_field_ir));
+  }
+  return record_type_fields_ir;
+}
+
+std::vector<CXXBaseSpecifierIR>
+ProtobufTextFormatToIRReader::RecordCXXBaseSpecifiersProtobufToIR(
+    const google::protobuf::RepeatedPtrField<abi_dump::CXXBaseSpecifier> &rbs) {
+  std::vector<CXXBaseSpecifierIR> record_type_bases_ir;
+  for (auto &&base : rbs) {
+    CXXBaseSpecifierIR record_base_ir(
+        base.referenced_type(), base.is_virtual(),
+        AccessProtobufToIR(base.access()));
+    record_type_bases_ir.emplace_back(std::move(record_base_ir));
+  }
+  return record_type_bases_ir;
+}
+
+RecordTypeIR ProtobufTextFormatToIRReader::RecordTypeProtobufToIR(
+    const abi_dump::RecordType &record_type_protobuf) {
+  RecordTypeIR record_type_ir;
+  ReadTypeInfo(record_type_protobuf.type_info(), &record_type_ir);
+  record_type_ir.SetTemplateInfo(
+      TemplateInfoProtobufToIR(record_type_protobuf.template_info()));
+  record_type_ir.SetAccess(AccessProtobufToIR(record_type_protobuf.access()));
+  record_type_ir.SetVTableLayout(
+      VTableLayoutProtobufToIR(record_type_protobuf.vtable_layout()));
+  // Get fields
+  record_type_ir.SetRecordFields(RecordFieldsProtobufToIR(
+      record_type_protobuf.fields()));
+  // Base Specifiers
+  record_type_ir.SetCXXBaseSpecifiers(RecordCXXBaseSpecifiersProtobufToIR(
+      record_type_protobuf.base_specifiers()));
+
+  return record_type_ir;
+}
+
+std::vector<EnumFieldIR>
+ProtobufTextFormatToIRReader::EnumFieldsProtobufToIR(
+    const google::protobuf::RepeatedPtrField<abi_dump::EnumFieldDecl> &efp) {
+  std::vector<EnumFieldIR> enum_type_fields_ir;
+  for (auto &&field : efp) {
+    EnumFieldIR enum_field_ir(field.name(), field.enum_field_value());
+    enum_type_fields_ir.emplace_back(std::move(enum_field_ir));
+  }
+  return enum_type_fields_ir;
+}
+
+EnumTypeIR ProtobufTextFormatToIRReader::EnumTypeProtobufToIR(
+    const abi_dump::EnumType &enum_type_protobuf) {
+  EnumTypeIR enum_type_ir;
+  ReadTypeInfo(enum_type_protobuf.type_info(), &enum_type_ir);
+  enum_type_ir.SetUnderlyingType(enum_type_protobuf.underlying_type());
+  enum_type_ir.SetAccess(AccessProtobufToIR(enum_type_protobuf.access()));
+  enum_type_ir.SetFields(
+      EnumFieldsProtobufToIR(enum_type_protobuf.enum_fields()));
+  return enum_type_ir;
+}
+
+std::vector<GlobalVarIR> ProtobufTextFormatToIRReader::ReadGlobalVariables(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<GlobalVarIR> global_variables;
+  for (auto &&global_variable_protobuf : tu.global_vars()) {
+    GlobalVarIR global_variable_ir;
+    global_variable_ir.SetName(global_variable_protobuf.name());
+    global_variable_ir.SetSourceFile(global_variable_protobuf.source_file());
+    global_variable_ir.SetReferencedType(
+        global_variable_protobuf.referenced_type());
+    global_variable_ir.SetLinkerSetKey(
+        global_variable_protobuf.linker_set_key());
+    global_variables.emplace_back(std::move(global_variable_ir));
+  }
+  return global_variables;
+}
+
+std::vector<PointerTypeIR> ProtobufTextFormatToIRReader::ReadPointerTypes(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<PointerTypeIR> pointer_types;
+  for (auto &&pointer_type_protobuf : tu.pointer_types()) {
+    PointerTypeIR pointer_type_ir;
+    ReadTypeInfo(pointer_type_protobuf.type_info(), &pointer_type_ir);
+    pointer_types.emplace_back(std::move(pointer_type_ir));
+  }
+  return pointer_types;
+}
+
+std::vector<BuiltinTypeIR> ProtobufTextFormatToIRReader::ReadBuiltinTypes(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<BuiltinTypeIR> builtin_types;
+  for (auto &&builtin_type_protobuf : tu.builtin_types()) {
+    BuiltinTypeIR builtin_type_ir;
+    ReadTypeInfo(builtin_type_protobuf.type_info(), &builtin_type_ir);
+    builtin_type_ir.SetSignedness(builtin_type_protobuf.is_unsigned());
+    builtin_type_ir.SetIntegralType(builtin_type_protobuf.is_integral());
+    builtin_types.emplace_back(std::move(builtin_type_ir));
+  }
+  return builtin_types;
+}
+
+std::vector<QualifiedTypeIR> ProtobufTextFormatToIRReader::ReadQualifiedTypes(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<QualifiedTypeIR> qualified_types;
+  for (auto &&qualified_type_protobuf : tu.qualified_types()) {
+    QualifiedTypeIR qualified_type_ir;
+    ReadTypeInfo(qualified_type_protobuf.type_info(), &qualified_type_ir);
+    qualified_types.emplace_back(std::move(qualified_type_ir));
+  }
+  return qualified_types;
+}
+
+std::vector<ArrayTypeIR> ProtobufTextFormatToIRReader::ReadArrayTypes(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<ArrayTypeIR> array_types;
+  for (auto &&array_type_protobuf : tu.array_types()) {
+    ArrayTypeIR array_type_ir;
+    ReadTypeInfo(array_type_protobuf.type_info(), &array_type_ir);
+    array_types.emplace_back(std::move(array_type_ir));
+  }
+  return array_types;
+}
+
+std::vector<LvalueReferenceTypeIR>
+ProtobufTextFormatToIRReader::ReadLvalueReferenceTypes(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<LvalueReferenceTypeIR> lvalue_reference_types;
+  for (auto &&lvalue_reference_type_protobuf : tu.lvalue_reference_types()) {
+    LvalueReferenceTypeIR lvalue_reference_type_ir;
+    ReadTypeInfo(lvalue_reference_type_protobuf.type_info(),
+                 &lvalue_reference_type_ir);
+    lvalue_reference_types.emplace_back(std::move(lvalue_reference_type_ir));
+  }
+  return lvalue_reference_types;
+}
+
+std::vector<RvalueReferenceTypeIR>
+ProtobufTextFormatToIRReader::ReadRvalueReferenceTypes(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<RvalueReferenceTypeIR> rvalue_reference_types;
+  for (auto &&rvalue_reference_type_protobuf : tu.rvalue_reference_types()) {
+    RvalueReferenceTypeIR rvalue_reference_type_ir;
+    ReadTypeInfo(rvalue_reference_type_protobuf.type_info(),
+                 &rvalue_reference_type_ir);
+    rvalue_reference_types.emplace_back(std::move(rvalue_reference_type_ir));
+  }
+  return rvalue_reference_types;
+}
+
+std::vector<FunctionIR> ProtobufTextFormatToIRReader::ReadFunctions(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<FunctionIR> functions;
+  for (auto &&function_protobuf : tu.functions()) {
+    FunctionIR function_ir = FunctionProtobufToIR(function_protobuf);
+    functions.emplace_back(std::move(function_ir));
+  }
+  return functions;
+}
+
+std::vector<RecordTypeIR> ProtobufTextFormatToIRReader::ReadRecordTypes(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<RecordTypeIR> record_types;
+  for (auto &&record_type_protobuf : tu.record_types()) {
+    RecordTypeIR record_type_ir = RecordTypeProtobufToIR(record_type_protobuf);
+    record_types.emplace_back(std::move(record_type_ir));
+  }
+  return record_types;
+}
+
+std::vector<EnumTypeIR> ProtobufTextFormatToIRReader::ReadEnumTypes(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<EnumTypeIR> enum_types;
+  for (auto &&enum_type_protobuf : tu.enum_types()) {
+    EnumTypeIR enum_type_ir = EnumTypeProtobufToIR(enum_type_protobuf);
+    enum_types.emplace_back(std::move(enum_type_ir));
+  }
+  return enum_types;
+}
+
+std::vector<ElfFunctionIR> ProtobufTextFormatToIRReader::ReadElfFunctions(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<ElfFunctionIR> elf_functions;
+  for (auto &&elf_function : tu.elf_functions()) {
+    elf_functions.emplace_back(ElfFunctionIR(elf_function.name()));
+  }
+  return elf_functions;
+}
+
+std::vector<ElfObjectIR> ProtobufTextFormatToIRReader::ReadElfObjects(
+    const abi_dump::TranslationUnit &tu) {
+  std::vector<ElfObjectIR> elf_objects;
+  for (auto &&elf_object : tu.elf_objects()) {
+    elf_objects.emplace_back(ElfObjectIR(elf_object.name()));
+  }
+  return elf_objects;
+}
+
+bool IRToProtobufConverter::AddTemplateInformation(
+    abi_dump::TemplateInfo *ti, const abi_util::TemplatedArtifactIR *ta) {
+  for (auto &&template_element : ta->GetTemplateElements()) {
+    abi_dump::TemplateElement *added_element = ti->add_elements();
+    if (!added_element) {
+      llvm::errs() << "Failed to add template element\n";
+      return false;
+    }
+    added_element->set_referenced_type(template_element.GetReferencedType());
+  }
+  return true;
+}
+
+bool IRToProtobufConverter::AddTypeInfo(
+    abi_dump::BasicNamedAndTypedDecl *type_info,
+    const TypeIR *typep) {
+  if (!type_info || !typep) {
+    llvm::errs() << "Typeinfo not valid\n";
+    return false;
+  }
+  type_info->set_linker_set_key(typep->GetLinkerSetKey());
+  type_info->set_source_file(typep->GetSourceFile());
+  type_info->set_name(typep->GetName());
+  type_info->set_size(typep->GetSize());
+  type_info->set_alignment(typep->GetAlignment());
+  type_info->set_referenced_type(typep->GetReferencedType());
+  return true;
+}
+
+static void SetIRToProtobufRecordField(
+    abi_dump::RecordFieldDecl *record_field_protobuf,
+    const RecordFieldIR *record_field_ir) {
+  record_field_protobuf->set_field_name(record_field_ir->GetName());
+  record_field_protobuf->set_referenced_type(
+      record_field_ir->GetReferencedType());
+  record_field_protobuf->set_access(
+      AccessIRToProtobuf(record_field_ir->GetAccess()));
+  record_field_protobuf->set_field_offset(record_field_ir->GetOffset());
+}
+
+bool IRToProtobufConverter::AddRecordFields(
+    abi_dump::RecordType *record_protobuf,
+    const RecordTypeIR *record_ir) {
+  // Iterate through the fields and create corresponding ones for the protobuf
+  // record
+  for (auto &&field_ir : record_ir->GetFields()) {
+    abi_dump::RecordFieldDecl *added_field = record_protobuf->add_fields();
+    if (!added_field) {
+      llvm::errs() << "Couldn't add record field\n";
+    }
+    SetIRToProtobufRecordField(added_field, &field_ir);
+  }
+  return true;
+}
+
+static bool SetIRToProtobufBaseSpecifier(
+    abi_dump::CXXBaseSpecifier *base_specifier_protobuf,
+    const CXXBaseSpecifierIR &base_specifier_ir) {
+  if (!base_specifier_protobuf) {
+    llvm::errs() << "Protobuf base specifier not valid\n";
+    return false;
+  }
+  base_specifier_protobuf->set_referenced_type(
+      base_specifier_ir.GetReferencedType());
+  base_specifier_protobuf->set_is_virtual(
+      base_specifier_ir.IsVirtual());
+  base_specifier_protobuf->set_access(
+      AccessIRToProtobuf(base_specifier_ir.GetAccess()));
+  return true;
+}
+
+bool IRToProtobufConverter::AddBaseSpecifiers(
+    abi_dump::RecordType *record_protobuf, const RecordTypeIR *record_ir) {
+  for (auto &&base_ir : record_ir->GetBases()) {
+    abi_dump::CXXBaseSpecifier *added_base =
+        record_protobuf->add_base_specifiers();
+    if (!SetIRToProtobufBaseSpecifier(added_base, base_ir)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static bool SetIRToProtobufVTableLayout(
+    abi_dump::VTableLayout *vtable_layout_protobuf,
+    const VTableLayoutIR &vtable_layout_ir) {
+  if (vtable_layout_protobuf == nullptr) {
+    llvm::errs() << "vtable layout protobuf not valid\n";
+    return false;
+  }
+  for (auto &&vtable_component_ir : vtable_layout_ir.GetVTableComponents()) {
+    abi_dump::VTableComponent *added_vtable_component =
+        vtable_layout_protobuf->add_vtable_components();
+    if (!added_vtable_component) {
+      llvm::errs() << "Couldn't add vtable component\n";
+      return false;
+    }
+    added_vtable_component->set_kind(
+        VTableComponentKindIRToProtobuf(vtable_component_ir.GetKind()));
+    added_vtable_component->set_component_value(vtable_component_ir.GetValue());
+    added_vtable_component->set_mangled_component_name(
+        vtable_component_ir.GetName());
+  }
+  return true;
+}
+
+bool IRToProtobufConverter::AddVTableLayout(
+    abi_dump::RecordType *record_protobuf,
+    const RecordTypeIR *record_ir) {
+  // If there are no entries in the vtable, just return.
+  if (record_ir->GetVTableNumEntries() == 0) {
+    return true;
+  }
+  const VTableLayoutIR &vtable_layout_ir = record_ir->GetVTableLayout();
+  abi_dump::VTableLayout *vtable_layout_protobuf =
+      record_protobuf->mutable_vtable_layout();
+  if (!SetIRToProtobufVTableLayout(vtable_layout_protobuf, vtable_layout_ir)) {
+    return false;
+  }
+  return true;
+}
+
+abi_dump::RecordType IRToProtobufConverter::ConvertRecordTypeIR(
+    const RecordTypeIR *recordp) {
+  abi_dump::RecordType added_record_type;
+  added_record_type.set_access(AccessIRToProtobuf(recordp->GetAccess()));
+  added_record_type.set_record_kind(
+      RecordKindIRToProtobuf(recordp->GetRecordKind()));
+  if (recordp->IsAnonymous()) {
+    added_record_type.set_is_anonymous(true);
+  }
+  if (!AddTypeInfo(added_record_type.mutable_type_info(), recordp) ||
+      !AddRecordFields(&added_record_type, recordp) ||
+      !AddBaseSpecifiers(&added_record_type, recordp) ||
+      !AddVTableLayout(&added_record_type, recordp) ||
+      !(recordp->GetTemplateElements().size() ?
+       AddTemplateInformation(added_record_type.mutable_template_info(),
+                              recordp) : true)) {
+    llvm::errs() << "Template information could not be added\n";
+    ::exit(1);
+  }
+  return added_record_type;
+}
+
+
+abi_dump::ElfObject IRToProtobufConverter::ConvertElfObjectIR(
+    const ElfObjectIR *elf_object_ir) {
+  abi_dump::ElfObject elf_object_protobuf;
+  elf_object_protobuf.set_name(elf_object_ir->GetName());
+  return elf_object_protobuf;
+}
+
+abi_dump::ElfFunction IRToProtobufConverter::ConvertElfFunctionIR(
+    const ElfFunctionIR *elf_function_ir) {
+  abi_dump::ElfFunction elf_function_protobuf;
+  elf_function_protobuf.set_name(elf_function_ir->GetName());
+  return elf_function_protobuf;
+}
+
+bool IRToProtobufConverter::AddFunctionParameters(
+    abi_dump::FunctionDecl *function_protobuf,
+    const FunctionIR *function_ir) {
+  for (auto &&parameter : function_ir->GetParameters()) {
+    abi_dump::ParamDecl *added_parameter = function_protobuf->add_parameters();
+    if (!added_parameter) {
+      return false;
+    }
+    added_parameter->set_referenced_type(
+        parameter.GetReferencedType());
+    added_parameter->set_default_arg(parameter.GetIsDefault());
+  }
+  return true;
+}
+
+abi_dump::FunctionDecl IRToProtobufConverter::ConvertFunctionIR(
+    const FunctionIR *functionp) {
+  abi_dump::FunctionDecl added_function;
+  added_function.set_access(AccessIRToProtobuf(functionp->GetAccess()));
+  added_function.set_linker_set_key(functionp->GetLinkerSetKey());
+  added_function.set_source_file(functionp->GetSourceFile());
+  added_function.set_function_name(functionp->GetName());
+  added_function.set_return_type(functionp->GetReturnType());
+  if (!AddFunctionParameters(&added_function, functionp) ||
+      !(functionp->GetTemplateElements().size() ?
+      AddTemplateInformation(added_function.mutable_template_info(), functionp)
+      : true)) {
+    llvm::errs() << "Template information could not be added\n";
+    ::exit(1);
+  }
+  return added_function;
+}
+
+static bool SetIRToProtobufEnumField(
+    abi_dump::EnumFieldDecl *enum_field_protobuf,
+    const EnumFieldIR *enum_field_ir) {
+  if (enum_field_protobuf == nullptr) {
+    return true;
+  }
+  enum_field_protobuf->set_name(enum_field_ir->GetName());
+  enum_field_protobuf->set_enum_field_value(enum_field_ir->GetValue());
+  return true;
+}
+
+bool IRToProtobufConverter::AddEnumFields(abi_dump::EnumType *enum_protobuf,
+                                     const EnumTypeIR *enum_ir) {
+  for (auto &&field : enum_ir->GetFields()) {
+    abi_dump::EnumFieldDecl *enum_fieldp = enum_protobuf->add_enum_fields();
+    if (!SetIRToProtobufEnumField(enum_fieldp, &field)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+
+abi_dump::EnumType IRToProtobufConverter::ConvertEnumTypeIR(
+    const EnumTypeIR *enump) {
+  abi_dump::EnumType added_enum_type;
+  added_enum_type.set_access(AccessIRToProtobuf(enump->GetAccess()));
+  added_enum_type.set_underlying_type(enump->GetUnderlyingType());
+  if (!AddTypeInfo(added_enum_type.mutable_type_info(), enump) ||
+      !AddEnumFields(&added_enum_type, enump)) {
+    llvm::errs() << "EnumTypeIR could not be converted\n";
+    ::exit(1);
+  }
+  return added_enum_type;
+}
+
+abi_dump::GlobalVarDecl IRToProtobufConverter::ConvertGlobalVarIR(
+    const GlobalVarIR *global_varp) {
+  abi_dump::GlobalVarDecl added_global_var;
+  added_global_var.set_referenced_type(global_varp->GetReferencedType());
+  added_global_var.set_source_file(global_varp->GetSourceFile());
+  added_global_var.set_name(global_varp->GetName());
+  added_global_var.set_linker_set_key(global_varp->GetLinkerSetKey());
+  added_global_var.set_access(
+      AccessIRToProtobuf(global_varp->GetAccess()));
+  return added_global_var;
+}
+
+abi_dump::PointerType IRToProtobufConverter::ConvertPointerTypeIR(
+    const PointerTypeIR *pointerp) {
+  abi_dump::PointerType added_pointer_type;
+  if (!AddTypeInfo(added_pointer_type.mutable_type_info(), pointerp)) {
+    llvm::errs() << "PointerTypeIR could not be converted\n";
+    ::exit(1);
+  }
+  return added_pointer_type;
+}
+
+abi_dump::QualifiedType IRToProtobufConverter::ConvertQualifiedTypeIR(
+    const QualifiedTypeIR *qualtypep) {
+  abi_dump::QualifiedType added_qualified_type;
+  if (!AddTypeInfo(added_qualified_type.mutable_type_info(), qualtypep)) {
+    llvm::errs() << "QualifiedTypeIR could not be converted\n";
+    ::exit(1);
+  }
+  added_qualified_type.set_is_const(qualtypep->IsConst());
+  added_qualified_type.set_is_volatile(qualtypep->IsVolatile());
+  added_qualified_type.set_is_restricted(qualtypep->IsRestricted());
+  return added_qualified_type;
+}
+
+abi_dump::BuiltinType IRToProtobufConverter::ConvertBuiltinTypeIR(
+    const BuiltinTypeIR *builtin_typep) {
+  abi_dump::BuiltinType added_builtin_type;
+  added_builtin_type.set_is_unsigned(builtin_typep->IsUnsigned());
+  added_builtin_type.set_is_integral(builtin_typep->IsIntegralType());
+  if (!AddTypeInfo(added_builtin_type.mutable_type_info(), builtin_typep)) {
+    llvm::errs() << "BuiltinTypeIR could not be converted\n";
+    ::exit(1);
+  }
+  return added_builtin_type;
+}
+
+abi_dump::ArrayType IRToProtobufConverter::ConvertArrayTypeIR(
+    const ArrayTypeIR *array_typep) {
+  abi_dump::ArrayType added_array_type;
+  if (!AddTypeInfo(added_array_type.mutable_type_info(), array_typep)) {
+    llvm::errs() << "ArrayTypeIR could not be converted\n";
+    ::exit(1);
+  }
+  return added_array_type;
+}
+
+abi_dump::LvalueReferenceType
+IRToProtobufConverter::ConvertLvalueReferenceTypeIR(
+    const LvalueReferenceTypeIR *lvalue_reference_typep) {
+  abi_dump::LvalueReferenceType added_lvalue_reference_type;
+  if (!AddTypeInfo(added_lvalue_reference_type.mutable_type_info(),
+                   lvalue_reference_typep)) {
+    llvm::errs() << "LvalueReferenceTypeIR could not be converted\n";
+    ::exit(1);
+  }
+  return added_lvalue_reference_type;
+}
+
+abi_dump::RvalueReferenceType
+IRToProtobufConverter::ConvertRvalueReferenceTypeIR(
+    const RvalueReferenceTypeIR *rvalue_reference_typep) {
+  abi_dump::RvalueReferenceType added_rvalue_reference_type;
+  if (!AddTypeInfo(added_rvalue_reference_type.mutable_type_info(),
+                   rvalue_reference_typep)) {
+    llvm::errs() << "RvalueReferenceTypeIR could not be converted\n";
+    ::exit(1);
+  }
+  return added_rvalue_reference_type;
+}
+
+
+bool IRDiffToProtobufConverter::AddTypeInfoDiff(
+    abi_diff::TypeInfoDiff *type_info_diff_protobuf,
+    const TypeDiffIR *type_diff_ir) {
+  abi_diff::TypeInfo *old_type_info_protobuf =
+      type_info_diff_protobuf->mutable_old_type_info();
+  abi_diff::TypeInfo *new_type_info_protobuf =
+      type_info_diff_protobuf->mutable_new_type_info();
+  if (old_type_info_protobuf == nullptr || new_type_info_protobuf == nullptr) {
+    return false;
+  }
+  const std::pair<uint64_t, uint64_t> &sizes = type_diff_ir->GetSizes();
+  const std::pair<uint32_t, uint32_t> &alignments =
+      type_diff_ir->GetAlignments();
+  old_type_info_protobuf->set_size(sizes.first);
+  new_type_info_protobuf->set_size(sizes.second);
+
+  old_type_info_protobuf->set_alignment(alignments.first);
+  new_type_info_protobuf->set_alignment(alignments.second);
+  return true;
+}
+
+bool IRDiffToProtobufConverter::AddVTableLayoutDiff(
+    abi_diff::VTableLayoutDiff *vtable_layout_diff_protobuf,
+    const VTableLayoutDiffIR *vtable_layout_diff_ir) {
+  abi_dump:: VTableLayout *old_vtable =
+      vtable_layout_diff_protobuf->mutable_old_vtable();
+  abi_dump:: VTableLayout *new_vtable =
+      vtable_layout_diff_protobuf->mutable_new_vtable();
+  if (old_vtable == nullptr || new_vtable == nullptr ||
+      !SetIRToProtobufVTableLayout(old_vtable,
+                                   vtable_layout_diff_ir->GetOldVTable()) ||
+      !SetIRToProtobufVTableLayout(new_vtable,
+                                   vtable_layout_diff_ir->GetNewVTable())) {
+    return false;
+  }
+  return true;
+}
+
+template <typename T>
+static bool CopyBaseSpecifiersDiffIRToProtobuf(
+    google::protobuf::RepeatedPtrField<T> *dst,
+    const std::vector<CXXBaseSpecifierIR> &bases_ir) {
+  for (auto &&base_ir : bases_ir) {
+    T *added_base = dst->Add();
+    if (!SetIRToProtobufBaseSpecifier(added_base, base_ir)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool IRDiffToProtobufConverter::AddBaseSpecifierDiffs(
+    abi_diff::CXXBaseSpecifierDiff *base_specifiers_diff_protobuf,
+    const CXXBaseSpecifierDiffIR *base_specifiers_diff_ir) {
+  if (!CopyBaseSpecifiersDiffIRToProtobuf(
+          base_specifiers_diff_protobuf->mutable_old_bases(),
+          base_specifiers_diff_ir->GetOldBases()) ||
+      !CopyBaseSpecifiersDiffIRToProtobuf(
+          base_specifiers_diff_protobuf->mutable_new_bases(),
+          base_specifiers_diff_ir->GetNewBases())) {
+    return false;
+  }
+  return true;
+}
+
+bool IRDiffToProtobufConverter::AddRecordFieldsRemoved(
+    abi_diff::RecordTypeDiff *record_diff_protobuf,
+    const std::vector<const RecordFieldIR *> &record_fields_removed_ir) {
+  for (auto &&record_field_ir : record_fields_removed_ir) {
+    abi_dump::RecordFieldDecl *field_removed =
+        record_diff_protobuf->add_fields_removed();
+    if (field_removed == nullptr) {
+      return false;
+    }
+    SetIRToProtobufRecordField(field_removed, record_field_ir);
+  }
+  return true;
+}
+
+bool IRDiffToProtobufConverter::AddRecordFieldDiffs(
+    abi_diff::RecordTypeDiff *record_diff_protobuf,
+    const std::vector<RecordFieldDiffIR> &record_field_diffs_ir) {
+  for (auto &&record_field_diff_ir : record_field_diffs_ir) {
+    abi_diff::RecordFieldDeclDiff *record_field_diff =
+        record_diff_protobuf->add_fields_diff();
+    if (record_field_diff == nullptr) {
+      return false;
+    }
+    abi_dump::RecordFieldDecl *old_field =
+        record_field_diff->mutable_old_field();
+    abi_dump::RecordFieldDecl *new_field =
+        record_field_diff->mutable_new_field();
+    if (old_field == nullptr || new_field == nullptr) {
+      return false;
+    }
+    SetIRToProtobufRecordField(old_field,
+                               record_field_diff_ir.GetOldField());
+    SetIRToProtobufRecordField(new_field,
+                               record_field_diff_ir.GetNewField());
+  }
+  return true;
+}
+
+abi_diff::RecordTypeDiff IRDiffToProtobufConverter::ConvertRecordTypeDiffIR(
+    const RecordTypeDiffIR *record_type_diff_ir) {
+  abi_diff::RecordTypeDiff record_type_diff_protobuf;
+  record_type_diff_protobuf.set_name(record_type_diff_ir->GetName());
+  const TypeDiffIR *type_diff_ir = record_type_diff_ir->GetTypeDiff();
+  // If a type_info diff exists
+  if (type_diff_ir != nullptr) {
+    abi_diff::TypeInfoDiff *type_info_diff =
+        record_type_diff_protobuf.mutable_type_info_diff();
+    if (!AddTypeInfoDiff(type_info_diff, type_diff_ir)) {
+        llvm::errs() << "RecordType could not be converted\n";
+       ::exit(1);
+    }
+  }
+  // If vtables differ.
+  const VTableLayoutDiffIR *vtable_layout_diff_ir =
+      record_type_diff_ir->GetVTableLayoutDiff();
+  if (vtable_layout_diff_ir != nullptr) {
+    abi_diff::VTableLayoutDiff *vtable_layout_diff_protobuf =
+        record_type_diff_protobuf.mutable_vtable_layout_diff();
+    if (!AddVTableLayoutDiff(vtable_layout_diff_protobuf,
+                             vtable_layout_diff_ir)) {
+      llvm::errs() << "VTable layout diff could not be added\n";
+      ::exit(1);
+    }
+  }
+  // If base specifiers differ.
+  const CXXBaseSpecifierDiffIR *base_specifier_diff_ir =
+      record_type_diff_ir->GetBaseSpecifiers();
+  if ( base_specifier_diff_ir != nullptr) {
+    abi_diff::CXXBaseSpecifierDiff *base_specifier_diff_protobuf =
+        record_type_diff_protobuf.mutable_bases_diff();
+    if (!AddBaseSpecifierDiffs(base_specifier_diff_protobuf,
+                               base_specifier_diff_ir)) {
+      llvm::errs() << "Base Specifier diff could not be added\n";
+      ::exit(1);
+    }
+  }
+  // Field diffs
+  if (!AddRecordFieldsRemoved(&record_type_diff_protobuf,
+                               record_type_diff_ir->GetFieldsRemoved()) ||
+      !AddRecordFieldDiffs(&record_type_diff_protobuf,
+                            record_type_diff_ir->GetFieldDiffs())) {
+    llvm::errs() << "Record Field diff could not be added\n";
+    ::exit(1);
+  }
+  return record_type_diff_protobuf;
+}
+
+bool IRDiffToProtobufConverter::AddEnumUnderlyingTypeDiff(
+    abi_diff::UnderlyingTypeDiff *underlying_type_diff_protobuf,
+    const std::pair<std::string, std::string> *underlying_type_diff_ir) {
+  if (underlying_type_diff_protobuf == nullptr) {
+    return false;
+  }
+  underlying_type_diff_protobuf->set_old_type(underlying_type_diff_ir->first);
+  underlying_type_diff_protobuf->set_new_type(underlying_type_diff_ir->second);
+  return true;
+}
+
+static bool AddEnumFields(
+    google::protobuf::RepeatedPtrField<abi_dump::EnumFieldDecl> *dst,
+    const std::vector<const EnumFieldIR *> &enum_fields) {
+  for (auto &&enum_field : enum_fields) {
+    abi_dump::EnumFieldDecl *added_enum_field = dst->Add();
+    if (!SetIRToProtobufEnumField(added_enum_field, enum_field)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static bool AddEnumFieldDiffs(
+    google::protobuf::RepeatedPtrField<abi_diff::EnumFieldDeclDiff> *dst,
+    const std::vector<EnumFieldDiffIR> &fields_diff_ir) {
+  for (auto &&field_diff_ir : fields_diff_ir) {
+    abi_diff::EnumFieldDeclDiff *field_diff_protobuf = dst->Add();
+    if (field_diff_protobuf == nullptr) {
+      return false;
+    }
+    if (!SetIRToProtobufEnumField(field_diff_protobuf->mutable_old_field(),
+                                  field_diff_ir.GetOldField()) ||
+        !SetIRToProtobufEnumField(field_diff_protobuf->mutable_new_field(),
+                                  field_diff_ir.GetNewField())) {
+      return false;
+    }
+  }
+  return true;
+}
+
+abi_diff::EnumTypeDiff IRDiffToProtobufConverter::ConvertEnumTypeDiffIR(
+    const EnumTypeDiffIR *enum_type_diff_ir) {
+  abi_diff::EnumTypeDiff enum_type_diff_protobuf;
+  enum_type_diff_protobuf.set_name(enum_type_diff_ir->GetName());
+  const std::pair<std::string, std::string> *underlying_type_diff =
+      enum_type_diff_ir->GetUnderlyingTypeDiff();
+  if ((underlying_type_diff != nullptr &&
+      !AddEnumUnderlyingTypeDiff(
+          enum_type_diff_protobuf.mutable_underlying_type_diff(),
+          underlying_type_diff)) ||
+      !AddEnumFields(enum_type_diff_protobuf.mutable_fields_removed(),
+                     enum_type_diff_ir->GetFieldsRemoved()) ||
+      !AddEnumFields(enum_type_diff_protobuf.mutable_fields_added(),
+                     enum_type_diff_ir->GetFieldsAdded()) ||
+      !AddEnumFieldDiffs(enum_type_diff_protobuf.mutable_fields_diff(),
+                         enum_type_diff_ir->GetFieldsDiff())) {
+    llvm::errs() << "Enum field diff could not be added\n";
+    ::exit(1);
+  }
+  return enum_type_diff_protobuf;
+}
+
+abi_diff::GlobalVarDeclDiff IRDiffToProtobufConverter::ConvertGlobalVarDiffIR(
+    const GlobalVarDiffIR *global_var_diff_ir) {
+  abi_diff::GlobalVarDeclDiff global_var_diff;
+  global_var_diff.set_name(global_var_diff_ir->GetName());
+  abi_dump::GlobalVarDecl *old_global_var = global_var_diff.mutable_old();
+  abi_dump::GlobalVarDecl *new_global_var = global_var_diff.mutable_new_();
+  if (old_global_var == nullptr || new_global_var == nullptr) {
+    llvm::errs() << "Globar Var diff could not be added\n";
+    ::exit(1);
+  }
+  *old_global_var =
+      IRToProtobufConverter::ConvertGlobalVarIR(
+          global_var_diff_ir->GetOldGlobalVar());
+  *new_global_var =
+      IRToProtobufConverter::ConvertGlobalVarIR(
+          global_var_diff_ir->GetNewGlobalVar());
+  return global_var_diff;
+}
+
+abi_diff::FunctionDeclDiff IRDiffToProtobufConverter::ConvertFunctionDiffIR(
+    const FunctionDiffIR *function_diff_ir) {
+  abi_diff::FunctionDeclDiff function_diff;
+  function_diff.set_name(function_diff_ir->GetName());
+  abi_dump::FunctionDecl *old_function = function_diff.mutable_old();
+  abi_dump::FunctionDecl *new_function = function_diff.mutable_new_();
+  if (old_function == nullptr || new_function == nullptr) {
+    llvm::errs() << "Function diff could not be added\n";
+    ::exit(1);
+  }
+  *old_function =
+      IRToProtobufConverter::ConvertFunctionIR(
+          function_diff_ir->GetOldFunction());
+  *new_function =
+      IRToProtobufConverter::ConvertFunctionIR(
+          function_diff_ir->GetNewFunction());
+  return function_diff;
+}
+
+bool ProtobufIRDumper::AddLinkableMessageIR (const LinkableMessageIR *lm) {
+  // No RTTI
+  switch (lm->GetKind()) {
+    case RecordTypeKind:
+      return AddRecordTypeIR(static_cast<const RecordTypeIR *>(lm));
+    case EnumTypeKind:
+      return AddEnumTypeIR(static_cast<const EnumTypeIR *>(lm));
+    case PointerTypeKind:
+      return AddPointerTypeIR(static_cast<const PointerTypeIR *>(lm));
+    case QualifiedTypeKind:
+      return AddQualifiedTypeIR(static_cast<const QualifiedTypeIR *>(lm));
+    case ArrayTypeKind:
+      return AddArrayTypeIR(static_cast<const ArrayTypeIR *>(lm));
+    case LvalueReferenceTypeKind:
+      return AddLvalueReferenceTypeIR(
+          static_cast<const LvalueReferenceTypeIR *>(lm));
+    case RvalueReferenceTypeKind:
+      return AddRvalueReferenceTypeIR(
+          static_cast<const RvalueReferenceTypeIR*>(lm));
+    case BuiltinTypeKind:
+      return AddBuiltinTypeIR(static_cast<const BuiltinTypeIR*>(lm));
+    case GlobalVarKind:
+      return AddGlobalVarIR(static_cast<const GlobalVarIR*>(lm));
+    case FunctionKind:
+      return AddFunctionIR(static_cast<const FunctionIR*>(lm));
+  }
+  return false;
+}
+
+bool ProtobufIRDumper::AddRecordTypeIR(const RecordTypeIR *recordp) {
+  abi_dump::RecordType *added_record_type = tu_ptr_->add_record_types();
+  if (!added_record_type) {
+    return false;
+  }
+  *added_record_type = ConvertRecordTypeIR(recordp);
+  return true;
+}
+
+bool ProtobufIRDumper::AddFunctionIR(const FunctionIR *functionp) {
+  abi_dump::FunctionDecl *added_function = tu_ptr_->add_functions();
+  if (!added_function) {
+    return false;
+  }
+  *added_function = ConvertFunctionIR(functionp);
+  return true;
+}
+
+bool ProtobufIRDumper::AddEnumTypeIR(const EnumTypeIR *enump) {
+  abi_dump::EnumType *added_enum_type = tu_ptr_->add_enum_types();
+  if (!added_enum_type) {
+    return false;
+  }
+  *added_enum_type = ConvertEnumTypeIR(enump);
+  return true;
+}
+
+bool ProtobufIRDumper::AddGlobalVarIR(const GlobalVarIR *global_varp) {
+  abi_dump::GlobalVarDecl *added_global_var = tu_ptr_->add_global_vars();
+  if (!added_global_var) {
+    return false;
+  }
+  *added_global_var = ConvertGlobalVarIR(global_varp);
+  return true;
+}
+
+bool ProtobufIRDumper::AddPointerTypeIR(const PointerTypeIR *pointerp) {
+  abi_dump::PointerType *added_pointer_type = tu_ptr_->add_pointer_types();
+  if (!added_pointer_type) {
+    return false;
+  }
+  *added_pointer_type = ConvertPointerTypeIR(pointerp);
+  return true;
+}
+
+bool ProtobufIRDumper::AddQualifiedTypeIR(const QualifiedTypeIR *qualtypep) {
+  abi_dump::QualifiedType *added_qualified_type =
+      tu_ptr_->add_qualified_types();
+  if (!added_qualified_type) {
+    return false;
+  }
+  *added_qualified_type = ConvertQualifiedTypeIR(qualtypep);
+  return true;
+}
+
+bool ProtobufIRDumper::AddBuiltinTypeIR(const BuiltinTypeIR *builtin_typep) {
+  abi_dump::BuiltinType *added_builtin_type =
+      tu_ptr_->add_builtin_types();
+  if (!added_builtin_type) {
+    return false;
+  }
+  *added_builtin_type = ConvertBuiltinTypeIR(builtin_typep);
+  return true;
+}
+
+bool ProtobufIRDumper::AddArrayTypeIR(const ArrayTypeIR *array_typep) {
+  abi_dump::ArrayType *added_array_type =
+      tu_ptr_->add_array_types();
+  if (!added_array_type) {
+    return false;
+  }
+  *added_array_type = ConvertArrayTypeIR(array_typep);
+  return true;
+}
+
+bool ProtobufIRDumper::AddLvalueReferenceTypeIR(
+    const LvalueReferenceTypeIR *lvalue_reference_typep) {
+  abi_dump::LvalueReferenceType *added_lvalue_reference_type =
+      tu_ptr_->add_lvalue_reference_types();
+  if (!added_lvalue_reference_type) {
+    return false;
+  }
+  *added_lvalue_reference_type =
+      ConvertLvalueReferenceTypeIR(lvalue_reference_typep);
+  return true;
+}
+
+bool ProtobufIRDumper::AddRvalueReferenceTypeIR(
+    const RvalueReferenceTypeIR *rvalue_reference_typep) {
+  abi_dump::RvalueReferenceType *added_rvalue_reference_type =
+      tu_ptr_->add_rvalue_reference_types();
+  if (!added_rvalue_reference_type) {
+    return false;
+  }
+  *added_rvalue_reference_type =
+      ConvertRvalueReferenceTypeIR(rvalue_reference_typep);
+  return true;
+}
+
+bool ProtobufIRDumper::Dump() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+  assert( tu_ptr_.get() != nullptr);
+  std::ofstream text_output(dump_path_);
+  google::protobuf::io::OstreamOutputStream text_os(&text_output);
+  return google::protobuf::TextFormat::Print(*tu_ptr_.get(), &text_os);
+}
+
+void ProtobufIRDiffDumper::AddLibNameIR(const std::string &name) {
+  diff_tu_->set_lib_name(name);
+}
+
+void ProtobufIRDiffDumper::AddArchIR(const std::string &arch) {
+  diff_tu_->set_arch(arch);
+}
+
+CompatibilityStatusIR ProtobufIRDiffDumper::GetCompatibilityStatusIR() {
+  if (diff_tu_->functions_removed().size() != 0 ||
+      diff_tu_->global_vars_removed().size() != 0 ||
+      diff_tu_->function_diffs().size() != 0 ||
+      diff_tu_->global_var_diffs().size() != 0 ||
+      diff_tu_->enum_type_diffs().size() != 0 ||
+      diff_tu_->record_type_diffs().size() != 0 ||
+      diff_tu_->removed_elf_functions().size() != 0 ||
+      diff_tu_->removed_elf_objects().size() != 0) {
+    return CompatibilityStatusIR::Incompatible;
+  }
+
+  CompatibilityStatusIR combined_status = CompatibilityStatusIR::Compatible;
+
+  if (diff_tu_->enum_type_extension_diffs().size() != 0 ||
+      diff_tu_->functions_added().size() != 0 ||
+      diff_tu_->global_vars_added().size() !=0 ||
+      diff_tu_->added_elf_functions().size() != 0 ||
+      diff_tu_->added_elf_objects().size() != 0) {
+    combined_status = combined_status | CompatibilityStatusIR::Extension;
+  }
+
+  if (diff_tu_->unreferenced_enum_type_diffs().size() != 0 ||
+      diff_tu_->unreferenced_enum_types_removed().size() != 0 ||
+      diff_tu_->unreferenced_record_types_removed().size() != 0 ||
+      diff_tu_->unreferenced_record_type_diffs().size() != 0 ||
+      diff_tu_->unreferenced_enum_type_extension_diffs().size() != 0 ||
+      diff_tu_->unreferenced_record_types_added().size() != 0 ||
+      diff_tu_->unreferenced_enum_types_added().size()) {
+    combined_status =
+        combined_status | CompatibilityStatusIR::UnreferencedChanges;
+  }
+
+  return combined_status;
+}
+
+void ProtobufIRDiffDumper::AddCompatibilityStatusIR(
+    CompatibilityStatusIR status) {
+  diff_tu_->set_compatibility_status(CompatibilityStatusIRToProtobuf(status));
+}
+
+bool ProtobufIRDiffDumper::AddDiffMessageIR(
+    const DiffMessageIR *message,
+    const std::string &type_stack,
+    DiffKind diff_kind) {
+  switch (message->Kind()) {
+    case RecordTypeKind:
+      return AddRecordTypeDiffIR(
+          static_cast<const RecordTypeDiffIR *>(message),
+          type_stack, diff_kind);
+    case EnumTypeKind:
+      return AddEnumTypeDiffIR(
+          static_cast<const EnumTypeDiffIR *>(message),
+          type_stack, diff_kind);
+    case GlobalVarKind:
+      return AddGlobalVarDiffIR(
+          static_cast<const GlobalVarDiffIR*>(message),
+          type_stack, diff_kind);
+    case FunctionKind:
+      return AddFunctionDiffIR(
+          static_cast<const FunctionDiffIR*>(message),
+          type_stack, diff_kind);
+    default:
+      break;
+  }
+  llvm::errs() << "Dump Diff attempted on something not a user defined type" <<
+                   "/ function / global variable\n";
+  return false;
+}
+
+bool ProtobufIRDiffDumper::AddLinkableMessageIR(
+    const LinkableMessageIR *message,
+    DiffKind diff_kind) {
+  switch (message->GetKind()) {
+    case RecordTypeKind:
+      return AddLoneRecordTypeDiffIR(
+          static_cast<const RecordTypeIR *>(message), diff_kind);
+    case EnumTypeKind:
+      return AddLoneEnumTypeDiffIR(
+          static_cast<const EnumTypeIR *>(message), diff_kind);
+    case GlobalVarKind:
+      return AddLoneGlobalVarDiffIR(
+          static_cast<const GlobalVarIR*>(message), diff_kind);
+    case FunctionKind:
+      return AddLoneFunctionDiffIR(
+          static_cast<const FunctionIR*>(message), diff_kind);
+    default:
+      break;
+  }
+  llvm::errs() << "Dump Diff attempted on something not a user defined type" <<
+                   "/ function / global variable\n";
+  return false;
+}
+
+bool ProtobufIRDiffDumper::AddElfSymbolMessageIR (const ElfSymbolIR *elf_symbol,
+                                                  DiffKind diff_kind) {
+  switch (elf_symbol->GetKind()) {
+    case ElfSymbolIR::ElfFunctionKind:
+      return AddElfFunctionIR(static_cast<const ElfFunctionIR *>(elf_symbol),
+                              diff_kind);
+      break;
+    case ElfSymbolIR::ElfObjectKind:
+      return AddElfObjectIR(static_cast<const ElfObjectIR *>(elf_symbol),
+                            diff_kind);
+      break;
+  }
+  // Any other kind is invalid
+  return false;
+}
+
+bool ProtobufIRDiffDumper::AddElfFunctionIR(
+    const ElfFunctionIR *elf_function_ir, DiffKind diff_kind) {
+  abi_dump::ElfFunction *added_elf_function = nullptr;
+  switch(diff_kind) {
+    case DiffKind::Removed:
+      added_elf_function = diff_tu_->add_removed_elf_functions();
+      break;
+    case DiffKind::Added:
+      added_elf_function = diff_tu_->add_added_elf_functions();
+      break;
+    default:
+      llvm::errs() << "Invalid call to AddElfFunctionIR\n";
+      return false;
+  }
+  if (added_elf_function == nullptr) {
+    return false;
+  }
+  *added_elf_function =
+      IRToProtobufConverter::ConvertElfFunctionIR(elf_function_ir);
+  return true;
+}
+
+bool ProtobufIRDiffDumper::AddElfObjectIR(
+    const ElfObjectIR *elf_object_ir, DiffKind diff_kind) {
+  abi_dump::ElfObject *added_elf_object = nullptr;
+  switch(diff_kind) {
+    case DiffKind::Removed:
+      added_elf_object = diff_tu_->add_removed_elf_objects();
+      break;
+    case DiffKind::Added:
+      added_elf_object = diff_tu_->add_added_elf_objects();
+      break;
+    default:
+      llvm::errs() << "Invalid call to AddElfObjectIR\n";
+      return false;
+  }
+  if (added_elf_object == nullptr) {
+    return false;
+  }
+  *added_elf_object =
+      IRToProtobufConverter::ConvertElfObjectIR(elf_object_ir);
+  return true;
+}
+
+bool ProtobufIRDiffDumper::AddLoneRecordTypeDiffIR(
+    const RecordTypeIR *record_type_ir,
+    DiffKind diff_kind) {
+  abi_dump::RecordType *added_record_type = nullptr;
+  switch (diff_kind) {
+    case DiffKind::Removed:
+      // Referenced record types do not get reported as added / removed,
+      // the diff shows up in the parent type / function/ global variable
+      // referencing the record.
+      added_record_type = diff_tu_->add_unreferenced_record_types_removed();
+      break;
+    case DiffKind::Added:
+      added_record_type = diff_tu_->add_unreferenced_record_types_added();
+      break;
+    default:
+      llvm::errs() << "Invalid call to AddLoneRecordTypeDiffIR\n";
+      return false;
+  }
+  if (added_record_type == nullptr) {
+    return false;
+  }
+  *added_record_type =
+      IRToProtobufConverter::ConvertRecordTypeIR(record_type_ir);
+  return true;
+}
+
+bool ProtobufIRDiffDumper::AddLoneFunctionDiffIR(
+    const FunctionIR *function_ir,
+    DiffKind diff_kind) {
+  abi_dump::FunctionDecl *added_function = nullptr;
+  switch (diff_kind) {
+    case DiffKind::Removed:
+      added_function = diff_tu_->add_functions_removed();
+      break;
+    case DiffKind::Added:
+      added_function = diff_tu_->add_functions_added();
+      break;
+    default:
+      llvm::errs() << "Invalid call to AddLoneFunctionDiffIR\n";
+      return false;
+  }
+  *added_function = IRToProtobufConverter::ConvertFunctionIR(function_ir);
+  return true;
+}
+
+bool ProtobufIRDiffDumper::AddLoneEnumTypeDiffIR(
+    const EnumTypeIR *enum_type_ir, DiffKind diff_kind) {
+  abi_dump::EnumType *added_enum_type = nullptr;
+  switch (diff_kind) {
+    case DiffKind::Removed:
+      // Referenced enum types do not get reported as added / removed,
+      // the diff shows up in the parent type / function/ global variable
+      // referencing the enum.
+      added_enum_type = diff_tu_->add_unreferenced_enum_types_removed();
+      break;
+    case DiffKind::Added:
+      added_enum_type = diff_tu_->add_unreferenced_enum_types_added();
+      break;
+    default:
+      llvm::errs() << "Invalid call to AddLoneRecordTypeDiffIR\n";
+      return false;
+  }
+  if (added_enum_type == nullptr) {
+    return false;
+  }
+  *added_enum_type = IRToProtobufConverter::ConvertEnumTypeIR(enum_type_ir);
+  return true;
+}
+
+bool ProtobufIRDiffDumper::AddLoneGlobalVarDiffIR(
+    const GlobalVarIR *global_var_ir, DiffKind diff_kind) {
+  abi_dump::GlobalVarDecl *added_global_var = nullptr;
+  switch (diff_kind) {
+    case DiffKind::Removed:
+      added_global_var = diff_tu_->add_global_vars_removed();
+      break;
+    case DiffKind::Added:
+      added_global_var = diff_tu_->add_global_vars_added();
+      break;
+    default:
+      llvm::errs() << "Invalid call to AddLoneFunctionDiffIR\n";
+      return false;
+  }
+  *added_global_var = IRToProtobufConverter::ConvertGlobalVarIR(global_var_ir);
+  return true;
+}
+
+bool ProtobufIRDiffDumper::AddRecordTypeDiffIR(
+    const RecordTypeDiffIR *record_diff_ir,
+    const std::string &type_stack,
+    DiffKind diff_kind) {
+  abi_diff::RecordTypeDiff *added_record_type_diff = nullptr;
+  switch (diff_kind) {
+    case DiffKind::Unreferenced:
+      added_record_type_diff = diff_tu_->add_unreferenced_record_type_diffs();
+      break;
+    case DiffKind::Referenced:
+      added_record_type_diff = diff_tu_->add_record_type_diffs();
+      break;
+    default:
+      break;
+  }
+  if (!added_record_type_diff) {
+    return false;
+  }
+
+  *added_record_type_diff =
+      IRDiffToProtobufConverter::ConvertRecordTypeDiffIR(record_diff_ir);
+  added_record_type_diff->set_type_stack(type_stack);
+  return true;
+}
+
+bool ProtobufIRDiffDumper::AddFunctionDiffIR(
+    const FunctionDiffIR *function_diff_ir, const std::string &type_stack,
+    DiffKind diff_kind) {
+  abi_diff::FunctionDeclDiff *added_function_diff =
+      diff_tu_->add_function_diffs();
+  if (!added_function_diff) {
+    return false;
+  }
+  *added_function_diff =
+      IRDiffToProtobufConverter::ConvertFunctionDiffIR(function_diff_ir);
+  return true;
+}
+
+bool ProtobufIRDiffDumper::AddEnumTypeDiffIR(const EnumTypeDiffIR *enum_diff_ir,
+                                             const std::string &type_stack,
+                                             DiffKind diff_kind) {
+  abi_diff::EnumTypeDiff *added_enum_type_diff = nullptr;
+  switch (diff_kind) {
+    case DiffKind::Unreferenced:
+      if (enum_diff_ir->IsExtended()) {
+        added_enum_type_diff =
+            diff_tu_->add_unreferenced_enum_type_extension_diffs();
+      } else {
+        added_enum_type_diff =
+            diff_tu_->add_unreferenced_enum_type_diffs();
+      }
+      break;
+    case DiffKind::Referenced:
+      if (enum_diff_ir->IsExtended()) {
+        added_enum_type_diff =
+            diff_tu_->add_enum_type_extension_diffs();
+      } else {
+        added_enum_type_diff =
+            diff_tu_->add_enum_type_diffs();
+      }
+      break;
+    default:
+      break;
+  }
+  if (!added_enum_type_diff) {
+    return false;
+  }
+  *added_enum_type_diff =
+      IRDiffToProtobufConverter::ConvertEnumTypeDiffIR(enum_diff_ir);
+  added_enum_type_diff->set_type_stack(type_stack);
+  return true;
+}
+
+bool ProtobufIRDiffDumper::AddGlobalVarDiffIR(
+    const GlobalVarDiffIR *global_var_diff_ir,
+    const std::string &type_stack,
+    DiffKind diff_kind) {
+  abi_diff::GlobalVarDeclDiff *added_global_var_diff =
+      diff_tu_->add_global_var_diffs();
+  if (!added_global_var_diff) {
+    return false;
+  }
+  *added_global_var_diff =
+      IRDiffToProtobufConverter::ConvertGlobalVarDiffIR(global_var_diff_ir);
+  return true;
+}
+
+bool ProtobufIRDiffDumper::Dump() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+  assert(diff_tu_.get() != nullptr);
+  std::ofstream text_output(dump_path_);
+  google::protobuf::io::OstreamOutputStream text_os(&text_output);
+  return google::protobuf::TextFormat::Print(*diff_tu_.get(), &text_os);
+}
+
+} //abi_util
diff --git a/vndk/tools/header-checker/proto/abi_diff.proto b/vndk/tools/header-checker/proto/abi_diff.proto
index 28dbd52..17cfc92 100644
--- a/vndk/tools/header-checker/proto/abi_diff.proto
+++ b/vndk/tools/header-checker/proto/abi_diff.proto
@@ -4,97 +4,112 @@
 
 package abi_diff;
 
-message RecordFieldDeclDiff {
-  optional abi_dump.RecordFieldDecl old = 1;
-  optional abi_dump.RecordFieldDecl new = 2;
-  optional uint32 index = 3;
+message TypeInfo {
+  optional uint64 size = 1;
+  optional uint32 alignment = 2;
 }
 
-message EnumFieldDeclDiff {
-  optional abi_dump.EnumFieldDecl old = 1;
-  optional abi_dump.EnumFieldDecl new = 2;
-  optional uint32 index = 3;
+message TypeInfoDiff {
+  optional TypeInfo old_type_info  = 1;
+  optional TypeInfo new_type_info  = 2;
+}
+
+message VTableLayoutDiff {
+  optional abi_dump.VTableLayout old_vtable = 1;
+  optional abi_dump.VTableLayout new_vtable = 2;
+}
+
+message RecordFieldDeclDiff {
+  optional abi_dump.RecordFieldDecl old_field = 1;
+  optional abi_dump.RecordFieldDecl new_field = 2;
 }
 
 message CXXBaseSpecifierDiff {
-  optional abi_dump.CXXBaseSpecifier old = 1;
-  optional abi_dump.CXXBaseSpecifier new = 2;
-  optional uint32 index = 3;
+  repeated abi_dump.CXXBaseSpecifier old_bases = 1;
+  repeated abi_dump.CXXBaseSpecifier new_bases = 2;
 }
 
-message CXXVTableDiff {
-  optional abi_dump.VTableComponent old = 1;
-  optional abi_dump.VTableComponent new = 2;
-  optional uint32 index = 3;
+message RecordTypeDiff {
+  optional string name = 1;
+  optional string type_stack = 2;
+  optional TypeInfoDiff type_info_diff = 3;
+  repeated abi_dump.RecordFieldDecl fields_removed = 4;
+  repeated RecordFieldDeclDiff fields_diff = 5;
+  optional CXXBaseSpecifierDiff bases_diff = 6;
+  optional VTableLayoutDiff vtable_layout_diff = 7;
 }
 
-message BasicNamedAndTypedDeclDiff {
-  optional abi_dump.BasicNamedAndTypedDecl old = 1;
-  optional abi_dump.BasicNamedAndTypedDecl new = 2;
+message UnderlyingTypeDiff {
+  optional string old_type  = 1;
+  optional string new_type  = 2;
 }
 
-message RecordDeclDiff {
-  repeated RecordFieldDeclDiff field_diffs = 1;
-  repeated CXXBaseSpecifierDiff base_diffs = 2;
-  repeated CXXVTableDiff vtable_diffs = 3;
-  optional BasicNamedAndTypedDeclDiff type_diff = 4;
-  optional string name = 5;
+message EnumFieldDeclDiff {
+  optional abi_dump.EnumFieldDecl old_field = 1;
+  optional abi_dump.EnumFieldDecl new_field = 2;
 }
 
-message EnumDeclDiff {
-  repeated EnumFieldDeclDiff field_diffs = 1;
-  optional BasicNamedAndTypedDeclDiff type_diff = 2;
-  optional string name = 3;
-}
-
-message ReturnTypeDiff {
-  optional abi_dump.BasicNamedAndTypedDecl old = 1;
-  optional abi_dump.BasicNamedAndTypedDecl new = 2;
-}
-
-message ParamDeclDiff {
-  optional abi_dump.ParamDecl old = 1;
-  optional abi_dump.ParamDecl new = 2;
-  optional uint32 index = 3;
+message EnumTypeDiff {
+  optional string type_stack = 1;
+  optional string name = 2;
+  repeated EnumFieldDeclDiff fields_diff = 3;
+  optional UnderlyingTypeDiff underlying_type_diff = 4;
+  repeated abi_dump.EnumFieldDecl fields_added = 5;
+  repeated abi_dump.EnumFieldDecl fields_removed = 6;
 }
 
 message FunctionDeclDiff {
-  optional ReturnTypeDiff return_type_diffs = 1;
-  repeated ParamDeclDiff param_diffs = 2;
-  optional string name = 3;
+  // Template diffs are not required since in C++, they will show up in mangled
+  // names and in C, templates are not supported.
+  optional string type_stack = 1;
+  optional string name = 2;
+  optional abi_dump.FunctionDecl old = 3;
+  optional abi_dump.FunctionDecl new = 4;
 }
 
 message GlobalVarDeclDiff {
-  optional BasicNamedAndTypedDeclDiff type_diff = 1;
-}
-
-enum CompatibilityStatus {
-  COMPATIBLE = 0;
-  EXTENSION = 1;
-  INCOMPATIBLE = 4;
+  optional string type_stack = 1;
+  optional string name = 2;
+  optional abi_dump.GlobalVarDecl old = 3; // Old global var
+  optional abi_dump.GlobalVarDecl new = 4; // New global var
 }
 
 message TranslationUnitDiff {
   // Library Name
   optional string lib_name = 1;
   optional string arch = 2;
-  // Differing Elements.
-  repeated RecordDeclDiff records_diff = 3;
-  repeated EnumDeclDiff enums_diff = 4;
-  repeated FunctionDeclDiff functions_diff = 5;
-  repeated GlobalVarDeclDiff global_vars_diff = 6;
-  // Removed Elements.
-  repeated abi_dump.RecordDecl records_removed = 7;
-  repeated abi_dump.FunctionDecl functions_removed = 8;
-  repeated abi_dump.EnumDecl enums_removed = 9;
-  repeated abi_dump.GlobalVarDecl global_vars_removed = 10;
-  // Added Elements.
-  repeated abi_dump.RecordDecl records_added = 11;
-  repeated abi_dump.FunctionDecl functions_added = 12;
-  repeated abi_dump.EnumDecl enums_added = 13;
-  repeated abi_dump.GlobalVarDecl global_vars_added = 14;
+  // Records.
+  repeated RecordTypeDiff record_type_diffs = 3;
+  repeated RecordTypeDiff unreferenced_record_type_diffs = 4;
+  repeated abi_dump.RecordType unreferenced_record_types_removed = 5;
+  repeated abi_dump.RecordType unreferenced_record_types_added = 6;
+
+  // Enums
+  repeated EnumTypeDiff enum_type_diffs = 7;
+  repeated EnumTypeDiff enum_type_extension_diffs = 8;
+  repeated EnumTypeDiff unreferenced_enum_type_diffs = 9;
+  repeated EnumTypeDiff unreferenced_enum_type_extension_diffs = 10;
+  repeated abi_dump.EnumType unreferenced_enum_types_removed = 11;
+  repeated abi_dump.EnumType unreferenced_enum_types_added = 12;
+
+  // Functions and Global variables.
+  repeated FunctionDeclDiff function_diffs = 13;
+  repeated GlobalVarDeclDiff global_var_diffs = 14;
+
+  repeated abi_dump.FunctionDecl functions_removed = 15;
+  repeated abi_dump.GlobalVarDecl global_vars_removed = 16;
+
+  repeated abi_dump.FunctionDecl functions_added = 17;
+  repeated abi_dump.GlobalVarDecl global_vars_added = 18;
+
+  repeated abi_dump.ElfFunction added_elf_functions = 19;
+  repeated abi_dump.ElfFunction removed_elf_functions = 20;
+
+  repeated abi_dump.ElfObject added_elf_objects = 21;
+  repeated abi_dump.ElfObject removed_elf_objects = 22;
+
   // Compatiblity Status
-  optional CompatibilityStatus compatibility_status = 15;
+  optional CompatibilityStatus compatibility_status = 23;
 }
 
 // Not merged with TranslationUnitDiff to allow future extensions.
@@ -108,3 +123,9 @@
 message MergedTranslationUnitDiff {
   repeated ConciseDiffReportInformation diff_reports = 1;
 }
+
+enum CompatibilityStatus {
+  COMPATIBLE = 0;
+  EXTENSION = 1;
+  INCOMPATIBLE = 4;
+}
diff --git a/vndk/tools/header-checker/proto/abi_dump.proto b/vndk/tools/header-checker/proto/abi_dump.proto
index 3633d20..870329c 100644
--- a/vndk/tools/header-checker/proto/abi_dump.proto
+++ b/vndk/tools/header-checker/proto/abi_dump.proto
@@ -2,50 +2,84 @@
 
 package abi_dump;
 
-message BasicTypeAbi {
-  // The type's name. for eg : a record field's type.
-  optional string name = 1;
-  // Optional since templated types will not have this information.
-  optional uint64 size = 2 [default = 0];
-  optional uint32 alignment = 3 [default = 0];
-}
-
 enum AccessSpecifier {
   public_access = 1;
   private_access = 2;
   protected_access = 3;
 }
 
+enum RecordKind {
+  struct_kind = 1;
+  class_kind = 2;
+  union_kind = 3;
+}
+
 message BasicNamedAndTypedDecl {
-  optional BasicTypeAbi type_abi = 1;
   // The TypedDecl's name.
-  optional string name = 2;
-  optional AccessSpecifier access = 3;
-  optional string linker_set_key = 4;
+  optional string name = 1;
+  optional uint64 size = 2 [default = 0];
+  optional uint32 alignment = 3 [default = 0];
+  optional string referenced_type = 4;
+  optional string source_file = 5;
+  optional string linker_set_key = 6;
+}
+
+message ArrayType {
+  optional BasicNamedAndTypedDecl type_info = 1;
+}
+
+message PointerType {
+  optional BasicNamedAndTypedDecl type_info = 1;
+}
+
+message QualifiedType {
+  optional BasicNamedAndTypedDecl type_info = 1;
+  optional bool is_const = 6;
+  optional bool is_volatile = 7;
+  optional bool is_restricted = 8;
+}
+
+message BuiltinType {
+  optional BasicNamedAndTypedDecl type_info = 1;
+  optional bool is_unsigned = 2;
+  optional bool is_integral = 3;
+}
+
+message LvalueReferenceType {
+  optional BasicNamedAndTypedDecl type_info = 1;
+}
+
+message RvalueReferenceType {
+  optional BasicNamedAndTypedDecl type_info = 1;
 }
 
 message FunctionDecl {
-  optional BasicNamedAndTypedDecl basic_abi = 1;
-  // Mangled name.
-  optional string mangled_function_name = 2;
+  // Return type reference
+  optional string return_type = 1;
+  optional string function_name = 2;
   optional string source_file = 3;
   repeated ParamDecl parameters = 4;
   optional TemplateInfo template_info = 5;
+  optional string linker_set_key = 6;
+  optional AccessSpecifier access = 7 [default = public_access];
 }
 
 message ParamDecl {
-  optional BasicNamedAndTypedDecl basic_abi = 1;
+  optional string referenced_type = 1;
   optional bool default_arg = 2;
 }
 
 message RecordFieldDecl {
   // For future additions.
-  optional BasicNamedAndTypedDecl basic_abi = 1;
+  optional string referenced_type = 1;
+  optional uint64 field_offset = 2;
+  optional string field_name = 3;
+  optional AccessSpecifier access = 4 [default = public_access];
 }
 
 message EnumFieldDecl {
-  optional BasicNamedAndTypedDecl basic_abi = 1;
-  optional int64 enum_field_value = 2; // assumption: fits int64
+  optional int64 enum_field_value = 1; // assumption: fits int64
+  optional string name = 3;
 }
 
 message TemplateInfo {
@@ -53,17 +87,13 @@
 }
 
 message TemplateElement {
-  optional BasicTemplateElementAbi basic_abi = 1;
-  message BasicTemplateElementAbi {
-    optional BasicTypeAbi type_abi = 1;
-    optional string name = 2;
-    optional string linker_set_key = 3;
-  }
+  optional string referenced_type = 1;
 }
 
 message CXXBaseSpecifier {
-  optional BasicNamedAndTypedDecl basic_abi = 1;
+  optional string referenced_type = 1;
   optional bool is_virtual = 2;
+  optional AccessSpecifier access = 3;
 }
 
 message VTableComponent {
@@ -89,30 +119,51 @@
   repeated VTableComponent vtable_components = 1;
 }
 
-message RecordDecl {
-  optional BasicNamedAndTypedDecl basic_abi = 1;
+message RecordType {
+  optional BasicNamedAndTypedDecl type_info = 1;
   repeated RecordFieldDecl fields = 2;
   repeated CXXBaseSpecifier base_specifiers = 3;
-  optional string source_file = 4;
   optional TemplateInfo template_info = 5;
-  optional string mangled_record_name = 6;
   optional VTableLayout vtable_layout = 7;
+  optional AccessSpecifier access = 8 [default = public_access];
+  optional bool is_anonymous = 9;
+  optional RecordKind record_kind = 10 [default = struct_kind];
 }
 
-message EnumDecl {
-  optional BasicNamedAndTypedDecl basic_abi = 1;
-  repeated EnumFieldDecl enum_fields = 2;
-  optional string source_file = 3;
+message EnumType {
+  optional BasicNamedAndTypedDecl type_info = 1;
+  optional string underlying_type = 2;
+  repeated EnumFieldDecl enum_fields = 3;
+  optional AccessSpecifier access = 4 [default = public_access];
 }
 
 message GlobalVarDecl {
-  optional BasicNamedAndTypedDecl basic_abi = 1;
+  optional string name = 1;
   optional string source_file = 2;
+  optional string linker_set_key = 3;
+  optional string referenced_type = 4;
+  optional AccessSpecifier access = 5 [default = public_access];
+}
+
+message ElfFunction {
+  optional string name = 1;
+}
+
+message ElfObject {
+  optional string name = 1;
 }
 
 message TranslationUnit {
-  repeated RecordDecl records = 1;
-  repeated FunctionDecl functions = 2;
-  repeated EnumDecl enums = 3;
-  repeated GlobalVarDecl global_vars = 4;
+  repeated RecordType record_types = 1;
+  repeated EnumType enum_types = 2;
+  repeated PointerType pointer_types = 3;
+  repeated LvalueReferenceType lvalue_reference_types = 4;
+  repeated RvalueReferenceType rvalue_reference_types = 5;
+  repeated BuiltinType builtin_types = 6;
+  repeated QualifiedType qualified_types = 7;
+  repeated ArrayType array_types = 8;
+  repeated FunctionDecl functions = 9;
+  repeated GlobalVarDecl global_vars = 10;
+  repeated ElfFunction elf_functions = 11;
+  repeated ElfObject elf_objects = 12;
 }
diff --git a/vndk/tools/header-checker/tests/input/example1.h b/vndk/tools/header-checker/tests/input/example1.h
index c00cf06..1ff0c1c 100644
--- a/vndk/tools/header-checker/tests/input/example1.h
+++ b/vndk/tools/header-checker/tests/input/example1.h
@@ -7,9 +7,21 @@
 extern "C" {
 #endif
 
+struct ForwardDeclaration;
+int uses_forward_decl(struct ForwardDeclaration *);
+
 struct Hello {
   int foo;
   int bar;
+  enum {A, B} enum_field;
+  enum {C, D} enum_field2;
+  struct {
+    int a;
+    int b;
+    struct {
+      int c;
+    };
+  };
 };
 
 #if defined(__cplusplus)
@@ -24,8 +36,17 @@
   cfloat_type cpp_bar;
   virtual int again() { return 0; }
   CPPHello() : cpp_foo(20), cpp_bar(1.234) { }
+  enum Bla{BLA = 1};
+  int test_enum() {return CPPHello::BLA;}
 };
 
+
+void fooVariadic (int &, int *, ...);
+
+int boo (const CPPHello, int *, float *) {
+  return CPPHello::BLA;
+}
+
 template<typename T>
 struct StackNode {
 public:
@@ -63,7 +84,7 @@
 template<typename T>
 class List
 {
-protected:
+public:
     /*
      * One element in the list.
      */
@@ -74,6 +95,7 @@
         inline T& getRef() { return mVal; }
         inline const T& getRef() const { return mVal; }
     private:
+        void PrivateNode();
         friend class List;
         friend class _ListIterator;
         T           mVal;
@@ -83,11 +105,20 @@
     _Node *middle;
 };
 
+
 typedef List<float> float_list;
 float_list float_list_test;
 
-
 typedef List<int> int_list;
 int_list int_list_test;
+List<float>::_Node node(2);
+int ListMangle(int_list *, StackNode<int> *);
+
+template<typename IChild, typename IParent, typename BpChild, typename BpParent>
+List<IChild> castInterface(List<IParent> parent, const char *childIndicator, bool emitError) {return List<IChild>();}
+
+void format() {
+castInterface<float, float, float , float>(List<float>(), "foo", true);
+}
 
 #endif  // EXAMPLE1_H_
diff --git a/vndk/tools/header-checker/tests/input/example2.h b/vndk/tools/header-checker/tests/input/example2.h
index acf0f42..bc225eb 100644
--- a/vndk/tools/header-checker/tests/input/example2.h
+++ b/vndk/tools/header-checker/tests/input/example2.h
@@ -22,6 +22,7 @@
   int bar_again;
   static int hello_forever;
   virtual int again();
+  virtual ~HelloAgain() {}
 };
 struct NowWeCrash;
 } // namespace test2
diff --git a/vndk/tools/vndk-compliance/parse-and-fix-errors.sh b/vndk/tools/vndk-compliance/parse-and-fix-errors.sh
index 84c6bbd..b4f6216 100755
--- a/vndk/tools/vndk-compliance/parse-and-fix-errors.sh
+++ b/vndk/tools/vndk-compliance/parse-and-fix-errors.sh
@@ -30,10 +30,10 @@
 cat log | grep "FAILED\|error:" > log.error
 
 #libs that should be added to LOCAL_HEADER_LIBRARIES
-ADD_TO_HEADER_LIBS=(hardware system)
+ADD_TO_HEADER_LIBS=(hardware system cutils utils)
 
 #libs that should be added to LOCAL_SHARED_LIBRARIES
-ADD_TO_SHARED_LIBS=(cutils utils log)
+ADD_TO_SHARED_LIBS=(log)
 
 ALL_LIBS=(${ADD_TO_HEADER_LIBS[@]} ${ADD_TO_SHARED_LIBS[@]})