header-checker: Remove getters from IRReader

This commit removes getter functions from IRReader.  Most users should
interact with ModuleIR instead.

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

4 files changed, 49 insertions, 104 deletions

diff --git a/vndk/tools/header-checker/src/diff/abi_diff.cpp b/vndk/tools/header-checker/src/diff/abi_diff.cpp
index 38110229f..0d2d759dc 100644
--- a/vndk/tools/header-checker/src/diff/abi_diff.cpp
+++ b/vndk/tools/header-checker/src/diff/abi_diff.cpp
@@ -42,7 +42,8 @@ repr::CompatibilityStatusIR HeaderAbiDiff::GenerateCompatibilityReport() {
   std::unique_ptr<repr::IRDiffDumper> ir_diff_dumper =
       repr::IRDiffDumper::CreateIRDiffDumper(text_format_diff_, cr_);
   repr::CompatibilityStatusIR status =
-      CompareTUs(old_reader.get(), new_reader.get(), ir_diff_dumper.get());
+      CompareTUs(old_reader->GetModule(), new_reader->GetModule(),
+                 ir_diff_dumper.get());
   if (!ir_diff_dumper->Dump()) {
     llvm::errs() << "Could not dump diff report\n";
     ::exit(1);
@@ -51,25 +52,25 @@ repr::CompatibilityStatusIR HeaderAbiDiff::GenerateCompatibilityReport() {
 }
 
 repr::CompatibilityStatusIR HeaderAbiDiff::CompareTUs(
-    const repr::IRReader *old_tu, const repr::IRReader *new_tu,
+    const repr::ModuleIR &old_tu, const repr::ModuleIR &new_tu,
     repr::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.
   const AbiElementMap<const repr::TypeIR *> old_types =
-      old_tu->GetTypeGraph();
+      old_tu.GetTypeGraph();
   const AbiElementMap<const repr::TypeIR *> new_types =
-      new_tu->GetTypeGraph();
+      new_tu.GetTypeGraph();
 
   // Collect fills in added, removed ,unsafe and safe function diffs.
-  if (!CollectDynsymExportables(old_tu->GetFunctions(), new_tu->GetFunctions(),
-                                old_tu->GetElfFunctions(),
-                                new_tu->GetElfFunctions(),
+  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(),
+      !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";
@@ -95,13 +96,13 @@ repr::CompatibilityStatusIR HeaderAbiDiff::CompareTUs(
 
 std::pair<AbiElementMap<const repr::EnumTypeIR *>,
           AbiElementMap<const repr::RecordTypeIR *>>
-HeaderAbiDiff::ExtractUserDefinedTypes(const repr::IRReader *tu) {
+HeaderAbiDiff::ExtractUserDefinedTypes(const repr::ModuleIR &tu) {
   AbiElementMap<const repr::EnumTypeIR *> enum_types;
   AbiElementMap<const repr::RecordTypeIR *> record_types;
   // Iterate through the ODRListMap, if there is more than 1 element in the
   // list, we cannot really unique the type by name, so skip it. If not, add a
   // map entry UniqueId -> const Record(Enum)TypeIR *.
-  for (auto &it : tu->GetODRListMap()) {
+  for (auto &it : tu.GetODRListMap()) {
     auto &odr_list = it.second;
     if (odr_list.size() != 1) {
       continue;
@@ -133,7 +134,7 @@ HeaderAbiDiff::ExtractUserDefinedTypes(const repr::IRReader *tu) {
 }
 
 bool HeaderAbiDiff::CollectUserDefinedTypes(
-    const repr::IRReader *old_tu, const repr::IRReader *new_tu,
+    const repr::ModuleIR &old_tu, const repr::ModuleIR &new_tu,
     const AbiElementMap<const repr::TypeIR *> &old_types_map,
     const AbiElementMap<const repr::TypeIR *> &new_types_map,
     repr::IRDiffDumper *ir_diff_dumper) {
diff --git a/vndk/tools/header-checker/src/diff/abi_diff.h b/vndk/tools/header-checker/src/diff/abi_diff.h
index 05298f689..cbda960c1 100644
--- a/vndk/tools/header-checker/src/diff/abi_diff.h
+++ b/vndk/tools/header-checker/src/diff/abi_diff.h
@@ -52,8 +52,8 @@ class HeaderAbiDiff {
 
  private:
   repr::CompatibilityStatusIR CompareTUs(
-      const repr::IRReader *old_tu,
-      const repr::IRReader *new_tu,
+      const repr::ModuleIR &old_tu,
+      const repr::ModuleIR &new_tu,
       repr::IRDiffDumper *ir_diff_dumper);
 
   template <typename T, typename ElfSymbolType>
@@ -122,11 +122,11 @@ class HeaderAbiDiff {
 
   std::pair<AbiElementMap<const repr::EnumTypeIR *>,
             AbiElementMap<const repr::RecordTypeIR *>>
-  ExtractUserDefinedTypes(const repr::IRReader *tu);
+  ExtractUserDefinedTypes(const repr::ModuleIR &tu);
 
   bool CollectUserDefinedTypes(
-      const repr::IRReader *old_tu,
-      const repr::IRReader *new_tu,
+      const repr::ModuleIR &old_tu,
+      const repr::ModuleIR &new_tu,
       const AbiElementMap<const repr::TypeIR *> &old_types_map,
       const AbiElementMap<const repr::TypeIR *> &new_types_map,
       repr::IRDiffDumper *ir_diff_dumper);
diff --git a/vndk/tools/header-checker/src/linker/header_abi_linker.cpp b/vndk/tools/header-checker/src/linker/header_abi_linker.cpp
index 4955186f2..99f008dd4 100644
--- a/vndk/tools/header-checker/src/linker/header_abi_linker.cpp
+++ b/vndk/tools/header-checker/src/linker/header_abi_linker.cpp
@@ -135,13 +135,11 @@ class HeaderAbiLinker {
 
   bool ReadExportedSymbolsFromSharedObjectFile();
 
-  bool LinkTypes(const repr::IRReader *ir_reader, repr::IRDumper *ir_dumper);
+  bool LinkTypes(repr::ModuleIR &module, repr::IRDumper *ir_dumper);
 
-  bool LinkFunctions(const repr::IRReader *ir_reader,
-                     repr::IRDumper *ir_dumper);
+  bool LinkFunctions(repr::ModuleIR &module, repr::IRDumper *ir_dumper);
 
-  bool LinkGlobalVars(const repr::IRReader *ir_reader,
-                      repr::IRDumper *ir_dumper);
+  bool LinkGlobalVars(repr::ModuleIR &module, repr::IRDumper *ir_dumper);
 
   bool LinkExportedSymbols(repr::IRDumper *ir_dumper);
 
@@ -246,6 +244,8 @@ bool HeaderAbiLinker::LinkAndDump() {
   // Read all input ABI dumps.
   auto greader = ReadInputDumpFiles();
 
+  repr::ModuleIR &module = greader->GetModule();
+
   // Link input ABI dumps.
   std::unique_ptr<repr::IRDumper> ir_dumper =
       repr::IRDumper::CreateIRDumper(output_format, out_dump_name_);
@@ -255,9 +255,9 @@ bool HeaderAbiLinker::LinkAndDump() {
     return false;
   }
 
-  if (!LinkTypes(greader.get(), ir_dumper.get()) ||
-      !LinkFunctions(greader.get(), ir_dumper.get()) ||
-      !LinkGlobalVars(greader.get(), ir_dumper.get())) {
+  if (!LinkTypes(module, ir_dumper.get()) ||
+      !LinkFunctions(module, ir_dumper.get()) ||
+      !LinkGlobalVars(module, ir_dumper.get())) {
     llvm::errs() << "Failed to link elements\n";
     return false;
   }
@@ -296,19 +296,18 @@ bool HeaderAbiLinker::LinkDecl(
   return true;
 }
 
-bool HeaderAbiLinker::LinkTypes(const repr::IRReader *reader,
+bool HeaderAbiLinker::LinkTypes(repr::ModuleIR &module,
                                 repr::IRDumper *ir_dumper) {
-  assert(reader != nullptr);
   auto no_filter = [](const std::string &symbol) { return true; };
-  return LinkDecl(ir_dumper, reader->GetRecordTypes(), no_filter) &&
-         LinkDecl(ir_dumper, reader->GetEnumTypes(), no_filter) &&
-         LinkDecl(ir_dumper, reader->GetFunctionTypes(), no_filter) &&
-         LinkDecl(ir_dumper, reader->GetBuiltinTypes(), no_filter) &&
-         LinkDecl(ir_dumper, reader->GetPointerTypes(), no_filter) &&
-         LinkDecl(ir_dumper, reader->GetRvalueReferenceTypes(), no_filter) &&
-         LinkDecl(ir_dumper, reader->GetLvalueReferenceTypes(), no_filter) &&
-         LinkDecl(ir_dumper, reader->GetArrayTypes(), no_filter) &&
-         LinkDecl(ir_dumper, reader->GetQualifiedTypes(), no_filter);
+  return LinkDecl(ir_dumper, module.GetRecordTypes(), no_filter) &&
+         LinkDecl(ir_dumper, module.GetEnumTypes(), no_filter) &&
+         LinkDecl(ir_dumper, module.GetFunctionTypes(), no_filter) &&
+         LinkDecl(ir_dumper, module.GetBuiltinTypes(), no_filter) &&
+         LinkDecl(ir_dumper, module.GetPointerTypes(), no_filter) &&
+         LinkDecl(ir_dumper, module.GetRvalueReferenceTypes(), no_filter) &&
+         LinkDecl(ir_dumper, module.GetLvalueReferenceTypes(), no_filter) &&
+         LinkDecl(ir_dumper, module.GetArrayTypes(), no_filter) &&
+         LinkDecl(ir_dumper, module.GetQualifiedTypes(), no_filter);
 }
 
 bool HeaderAbiLinker::IsSymbolExported(const std::string &name) const {
@@ -321,22 +320,20 @@ bool HeaderAbiLinker::IsSymbolExported(const std::string &name) const {
   return true;
 }
 
-bool HeaderAbiLinker::LinkFunctions(
-    const repr::IRReader *reader, repr::IRDumper *ir_dumper) {
-  assert(reader != nullptr);
+bool HeaderAbiLinker::LinkFunctions(repr::ModuleIR &module,
+                                    repr::IRDumper *ir_dumper) {
   auto symbol_filter = [this](const std::string &linker_set_key) {
     return IsSymbolExported(linker_set_key);
   };
-  return LinkDecl(ir_dumper, reader->GetFunctions(), symbol_filter);
+  return LinkDecl(ir_dumper, module.GetFunctions(), symbol_filter);
 }
 
-bool HeaderAbiLinker::LinkGlobalVars(
-    const repr::IRReader *reader, repr::IRDumper *ir_dumper) {
-  assert(reader != nullptr);
+bool HeaderAbiLinker::LinkGlobalVars(repr::ModuleIR &module,
+                                     repr::IRDumper *ir_dumper) {
   auto symbol_filter = [this](const std::string &linker_set_key) {
     return IsSymbolExported(linker_set_key);
   };
-  return LinkDecl(ir_dumper, reader->GetGlobalVariables(), symbol_filter);
+  return LinkDecl(ir_dumper, module.GetGlobalVariables(), symbol_filter);
 }
 
 template <typename SymbolMap>
diff --git a/vndk/tools/header-checker/src/repr/ir_reader.h b/vndk/tools/header-checker/src/repr/ir_reader.h
index 3467f1d16..344927d92 100644
--- a/vndk/tools/header-checker/src/repr/ir_reader.h
+++ b/vndk/tools/header-checker/src/repr/ir_reader.h
@@ -54,69 +54,16 @@ class IRReader {
 
   virtual ~IRReader() {}
 
-  const AbiElementMap<FunctionIR> &GetFunctions() const {
-    return module_->functions_;
-  }
-
-  const AbiElementMap<GlobalVarIR> &GetGlobalVariables() const {
-    return module_->global_variables_;
-  }
-
-  const AbiElementMap<RecordTypeIR> &GetRecordTypes() const {
-    return module_->record_types_;
-  }
-
-  const AbiElementMap<FunctionTypeIR> &GetFunctionTypes() const {
-    return module_->function_types_;
-  }
-
-  const AbiElementMap<EnumTypeIR> &GetEnumTypes() const {
-    return module_->enum_types_;
-  }
-
-  const AbiElementMap<LvalueReferenceTypeIR> &GetLvalueReferenceTypes() const {
-    return module_->lvalue_reference_types_;
-  }
-
-  const AbiElementMap<RvalueReferenceTypeIR> &GetRvalueReferenceTypes() const {
-    return module_->rvalue_reference_types_;
-  }
-
-  const AbiElementMap<QualifiedTypeIR> &GetQualifiedTypes() const {
-    return module_->qualified_types_;
-  }
-
-  const AbiElementMap<ArrayTypeIR> &GetArrayTypes() const {
-    return module_->array_types_;
-  }
-
-  const AbiElementMap<PointerTypeIR> &GetPointerTypes() const {
-    return module_->pointer_types_;
-  }
-
-  const AbiElementMap<BuiltinTypeIR> &GetBuiltinTypes() const {
-    return module_->builtin_types_;
-  }
-
-  const AbiElementMap<ElfFunctionIR> &GetElfFunctions() const {
-    return module_->elf_functions_;
-  }
-
-  const AbiElementMap<ElfObjectIR> &GetElfObjects() const {
-    return module_->elf_objects_;
-  }
+  virtual bool ReadDump(const std::string &dump_file) = 0;
 
-  const AbiElementMap<const TypeIR *> &GetTypeGraph() const {
-    return module_->type_graph_;
+  ModuleIR &GetModule() {
+    return *module_;
   }
 
-  const AbiElementUnorderedMap<std::list<const TypeIR *>> &
-  GetODRListMap() const {
-    return module_->odr_list_map_;
+  std::unique_ptr<ModuleIR> TakeModule() {
+    return std::move(module_);
   }
 
-  virtual bool ReadDump(const std::string &dump_file) = 0;
-
   void Merge(IRReader &&addend) {
     MergeElements(&module_->functions_, std::move(addend.module_->functions_));
     MergeElements(&module_->global_variables_,