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 2a486d17e..68dec0c4a 100644 --- a/vndk/tools/header-checker/src/linker/header_abi_linker.cpp +++ b/vndk/tools/header-checker/src/linker/header_abi_linker.cpp @@ -135,7 +135,7 @@ class HeaderAbiLinker { const repr::AbiElementMap &src, const std::function &symbol_filter); - std::unique_ptr ReadInputDumpFiles(); + std::unique_ptr ReadInputDumpFiles(); bool ReadExportedSymbols(); @@ -187,10 +187,10 @@ class HeaderAbiLinker { static void DeDuplicateAbiElementsThread(const std::vector &dump_files, const std::set *exported_headers, - repr::ModuleMerger *global_merger, + linker::ModuleMerger *global_merger, std::mutex *global_merger_lock, std::atomic *cnt) { - repr::ModuleMerger local_merger(exported_headers); + linker::ModuleMerger local_merger(exported_headers); auto begin_it = dump_files.begin(); std::size_t num_sources = dump_files.size(); @@ -216,9 +216,9 @@ DeDuplicateAbiElementsThread(const std::vector &dump_files, global_merger->MergeGraphs(local_merger.GetModule()); } -std::unique_ptr HeaderAbiLinker::ReadInputDumpFiles() { - std::unique_ptr merger( - new repr::ModuleMerger(&exported_headers_)); +std::unique_ptr HeaderAbiLinker::ReadInputDumpFiles() { + std::unique_ptr merger( + new linker::ModuleMerger(&exported_headers_)); std::size_t max_threads = std::thread::hardware_concurrency(); std::size_t num_threads = diff --git a/vndk/tools/header-checker/src/linker/module_merger.cpp b/vndk/tools/header-checker/src/linker/module_merger.cpp index 5132d2fe6..af175ed2e 100644 --- a/vndk/tools/header-checker/src/linker/module_merger.cpp +++ b/vndk/tools/header-checker/src/linker/module_merger.cpp @@ -22,12 +22,12 @@ namespace header_checker { -namespace repr { +namespace linker { MergeStatus ModuleMerger::MergeBuiltinType( - const BuiltinTypeIR *builtin_type, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map) { + const repr::BuiltinTypeIR *builtin_type, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map) { std::string linker_set_key = builtin_type->GetLinkerSetKey(); auto builtin_it = module_->builtin_types_.find(linker_set_key); if (builtin_it != module_->builtin_types_.end()) { @@ -46,9 +46,9 @@ MergeStatus ModuleMerger::MergeBuiltinType( MergeStatus ModuleMerger::LookupUserDefinedType( - const TypeIR *ud_type, const ModuleIR &addend, + const repr::TypeIR *ud_type, const repr::ModuleIR &addend, const std::string &ud_type_unique_id_and_source, - AbiElementMap *local_to_global_type_id_map_) { + repr::AbiElementMap *local_to_global_type_id_map_) { auto it = module_->odr_list_map_.find(ud_type_unique_id_and_source); if (it == module_->odr_list_map_.end()) { // Calling this an ODR violation even though it means no UD with the same @@ -61,17 +61,17 @@ MergeStatus ModuleMerger::LookupUserDefinedType( // Initialize type comparator (which will compare the referenced types // recursively). std::set type_cache; - DiffPolicyOptions diff_policy_options(false); - AbiDiffHelper diff_helper(module_->type_graph_, addend.type_graph_, - diff_policy_options, &type_cache, nullptr); + repr::DiffPolicyOptions diff_policy_options(false); + repr::AbiDiffHelper diff_helper(module_->type_graph_, addend.type_graph_, + diff_policy_options, &type_cache, nullptr); // Compare each user-defined type with the latest input user-defined type. // If there is a match, re-use the existing user-defined type. for (auto &definition : it->second) { - const TypeIR *contender_ud = definition.type_ir_; - DiffStatus result = diff_helper.CompareAndDumpTypeDiff( + const repr::TypeIR *contender_ud = definition.type_ir_; + repr::DiffStatus result = diff_helper.CompareAndDumpTypeDiff( contender_ud->GetSelfType(), ud_type->GetSelfType()); - if (result == DiffStatus::no_diff) { + if (result == repr::DiffStatus::no_diff) { local_to_global_type_id_map_->emplace( ud_type->GetSelfType(), MergeStatus(false, contender_ud->GetSelfType())); @@ -87,21 +87,21 @@ MergeStatus ModuleMerger::LookupUserDefinedType( MergeStatus ModuleMerger::LookupType( - const TypeIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map) { + const repr::TypeIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map) { std::string unique_type_id; switch (addend_node->GetKind()) { - case RecordTypeKind: - unique_type_id = - GetODRListMapKey(static_cast(addend_node)); + case repr::RecordTypeKind: + unique_type_id = repr::GetODRListMapKey( + static_cast(addend_node)); break; - case EnumTypeKind: - unique_type_id = - GetODRListMapKey(static_cast(addend_node)); + case repr::EnumTypeKind: + unique_type_id = repr::GetODRListMapKey( + static_cast(addend_node)); break; - case FunctionTypeKind: - unique_type_id = - GetODRListMapKey(static_cast(addend_node)); + case repr::FunctionTypeKind: + unique_type_id = repr::GetODRListMapKey( + static_cast(addend_node)); break; default: // Other kinds (e.g. PointerTypeKind, QualifiedTypeKind, ArrayTypeKind, @@ -120,8 +120,8 @@ MergeStatus ModuleMerger::LookupType( // graph. It also corrects the referenced_type field in the references_type // object passed and returns the merge status of the *referenced type*. MergeStatus ModuleMerger::MergeReferencingTypeInternal( - const ModuleIR &addend, ReferencesOtherType *references_type, - AbiElementMap *local_to_global_type_id_map) { + const repr::ModuleIR &addend, repr::ReferencesOtherType *references_type, + repr::AbiElementMap *local_to_global_type_id_map) { // First look in the local_to_global_type_id_map for the referenced type's // id. const std::string &referenced_type_id = references_type->GetReferencedType(); @@ -154,8 +154,8 @@ MergeStatus ModuleMerger::MergeReferencingTypeInternal( void ModuleMerger::MergeRecordFields( - const ModuleIR &addend, RecordTypeIR *added_node, - AbiElementMap *local_to_global_type_id_map) { + const repr::ModuleIR &addend, repr::RecordTypeIR *added_node, + repr::AbiElementMap *local_to_global_type_id_map) { for (auto &field : added_node->GetFields()) { MergeReferencingTypeInternal(addend, &field, local_to_global_type_id_map); } @@ -163,8 +163,8 @@ void ModuleMerger::MergeRecordFields( void ModuleMerger::MergeRecordCXXBases( - const ModuleIR &addend, RecordTypeIR *added_node, - AbiElementMap *local_to_global_type_id_map) { + const repr::ModuleIR &addend, repr::RecordTypeIR *added_node, + repr::AbiElementMap *local_to_global_type_id_map) { for (auto &base : added_node->GetBases()) { MergeReferencingTypeInternal(addend, &base, local_to_global_type_id_map); } @@ -172,8 +172,8 @@ void ModuleMerger::MergeRecordCXXBases( void ModuleMerger::MergeRecordTemplateElements( - const ModuleIR &addend, RecordTypeIR *added_node, - AbiElementMap *local_to_global_type_id_map) { + const repr::ModuleIR &addend, repr::RecordTypeIR *added_node, + repr::AbiElementMap *local_to_global_type_id_map) { for (auto &template_element : added_node->GetTemplateElements()) { MergeReferencingTypeInternal( addend, &template_element, local_to_global_type_id_map); @@ -182,8 +182,8 @@ void ModuleMerger::MergeRecordTemplateElements( void ModuleMerger::MergeRecordDependencies( - const ModuleIR &addend, RecordTypeIR *added_node, - AbiElementMap *local_to_global_type_id_map) { + const repr::ModuleIR &addend, repr::RecordTypeIR *added_node, + repr::AbiElementMap *local_to_global_type_id_map) { // First call MergeType on all its fields. MergeRecordFields(addend, added_node, local_to_global_type_id_map); @@ -195,11 +195,11 @@ void ModuleMerger::MergeRecordDependencies( template -std::pair::iterator> +std::pair::iterator> ModuleMerger::UpdateUDTypeAccounting( - const T *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map, - AbiElementMap *specific_type_map) { + const T *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map, + repr::AbiElementMap *specific_type_map) { const std::string addend_compilation_unit_path = addend.GetCompilationUnitPath(addend_node); assert(addend_compilation_unit_path != ""); @@ -231,8 +231,8 @@ ModuleMerger::UpdateUDTypeAccounting( // This method is necessarily going to have a was_newly_merged_ = true in its // MergeStatus return. So it necessarily merges a new RecordType. MergeStatus ModuleMerger::MergeRecordAndDependencies( - const RecordTypeIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map) { + const repr::RecordTypeIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map) { auto p = UpdateUDTypeAccounting( addend_node, addend, local_to_global_type_id_map, &module_->record_types_); @@ -243,8 +243,8 @@ MergeStatus ModuleMerger::MergeRecordAndDependencies( void ModuleMerger::MergeEnumDependencies( - const ModuleIR &addend, EnumTypeIR *added_node, - AbiElementMap *local_to_global_type_id_map) { + const repr::ModuleIR &addend, repr::EnumTypeIR *added_node, + repr::AbiElementMap *local_to_global_type_id_map) { const std::string underlying_type_id = added_node->GetUnderlyingType(); // Get the underlying type, it nessarily has to be present in the addend's // type graph since builtin types can't be hidden. Call MergeType on it and @@ -263,8 +263,8 @@ void ModuleMerger::MergeEnumDependencies( // This method is necessarily going to have a was_newly_merged_ = true in its // MergeStatus return. So it necessarily merges a new EnumType. MergeStatus ModuleMerger::MergeEnumType( - const EnumTypeIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map) { + const repr::EnumTypeIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map) { auto p = UpdateUDTypeAccounting( addend_node, addend, local_to_global_type_id_map, &module_->enum_types_); MergeEnumDependencies(addend, &p.second->second, local_to_global_type_id_map); @@ -273,8 +273,8 @@ MergeStatus ModuleMerger::MergeEnumType( MergeStatus ModuleMerger::MergeFunctionType( - const FunctionTypeIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map) { + const repr::FunctionTypeIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map) { auto p = UpdateUDTypeAccounting( addend_node, addend, local_to_global_type_id_map, &module_->function_types_); @@ -286,11 +286,11 @@ MergeStatus ModuleMerger::MergeFunctionType( template MergeStatus ModuleMerger::MergeReferencingTypeInternalAndUpdateParent( - const ModuleIR &addend, const T *addend_node, - AbiElementMap *local_to_global_type_id_map, - AbiElementMap *parent_map, const std::string &updated_self_type_id) { + const repr::ModuleIR &addend, const T *addend_node, + repr::AbiElementMap *local_to_global_type_id_map, + repr::AbiElementMap *parent_map, + const std::string &updated_self_type_id) { MergeStatus merge_status; - uint64_t old_max_type_id = max_type_id_; // Create copy of addend_node T added_node = *addend_node; @@ -306,19 +306,6 @@ MergeStatus ModuleMerger::MergeReferencingTypeInternalAndUpdateParent( return MergeStatus(true, updated_self_type_id); } - // The type that the added_node references was not newly added to the parent - // graph. However, we still might need to add the added_node to the parent - // graph, since for the particular 'Kind' of the added_node, it may not be - // present in the parent graph. This will be determined by looking at the - // appropriate 'type-referenced' -> TypeElement map in the parent for the - // type-id returned by the MergeStatus. If the map doesn't have an entry for - // the type-id returned by the MergeStatus, the added_type is not present in - // the parent graph and needs to be 'newly' added. We also need to modify the - // global type id in the local_to_global_type_id map. The added_node should - // already have it's self_type and referenced_type fields fixed up. - // We maintain a rollback id to have contiguous type ids. - max_type_id_ = old_max_type_id; - // Try finding the referenced_type is referred to by any referencing type // of the same kind in the parent graph. It is safe to call this on the // added_node, since the referenced_type in the added_node would have been @@ -349,30 +336,29 @@ MergeStatus ModuleMerger::MergeReferencingTypeInternalAndUpdateParent( } -static bool IsReferencingType(LinkableMessageKind kind) { +static bool IsReferencingType(repr::LinkableMessageKind kind) { switch (kind) { - case PointerTypeKind: - case QualifiedTypeKind: - case ArrayTypeKind: - case LvalueReferenceTypeKind: - case RvalueReferenceTypeKind: + case repr::PointerTypeKind: + case repr::QualifiedTypeKind: + case repr::ArrayTypeKind: + case repr::LvalueReferenceTypeKind: + case repr::RvalueReferenceTypeKind: return true; - case RecordTypeKind: - case EnumTypeKind: - case BuiltinTypeKind: - case FunctionTypeKind: - case FunctionKind: - case GlobalVarKind: + case repr::RecordTypeKind: + case repr::EnumTypeKind: + case repr::BuiltinTypeKind: + case repr::FunctionTypeKind: + case repr::FunctionKind: + case repr::GlobalVarKind: return false; } } - // Trace the referenced type until reaching a RecordTypeIR, EnumTypeIR, // FunctionTypeIR, or BuiltinTypeIR. Return nullptr if the referenced type is // undefined or built-in. -static const TypeIR *DereferenceType(const ModuleIR &module, - const TypeIR *type_ir) { +static const repr::TypeIR *DereferenceType(const repr::ModuleIR &module, + const repr::TypeIR *type_ir) { auto &type_graph = module.GetTypeGraph(); while (IsReferencingType(type_ir->GetKind())) { auto it = type_graph.find(type_ir->GetReferencedType()); @@ -389,15 +375,16 @@ static const TypeIR *DereferenceType(const ModuleIR &module, // This method creates a new node for the addend node in the graph if MergeType // on the reference returned a MergeStatus with was_newly_added_ = true. MergeStatus ModuleMerger::MergeReferencingType( - const ModuleIR &addend, const TypeIR *addend_node, - AbiElementMap *local_to_global_type_id_map) { + const repr::ModuleIR &addend, const repr::TypeIR *addend_node, + repr::AbiElementMap *local_to_global_type_id_map) { // First add the type 'pro-actively'. We need to do this since we'll need to // fill in 'referenced-type' fields in all this type's descendants and // descendants which are compound types (records), can refer to this type. std::string added_type_id = addend_node->GetSelfType(); auto type_id_it = module_->type_graph_.find(added_type_id); if (type_id_it != module_->type_graph_.end()) { - const TypeIR *final_referenced_type = DereferenceType(addend, addend_node); + const repr::TypeIR *final_referenced_type = + DereferenceType(addend, addend_node); if (final_referenced_type != nullptr) { std::string compilation_unit_path = addend.GetCompilationUnitPath(final_referenced_type); @@ -414,29 +401,29 @@ MergeStatus ModuleMerger::MergeReferencingType( // Merge the type. switch (addend_node->GetKind()) { - case PointerTypeKind: + case repr::PointerTypeKind: return MergeReferencingTypeInternalAndUpdateParent( - addend, static_cast(addend_node), + addend, static_cast(addend_node), local_to_global_type_id_map, &module_->pointer_types_, added_type_id); - case QualifiedTypeKind: + case repr::QualifiedTypeKind: return MergeReferencingTypeInternalAndUpdateParent( - addend, static_cast(addend_node), + addend, static_cast(addend_node), local_to_global_type_id_map, &module_->qualified_types_, added_type_id); - case ArrayTypeKind: + case repr::ArrayTypeKind: return MergeReferencingTypeInternalAndUpdateParent( - addend, static_cast(addend_node), + addend, static_cast(addend_node), local_to_global_type_id_map, &module_->array_types_, added_type_id); - case LvalueReferenceTypeKind: + case repr::LvalueReferenceTypeKind: return MergeReferencingTypeInternalAndUpdateParent( - addend, static_cast(addend_node), + addend, static_cast(addend_node), local_to_global_type_id_map, &module_->lvalue_reference_types_, added_type_id); - case RvalueReferenceTypeKind: + case repr::RvalueReferenceTypeKind: return MergeReferencingTypeInternalAndUpdateParent( - addend, static_cast(addend_node), + addend, static_cast(addend_node), local_to_global_type_id_map, &module_->rvalue_reference_types_, added_type_id); default: @@ -447,24 +434,23 @@ MergeStatus ModuleMerger::MergeReferencingType( MergeStatus ModuleMerger::MergeTypeInternal( - const TypeIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map) { + const repr::TypeIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map) { switch (addend_node->GetKind()) { - case BuiltinTypeKind: + case repr::BuiltinTypeKind: return MergeBuiltinType( - static_cast(addend_node), addend, + static_cast(addend_node), addend, local_to_global_type_id_map); - case RecordTypeKind: + case repr::RecordTypeKind: return MergeRecordAndDependencies( - static_cast(addend_node), addend, + static_cast(addend_node), addend, local_to_global_type_id_map); - case EnumTypeKind: - return MergeEnumType( - static_cast(addend_node), addend, - local_to_global_type_id_map); - case FunctionTypeKind: + case repr::EnumTypeKind: + return MergeEnumType(static_cast(addend_node), + addend, local_to_global_type_id_map); + case repr::FunctionTypeKind: return MergeFunctionType( - static_cast(addend_node), addend, + static_cast(addend_node), addend, local_to_global_type_id_map); default: return MergeReferencingType(addend, addend_node, @@ -475,8 +461,8 @@ MergeStatus ModuleMerger::MergeTypeInternal( MergeStatus ModuleMerger::MergeType( - const TypeIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map) { + const repr::TypeIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map) { // Check if the addend type is already in the parent graph. Since we're // going to traverse all the dependencies add whichever ones are not in the // parent graph. This does not add the node itself though. @@ -497,8 +483,8 @@ MergeStatus ModuleMerger::MergeType( void ModuleMerger::MergeCFunctionLikeDeps( - const ModuleIR &addend, CFunctionLikeIR *cfunction_like_ir, - AbiElementMap *local_to_global_type_id_map) { + const repr::ModuleIR &addend, repr::CFunctionLikeIR *cfunction_like_ir, + repr::AbiElementMap *local_to_global_type_id_map) { // Merge the return type. auto ret_type_it = addend.type_graph_.find(cfunction_like_ir->GetReturnType()); @@ -517,8 +503,8 @@ void ModuleMerger::MergeCFunctionLikeDeps( void ModuleMerger::MergeFunctionDeps( - FunctionIR *added_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map) { + repr::FunctionIR *added_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map) { MergeCFunctionLikeDeps(addend, added_node, local_to_global_type_id_map); // Merge the template arguments. @@ -530,22 +516,23 @@ void ModuleMerger::MergeFunctionDeps( template -static bool IsLinkableMessagePresent(const LinkableMessageIR *lm, - const AbiElementMap &message_map) { +static bool +IsLinkableMessagePresent(const repr::LinkableMessageIR *lm, + const repr::AbiElementMap &message_map) { return (message_map.find(lm->GetLinkerSetKey()) != message_map.end()); } void ModuleMerger::MergeFunction( - const FunctionIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map) { + const repr::FunctionIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map) { const std::string &function_linkage_name = addend_node->GetLinkerSetKey(); if (IsLinkableMessagePresent(addend_node, module_->functions_)) { // The functions and all of its dependencies have already been added. // No two globally visible functions can have the same symbol name. return; } - FunctionIR function_ir = *addend_node; + repr::FunctionIR function_ir = *addend_node; MergeFunctionDeps(&function_ir, addend, local_to_global_type_id_map); // Add it to the parent's function map. module_->functions_.emplace(function_linkage_name, std::move(function_ir)); @@ -553,15 +540,15 @@ void ModuleMerger::MergeFunction( void ModuleMerger::MergeGlobalVariable( - const GlobalVarIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map) { + const repr::GlobalVarIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map) { const std::string &global_variable_linkage_name = addend_node->GetLinkerSetKey(); if (IsLinkableMessagePresent(addend_node, module_->global_variables_)) { // The global variable and all of its dependencies have already been added. return; } - GlobalVarIR global_variable_ir = *addend_node; + repr::GlobalVarIR global_variable_ir = *addend_node; MergeReferencingTypeInternal(addend, &global_variable_ir, local_to_global_type_id_map); module_->global_variables_.emplace( @@ -569,11 +556,11 @@ void ModuleMerger::MergeGlobalVariable( } -void ModuleMerger::MergeGraphs(const ModuleIR &addend) { +void ModuleMerger::MergeGraphs(const repr::ModuleIR &addend) { // Iterate through nodes of addend reader and merge them. // Keep a merged types cache since if a type is merged, so will all of its // dependencies which weren't already merged. - AbiElementMap merged_types_cache; + repr::AbiElementMap merged_types_cache; for (auto &&type_ir : addend.type_graph_) { MergeType(type_ir.second, addend, &merged_types_cache); @@ -589,6 +576,6 @@ void ModuleMerger::MergeGraphs(const ModuleIR &addend) { } -} // namespace repr +} // namespace linker } // namespace header_checker diff --git a/vndk/tools/header-checker/src/linker/module_merger.h b/vndk/tools/header-checker/src/linker/module_merger.h index 56acbfa69..b49305feb 100644 --- a/vndk/tools/header-checker/src/linker/module_merger.h +++ b/vndk/tools/header-checker/src/linker/module_merger.h @@ -16,7 +16,7 @@ namespace header_checker { -namespace repr { +namespace linker { class MergeStatus { @@ -41,115 +41,116 @@ public: class ModuleMerger { public: ModuleMerger(const std::set *exported_headers) - : module_(new ModuleIR(exported_headers)) {} + : module_(new repr::ModuleIR(exported_headers)) {} - const ModuleIR &GetModule() { + const repr::ModuleIR &GetModule() { return *module_; } - void MergeGraphs(const ModuleIR &addend); + void MergeGraphs(const repr::ModuleIR &addend); private: void MergeCFunctionLikeDeps( - const ModuleIR &addend, CFunctionLikeIR *cfunction_like_ir, - AbiElementMap *local_to_global_type_id_map); + const repr::ModuleIR &addend, repr::CFunctionLikeIR *cfunction_like_ir, + repr::AbiElementMap *local_to_global_type_id_map); MergeStatus MergeFunctionType( - const FunctionTypeIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map); + const repr::FunctionTypeIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map); - MergeStatus MergeEnumType( - const EnumTypeIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map); + MergeStatus + MergeEnumType(const repr::EnumTypeIR *addend_node, + const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map); void MergeEnumDependencies( - const ModuleIR &addend, EnumTypeIR *added_node, - AbiElementMap *local_to_global_type_id_map); + const repr::ModuleIR &addend, repr::EnumTypeIR *added_node, + repr::AbiElementMap *local_to_global_type_id_map); MergeStatus MergeRecordAndDependencies( - const RecordTypeIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map); + const repr::RecordTypeIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map); void MergeRecordDependencies( - const ModuleIR &addend, RecordTypeIR *added_node, - AbiElementMap *local_to_global_type_id_map); + const repr::ModuleIR &addend, repr::RecordTypeIR *added_node, + repr::AbiElementMap *local_to_global_type_id_map); void MergeRecordFields( - const ModuleIR &addend, RecordTypeIR *added_node, - AbiElementMap *local_to_global_type_id_map); + const repr::ModuleIR &addend, repr::RecordTypeIR *added_node, + repr::AbiElementMap *local_to_global_type_id_map); void MergeRecordCXXBases( - const ModuleIR &addend, RecordTypeIR *added_node, - AbiElementMap *local_to_global_type_id_map); + const repr::ModuleIR &addend, repr::RecordTypeIR *added_node, + repr::AbiElementMap *local_to_global_type_id_map); void MergeRecordTemplateElements( - const ModuleIR &addend, RecordTypeIR *added_node, - AbiElementMap *local_to_global_type_id_map); + const repr::ModuleIR &addend, repr::RecordTypeIR *added_node, + repr::AbiElementMap *local_to_global_type_id_map); void MergeGlobalVariable( - const GlobalVarIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map); + const repr::GlobalVarIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map); void MergeGlobalVariables( - const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map); + const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map); void MergeFunctionDeps( - FunctionIR *added_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map); + repr::FunctionIR *added_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map); - void MergeFunction( - const FunctionIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map); + void + MergeFunction(const repr::FunctionIR *addend_node, + const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map); template MergeStatus MergeReferencingTypeInternalAndUpdateParent( - const ModuleIR &addend, const T *addend_node, - AbiElementMap *local_to_global_type_id_map, - AbiElementMap *parent_map, const std::string &updated_self_type_id); + const repr::ModuleIR &addend, const T *addend_node, + repr::AbiElementMap *local_to_global_type_id_map, + repr::AbiElementMap *parent_map, + const std::string &updated_self_type_id); MergeStatus MergeReferencingTypeInternal( - const ModuleIR &addend, ReferencesOtherType *references_type, - AbiElementMap *local_to_global_type_id_map); + const repr::ModuleIR &addend, repr::ReferencesOtherType *references_type, + repr::AbiElementMap *local_to_global_type_id_map); MergeStatus MergeReferencingType( - const ModuleIR &addend, const TypeIR *addend_node, - AbiElementMap *local_to_global_type_id_map); + const repr::ModuleIR &addend, const repr::TypeIR *addend_node, + repr::AbiElementMap *local_to_global_type_id_map); template - std::pair::iterator> + std::pair::iterator> UpdateUDTypeAccounting( - const T *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map, - AbiElementMap *specific_type_map); + const T *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map, + repr::AbiElementMap *specific_type_map); MergeStatus MergeBuiltinType( - const BuiltinTypeIR *builtin_type, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map); + const repr::BuiltinTypeIR *builtin_type, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map); MergeStatus LookupUserDefinedType( - const TypeIR *ud_type, const ModuleIR &addend, + const repr::TypeIR *ud_type, const repr::ModuleIR &addend, const std::string &ud_type_unique_id, - AbiElementMap *local_to_global_type_id_map_); + repr::AbiElementMap *local_to_global_type_id_map_); - MergeStatus LookupType( - const TypeIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map); + MergeStatus + LookupType(const repr::TypeIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map); MergeStatus MergeTypeInternal( - const TypeIR *addend_node, const ModuleIR &addend, - AbiElementMap *local_to_global_type_id_map); + const repr::TypeIR *addend_node, const repr::ModuleIR &addend, + repr::AbiElementMap *local_to_global_type_id_map); - MergeStatus MergeType( - const TypeIR *addend_type, const ModuleIR &addend, - AbiElementMap *merged_types_cache); + MergeStatus MergeType(const repr::TypeIR *addend_type, + const repr::ModuleIR &addend, + repr::AbiElementMap *merged_types_cache); private: - std::unique_ptr module_; - - uint64_t max_type_id_ = 0; + std::unique_ptr module_; }; -} // namespace repr +} // namespace linker } // namespace header_checker