header-checker: Extract common code to ModuleIR

This commit extracts common IRReader code to ModuleIR.

Test: tests/test.py
Change-Id: I4e8a06833fae8d44718bd52628b3d7351882a3d8

7 files changed, 220 insertions, 161 deletions

diff --git a/vndk/tools/header-checker/Android.bp b/vndk/tools/header-checker/Android.bp
index f49e620b7..d83bd477f 100644
--- a/vndk/tools/header-checker/Android.bp
+++ b/vndk/tools/header-checker/Android.bp
@@ -153,6 +153,7 @@ cc_library_host_static {
         "src/repr/ir_diff_dumper.cpp",
         "src/repr/ir_dumper.cpp",
         "src/repr/ir_reader.cpp",
+        "src/repr/ir_representation.cpp",
         "src/repr/json/converter.cpp",
         "src/repr/json/ir_dumper.cpp",
         "src/repr/json/ir_reader.cpp",
diff --git a/vndk/tools/header-checker/src/repr/ir_reader.cpp b/vndk/tools/header-checker/src/repr/ir_reader.cpp
index 18a983506..3e4e928af 100644
--- a/vndk/tools/header-checker/src/repr/ir_reader.cpp
+++ b/vndk/tools/header-checker/src/repr/ir_reader.cpp
@@ -50,16 +50,6 @@ IRReader::CreateIRReader(
 }
 
 
-void IRReader::AddToODRListMap(const std::string &key, const TypeIR *value) {
-  auto map_it = module_->odr_list_map_.find(key);
-  if (map_it == module_->odr_list_map_.end()) {
-    module_->odr_list_map_.emplace(key, std::list<const TypeIR *>({value}));
-    return;
-  }
-  module_->odr_list_map_[key].emplace_back(value);
-}
-
-
 MergeStatus IRReader::IsBuiltinTypeNodePresent(
     const BuiltinTypeIR *builtin_type, const IRReader &addend,
     AbiElementMap<MergeStatus> *local_to_global_type_id_map) {
@@ -250,7 +240,7 @@ IRReader::UpdateUDTypeAccounting(
   // Add to faciliate ODR checking.
   const std::string &key = GetODRListMapKey(&(it->second));
   MergeStatus type_merge_status = MergeStatus(true, added_type_id);
-  AddToODRListMap(key, &(it->second));
+  module_->AddToODRListMap(key, &(it->second));
   local_to_global_type_id_map->emplace(addend_node->GetSelfType(),
                                        type_merge_status);
   return {type_merge_status, it};
@@ -580,16 +570,5 @@ void IRReader::MergeGraphs(const IRReader &addend) {
 }
 
 
-bool IRReader::IsLinkableMessageInExportedHeaders(
-    const LinkableMessageIR *linkable_message) const {
-  if (module_->exported_headers_ == nullptr ||
-      module_->exported_headers_->empty()) {
-    return true;
-  }
-  return module_->exported_headers_->find(linkable_message->GetSourceFile()) !=
-         module_->exported_headers_->end();
-}
-
-
 }  // namespace repr
 }  // header_checker
diff --git a/vndk/tools/header-checker/src/repr/ir_reader.h b/vndk/tools/header-checker/src/repr/ir_reader.h
index 344927d92..21a8f6951 100644
--- a/vndk/tools/header-checker/src/repr/ir_reader.h
+++ b/vndk/tools/header-checker/src/repr/ir_reader.h
@@ -86,8 +86,6 @@ class IRReader {
                   std::move(addend.module_->qualified_types_));
   }
 
-  void AddToODRListMap(const std::string &key, const TypeIR *value);
-
   template <typename T>
   MergeStatus MergeReferencingTypeInternalAndUpdateParent(
       const IRReader &addend, const T *addend_node,
@@ -206,9 +204,6 @@ class IRReader {
                    std::make_move_iterator(addend.end()));
   }
 
-  bool IsLinkableMessageInExportedHeaders(
-      const LinkableMessageIR *linkable_message) const;
-
   std::unique_ptr<ModuleIR> module_;
 
   uint64_t max_type_id_ = 0;
diff --git a/vndk/tools/header-checker/src/repr/ir_representation.cpp b/vndk/tools/header-checker/src/repr/ir_representation.cpp
new file mode 100644
index 000000000..73577afdb
--- /dev/null
+++ b/vndk/tools/header-checker/src/repr/ir_representation.cpp
@@ -0,0 +1,150 @@
+// Copyright (C) 2019 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 "repr/ir_representation.h"
+
+#include "repr/ir_reader.h"
+#include "repr/ir_representation_internal.h"
+
+#include <utility>
+
+
+namespace header_checker {
+namespace repr {
+
+
+void ModuleIR::AddFunction(FunctionIR &&function) {
+  if (!IsLinkableMessageInExportedHeaders(&function)) {
+    return;
+  }
+  functions_.insert({function.GetLinkerSetKey(), std::move(function)});
+}
+
+
+void ModuleIR::AddGlobalVariable(GlobalVarIR &&global_var) {
+  if (!IsLinkableMessageInExportedHeaders(&global_var)) {
+    return;
+  }
+  global_variables_.insert(
+      {global_var.GetLinkerSetKey(), std::move(global_var)});
+}
+
+
+void ModuleIR::AddRecordType(RecordTypeIR &&record_type) {
+  if (!IsLinkableMessageInExportedHeaders(&record_type)) {
+    return;
+  }
+  auto it = AddToMapAndTypeGraph(
+      std::move(record_type), &record_types_, &type_graph_);
+  const std::string &key = GetODRListMapKey(&(it->second));
+  AddToODRListMap(key, &(it->second));
+}
+
+
+void ModuleIR::AddFunctionType(FunctionTypeIR &&function_type) {
+  if (!IsLinkableMessageInExportedHeaders(&function_type)) {
+    return;
+  }
+  auto it = AddToMapAndTypeGraph(
+      std::move(function_type), &function_types_, &type_graph_);
+  const std::string &key = GetODRListMapKey(&(it->second));
+  AddToODRListMap(key, &(it->second));
+}
+
+
+void ModuleIR::AddEnumType(EnumTypeIR &&enum_type) {
+  if (!IsLinkableMessageInExportedHeaders(&enum_type)) {
+    return;
+  }
+  auto it = AddToMapAndTypeGraph(
+      std::move(enum_type), &enum_types_, &type_graph_);
+  AddToODRListMap(it->second.GetUniqueId() + it->second.GetSourceFile(),
+                  (&it->second));
+}
+
+
+void ModuleIR::AddLvalueReferenceType(
+    LvalueReferenceTypeIR &&lvalue_reference_type) {
+  if (!IsLinkableMessageInExportedHeaders(&lvalue_reference_type)) {
+    return;
+  }
+  AddToMapAndTypeGraph(std::move(lvalue_reference_type),
+                       &lvalue_reference_types_, &type_graph_);
+}
+
+
+void ModuleIR::AddRvalueReferenceType(
+    RvalueReferenceTypeIR &&rvalue_reference_type) {
+  if (!IsLinkableMessageInExportedHeaders(&rvalue_reference_type)) {
+    return;
+  }
+  AddToMapAndTypeGraph(std::move(rvalue_reference_type),
+                       &rvalue_reference_types_, &type_graph_);
+}
+
+
+void ModuleIR::AddQualifiedType(QualifiedTypeIR &&qualified_type) {
+  if (!IsLinkableMessageInExportedHeaders(&qualified_type)) {
+    return;
+  }
+  AddToMapAndTypeGraph(std::move(qualified_type), &qualified_types_,
+                       &type_graph_);
+}
+
+
+void ModuleIR::AddArrayType(ArrayTypeIR &&array_type) {
+  if (!IsLinkableMessageInExportedHeaders(&array_type)) {
+    return;
+  }
+  AddToMapAndTypeGraph(std::move(array_type), &array_types_, &type_graph_);
+}
+
+
+void ModuleIR::AddPointerType(PointerTypeIR &&pointer_type) {
+  if (!IsLinkableMessageInExportedHeaders(&pointer_type)) {
+    return;
+  }
+  AddToMapAndTypeGraph(std::move(pointer_type), &pointer_types_, &type_graph_);
+}
+
+
+void ModuleIR::AddBuiltinType(BuiltinTypeIR &&builtin_type) {
+  AddToMapAndTypeGraph(std::move(builtin_type), &builtin_types_, &type_graph_);
+}
+
+
+void ModuleIR::AddElfFunction(ElfFunctionIR &&elf_function) {
+  elf_functions_.insert(
+      {elf_function.GetName(), std::move(elf_function)});
+}
+
+
+void ModuleIR::AddElfObject(ElfObjectIR &&elf_object) {
+  elf_objects_.insert(
+      {elf_object.GetName(), std::move(elf_object)});
+}
+
+
+bool ModuleIR::IsLinkableMessageInExportedHeaders(
+    const LinkableMessageIR *linkable_message) const {
+  if (exported_headers_ == nullptr || exported_headers_->empty()) {
+    return true;
+  }
+  return exported_headers_->find(linkable_message->GetSourceFile()) !=
+         exported_headers_->end();
+}
+
+
+}  // namespace repr
+}  // namespace header_checker
diff --git a/vndk/tools/header-checker/src/repr/ir_representation.h b/vndk/tools/header-checker/src/repr/ir_representation.h
index 32ec8b019..5c993ea80 100644
--- a/vndk/tools/header-checker/src/repr/ir_representation.h
+++ b/vndk/tools/header-checker/src/repr/ir_representation.h
@@ -840,6 +840,48 @@ class ModuleIR {
     return odr_list_map_;
   }
 
+
+  void AddFunction(FunctionIR &&function);
+
+  void AddGlobalVariable(GlobalVarIR &&global_var);
+
+  void AddRecordType(RecordTypeIR &&record_type);
+
+  void AddFunctionType(FunctionTypeIR &&function_type);
+
+  void AddEnumType(EnumTypeIR &&enum_type);
+
+  void AddLvalueReferenceType(LvalueReferenceTypeIR &&lvalue_reference_type);
+
+  void AddRvalueReferenceType(RvalueReferenceTypeIR &&rvalue_reference_type);
+
+  void AddQualifiedType(QualifiedTypeIR &&qualified_type);
+
+  void AddArrayType(ArrayTypeIR &&array_type);
+
+  void AddPointerType(PointerTypeIR &&pointer_type);
+
+  void AddBuiltinType(BuiltinTypeIR &&builtin_type);
+
+  void AddElfFunction(ElfFunctionIR &&elf_function);
+
+  void AddElfObject(ElfObjectIR &&elf_object);
+
+  void AddToODRListMap(const std::string &key, const TypeIR *value) {
+    auto map_it = odr_list_map_.find(key);
+    if (map_it == odr_list_map_.end()) {
+      odr_list_map_.emplace(key, std::list<const TypeIR *>({value}));
+      return;
+    }
+    odr_list_map_[key].emplace_back(value);
+  }
+
+
+ private:
+  bool IsLinkableMessageInExportedHeaders(
+      const LinkableMessageIR *linkable_message) const;
+
+
  public:
   AbiElementList<RecordTypeIR> record_types_list_;
   AbiElementMap<FunctionIR> functions_;
diff --git a/vndk/tools/header-checker/src/repr/json/ir_reader.cpp b/vndk/tools/header-checker/src/repr/json/ir_reader.cpp
index 3c90bc193..a1d2df793 100644
--- a/vndk/tools/header-checker/src/repr/json/ir_reader.cpp
+++ b/vndk/tools/header-checker/src/repr/json/ir_reader.cpp
@@ -323,11 +323,7 @@ void JsonIRReader::ReadGlobalVariables(const JsonObjectRef &tu) {
         global_variable.GetString("referenced_type"));
     global_variable_ir.SetLinkerSetKey(
         global_variable.GetString("linker_set_key"));
-    if (!IsLinkableMessageInExportedHeaders(&global_variable_ir)) {
-      continue;
-    }
-    module_->global_variables_.insert(
-        {global_variable_ir.GetLinkerSetKey(), std::move(global_variable_ir)});
+    module_->AddGlobalVariable(std::move(global_variable_ir));
   }
 }
 
@@ -335,11 +331,7 @@ void JsonIRReader::ReadPointerTypes(const JsonObjectRef &tu) {
   for (auto &&pointer_type : tu.GetObjects("pointer_types")) {
     PointerTypeIR pointer_type_ir;
     ReadTypeInfo(pointer_type, &pointer_type_ir);
-    if (!IsLinkableMessageInExportedHeaders(&pointer_type_ir)) {
-      continue;
-    }
-    AddToMapAndTypeGraph(std::move(pointer_type_ir), &module_->pointer_types_,
-                         &module_->type_graph_);
+    module_->AddPointerType(std::move(pointer_type_ir));
   }
 }
 
@@ -349,8 +341,7 @@ void JsonIRReader::ReadBuiltinTypes(const JsonObjectRef &tu) {
     ReadTypeInfo(builtin_type, &builtin_type_ir);
     builtin_type_ir.SetSignedness(builtin_type.GetBool("is_unsigned"));
     builtin_type_ir.SetIntegralType(builtin_type.GetBool("is_integral"));
-    AddToMapAndTypeGraph(std::move(builtin_type_ir), &module_->builtin_types_,
-                         &module_->type_graph_);
+    module_->AddBuiltinType(std::move(builtin_type_ir));
   }
 }
 
@@ -362,11 +353,7 @@ void JsonIRReader::ReadQualifiedTypes(const JsonObjectRef &tu) {
     qualified_type_ir.SetVolatility(qualified_type.GetBool("is_volatile"));
     qualified_type_ir.SetRestrictedness(
         qualified_type.GetBool("is_restricted"));
-    if (!IsLinkableMessageInExportedHeaders(&qualified_type_ir)) {
-      continue;
-    }
-    AddToMapAndTypeGraph(std::move(qualified_type_ir),
-                         &module_->qualified_types_, &module_->type_graph_);
+    module_->AddQualifiedType(std::move(qualified_type_ir));
   }
 }
 
@@ -374,11 +361,7 @@ void JsonIRReader::ReadArrayTypes(const JsonObjectRef &tu) {
   for (auto &&array_type : tu.GetObjects("array_types")) {
     ArrayTypeIR array_type_ir;
     ReadTypeInfo(array_type, &array_type_ir);
-    if (!IsLinkableMessageInExportedHeaders(&array_type_ir)) {
-      continue;
-    }
-    AddToMapAndTypeGraph(std::move(array_type_ir), &module_->array_types_,
-                         &module_->type_graph_);
+    module_->AddArrayType(std::move(array_type_ir));
   }
 }
 
@@ -386,12 +369,7 @@ void JsonIRReader::ReadLvalueReferenceTypes(const JsonObjectRef &tu) {
   for (auto &&lvalue_reference_type : tu.GetObjects("lvalue_reference_types")) {
     LvalueReferenceTypeIR lvalue_reference_type_ir;
     ReadTypeInfo(lvalue_reference_type, &lvalue_reference_type_ir);
-    if (!IsLinkableMessageInExportedHeaders(&lvalue_reference_type_ir)) {
-      continue;
-    }
-    AddToMapAndTypeGraph(std::move(lvalue_reference_type_ir),
-                         &module_->lvalue_reference_types_,
-                         &module_->type_graph_);
+    module_->AddLvalueReferenceType(std::move(lvalue_reference_type_ir));
   }
 }
 
@@ -399,65 +377,35 @@ void JsonIRReader::ReadRvalueReferenceTypes(const JsonObjectRef &tu) {
   for (auto &&rvalue_reference_type : tu.GetObjects("rvalue_reference_types")) {
     RvalueReferenceTypeIR rvalue_reference_type_ir;
     ReadTypeInfo(rvalue_reference_type, &rvalue_reference_type_ir);
-    if (!IsLinkableMessageInExportedHeaders(&rvalue_reference_type_ir)) {
-      continue;
-    }
-    AddToMapAndTypeGraph(std::move(rvalue_reference_type_ir),
-                         &module_->rvalue_reference_types_,
-                         &module_->type_graph_);
+    module_->AddRvalueReferenceType(std::move(rvalue_reference_type_ir));
   }
 }
 
 void JsonIRReader::ReadFunctions(const JsonObjectRef &tu) {
   for (auto &&function : tu.GetObjects("functions")) {
     FunctionIR function_ir = FunctionJsonToIR(function);
-    if (!IsLinkableMessageInExportedHeaders(&function_ir)) {
-      continue;
-    }
-    module_->functions_.insert(
-        {function_ir.GetLinkerSetKey(), std::move(function_ir)});
+    module_->AddFunction(std::move(function_ir));
   }
 }
 
 void JsonIRReader::ReadRecordTypes(const JsonObjectRef &tu) {
   for (auto &&record_type : tu.GetObjects("record_types")) {
     RecordTypeIR record_type_ir = RecordTypeJsonToIR(record_type);
-    if (!IsLinkableMessageInExportedHeaders(&record_type_ir)) {
-      continue;
-    }
-    auto it = AddToMapAndTypeGraph(std::move(record_type_ir),
-                                   &module_->record_types_,
-                                   &module_->type_graph_);
-    const std::string &key = GetODRListMapKey(&(it->second));
-    AddToODRListMap(key, &(it->second));
+    module_->AddRecordType(std::move(record_type_ir));
   }
 }
 
 void JsonIRReader::ReadFunctionTypes(const JsonObjectRef &tu) {
   for (auto &&function_type : tu.GetObjects("function_types")) {
     FunctionTypeIR function_type_ir = FunctionTypeJsonToIR(function_type);
-    if (!IsLinkableMessageInExportedHeaders(&function_type_ir)) {
-      continue;
-    }
-    auto it = AddToMapAndTypeGraph(std::move(function_type_ir),
-                                   &module_->function_types_,
-                                   &module_->type_graph_);
-    const std::string &key = GetODRListMapKey(&(it->second));
-    AddToODRListMap(key, &(it->second));
+    module_->AddFunctionType(std::move(function_type_ir));
   }
 }
 
 void JsonIRReader::ReadEnumTypes(const JsonObjectRef &tu) {
   for (auto &&enum_type : tu.GetObjects("enum_types")) {
     EnumTypeIR enum_type_ir = EnumTypeJsonToIR(enum_type);
-    if (!IsLinkableMessageInExportedHeaders(&enum_type_ir)) {
-      continue;
-    }
-    auto it = AddToMapAndTypeGraph(std::move(enum_type_ir),
-                                   &module_->enum_types_,
-                                   &module_->type_graph_);
-    AddToODRListMap(it->second.GetUniqueId() + it->second.GetSourceFile(),
-                    (&it->second));
+    module_->AddEnumType(std::move(enum_type_ir));
   }
 }
 
@@ -465,8 +413,7 @@ void JsonIRReader::ReadElfFunctions(const JsonObjectRef &tu) {
   for (auto &&elf_function : tu.GetObjects("elf_functions")) {
     ElfFunctionIR elf_function_ir(elf_function.GetString("name"),
                                   GetElfSymbolBinding(elf_function));
-    module_->elf_functions_.insert(
-        {elf_function_ir.GetName(), std::move(elf_function_ir)});
+    module_->AddElfFunction(std::move(elf_function_ir));
   }
 }
 
@@ -474,8 +421,7 @@ void JsonIRReader::ReadElfObjects(const JsonObjectRef &tu) {
   for (auto &&elf_object : tu.GetObjects("elf_objects")) {
     ElfObjectIR elf_object_ir(elf_object.GetString("name"),
                               GetElfSymbolBinding(elf_object));
-    module_->elf_objects_.insert(
-        {elf_object_ir.GetName(), std::move(elf_object_ir)});
+    module_->AddElfObject(std::move(elf_object_ir));
   }
 }
 
diff --git a/vndk/tools/header-checker/src/repr/protobuf/ir_reader.cpp b/vndk/tools/header-checker/src/repr/protobuf/ir_reader.cpp
index 1f92c9618..23b250d3e 100644
--- a/vndk/tools/header-checker/src/repr/protobuf/ir_reader.cpp
+++ b/vndk/tools/header-checker/src/repr/protobuf/ir_reader.cpp
@@ -209,11 +209,7 @@ void ProtobufIRReader::ReadGlobalVariables(
         global_variable_protobuf.referenced_type());
     global_variable_ir.SetLinkerSetKey(
         global_variable_protobuf.linker_set_key());
-    if (!IsLinkableMessageInExportedHeaders(&global_variable_ir)) {
-      continue;
-    }
-    module_->global_variables_.insert(
-        {global_variable_ir.GetLinkerSetKey(), std::move(global_variable_ir)});
+    module_->AddGlobalVariable(std::move(global_variable_ir));
   }
 }
 
@@ -221,11 +217,7 @@ void ProtobufIRReader::ReadPointerTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&pointer_type_protobuf : tu.pointer_types()) {
     PointerTypeIR pointer_type_ir;
     ReadTypeInfo(pointer_type_protobuf.type_info(), &pointer_type_ir);
-    if (!IsLinkableMessageInExportedHeaders(&pointer_type_ir)) {
-      continue;
-    }
-    AddToMapAndTypeGraph(std::move(pointer_type_ir), &module_->pointer_types_,
-                         &module_->type_graph_);
+    module_->AddPointerType(std::move(pointer_type_ir));
   }
 }
 
@@ -235,8 +227,7 @@ void ProtobufIRReader::ReadBuiltinTypes(const abi_dump::TranslationUnit &tu) {
     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());
-    AddToMapAndTypeGraph(std::move(builtin_type_ir), &module_->builtin_types_,
-                         &module_->type_graph_);
+    module_->AddBuiltinType(std::move(builtin_type_ir));
   }
 }
 
@@ -248,11 +239,7 @@ void ProtobufIRReader::ReadQualifiedTypes(const abi_dump::TranslationUnit &tu) {
     qualified_type_ir.SetVolatility(qualified_type_protobuf.is_volatile());
     qualified_type_ir.SetRestrictedness(
         qualified_type_protobuf.is_restricted());
-    if (!IsLinkableMessageInExportedHeaders(&qualified_type_ir)) {
-      continue;
-    }
-    AddToMapAndTypeGraph(std::move(qualified_type_ir),
-                         &module_->qualified_types_, &module_->type_graph_);
+    module_->AddQualifiedType(std::move(qualified_type_ir));
   }
 }
 
@@ -260,11 +247,7 @@ void ProtobufIRReader::ReadArrayTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&array_type_protobuf : tu.array_types()) {
     ArrayTypeIR array_type_ir;
     ReadTypeInfo(array_type_protobuf.type_info(), &array_type_ir);
-    if (!IsLinkableMessageInExportedHeaders(&array_type_ir)) {
-      continue;
-    }
-    AddToMapAndTypeGraph(std::move(array_type_ir), &module_->array_types_,
-                         &module_->type_graph_);
+    module_->AddArrayType(std::move(array_type_ir));
   }
 }
 
@@ -274,12 +257,7 @@ void ProtobufIRReader::ReadLvalueReferenceTypes(
     LvalueReferenceTypeIR lvalue_reference_type_ir;
     ReadTypeInfo(lvalue_reference_type_protobuf.type_info(),
                  &lvalue_reference_type_ir);
-    if (!IsLinkableMessageInExportedHeaders(&lvalue_reference_type_ir)) {
-      continue;
-    }
-    AddToMapAndTypeGraph(std::move(lvalue_reference_type_ir),
-                         &module_->lvalue_reference_types_,
-                         &module_->type_graph_);
+    module_->AddLvalueReferenceType(std::move(lvalue_reference_type_ir));
   }
 }
 
@@ -289,37 +267,21 @@ void ProtobufIRReader::ReadRvalueReferenceTypes(
     RvalueReferenceTypeIR rvalue_reference_type_ir;
     ReadTypeInfo(rvalue_reference_type_protobuf.type_info(),
                  &rvalue_reference_type_ir);
-    if (!IsLinkableMessageInExportedHeaders(&rvalue_reference_type_ir)) {
-      continue;
-    }
-    AddToMapAndTypeGraph(std::move(rvalue_reference_type_ir),
-                         &module_->rvalue_reference_types_,
-                         &module_->type_graph_);
+    module_->AddRvalueReferenceType(std::move(rvalue_reference_type_ir));
   }
 }
 
 void ProtobufIRReader::ReadFunctions(const abi_dump::TranslationUnit &tu) {
   for (auto &&function_protobuf : tu.functions()) {
     FunctionIR function_ir = FunctionProtobufToIR(function_protobuf);
-    if (!IsLinkableMessageInExportedHeaders(&function_ir)) {
-      continue;
-    }
-    module_->functions_.insert(
-        {function_ir.GetLinkerSetKey(), std::move(function_ir)});
+    module_->AddFunction(std::move(function_ir));
   }
 }
 
 void ProtobufIRReader::ReadRecordTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&record_type_protobuf : tu.record_types()) {
     RecordTypeIR record_type_ir = RecordTypeProtobufToIR(record_type_protobuf);
-    if (!IsLinkableMessageInExportedHeaders(&record_type_ir)) {
-      continue;
-    }
-    auto it = AddToMapAndTypeGraph(std::move(record_type_ir),
-                                   &module_->record_types_,
-                                   &module_->type_graph_);
-    const std::string &key = GetODRListMapKey(&(it->second));
-    AddToODRListMap(key, &(it->second));
+    module_->AddRecordType(std::move(record_type_ir));
   }
 }
 
@@ -327,28 +289,14 @@ void ProtobufIRReader::ReadFunctionTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&function_type_protobuf : tu.function_types()) {
     FunctionTypeIR function_type_ir =
         FunctionTypeProtobufToIR(function_type_protobuf);
-    if (!IsLinkableMessageInExportedHeaders(&function_type_ir)) {
-      continue;
-    }
-    auto it = AddToMapAndTypeGraph(std::move(function_type_ir),
-                                   &module_->function_types_,
-                                   &module_->type_graph_);
-    const std::string &key = GetODRListMapKey(&(it->second));
-    AddToODRListMap(key, &(it->second));
+    module_->AddFunctionType(std::move(function_type_ir));
   }
 }
 
 void ProtobufIRReader::ReadEnumTypes(const abi_dump::TranslationUnit &tu) {
   for (auto &&enum_type_protobuf : tu.enum_types()) {
     EnumTypeIR enum_type_ir = EnumTypeProtobufToIR(enum_type_protobuf);
-    if (!IsLinkableMessageInExportedHeaders(&enum_type_ir)) {
-      continue;
-    }
-    auto it = AddToMapAndTypeGraph(std::move(enum_type_ir),
-                                   &module_->enum_types_,
-                                   &module_->type_graph_);
-    AddToODRListMap(it->second.GetUniqueId() + it->second.GetSourceFile(),
-                    (&it->second));
+    module_->AddEnumType(std::move(enum_type_ir));
   }
 }
 
@@ -357,8 +305,7 @@ void ProtobufIRReader::ReadElfFunctions(const abi_dump::TranslationUnit &tu) {
     ElfFunctionIR elf_function_ir(
         elf_function.name(),
         ElfSymbolBindingProtobufToIR(elf_function.binding()));
-    module_->elf_functions_.insert(
-        {elf_function_ir.GetName(), std::move(elf_function_ir)});
+    module_->AddElfFunction(std::move(elf_function_ir));
   }
 }
 
@@ -366,8 +313,7 @@ void ProtobufIRReader::ReadElfObjects(const abi_dump::TranslationUnit &tu) {
   for (auto &&elf_object : tu.elf_objects()) {
     ElfObjectIR elf_object_ir(
         elf_object.name(), ElfSymbolBindingProtobufToIR(elf_object.binding()));
-    module_->elf_objects_.insert(
-        {elf_object_ir.GetName(), std::move(elf_object_ir)});
+    module_->AddElfObject(std::move(elf_object_ir));
   }
 }