dwarfdump: move dwo parent parsing to one location

philipc · philipc · commit c13c17284f13 · 2021-07-16T14:30:40.000+10:00
diff --git a/examples/dwarfdump.rs b/examples/dwarfdump.rs
@@ -592,28 +592,52 @@ where
         load_file_section(id, file, endian, flags.dwo, &arena_data, &arena_relocations)
     };
     let mut dwarf = gimli::Dwarf::load(&mut load_section)?;
-    let mut load_dwo_parent_section = None;
+    let mut dwo_parent_units = HashMap::new();
     if flags.dwo {
         dwarf.file_type = gimli::DwarfFileType::Dwo;
 
         if let Some(dwo_parent_file) = flags.dwo_parent.as_ref() {
-            let arena_data = &arena_data;
-            let arena_relocations = &arena_relocations;
-            load_dwo_parent_section = Some(move |id: gimli::SectionId| -> Result<_> {
+            let mut load_dwo_parent_section = |id: gimli::SectionId| -> Result<_> {
                 load_file_section(
                     id,
                     dwo_parent_file,
                     endian,
                     false,
-                    arena_data,
-                    arena_relocations,
+                    &arena_data,
+                    &arena_relocations,
                 )
-            });
-            dwarf.debug_addr = gimli::Section::load(load_dwo_parent_section.as_mut().unwrap())?;
-            dwarf.ranges = gimli::RangeLists::new(
-                gimli::Section::load(load_dwo_parent_section.as_mut().unwrap())?,
-                gimli::Section::load(load_dwo_parent_section.as_mut().unwrap())?,
-            );
+            };
+            let dwo_parent = gimli::Dwarf::load(&mut load_dwo_parent_section)?;
+            dwarf.debug_addr = dwo_parent.debug_addr.clone();
+            dwarf.ranges = dwo_parent.ranges.clone();
+            dwo_parent_units = match dwo_parent
+                .units()
+                .map(|unit_header| dwo_parent.unit(unit_header))
+                .filter_map(|unit| {
+                    let dwo_id = match unit.header.type_() {
+                        gimli::UnitType::Skeleton(dwo_id) => dwo_id,
+                        gimli::UnitType::Compilation => {
+                            let mut entries = unit.entries();
+                            let (_, this) = entries.next_dfs()?.unwrap();
+                            match this.attr_value(gimli::constants::DW_AT_GNU_dwo_id)? {
+                                Some(gimli::AttributeValue::DwoId(dwo_id)) => dwo_id,
+                                Some(_) => unreachable!(),
+                                None => return Ok(None),
+                            }
+                        }
+                        _ => return Ok(None),
+                    };
+
+                    Ok(Some((dwo_id, unit)))
+                })
+                .collect()
+            {
+                Ok(units) => units,
+                Err(err) => {
+                    eprintln!("Failed to process --dwo-parent units: {}", err);
+                    return Ok(());
+                }
+            }
         }
     }
 
@@ -672,40 +696,7 @@ where
         )?;
     }
     if flags.info {
-        let dwo_parent_headers = if let Some(loader) = load_dwo_parent_section.as_mut() {
-            let dwarf = gimli::Dwarf::load(loader)?;
-            match dwarf
-                .units()
-                .map(|unit_header| dwarf.unit(unit_header))
-                .filter_map(|unit| {
-                    let dwo_id = match unit.header.type_() {
-                        gimli::UnitType::Skeleton(dwo_id) => dwo_id,
-                        gimli::UnitType::Compilation => {
-                            let mut entries = unit.entries();
-                            let (_, this) = entries.next_dfs()?.unwrap();
-                            match this.attr_value(gimli::constants::DW_AT_GNU_dwo_id)? {
-                                Some(gimli::AttributeValue::DwoId(dwo_id)) => dwo_id,
-                                Some(_) => unreachable!(),
-                                None => return Ok(None),
-                            }
-                        }
-                        _ => return Ok(None),
-                    };
-
-                    Ok(Some((dwo_id, unit)))
-                })
-                .collect()
-            {
-                Ok(units) => units,
-                Err(err) => {
-                    eprintln!("Failed to process --dwo-parent units: {}", err);
-                    return Ok(());
-                }
-            }
-        } else {
-            HashMap::new()
-        };
-        dump_info(&dwarf, dwo_parent_headers, flags)?;
+        dump_info(&dwarf, dwo_parent_units, flags)?;
         dump_types(&mut BufWriter::new(out.lock()), &dwarf, flags)?;
         writeln!(&mut out.lock())?;
     }
@@ -1010,7 +1001,7 @@ fn dump_cfi_instructions<R: Reader, W: Write>(
 
 fn dump_info<R: Reader>(
     dwarf: &gimli::Dwarf<R>,
-    dwo_parent_headers: HashMap<gimli::DwoId, gimli::Unit<R>>,
+    dwo_parent_units: HashMap<gimli::DwoId, gimli::Unit<R>>,
     flags: &Flags,
 ) -> Result<()>
 where
@@ -1096,7 +1087,7 @@ where
                 }
                 _ => None,
             } {
-                if let Some(parent_unit) = dwo_parent_headers.get(&dwo_id) {
+                if let Some(parent_unit) = dwo_parent_units.get(&dwo_id) {
                     unit.copy_relocated_attributes(parent_unit);
                 }
             }
