PDB support about cargo-bloat HOT 34 CLOSED

use pdb::FallibleIterator;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let dir = std::path::Path::new("D:\\your\\path\\to\\pdb\\folder");
    let file_name = "cargo-bloat";

    let exe_path = dir.join(file_name).with_extension("exe");
    let exe_size = std::fs::metadata(&exe_path)?.len();
    let (_, text_size) = binfarce::pe::parse(&std::fs::read(&exe_path).unwrap())?.symbols()?;

    let pdb_path = dir.join(file_name.replace("-", "_")).with_extension("pdb");
    let file = std::fs::File::open(&pdb_path)?;
    let mut pdb = pdb::PDB::open(file)?;

    let dbi = pdb.debug_information()?;
    let symbol_table = pdb.global_symbols()?;

    let mut total_parsed_size = 0usize;
    let mut demangled_total_parsed_size = 0usize;
    let mut out_symbols = vec![];

    // Collect the PublicSymbols
    let mut public_symbols = vec![];

    let mut symbols = symbol_table.iter();
    while let Ok(Some(symbol)) = symbols.next() {
        match symbol.parse() {
            Ok(pdb::SymbolData::Public(data)) => {
                if data.code || data.function {
                    public_symbols.push((data.offset, data.name.to_string().into_owned()));
                }
                if data.name.to_string().contains("try_small_punycode_decode") {
                    dbg!(&data);
                }
            }
            _ => {}
        }
    }

    let mut modules = dbi.modules()?;
    while let Some(module) = modules.next()? {
        let info = match pdb.module_info(&module)? {
            Some(info) => info,
            None => continue,
        };
        let mut symbols = info.symbols()?;
        while let Some(symbol) = symbols.next()? {
            if let Ok(pdb::SymbolData::Public(data)) = symbol.parse() {
                if data.code || data.function {
                    public_symbols.push((data.offset, data.name.to_string().into_owned()));
                }
                if data.name.to_string().contains("try_small_punycode_decode") {
                    dbg!(&data);
                }
            }
        }
    }

    let cmp_offsets = |a: &pdb::PdbInternalSectionOffset, b: &pdb::PdbInternalSectionOffset| {
        a.section.cmp(&b.section).then(a.offset.cmp(&b.offset))
    };
    public_symbols.sort_unstable_by(|a, b| cmp_offsets(&a.0, &b.0));

    // Now find the Procedure symbols in all modules
    // and if possible the matching PublicSymbol record with the mangled name
    let mut handle_proc = |proc: pdb::ProcedureSymbol| {
        let mangled_symbol = public_symbols
            .binary_search_by(|probe| {
                let low = cmp_offsets(&probe.0, &proc.offset);
                let high = cmp_offsets(&probe.0, &(proc.offset + proc.len));

                use std::cmp::Ordering::*;
                match (low, high) {
                    // Less than the low bound -> less
                    (Less, _) => Less,
                    // More than the high bound -> greater
                    (_, Greater) => Greater,
                    _ => Equal,
                }
            })
            .ok()
            .map(|x| &public_symbols[x]);
        // Uncomment to verify binary search isn't screwing up anything
        /*
        let mangled_symbol = public_symbols
            .iter()
            .filter(|probe| probe.0 >= proc.offset && probe.0 <= (proc.offset + proc.len))
            .take(1)
            .next();
        */

        let demangled_name = proc.name.to_string().into_owned();
        out_symbols.push((proc.len as usize, demangled_name, mangled_symbol));

        total_parsed_size += proc.len as usize;
        if mangled_symbol.is_some() {
            demangled_total_parsed_size += proc.len as usize;
        }
    };

    let mut symbols = symbol_table.iter();
    while let Ok(Some(symbol)) = symbols.next() {
        if let Ok(pdb::SymbolData::Procedure(proc)) = symbol.parse() {
            handle_proc(proc);
        }
    }
    let mut modules = dbi.modules()?;
    while let Some(module) = modules.next()? {
        let info = match pdb.module_info(&module)? {
            Some(info) => info,
            None => continue,
        };

        let mut symbols = info.symbols()?;

        while let Some(symbol) = symbols.next()? {
            if let Ok(pdb::SymbolData::Procedure(proc)) = symbol.parse() {
                handle_proc(proc);
            }
        }
    }

    println!(
        "exe size:{}\ntext size:{}\nsize of fns found: {}\nratio:{}\nsize of fns with mangles found: {}\nratio:{}",
        exe_size,
        text_size,
        total_parsed_size,
        total_parsed_size as f32 / text_size as f32,
        demangled_total_parsed_size,
        demangled_total_parsed_size as f32 / text_size as f32
    );

    /*
    // Test for the symbolic crate. It turns out it prints gives all the function names unmangled
    // which is the opposite of what we need

    use symbolic::common::{ByteView, Language, Name, NameMangling};
    use symbolic::debuginfo::{Function, Object};
    use symbolic::demangle::{Demangle, DemangleOptions};

    let view = ByteView::open(&pdb_path).expect("failed to open file");
    let object = Object::parse(&view).expect("failed to parse file");
    let session = object.debug_session().expect("failed to process file");
    for function in session.functions() {
        if let Ok(function) = function {
            if function.name.mangling() == symbolic::common::NameMangling::Unmangled {
                dbg!(function);
            }
        }
    }
    */

    Ok(())
}

D:\dev\cargo-bloat [master ≡ +0 ~3 -0 !]> cargo run ; cargo run --release -- --release
    Finished dev [unoptimized + debuginfo] target(s) in 0.02s
     Running `target\debug\cargo-bloat.exe`
    Finished dev [unoptimized + debuginfo] target(s) in 0.02s
[src\main.rs:912] &pdb_path = "D:\\dev\\cargo-bloat\\target\\debug\\cargo_bloat.pdb"
    Analyzing target\debug\cargo-bloat.exe

 File  .text    Size        Crate Name
 1.1%   1.4% 28.1KiB         json json::parser::Parser::parse
 0.5%   0.7% 13.2KiB         json json::util::print_dec::write
 0.5%   0.6% 11.7KiB         json json::codegen::Generator::write_json
 0.3%   0.4%  8.0KiB          pdb <pdb::symbol::SymbolData as scroll::ctx::TryFromCtx>::try_from_ctx
 0.3%   0.4%  7.0KiB regex_syntax <regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_class_set_item_post
 0.3%   0.3%  6.6KiB regex_syntax <regex_syntax::hir::translate::TranslatorI as regex_syntax::ast::visitor::Visitor>::visit_post
 0.2%   0.3%  5.3KiB        regex regex::exec::ExecBuilder::build
 0.2%   0.3%  5.3KiB          std core::num::flt2dec::strategy::dragon::format_shortest
 0.2%   0.2%  4.7KiB regex_syntax alloc::str::join_generic_copy
 0.2%   0.2%  4.5KiB     binfarce <binfarce::demangle::legacy::Demangle as core::fmt::Display>::fmt
 0.2%   0.2%  4.4KiB     binfarce binfarce::pe::Pe::symbols
 0.2%   0.2%  4.4KiB          std core::num::flt2dec::strategy::dragon::format_exact
 0.2%   0.2%  4.0KiB         json json::object::Object::insert_index
 0.1%   0.2%  3.7KiB          pdb <pdb::common::Error as core::fmt::Debug>::fmt
 0.1%   0.2%  3.5KiB regex_syntax <regex_syntax::error::Formatter<E> as core::fmt::Display>::fmt
 0.1%   0.2%  3.5KiB regex_syntax <regex_syntax::error::Formatter<E> as core::fmt::Display>::fmt
 0.1%   0.2%  3.5KiB     binfarce binfarce::elf64::Elf64::symbols
 0.1%   0.2%  3.4KiB     binfarce binfarce::macho::Macho::find_section
 0.1%   0.2%  3.3KiB          std rustc_demangle::demangle
 0.1%   0.2%  3.2KiB cargo_bloat? <cargo_bloat::table::Table as core::fmt::Display>::fmt
47.3%  59.3%  1.1MiB              And 8776 smaller methods. Use -n N to show more.
79.6% 100.0%  1.9MiB              .text section size, the file size is 2.4MiB
    Finished release [optimized] target(s) in 0.02s
     Running `target\release\cargo-bloat.exe --release`
    Finished release [optimized] target(s) in 0.02s
[src\main.rs:912] &pdb_path = "D:\\dev\\cargo-bloat\\target\\release\\cargo_bloat.pdb"
    Analyzing target\release\cargo-bloat.exe

 File  .text     Size Crate Name
 0.6%   0.7%   5.3KiB   std core::num::flt2dec::strategy::dragon::format_shortest
 0.5%   0.6%   4.4KiB   std core::num::flt2dec::strategy::dragon::format_exact
 0.3%   0.4%   3.3KiB   std rustc_demangle::demangle
 0.3%   0.4%   3.1KiB   std <rustc_demangle::legacy::Demangle as core::fmt::Display>::fmt
 0.3%   0.4%   3.0KiB   std std::process::Child::wait_with_output
 0.3%   0.3%   2.5KiB   std <std::env::Args as core::iter::traits::iterator::Iterator>::next
 0.2%   0.3%   2.3KiB   std core::num::flt2dec::strategy::grisu::format_shortest_opt
 0.2%   0.2%   1.5KiB   std <std::sys_common::backtrace::_print::DisplayBacktrace as core::fmt::Display>::fmt
 0.1%   0.2%   1.4KiB   std core::str::pattern::StrSearcher::new
 0.1%   0.2%   1.3KiB   std core::fmt::Formatter::pad_integral
 0.1%   0.2%   1.2KiB   std core::num::flt2dec::strategy::grisu::format_exact_opt
 0.1%   0.2%   1.2KiB   std std::path::Path::components
 0.1%   0.2%   1.2KiB   std <rustc_demangle::v0::Ident as core::fmt::Display>::fmt
 0.1%   0.2%   1.2KiB   std core::fmt::Formatter::pad
 0.1%   0.2%   1.2KiB   std <str as core::fmt::Debug>::fmt
 0.1%   0.2%   1.2KiB   std core::str::slice_error_fail
 0.1%   0.1%   1.1KiB   std core::num::bignum::Big32x40::mul_pow2
 0.1%   0.1%   1.1KiB   std <std::path::Components as core::iter::traits::iterator::Iterator>::next
 0.1%   0.1%   1.0KiB   std <std::io::error::Error as core::fmt::Display>::fmt
 0.1%   0.1%   1.0KiB   std <core::str::lossy::Utf8LossyChunksIter as core::iter::traits::iterator::Iterator>::next
 5.3%   6.8%  51.0KiB       And 260 smaller methods. Use -n N to show more.
78.3% 100.0% 748.0KiB       .text section size, the file size is 955.5KiB