Handle DW_AT_ranges for functions

Author: philipc

main/src/print/file.rs

@@ -776,7 +776,7 @@ pub fn bloat_index(file: &File, options: &Options) -> BloatIndex {
     let mut callers = HashMap::new();
     for (unit_index, unit) in file.units().iter().enumerate() {
         for (function_index, function) in unit.functions().iter().enumerate() {
-            if let Some(range) = function.range() {
+            if let Some(size) = function.size() {
                 let mut name = Vec::new();
                 print::function::print_ref(function, &mut name).unwrap();
                 let mut source = Vec::new();
@@ -785,17 +785,19 @@ pub fn bloat_index(file: &File, options: &Options) -> BloatIndex {
                 let mut function_total = function_totals
                     .entry(id)
                     .or_insert(FunctionTotal::default());
-                function_total.size += range.size();
+                function_total.size += size;
                 function_total.functions.push((unit_index, function_index));
 
                 if let Some(code) = code.as_ref() {
-                    for call in code.calls(range) {
-                        let entry = callers.entry(call.to).or_insert(Vec::new());
-                        entry.push(Caller {
-                            unit_index,
-                            function_index,
-                            _address: call.from,
-                        });
+                    for range in function.ranges() {
+                        for call in code.calls(*range) {
+                            let entry = callers.entry(call.to).or_insert(Vec::new());
+                            entry.push(Caller {
+                                unit_index,
+                                function_index,
+                                _address: call.from,
+                            });
+                        }
                     }
                 }
             }
@@ -838,17 +840,18 @@ pub fn bloat(
                 for (unit_index, function_index) in &function_total.functions {
                     let unit = &file.units()[*unit_index];
                     let function = &unit.functions()[*function_index];
-                    let range = function.range().unwrap();
+                    let address = function.address().unwrap();
+                    let size = function.size().unwrap();
                     state.id(
                         function.id(),
                         |state| {
                             state.line(|w, _hash| {
-                                write!(w, "{} ", range.size())?;
+                                write!(w, "{} ", size)?;
                                 print::unit::print_ref(unit, w)?;
                                 Ok(())
                             })
                         },
-                        |state| bloat_callers(state, file, index, range.begin),
+                        |state| bloat_callers(state, file, index, address),
                     )?;
                 }
                 Ok(())

main/src/print/function.rs

@@ -48,8 +48,8 @@ fn print_source(f: &Function, w: &mut dyn ValuePrinter, unit: &Unit) -> Result<(
     print::source::print(f.source(), w, unit)
 }
 
-fn print_address(f: &Function, w: &mut dyn ValuePrinter) -> Result<()> {
-    if let Some(ref range) = f.range() {
+fn print_range(range: Option<&Range>, w: &mut dyn ValuePrinter) -> Result<()> {
+    if let Some(range) = range {
         print::range::print_address(range, w)?;
     }
     Ok(())
@@ -100,7 +100,13 @@ impl<'input> PrintHeader for Function<'input> {
         if state.options().print_source {
             state.field("source", |w, _state| print_source(self, w, unit))?;
         }
-        state.field("address", |w, _state| print_address(self, w))?;
+        let ranges = self.ranges();
+        if ranges.len() > 1 {
+            state.field_collapsed("addresses", |state| state.list(&(), ranges))?;
+        } else {
+            let range = ranges.first();
+            state.field("address", |w, _state| print_range(range, w))?;
+        }
         state.field("size", |w, _state| print_size(self, w))?;
         state.field("inline", |w, _state| print_inline(self, w))?;
         state.field("declaration", |w, _state| print_declaration(self, w))?;
@@ -125,7 +131,7 @@ impl<'input> PrintHeader for Function<'input> {
             let calls = calls(self, state.code);
             state.field_collapsed("calls", |state| state.list(&(), &calls))?;
         }
-        if state.options().print_function_instructions && self.range().is_some() {
+        if state.options().print_function_instructions && !self.ranges().is_empty() {
             state.field_detail("code", "instructions", |state| {
                 print_instructions(state, self, &details)
             })?;
@@ -164,7 +170,19 @@ impl<'input> PrintHeader for Function<'input> {
         }
         let flag = state.options().ignore_function_address;
         state.ignore_diff(flag, |state| {
-            state.field("address", a, b, |w, _state, x| print_address(x, w))
+            let ranges_a = a.ranges();
+            let ranges_b = b.ranges();
+            if ranges_a.len() > 1 || ranges_b.len() > 1 {
+                state.field_collapsed("addresses", |state| {
+                    state.ord_list(&(), ranges_a, &(), ranges_b)
+                })
+            } else {
+                let range_a = ranges_a.first();
+                let range_b = ranges_b.first();
+                state.field("address", range_a, range_b, |w, _state, range| {
+                    print_range(range, w)
+                })
+            }
         })?;
         let flag = state.options().ignore_function_size;
         state.ignore_diff(flag, |state| {
@@ -391,21 +409,24 @@ impl DiffList for Call {
 }
 
 pub(crate) fn calls(f: &Function, code: Option<&Code>) -> Vec<Call> {
-    if let (Some(code), Some(range)) = (code, f.range()) {
-        return code.calls(range);
+    let mut calls = Vec::new();
+    if let Some(code) = code {
+        for range in f.ranges() {
+            calls.extend(code.calls(*range));
+        }
     }
-    Vec::new()
+    calls
 }
 
 pub(crate) fn print_instructions(
     state: &mut PrintState,
     f: &Function,
     details: &FunctionDetails,
 ) -> Result<()> {
-    let range = match f.range() {
-        Some(x) => x,
-        None => return Ok(()),
-    };
+    let ranges = f.ranges();
+    if ranges.is_empty() {
+        return Ok(());
+    }
     let code = match state.code {
         Some(x) => x,
         None => return Ok(()),
@@ -414,37 +435,44 @@ pub(crate) fn print_instructions(
         Some(x) => x,
         None => return Ok(()),
     };
-    let insns = match disassembler.instructions(code, range) {
-        Some(x) => x,
-        None => return Ok(()),
-    };
-    let cfis = f.cfi(state.hash());
-
-    let mut insns = insns.iter();
-    let mut cfis = cfis.iter();
+    for range in ranges.iter().copied() {
+        state.instruction(None, "", |w, _hash| {
+            write!(w, ".org 0x{:x}", range.begin)?;
+            Ok(())
+        })?;
 
-    let mut insn_next = insns.next();
-    let mut cfi_next = cfis.next();
-    loop {
-        match (&insn_next, cfi_next) {
-            (&Some(ref insn), Some(cfi)) => {
-                if cfi.0.is_none() || cfi.0 <= insn.address() {
-                    print_cfi(state, cfi, range)?;
-                    cfi_next = cfis.next();
-                } else {
+        let insns = match disassembler.instructions(code, range) {
+            Some(x) => x,
+            None => return Ok(()),
+        };
+        let cfis = state.hash().file.cfi(range);
+
+        let mut insns = insns.iter();
+        let mut cfis = cfis.iter();
+
+        let mut insn_next = insns.next();
+        let mut cfi_next = cfis.next();
+        loop {
+            match (&insn_next, cfi_next) {
+                (&Some(ref insn), Some(cfi)) => {
+                    if cfi.0.is_none() || cfi.0 <= insn.address() {
+                        print_cfi(state, cfi, range)?;
+                        cfi_next = cfis.next();
+                    } else {
+                        insn.print(state, code, &disassembler, details, range)?;
+                        insn_next = insns.next();
+                    }
+                }
+                (&Some(ref insn), None) => {
                     insn.print(state, code, &disassembler, details, range)?;
                     insn_next = insns.next();
                 }
+                (&None, Some(cfi)) => {
+                    print_cfi(state, cfi, range)?;
+                    cfi_next = cfis.next();
+                }
+                (&None, None) => break,
             }
-            (&Some(ref insn), None) => {
-                insn.print(state, code, &disassembler, details, range)?;
-                insn_next = insns.next();
-            }
-            (&None, Some(cfi)) => {
-                print_cfi(state, cfi, range)?;
-                cfi_next = cfis.next();
-            }
-            (&None, None) => break,
         }
     }
     Ok(())

main/src/print/unit.rs

@@ -216,7 +216,7 @@ pub(crate) fn diff_body(state: &mut DiffState, unit_a: &Unit, unit_b: &Unit) ->
         if options.print_unit_address {
             let ranges_a = unit_a.ranges(state.hash_a());
             let ranges_b = unit_b.ranges(state.hash_b());
-            if ranges_a.list().len() > 1 || ranges_a.list().len() > 1 {
+            if ranges_a.list().len() > 1 || ranges_b.list().len() > 1 {
                 state.field_collapsed("addresses", |state| {
                     state.ord_list(&(), ranges_a.list(), &(), ranges_b.list())
                 })?;

parser/src/file/dwarf.rs

@@ -347,8 +347,8 @@ where
         })
     }
 
-    pub(crate) fn get_cfi(&self, address: Address, size: Size) -> Vec<Cfi> {
-        self.frame.get_cfi(address, size).unwrap_or_default()
+    pub(crate) fn get_cfi(&self, range: Range) -> Vec<Cfi> {
+        self.frame.get_cfi(range).unwrap_or_default()
     }
 
     pub(crate) fn get_register_name(
@@ -2164,6 +2164,7 @@ where
         source: Source::default(),
         address: Address::none(),
         size: Size::none(),
+        ranges: Vec::new(),
         inline: false,
         declaration: false,
         parameters: Vec::new(),
@@ -2174,6 +2175,7 @@ where
     let mut abstract_origin = false;
     let mut high_pc = None;
     let mut size = None;
+    let mut ranges = None;
 
     let entry = node.entry();
     let mut attrs = entry.attrs();
@@ -2216,6 +2218,11 @@ where
                 }
                 _ => {}
             },
+            gimli::DW_AT_ranges => {
+                if let gimli::AttributeValue::RangeListsRef(val) = attr.value() {
+                    ranges = Some(val);
+                }
+            }
             gimli::DW_AT_type => {
                 if let Some(offset) = parse_type_offset(dwarf_unit, &attr) {
                     function.return_type = offset;
@@ -2259,13 +2266,36 @@ where
         }
     }
 
-    if let Some(address) = function.address() {
+    if let Some(offset) = ranges {
+        let offset = dwarf.read.ranges_offset_from_raw(&dwarf_unit, offset);
+        let mut ranges = dwarf.read.ranges(&dwarf_unit, offset)?;
+        let mut size = 0;
+        while let Some(range) = ranges.next()? {
+            if range.end > range.begin {
+                size += range.end - range.begin;
+                function.ranges.push(Range {
+                    begin: range.begin,
+                    end: range.end,
+                });
+            }
+        }
+        function.size = Size::new(size);
+        function.address = Address::new(function.ranges.first().map(|r| r.begin).unwrap_or(0));
+    } else if let Some(address) = function.address.get() {
         if let Some(high_pc) = high_pc {
             if high_pc > address {
                 function.size = Size::new(high_pc - address);
+                function.ranges.push(Range {
+                    begin: address,
+                    end: high_pc,
+                });
             }
         } else if let Some(size) = size {
             function.size = Size::new(size);
+            function.ranges.push(Range {
+                begin: address,
+                end: address.wrapping_add(size),
+            });
         }
     }
 
@@ -3902,17 +3932,13 @@ impl<R: gimli::Reader<Offset = usize>> DwarfFrame<R> {
         }
     }
 
-    fn get_cfi(&self, address: Address, size: Size) -> Option<Vec<Cfi>> {
+    fn get_cfi(&self, range: Range) -> Option<Vec<Cfi>> {
         let cfi = self
             .eh_frame
-            .get_cfi(address, size)
-            .or_else(|| self.debug_frame.get_cfi(address, size));
+            .get_cfi(range)
+            .or_else(|| self.debug_frame.get_cfi(range));
         if cfi.is_none() {
-            debug!(
-                "no FDE for 0x{:x}[0x{:x}]",
-                address.get().unwrap_or(0),
-                size.get().unwrap_or(0)
-            );
+            debug!("no FDE for 0x{:x}[0x{:x}]", range.begin, range.size());
         }
         cfi
     }
@@ -3935,8 +3961,8 @@ impl<R: gimli::Reader<Offset = usize>> DebugFrameTable<R> {
         }
     }
 
-    fn get_cfi(&self, address: Address, size: Size) -> Option<Vec<Cfi>> {
-        get_cfi(&self.debug_frame, &self.bases, &self.fdes, address, size)
+    fn get_cfi(&self, range: Range) -> Option<Vec<Cfi>> {
+        get_cfi(&self.debug_frame, &self.bases, &self.fdes, range)
     }
 }
 
@@ -3956,8 +3982,8 @@ impl<R: gimli::Reader<Offset = usize>> EhFrameTable<R> {
         }
     }
 
-    fn get_cfi(&self, address: Address, size: Size) -> Option<Vec<Cfi>> {
-        get_cfi(&self.eh_frame, &self.bases, &self.fdes, address, size)
+    fn get_cfi(&self, range: Range) -> Option<Vec<Cfi>> {
+        get_cfi(&self.eh_frame, &self.bases, &self.fdes, range)
     }
 }
 
@@ -4019,14 +4045,13 @@ fn get_cfi<R: gimli::Reader, S: gimli::UnwindSection<R>>(
     section: &S,
     bases: &gimli::BaseAddresses,
     fdes: &FdeOffsetTable,
-    address: Address,
-    size: Size,
+    range: Range,
 ) -> Option<Vec<Cfi>>
 where
     S::Offset: gimli::UnwindOffset,
 {
-    let address = address.get()?;
-    let size = size.get()?;
+    let address = range.begin;
+    let size = range.size();
     let fde_offset = S::Offset::from(fdes.find(address)?);
     let fde = section
         .fde_from_offset(bases, fde_offset, S::cie_from_offset)