header-checker: Extract common code to ModuleIR
This commit extracts common IRReader code to ModuleIR.
Test: tests/test.py
Change-Id: I4e8a06833fae8d44718bd52628b3d7351882a3d8
diff --git a/vndk/tools/header-checker/Android.bp b/vndk/tools/header-checker/Android.bp
index f49e620..d83bd47 100644
--- a/vndk/tools/header-checker/Android.bp
+++ b/vndk/tools/header-checker/Android.bp
@@ -153,6 +153,7 @@
"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 18a9835..3e4e928 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 @@
}
-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 @@
// 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 @@
}
-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 344927d..21a8f69 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 @@
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 @@
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 0000000..73577af
--- /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 32ec8b0..5c993ea 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 @@
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 3c90bc1..a1d2df7 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 1f92c96..23b250d 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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));
}
}
