diff --git a/Cargo.toml b/Cargo.toml index 75e8461..85404e9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,8 +9,8 @@ license = "MIT OR Apache-2.0" [dependencies] a2lfile = "2.0.0" -object = { version = "~0.35", default_features = false, features = ["read"] } -gimli = { version = "~0.29", default_features = false, features = ["read"] } +object = { version = "~0.35", default-features = false, features = ["read"] } +gimli = { version = "~0.29", default-features = false, features = ["read"] } memmap2 = "~0.9" clap = { version = "~4.5", features = ["wrap_help"]} cpp_demangle = "0.4.3" diff --git a/src/dwarf/typereader.rs b/src/dwarf/typereader.rs index b5aeb43..51dc9da 100644 --- a/src/dwarf/typereader.rs +++ b/src/dwarf/typereader.rs @@ -33,7 +33,7 @@ impl<'elffile> DebugDataReader<'elffile> { for (name, var_list) in variables { for VarInfo { typeref, .. } in var_list { // check if the type was already loaded - if typereader_data.types.get(typeref).is_none() { + if !typereader_data.types.contains_key(typeref) { if let Some(unit_idx) = self.units.get_unit(*typeref) { // create an entries_tree iterator that makes it possible to read the DIEs of this type let dbginfo_offset = gimli::DebugInfoOffset(*typeref); @@ -313,12 +313,9 @@ impl<'elffile> DebugDataReader<'elffile> { } else { 0 } - } else if let Some(count) = get_count_attribute(child_entry) { - // clang generates DW_AT_count instead of DW_AT_ubound - count } else { - // unknown size of this array dimension - 0 + // clang generates DW_AT_count instead of DW_AT_ubound + get_count_attribute(child_entry).unwrap_or_default() }; dim.push(count); } else if child_entry.tag() == gimli::constants::DW_TAG_enumeration_type { diff --git a/src/update/axis_pts.rs b/src/update/axis_pts.rs index 82776f4..194dcc0 100644 --- a/src/update/axis_pts.rs +++ b/src/update/axis_pts.rs @@ -10,18 +10,13 @@ use crate::update::{ enums::{cond_create_enum_conversion, update_enum_compu_methods}, get_axis_pts_x_memberid, get_inner_type, get_symbol_info, ifdata_update::{update_ifdata, zero_if_data}, - log_update_errors, set_symbol_link, update_record_layout, RecordLayoutInfo, + log_update_errors, set_symbol_link, update_record_layout, }; -use super::make_symbol_link_string; +use super::{make_symbol_link_string, UpdateInfo}; pub(crate) fn update_module_axis_pts( - module: &mut Module, - debug_data: &DebugData, - log_msgs: &mut Vec, - preserve_unknown: bool, - version: A2lVersion, - recordlayout_info: &mut RecordLayoutInfo, + info: &mut UpdateInfo, compu_method_index: &HashMap, ) -> (u32, u32) { let mut enum_convlist = HashMap::::new(); @@ -30,14 +25,17 @@ pub(crate) fn update_module_axis_pts( let mut axis_pts_updated: u32 = 0; let mut axis_pts_not_updated: u32 = 0; - std::mem::swap(&mut module.axis_pts, &mut axis_pts_list); + std::mem::swap(&mut info.module.axis_pts, &mut axis_pts_list); for mut axis_pts in axis_pts_list { - match update_axis_pts_address(&mut axis_pts, debug_data, version) { + match update_axis_pts_address(&mut axis_pts, info.debug_data, info.version) { Ok(typeinfo) => { // the variable used for the axis should be a 1-dimensional array, or a struct containing a 1-dimensional array // if the type is a struct, then the AXIS_PTS_X inside the referenced RECORD_LAYOUT tells us which member of the struct to use. - let member_id = - get_axis_pts_x_memberid(module, recordlayout_info, &axis_pts.deposit_record); + let member_id = get_axis_pts_x_memberid( + info.module, + &info.reclayout_info, + &axis_pts.deposit_record, + ); if let Some(inner_typeinfo) = get_inner_type(typeinfo, member_id) { match &inner_typeinfo.datatype { DwarfDataType::Array { dim, arraytype, .. } => { @@ -57,7 +55,7 @@ pub(crate) fn update_module_axis_pts( .clone(); } cond_create_enum_conversion( - module, + info.module, &axis_pts.conversion, enumerators, ); @@ -73,7 +71,7 @@ pub(crate) fn update_module_axis_pts( let opt_compu_method = compu_method_index .get(&axis_pts.conversion) - .and_then(|idx| module.compu_method.get(*idx)); + .and_then(|idx| info.module.compu_method.get(*idx)); let (ll, ul) = adjust_limits( inner_typeinfo, axis_pts.lower_limit, @@ -86,23 +84,23 @@ pub(crate) fn update_module_axis_pts( // update the data type in the referenced RECORD_LAYOUT axis_pts.deposit_record = update_record_layout( - module, - recordlayout_info, + info.module, + &mut info.reclayout_info, &axis_pts.deposit_record, typeinfo, ); // put the updated AXIS_PTS back on the module's list - module.axis_pts.push(axis_pts); + info.module.axis_pts.push(axis_pts); axis_pts_updated += 1; } Err(errmsgs) => { - log_update_errors(log_msgs, errmsgs, "AXIS_PTS", axis_pts.get_line()); + log_update_errors(info.log_msgs, errmsgs, "AXIS_PTS", axis_pts.get_line()); - if preserve_unknown { + if info.preserve_unknown { axis_pts.address = 0; zero_if_data(&mut axis_pts.if_data); - module.axis_pts.push(axis_pts); + info.module.axis_pts.push(axis_pts); } else { // item is removed implicitly, because it is not added back to the list removed_items.insert(axis_pts.name.clone()); @@ -113,8 +111,8 @@ pub(crate) fn update_module_axis_pts( } // update COMPU_VTABs and COMPU_VTAB_RANGEs based on the data types used in MEASUREMENTs etc. - update_enum_compu_methods(module, &enum_convlist); - cleanup_removed_axis_pts(module, &removed_items); + update_enum_compu_methods(info.module, &enum_convlist); + cleanup_removed_axis_pts(info.module, &removed_items); (axis_pts_updated, axis_pts_not_updated) } diff --git a/src/update/characteristic.rs b/src/update/characteristic.rs index 22cc13e..b75d068 100644 --- a/src/update/characteristic.rs +++ b/src/update/characteristic.rs @@ -10,19 +10,12 @@ use crate::update::{ enums::{cond_create_enum_conversion, update_enum_compu_methods}, get_fnc_values_memberid, get_inner_type, get_symbol_info, ifdata_update::{update_ifdata, zero_if_data}, - log_update_errors, set_bitmask, set_matrix_dim, set_symbol_link, update_record_layout, - RecordLayoutInfo, + log_update_errors, make_symbol_link_string, set_bitmask, set_matrix_dim, set_symbol_link, + update_record_layout, RecordLayoutInfo, UpdateInfo, }; -use super::make_symbol_link_string; - pub(crate) fn update_module_characteristics( - module: &mut Module, - debug_data: &DebugData, - log_msgs: &mut Vec, - preserve_unknown: bool, - version: A2lVersion, - recordlayout_info: &mut RecordLayoutInfo, + info: &mut UpdateInfo, compu_method_index: &HashMap, ) -> (u32, u32) { let mut enum_convlist = HashMap::::new(); @@ -32,45 +25,47 @@ pub(crate) fn update_module_characteristics( let mut characteristic_not_updated: u32 = 0; // store the max_axis_points of each AXIS_PTS, so that the AXIS_DESCRs inside of CHARACTERISTICS can be updated to match - let axis_pts_dim: HashMap = module + let axis_pts_dim: HashMap = info + .module .axis_pts .iter() .map(|item| (item.name.clone(), item.max_axis_points)) .collect(); - std::mem::swap(&mut module.characteristic, &mut characteristic_list); + std::mem::swap(&mut info.module.characteristic, &mut characteristic_list); for mut characteristic in characteristic_list { if characteristic.virtual_characteristic.is_none() { // only update the address if the CHARACTERISTIC is not a VIRTUAL_CHARACTERISTIC - match update_characteristic_address(&mut characteristic, debug_data, version) { + match update_characteristic_address(&mut characteristic, info.debug_data, info.version) + { Ok(typeinfo) => { // update as much as possible of the information inside the CHARACTERISTIC update_characteristic_information( - module, - recordlayout_info, + info.module, + &mut info.reclayout_info, &mut characteristic, typeinfo, &mut enum_convlist, &axis_pts_dim, - version >= A2lVersion::V1_7_0, + info.version >= A2lVersion::V1_7_0, compu_method_index, ); - module.characteristic.push(characteristic); + info.module.characteristic.push(characteristic); characteristic_updated += 1; } Err(errmsgs) => { log_update_errors( - log_msgs, + info.log_msgs, errmsgs, "CHARACTERISTIC", characteristic.get_line(), ); - if preserve_unknown { + if info.preserve_unknown { characteristic.address = 0; zero_if_data(&mut characteristic.if_data); - module.characteristic.push(characteristic); + info.module.characteristic.push(characteristic); } else { // item is removed implicitly, because it is not added back to the list removed_items.insert(characteristic.name.clone()); @@ -80,18 +75,19 @@ pub(crate) fn update_module_characteristics( } } else { // computed CHARACTERISTICS with a VIRTUAL_CHARACTERISTIC block shouldn't have an address and don't need to be updated - module.characteristic.push(characteristic); + info.module.characteristic.push(characteristic); } } // update COMPU_VTABs and COMPU_VTAB_RANGEs based on the data types used in CHARACTERISTICs - update_enum_compu_methods(module, &enum_convlist); - cleanup_removed_characteristics(module, &removed_items); + update_enum_compu_methods(info.module, &enum_convlist); + cleanup_removed_characteristics(info.module, &removed_items); (characteristic_updated, characteristic_not_updated) } // update as much as possible of the information inside the CHARACTERISTIC +#[allow(clippy::too_many_arguments)] fn update_characteristic_information<'enumlist, 'typeinfo: 'enumlist>( module: &mut Module, recordlayout_info: &mut RecordLayoutInfo, diff --git a/src/update/instance.rs b/src/update/instance.rs index 45fb84d..10cd75f 100644 --- a/src/update/instance.rs +++ b/src/update/instance.rs @@ -9,23 +9,20 @@ use crate::update::{ log_update_errors, set_symbol_link, TypedefNames, TypedefReferrer, TypedefsRefInfo, }; -use super::{make_symbol_link_string, set_address_type, set_matrix_dim}; +use super::{make_symbol_link_string, set_address_type, set_matrix_dim, UpdateInfo}; -pub(crate) fn update_module_instances<'a>( - module: &mut Module, - debug_data: &'a DebugData, - log_msgs: &mut Vec, - preserve_unknown: bool, +pub(crate) fn update_module_instances<'dbg>( + info: &mut UpdateInfo<'_, 'dbg, '_>, nameset: &TypedefNames, -) -> (u32, u32, TypedefsRefInfo<'a>) { +) -> (u32, u32, TypedefsRefInfo<'dbg>) { let mut removed_items = HashSet::::new(); let mut instance_list = Vec::new(); let mut instance_updated: u32 = 0; let mut instance_not_updated: u32 = 0; let mut typedef_types = TypedefsRefInfo::new(); - std::mem::swap(&mut module.instance, &mut instance_list); + std::mem::swap(&mut info.module.instance, &mut instance_list); for mut instance in instance_list { - match update_instance_address(&mut instance, debug_data) { + match update_instance_address(&mut instance, info.debug_data) { Ok((typedef_ref, typeinfo)) => { if nameset.contains(&typedef_ref) { // Each INSTANCE can have: @@ -39,7 +36,7 @@ pub(crate) fn update_module_instances<'a>( // More complicted constructions like pointers to pointers, arrays of pointers, etc. can not be represented directly set_address_type(&mut instance.address_type, typeinfo); let basetype = typeinfo - .get_pointer(&debug_data.types) + .get_pointer(&info.debug_data.types) .map_or(typeinfo, |(_, t)| t); set_matrix_dim(&mut instance.matrix_dim, basetype, true); @@ -47,30 +44,30 @@ pub(crate) fn update_module_instances<'a>( typedef_types.entry(typedef_ref).or_default().push(( Some(basetype), - TypedefReferrer::Instance(module.instance.len()), + TypedefReferrer::Instance(info.module.instance.len()), )); - module.instance.push(instance); + info.module.instance.push(instance); instance_updated += 1; - } else if preserve_unknown { - module.instance.push(instance); + } else if info.preserve_unknown { + info.module.instance.push(instance); instance_updated += 1; } else { - log_msgs.push(format!("Error updating INSTANCE on line {}: type ref {} does not refer to any TYPEDEF_*", instance.get_line(), instance.type_ref)); + info.log_msgs.push(format!("Error updating INSTANCE on line {}: type ref {} does not refer to any TYPEDEF_*", instance.get_line(), instance.type_ref)); instance_not_updated += 1; } } Err(errmsgs) => { - log_update_errors(log_msgs, errmsgs, "INSTANCE", instance.get_line()); + log_update_errors(info.log_msgs, errmsgs, "INSTANCE", instance.get_line()); - if preserve_unknown { + if info.preserve_unknown { instance.start_address = 0; zero_if_data(&mut instance.if_data); typedef_types .entry(instance.type_ref.clone()) .or_default() - .push((None, TypedefReferrer::Instance(module.instance.len()))); - module.instance.push(instance); + .push((None, TypedefReferrer::Instance(info.module.instance.len()))); + info.module.instance.push(instance); } else { // item is removed implicitly, because it is not added back to the list removed_items.insert(instance.name.clone()); @@ -79,7 +76,7 @@ pub(crate) fn update_module_instances<'a>( } } } - cleanup_removed_instances(module, &removed_items); + cleanup_removed_instances(info.module, &removed_items); (instance_updated, instance_not_updated, typedef_types) } diff --git a/src/update/measurement.rs b/src/update/measurement.rs index 6502028..a1c24ae 100644 --- a/src/update/measurement.rs +++ b/src/update/measurement.rs @@ -13,14 +13,10 @@ use crate::update::{ log_update_errors, set_bitmask, set_matrix_dim, set_measurement_ecu_address, set_symbol_link, }; -use super::{make_symbol_link_string, set_address_type}; +use super::{make_symbol_link_string, set_address_type, UpdateInfo}; pub(crate) fn update_module_measurements( - module: &mut Module, - debug_data: &DebugData, - log_msgs: &mut Vec, - preserve_unknown: bool, - version: A2lVersion, + info: &mut UpdateInfo, compu_method_index: &HashMap, ) -> (u32, u32) { let mut removed_items = HashSet::::new(); @@ -29,33 +25,38 @@ pub(crate) fn update_module_measurements( let mut measurement_updated: u32 = 0; let mut measurement_not_updated: u32 = 0; - std::mem::swap(&mut module.measurement, &mut measurement_list); + std::mem::swap(&mut info.module.measurement, &mut measurement_list); for mut measurement in measurement_list { if measurement.var_virtual.is_none() { // only MEASUREMENTS that are not VIRTUAL can be updated - match update_measurement_address(&mut measurement, debug_data, version) { + match update_measurement_address(&mut measurement, info.debug_data, info.version) { Ok(typeinfo) => { // update all the information instide a MEASUREMENT update_content( - module, - debug_data, + info.module, + info.debug_data, &mut measurement, typeinfo, &mut enum_convlist, - version >= A2lVersion::V1_7_0, + info.version >= A2lVersion::V1_7_0, compu_method_index, ); - module.measurement.push(measurement); + info.module.measurement.push(measurement); measurement_updated += 1; } Err(errmsgs) => { - log_update_errors(log_msgs, errmsgs, "MEASUREMENT", measurement.get_line()); + log_update_errors( + info.log_msgs, + errmsgs, + "MEASUREMENT", + measurement.get_line(), + ); - if preserve_unknown { + if info.preserve_unknown { measurement.ecu_address = None; zero_if_data(&mut measurement.if_data); - module.measurement.push(measurement); + info.module.measurement.push(measurement); } else { // item is removed implicitly, because it is not added back to the list // but we need to track the name of the removed item so that references to it can be deleted @@ -66,13 +67,13 @@ pub(crate) fn update_module_measurements( } } else { // VIRTUAL MEASUREMENTS don't need an address - module.measurement.push(measurement); + info.module.measurement.push(measurement); } } // update COMPU_VTABs and COMPU_VTAB_RANGEs based on the data types used in MEASUREMENTs - update_enum_compu_methods(module, &enum_convlist); - cleanup_removed_measurements(module, &removed_items); + update_enum_compu_methods(info.module, &enum_convlist); + cleanup_removed_measurements(info.module, &removed_items); (measurement_updated, measurement_not_updated) } diff --git a/src/update/mod.rs b/src/update/mod.rs index 3c39e9a..4df1329 100644 --- a/src/update/mod.rs +++ b/src/update/mod.rs @@ -54,6 +54,15 @@ pub(crate) struct TypedefNames { structure: HashSet, } +pub(crate) struct UpdateInfo<'a2l, 'dbg, 'log> { + pub(crate) module: &'a2l mut Module, + pub(crate) debug_data: &'dbg DebugData, + pub(crate) log_msgs: &'log mut Vec, + pub(crate) preserve_unknown: bool, + pub(crate) version: A2lVersion, + pub(crate) reclayout_info: RecordLayoutInfo, +} + type TypedefsRefInfo<'a> = HashMap, TypedefReferrer)>>; // perform an address update. @@ -70,8 +79,18 @@ pub(crate) fn update_addresses( let mut summary = UpdateSumary::new(); for module in &mut a2l_file.project.module { - let mut reclayout_info = RecordLayoutInfo::build(module); - let compu_method_index = module + let reclayout_info = RecordLayoutInfo::build(module); + let mut info = UpdateInfo { + module, + debug_data, + log_msgs, + preserve_unknown, + version, + reclayout_info, + }; + + let compu_method_index = info + .module .compu_method .iter() .enumerate() @@ -79,71 +98,39 @@ pub(crate) fn update_addresses( .collect::>(); // update all AXIS_PTS - let (updated, not_updated) = update_module_axis_pts( - module, - debug_data, - log_msgs, - preserve_unknown, - version, - &mut reclayout_info, - &compu_method_index, - ); + let (updated, not_updated) = update_module_axis_pts(&mut info, &compu_method_index); summary.measurement_updated += updated; summary.measurement_not_updated += not_updated; // update all MEASUREMENTs - let (updated, not_updated) = update_module_measurements( - module, - debug_data, - log_msgs, - preserve_unknown, - version, - &compu_method_index, - ); + let (updated, not_updated) = update_module_measurements(&mut info, &compu_method_index); summary.measurement_updated += updated; summary.measurement_not_updated += not_updated; // update all CHARACTERISTICs - let (updated, not_updated) = update_module_characteristics( - module, - debug_data, - log_msgs, - preserve_unknown, - version, - &mut reclayout_info, - &compu_method_index, - ); + let (updated, not_updated) = update_module_characteristics(&mut info, &compu_method_index); summary.characteristic_updated += updated; summary.characteristic_not_updated += not_updated; // update all BLOBs let (updated, not_updated) = - update_module_blobs(module, debug_data, log_msgs, preserve_unknown); + update_module_blobs(info.module, debug_data, info.log_msgs, preserve_unknown); summary.blob_updated += updated; summary.blob_not_updated += not_updated; - let typedef_names = TypedefNames::new(module); + let typedef_names = TypedefNames::new(info.module); // update all INSTANCEs - let (updated, not_updated, typedef_ref_info) = update_module_instances( - module, - debug_data, - log_msgs, - preserve_unknown, - &typedef_names, - ); + let (updated, not_updated, typedef_ref_info) = + update_module_instances(&mut info, &typedef_names); summary.instance_updated += updated; summary.instance_not_updated += not_updated; if enable_structures { update_module_typedefs( - module, - debug_data, - log_msgs, - preserve_unknown, + &mut info, typedef_ref_info, typedef_names, - &mut reclayout_info, &compu_method_index, ); } diff --git a/src/update/record_layout.rs b/src/update/record_layout.rs index f62f30d..9298981 100644 --- a/src/update/record_layout.rs +++ b/src/update/record_layout.rs @@ -237,7 +237,7 @@ fn make_unique_reclayout_name( initial_name: String, recordlayout_info: &RecordLayoutInfo, ) -> String { - if recordlayout_info.idxmap.get(&initial_name).is_some() { + if recordlayout_info.idxmap.contains_key(&initial_name) { // the record layout name already exists. Now we want to extend the name to make it unique // e.g. BASIC_RECORD_LAYOUT to BASIC_RECORD_LAYOUT_UPDATED // if there are multiple BASIC_RECORD_LAYOUT_UPDATED we want to continue with BASIC_RECORD_LAYOUT_UPDATED.2, .3 , etc @@ -256,7 +256,7 @@ fn make_unique_reclayout_name( }; let mut outname = basename.clone(); let mut counter = 1; - while recordlayout_info.idxmap.get(&outname).is_some() { + while recordlayout_info.idxmap.contains_key(&outname) { counter += 1; outname = format!("{basename}.{counter}"); } diff --git a/src/update/typedef.rs b/src/update/typedef.rs index 2db0c34..7462a88 100644 --- a/src/update/typedef.rs +++ b/src/update/typedef.rs @@ -1,8 +1,9 @@ use crate::dwarf::{make_simple_unit_name, DebugData, DwarfDataType, TypeInfo}; +use crate::update::enums::{cond_create_enum_conversion, update_enum_compu_methods}; use crate::update::{ adjust_limits, get_a2l_datatype, get_fnc_values_memberid, get_inner_type, set_address_type, set_bitmask, set_matrix_dim, update_characteristic_axis, update_record_layout, - RecordLayoutInfo, TypedefNames, TypedefReferrer, TypedefsRefInfo, + RecordLayoutInfo, TypedefNames, TypedefReferrer, TypedefsRefInfo, UpdateInfo, }; use a2lfile::{ A2lObject, AddrType, CharacteristicType, FncValues, IndexMode, Module, Number, RecordLayout, @@ -15,8 +16,6 @@ use std::borrow::Cow; use std::collections::{HashMap, HashSet}; use std::fmt::Write; -use crate::update::enums::{cond_create_enum_conversion, update_enum_compu_methods}; - type FxIndexMap = IndexMap; /// `TypeQuality` is used to identify how precise the information in `typedef_map` is. @@ -70,27 +69,23 @@ struct TypedefUpdater<'dbg, 'a2l, 'rl, 'log, 'cm> { pub(crate) const FLAG_CREATE_CALIB: &str = "||calib||"; pub(crate) const FLAG_CREATE_MEAS: &str = "||meas||"; -pub(crate) fn update_module_typedefs<'a>( - module: &mut Module, - debug_data: &'a DebugData, - log_msgs: &mut Vec, - preserve_unknown: bool, - typedef_ref_info: TypedefsRefInfo<'a>, +pub(crate) fn update_module_typedefs( + info: &mut UpdateInfo, + typedef_ref_info: TypedefsRefInfo, typedef_names: TypedefNames, - recordlayout_info: &mut RecordLayoutInfo, compu_method_index: &HashMap, ) { let updater = TypedefUpdater::new( - module, - debug_data, - log_msgs, + info.module, + info.debug_data, + info.log_msgs, typedef_names, - recordlayout_info, + &mut info.reclayout_info, typedef_ref_info, compu_method_index, ); - updater.process_typedefs(preserve_unknown, false); + updater.process_typedefs(info.preserve_unknown, false); } pub(crate) fn create_new_typedefs<'a>( @@ -1833,7 +1828,8 @@ mod test { use super::{update_module_typedefs, TypedefUpdater}; use crate::{ dwarf::{DebugData, TypeInfo}, - update::{get_symbol_info, RecordLayoutInfo, TypedefNames, TypedefReferrer}, + update::{get_symbol_info, RecordLayoutInfo, TypedefNames, TypedefReferrer, UpdateInfo}, + A2lVersion, }; use a2lfile::A2lFile; use std::{ @@ -2141,7 +2137,7 @@ mod test { #[test] fn test_update() { - let (mut a2l, debug_data, names, mut reclayout) = + let (mut a2l, debug_data, names, reclayout) = test_setup("tests/update_test3.a2l", "tests/elffiles/update_test.elf"); let mut typedef_ref_info: HashMap> = HashMap::new(); @@ -2161,17 +2157,17 @@ mod test { } } + let version = A2lVersion::from(&a2l); let mut log_msgs = Vec::new(); - update_module_typedefs( - &mut a2l.project.module[0], - &debug_data, - &mut log_msgs, - false, - typedef_ref_info, - names, - &mut reclayout, - &HashMap::new(), - ); + let mut info = UpdateInfo { + module: &mut a2l.project.module[0], + debug_data: &debug_data, + log_msgs: &mut log_msgs, + preserve_unknown: false, + version, + reclayout_info: reclayout, + }; + update_module_typedefs(&mut info, typedef_ref_info, names, &HashMap::new()); let mut log_msgs = Vec::new(); let mut reference_a2l =