Method execute

src/commands/hot_blocks.rs:95–193

Executes the command.

(mut self)

impl HotBlocksCommand {
    /// Executes the command.
    pub fn execute(mut self) -> Result<()> {
        self.run.common.init_logging()?;

        if !(0.0..=100.0).contains(&self.percent) {
            bail!("--percent must be between 0 and 100 inclusive");
        }

        // Ensure address maps are enabled (error if explicitly disabled).
        if self.run.common.debug.address_map == Some(false) {
            bail!(
                "address maps must be enabled for hot-blocks profiling; do not pass -Daddress-map=n"
            );
        }
        self.run.common.debug.address_map = Some(true);

        let tmp_dir = tempdir().context("failed to create temp directory")?;

        // Compile the input Wasm to a .cwasm, emitting CLIF to the temp dir.
        let clif_dir = tmp_dir.path().join("clif");
        std::fs::create_dir(&clif_dir)?;
        let cwasm_path = tmp_dir.path().join("module.cwasm");

        let wasm_bytes =
            Cow::Owned(std::fs::read(&self.module).with_context(|| {
                format!("failed to read Wasm module: {}", self.module.display())
            })?);
        #[cfg(feature = "wat")]
        let wasm_bytes = wat::parse_bytes(&wasm_bytes).map_err(|mut e| {
            e.set_path(&self.module);
            e
        })?;

        let engine = self.compile_to_cwasm(&clif_dir, &cwasm_path, &wasm_bytes)?;

        // Run perf record.
        let perf_data_path = tmp_dir.path().join("perf.data");
        self.run_perf_record(&cwasm_path, &perf_data_path)?;

        // Run perf script and parse samples.
        let (samples, total_samples) = self.run_perf_script(&perf_data_path)?;

        let target = match self.run.common.target.as_deref() {
            None => target_lexicon::Triple::host(),
            Some(t) => target_lexicon::Triple::from_str(t)?,
        };

        // Build the WAT offset map using wasmprinter.
        let wat_map = build_wat_offset_map(&wasm_bytes);

        // Deserialize the cwasm to extract functions, text, and address map.
        self.run.allow_precompiled = true;
        let run_target = self.run.load_module(&engine, &cwasm_path, None)?;
        let (functions, text, address_map) = match &run_target {
            RunTarget::Core(module) => (
                module.functions().collect::<Vec<_>>(),
                module.text(),
                module
                    .address_map()