wasmtime 37.0.2 → 38.0.4

data/ext/cargo-vendor/fxprof-processed-profile-0.6.0/Cargo.toml

@@ -1,41 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2021"
-rust-version = "1.58"
-name = "fxprof-processed-profile"
-version = "0.6.0"
-authors = ["Markus Stange <mstange.moz@gmail.com>"]
-description = "Create profiles in the Firefox Profiler's processed profile JSON format."
-readme = "README.md"
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/mstange/samply/"
-resolver = "1"
-
-[dependencies.bitflags]
-version = "2.0"
-
-[dependencies.debugid]
-version = "0.8.0"
-
-[dependencies.fxhash]
-version = "0.2.1"
-
-[dependencies.serde]
-version = "1.0"
-features = ["derive"]
-
-[dependencies.serde_json]
-version = "1.0"
-
-[dev-dependencies.assert-json-diff]
-version = "2.0.1"

data/ext/cargo-vendor/fxprof-processed-profile-0.6.0/Cargo.toml.orig

@@ -1,20 +0,0 @@
-[package]
-name = "fxprof-processed-profile"
-version = "0.6.0"
-edition = "2021"
-rust-version = "1.58"
-authors = ["Markus Stange <mstange.moz@gmail.com>"]
-license = "MIT OR Apache-2.0"
-description = "Create profiles in the Firefox Profiler's processed profile JSON format."
-repository = "https://github.com/mstange/samply/"
-readme = "README.md"
-
-[dependencies]
-bitflags = "2.0"
-serde_json = "1.0"
-serde = { version = "1.0", features = ["derive"] }
-debugid = "0.8.0"
-fxhash = "0.2.1"
-
-[dev-dependencies]
-assert-json-diff = "2.0.1"

data/ext/cargo-vendor/fxprof-processed-profile-0.6.0/README.md

@@ -1,27 +0,0 @@
-# fxprof-processed-profile
-
-A crate that allows creating profiles in the [Firefox Profiler](https://github.com/firefox-devtools/profiler)'s ["Processed profile" format](https://github.com/firefox-devtools/profiler/blob/main/docs-developer/processed-profile-format.md).
-
-Still work in progress, under-documented, and will have breaking changes frequently.
-
-## Description
-
-This crate is a sibling crate to the `gecko_profile` crate.
-
-Profiles produced with this crate can be more efficient because they allow the Firefox Profiler to skip a processing step during loading, and because this format supports a "weight" column in the sample table. The sample weight can be used to collapse duplicate consecutive samples into one sample, which means that the individual sample timestamps don't have to be serialized into the JSON. This can save a ton of space.
-
-## About the format
-
-When the Firefox Profiler is used with Firefox, the Firefox Profiler receives profile data in the "Gecko profile" format. Then it converts it into the "processed profile" format.
-
-The "processed profile" format is the format in which the files are stored when you upload the profile for sharing, or when you download it as a file. It is different from the "Gecko profile" format in the following ways:
-
- - There is one flat list of threads across all processes. Each thread comes with some information about its process, which allows the Firefox Profiler to group threads which belong to the same process.
- - Because of the flat list, the timestamps in all threads (from all processes) are relative to the same reference timestamp. This is different to the "Gecko profile" format where each process has its own time base.
- - The various tables in each thread are stored in a "struct of arrays" form. For example, the sample table has one flat list of timestamps, one flat list of stack indexes, and so forth. This is different to the "Gecko profile" format which contains one JS object for every individual sample - that object being an array such as `[stack_index, time, eventDelay, cpuDelta]`. The struct-of-arrays form makes the data cheaper to access and is much easier on the browser's GC.
- - The sample table in the "processed profile" format supports a weight column. The "Gecko profile" format currently does not have support for sample weights.
- - Each thread has a `funcTable`, a `resourceTable` and a `nativeSymbols` table. These tables do not exist in the "Gecko profile" format.
- - The structure of the `frameTable` is different. For example, each frame from the native stack has an integer code address, relative to the library that contains this address. In the "Gecko profile" format, the code address is stored in absolute form (process virtual memory address) as a hex string.
- - Native stacks in the "processed profile" format use "nudged" return addresses, i.e. return address minus one byte, so that they point into the calling instruction. This is different from the "Gecko profile" format, which uses raw return addresses.
-
-The "processed profile" format is almost identical to the JavaScript object structure which the Firefox Profiler keeps in memory; [the only difference](https://github.com/firefox-devtools/profiler/blob/af469ed357890f816ab71fb4ba4c9fe125336d94/src/profile-logic/process-profile.js#L1539-L1556) being the use of `stringArray` (which is a plain JSON array of strings) instead of `stringTable` (which is an object containing both the array and a map for fast string-to-index lookup).

data/ext/cargo-vendor/fxprof-processed-profile-0.6.0/src/category.rs

@@ -1,98 +0,0 @@
-use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
-
-use super::category_color::CategoryColor;
-
-/// A profiling category, can be set on stack frames and markers as part of a [`CategoryPairHandle`].
-///
-/// Categories can be created with [`Profile::add_category`](crate::Profile::add_category).
-#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct CategoryHandle(pub(crate) u16);
-
-impl CategoryHandle {
-    /// The "Other" category. All profiles have this category.
-    pub const OTHER: Self = CategoryHandle(0);
-}
-
-impl Serialize for CategoryHandle {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.0.serialize(serializer)
-    }
-}
-
-/// A profiling subcategory, can be set on stack frames and markers as part of a [`CategoryPairHandle`].
-///
-/// Subategories can be created with [`Profile::add_subcategory`](crate::Profile::add_subcategory).
-#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct SubcategoryIndex(pub u8);
-
-/// A profiling category pair, consisting of a category and an optional subcategory. Can be set on stack frames and markers.
-///
-/// Category pairs can be created with [`Profile::add_subcategory`](crate::Profile::add_subcategory)
-/// and from a [`CategoryHandle`].
-#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct CategoryPairHandle(
-    pub(crate) CategoryHandle,
-    pub(crate) Option<SubcategoryIndex>,
-);
-
-impl From<CategoryHandle> for CategoryPairHandle {
-    fn from(category: CategoryHandle) -> Self {
-        CategoryPairHandle(category, None)
-    }
-}
-
-/// The information about a category.
-#[derive(Debug)]
-pub struct Category {
-    pub name: String,
-    pub color: CategoryColor,
-    pub subcategories: Vec<String>,
-}
-
-impl Category {
-    /// Add a subcategory to this category.
-    pub fn add_subcategory(&mut self, subcategory_name: String) -> SubcategoryIndex {
-        let subcategory_index = SubcategoryIndex(u8::try_from(self.subcategories.len()).unwrap());
-        self.subcategories.push(subcategory_name);
-        subcategory_index
-    }
-}
-
-impl Serialize for Category {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut subcategories = self.subcategories.clone();
-        subcategories.push("Other".to_string());
-
-        let mut map = serializer.serialize_map(None)?;
-        map.serialize_entry("name", &self.name)?;
-        map.serialize_entry("color", &self.color)?;
-        map.serialize_entry("subcategories", &subcategories)?;
-        map.end()
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum Subcategory {
-    Normal(SubcategoryIndex),
-    Other(CategoryHandle),
-}
-
-pub struct SerializableSubcategoryColumn<'a>(pub &'a [Subcategory], pub &'a [Category]);
-
-impl<'a> Serialize for SerializableSubcategoryColumn<'a> {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut seq = serializer.serialize_seq(Some(self.0.len()))?;
-        for subcategory in self.0 {
-            match subcategory {
-                Subcategory::Normal(index) => seq.serialize_element(&index.0)?,
-                Subcategory::Other(category) => {
-                    // There is an implicit "Other" subcategory at the end of each category's
-                    // subcategory list.
-                    let subcategory_count = self.1[category.0 as usize].subcategories.len();
-                    seq.serialize_element(&subcategory_count)?
-                }
-            }
-        }
-        seq.end()
-    }
-}

data/ext/cargo-vendor/fxprof-processed-profile-0.6.0/src/category_color.rs

@@ -1,41 +0,0 @@
-use serde::ser::{Serialize, Serializer};
-
-/// One of the available colors for a category.
-#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq)]
-pub enum CategoryColor {
-    Transparent,
-    LightBlue,
-    Red,
-    LightRed,
-    Orange,
-    Blue,
-    Green,
-    Purple,
-    Yellow,
-    Brown,
-    Magenta,
-    LightGreen,
-    Gray,
-    DarkGray,
-}
-
-impl Serialize for CategoryColor {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        match self {
-            CategoryColor::Transparent => "transparent".serialize(serializer),
-            CategoryColor::LightBlue => "lightblue".serialize(serializer),
-            CategoryColor::Red => "red".serialize(serializer),
-            CategoryColor::LightRed => "lightred".serialize(serializer),
-            CategoryColor::Orange => "orange".serialize(serializer),
-            CategoryColor::Blue => "blue".serialize(serializer),
-            CategoryColor::Green => "green".serialize(serializer),
-            CategoryColor::Purple => "purple".serialize(serializer),
-            CategoryColor::Yellow => "yellow".serialize(serializer),
-            CategoryColor::Brown => "brown".serialize(serializer),
-            CategoryColor::Magenta => "magenta".serialize(serializer),
-            CategoryColor::LightGreen => "lightgreen".serialize(serializer),
-            CategoryColor::Gray => "grey".serialize(serializer),
-            CategoryColor::DarkGray => "darkgray".serialize(serializer),
-        }
-    }
-}

data/ext/cargo-vendor/fxprof-processed-profile-0.6.0/src/counters.rs

@@ -1,130 +0,0 @@
-use serde::ser::{Serialize, SerializeMap, Serializer};
-
-use crate::{ProcessHandle, Timestamp};
-
-/// A counter. Can be created with [`Profile::add_counter`](crate::Profile::add_counter).
-#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct CounterHandle(pub(crate) usize);
-
-#[derive(Debug)]
-pub struct Counter {
-    name: String,
-    category: String,
-    description: String,
-    process: ProcessHandle,
-    pid: String,
-    samples: CounterSamples,
-}
-
-impl Counter {
-    pub fn new(
-        name: &str,
-        category: &str,
-        description: &str,
-        process: ProcessHandle,
-        pid: &str,
-    ) -> Self {
-        Counter {
-            name: name.to_owned(),
-            category: category.to_owned(),
-            description: description.to_owned(),
-            process,
-            pid: pid.to_owned(),
-            samples: CounterSamples::new(),
-        }
-    }
-
-    pub fn process(&self) -> ProcessHandle {
-        self.process
-    }
-
-    pub fn add_sample(
-        &mut self,
-        timestamp: Timestamp,
-        value_delta: f64,
-        number_of_operations_delta: u32,
-    ) {
-        self.samples
-            .add_sample(timestamp, value_delta, number_of_operations_delta)
-    }
-
-    pub fn as_serializable(&self, main_thread_index: usize) -> impl Serialize + '_ {
-        SerializableCounter {
-            counter: self,
-            main_thread_index,
-        }
-    }
-}
-
-struct SerializableCounter<'a> {
-    counter: &'a Counter,
-    /// The index of the main thread for the counter's process in the profile threads list.
-    main_thread_index: usize,
-}
-
-impl<'a> Serialize for SerializableCounter<'a> {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut map = serializer.serialize_map(None)?;
-        map.serialize_entry("category", &self.counter.category)?;
-        map.serialize_entry("name", &self.counter.name)?;
-        map.serialize_entry("description", &self.counter.description)?;
-        map.serialize_entry("mainThreadIndex", &self.main_thread_index)?;
-        map.serialize_entry("pid", &self.counter.pid)?;
-        map.serialize_entry(
-            "sampleGroups",
-            &[SerializableCounterSampleGroup(self.counter)],
-        )?;
-        map.end()
-    }
-}
-
-struct SerializableCounterSampleGroup<'a>(&'a Counter);
-
-impl<'a> Serialize for SerializableCounterSampleGroup<'a> {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut map = serializer.serialize_map(None)?;
-        map.serialize_entry("id", &0)?; // It's not clear what the meaning of this ID is.
-        map.serialize_entry("samples", &self.0.samples)?;
-        map.end()
-    }
-}
-
-#[derive(Debug)]
-struct CounterSamples {
-    time: Vec<Timestamp>,
-    number: Vec<u32>,
-    count: Vec<f64>,
-}
-
-impl CounterSamples {
-    pub fn new() -> Self {
-        Self {
-            time: Vec::new(),
-            number: Vec::new(),
-            count: Vec::new(),
-        }
-    }
-
-    pub fn add_sample(
-        &mut self,
-        timestamp: Timestamp,
-        value_delta: f64,
-        number_of_operations_delta: u32,
-    ) {
-        self.time.push(timestamp);
-        self.count.push(value_delta);
-        self.number.push(number_of_operations_delta);
-    }
-}
-
-impl Serialize for CounterSamples {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let len = self.time.len();
-        let mut map = serializer.serialize_map(None)?;
-        map.serialize_entry("length", &len)?;
-        map.serialize_entry("count", &self.count)?;
-        map.serialize_entry("number", &self.number)?;
-        map.serialize_entry("time", &self.time)?;
-        map.end()
-    }
-}

data/ext/cargo-vendor/fxprof-processed-profile-0.6.0/src/cpu_delta.rs

@@ -1,59 +0,0 @@
-use serde::ser::{Serialize, Serializer};
-use std::time::Duration;
-
-/// The amount of CPU time between thread samples.
-///
-/// This is used in the Firefox Profiler UI to draw an activity graph per thread.
-///
-/// A thread only runs on one CPU at any time, and can get scheduled off and on
-/// the CPU between two samples. The CPU delta is the accumulation of time it
-/// was running on the CPU.
-#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct CpuDelta {
-    micros: u64,
-}
-
-impl From<Duration> for CpuDelta {
-    fn from(duration: Duration) -> Self {
-        Self {
-            micros: duration.as_micros() as u64,
-        }
-    }
-}
-
-impl CpuDelta {
-    /// A CPU delta of zero.
-    pub const ZERO: Self = Self { micros: 0 };
-
-    /// Create a CPU delta from integer nanoseconds.
-    pub fn from_nanos(nanos: u64) -> Self {
-        Self {
-            micros: nanos / 1000,
-        }
-    }
-
-    /// Create a CPU delta from integer microseconds.
-    pub fn from_micros(micros: u64) -> Self {
-        Self { micros }
-    }
-
-    /// Create a CPU delta from float milliseconds.
-    pub fn from_millis(millis: f64) -> Self {
-        Self {
-            micros: (millis * 1_000.0) as u64,
-        }
-    }
-
-    /// Whether the CPU delta is zero.
-    pub fn is_zero(&self) -> bool {
-        self.micros == 0
-    }
-}
-
-impl Serialize for CpuDelta {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        // CPU deltas are serialized as float microseconds, because
-        // we set profile.meta.sampleUnits.threadCPUDelta to "µs".
-        self.micros.serialize(serializer)
-    }
-}

data/ext/cargo-vendor/fxprof-processed-profile-0.6.0/src/fast_hash_map.rs

@@ -1,5 +0,0 @@
-use fxhash::FxHasher;
-use std::collections::HashMap;
-use std::hash::BuildHasherDefault;
-
-pub type FastHashMap<K, V> = HashMap<K, V, BuildHasherDefault<FxHasher>>;

data/ext/cargo-vendor/fxprof-processed-profile-0.6.0/src/frame.rs

@@ -1,54 +0,0 @@
-use bitflags::bitflags;
-
-use crate::category::CategoryPairHandle;
-use crate::global_lib_table::LibraryHandle;
-use crate::profile::StringHandle;
-
-/// A part of the information about a single stack frame.
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
-pub enum Frame {
-    /// A code address taken from the instruction pointer.
-    ///
-    /// This code address will be resolved to a library-relative address using
-    /// the library mappings on the process which were specified using
-    /// [`Profile::add_lib_mapping`](crate::Profile::add_lib_mapping).
-    InstructionPointer(u64),
-    /// A code address taken from a return address
-    ///
-    /// This code address will be resolved to a library-relative address using
-    /// the library mappings on the process which were specified using
-    /// [`Profile::add_lib_mapping`](crate::Profile::add_lib_mapping).
-    ReturnAddress(u64),
-    /// A relative address taken from the instruction pointer which
-    /// has already been resolved to a `LibraryHandle`.
-    RelativeAddressFromInstructionPointer(LibraryHandle, u32),
-    /// A relative address taken from a return address which
-    /// has already been resolved to a `LibraryHandle`.
-    RelativeAddressFromReturnAddress(LibraryHandle, u32),
-    /// A string, containing an index returned by Profile::intern_string
-    Label(StringHandle),
-}
-
-/// All the information about a single stack frame.
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
-pub struct FrameInfo {
-    /// The absolute address or label of this frame.
-    pub frame: Frame,
-    /// The category pair of this frame.
-    pub category_pair: CategoryPairHandle,
-    /// The flags of this frame. Use `FrameFlags::empty()` if unsure.
-    pub flags: FrameFlags,
-}
-
-bitflags! {
-    /// Flags for a stack frame.
-    #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
-    pub struct FrameFlags: u32 {
-        /// Set on frames which are JavaScript functions.
-        const IS_JS = 0b00000001;
-
-        /// Set on frames which are not strictly JavaScript functions but which
-        /// should be included in the JS-only call tree, such as DOM API calls.
-        const IS_RELEVANT_FOR_JS = 0b00000010;
-    }
-}

data/ext/cargo-vendor/fxprof-processed-profile-0.6.0/src/frame_table.rs

@@ -1,166 +0,0 @@
-use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
-
-use crate::category::{
-    Category, CategoryHandle, CategoryPairHandle, SerializableSubcategoryColumn, Subcategory,
-};
-use crate::fast_hash_map::FastHashMap;
-use crate::frame::FrameFlags;
-use crate::func_table::{FuncIndex, FuncTable};
-use crate::global_lib_table::{GlobalLibIndex, GlobalLibTable};
-use crate::native_symbols::{NativeSymbolIndex, NativeSymbols};
-use crate::resource_table::ResourceTable;
-use crate::serialization_helpers::SerializableSingleValueColumn;
-use crate::thread_string_table::{ThreadInternalStringIndex, ThreadStringTable};
-
-#[derive(Debug, Clone, Default)]
-pub struct FrameTable {
-    addresses: Vec<Option<u32>>,
-    categories: Vec<CategoryHandle>,
-    subcategories: Vec<Subcategory>,
-    funcs: Vec<FuncIndex>,
-    native_symbols: Vec<Option<NativeSymbolIndex>>,
-    internal_frame_to_frame_index: FastHashMap<InternalFrame, usize>,
-}
-
-impl FrameTable {
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    pub fn index_for_frame(
-        &mut self,
-        string_table: &mut ThreadStringTable,
-        resource_table: &mut ResourceTable,
-        func_table: &mut FuncTable,
-        native_symbol_table: &mut NativeSymbols,
-        global_libs: &GlobalLibTable,
-        frame: InternalFrame,
-    ) -> usize {
-        let addresses = &mut self.addresses;
-        let funcs = &mut self.funcs;
-        let native_symbols = &mut self.native_symbols;
-        let categories = &mut self.categories;
-        let subcategories = &mut self.subcategories;
-        *self
-            .internal_frame_to_frame_index
-            .entry(frame.clone())
-            .or_insert_with(|| {
-                let frame_index = addresses.len();
-                let (address, location_string_index, native_symbol, resource) = match frame.location
-                {
-                    InternalFrameLocation::UnknownAddress(address) => {
-                        let location_string = format!("0x{address:x}");
-                        let s = string_table.index_for_string(&location_string);
-                        (None, s, None, None)
-                    }
-                    InternalFrameLocation::AddressInLib(address, lib_index) => {
-                        let res =
-                            resource_table.resource_for_lib(lib_index, global_libs, string_table);
-                        let lib = global_libs.get_lib(lib_index).unwrap();
-                        let native_symbol_and_name =
-                            lib.symbol_table.as_deref().and_then(|symbol_table| {
-                                let symbol = symbol_table.lookup(address)?;
-                                Some(
-                                    native_symbol_table.symbol_index_and_string_index_for_symbol(
-                                        lib_index,
-                                        symbol,
-                                        string_table,
-                                    ),
-                                )
-                            });
-                        let (native_symbol, s) = match native_symbol_and_name {
-                            Some((native_symbol, name_string_index)) => {
-                                (Some(native_symbol), name_string_index)
-                            }
-                            None => {
-                                let location_string = format!("0x{address:x}");
-                                (None, string_table.index_for_string(&location_string))
-                            }
-                        };
-                        (Some(address), s, native_symbol, Some(res))
-                    }
-                    InternalFrameLocation::Label(string_index) => (None, string_index, None, None),
-                };
-                let func_index =
-                    func_table.index_for_func(location_string_index, resource, frame.flags);
-                let CategoryPairHandle(category, subcategory_index) = frame.category_pair;
-                let subcategory = match subcategory_index {
-                    Some(index) => Subcategory::Normal(index),
-                    None => Subcategory::Other(category),
-                };
-                addresses.push(address);
-                categories.push(category);
-                subcategories.push(subcategory);
-                funcs.push(func_index);
-                native_symbols.push(native_symbol);
-                frame_index
-            })
-    }
-
-    pub fn as_serializable<'a>(&'a self, categories: &'a [Category]) -> impl Serialize + 'a {
-        SerializableFrameTable {
-            table: self,
-            categories,
-        }
-    }
-}
-
-struct SerializableFrameTable<'a> {
-    table: &'a FrameTable,
-    categories: &'a [Category],
-}
-
-impl<'a> Serialize for SerializableFrameTable<'a> {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let len = self.table.addresses.len();
-        let mut map = serializer.serialize_map(None)?;
-        map.serialize_entry("length", &len)?;
-        map.serialize_entry(
-            "address",
-            &SerializableFrameTableAddressColumn(&self.table.addresses),
-        )?;
-        map.serialize_entry("inlineDepth", &SerializableSingleValueColumn(0u32, len))?;
-        map.serialize_entry("category", &self.table.categories)?;
-        map.serialize_entry(
-            "subcategory",
-            &SerializableSubcategoryColumn(&self.table.subcategories, self.categories),
-        )?;
-        map.serialize_entry("func", &self.table.funcs)?;
-        map.serialize_entry("nativeSymbol", &self.table.native_symbols)?;
-        map.serialize_entry("innerWindowID", &SerializableSingleValueColumn((), len))?;
-        map.serialize_entry("implementation", &SerializableSingleValueColumn((), len))?;
-        map.serialize_entry("line", &SerializableSingleValueColumn((), len))?;
-        map.serialize_entry("column", &SerializableSingleValueColumn((), len))?;
-        map.serialize_entry("optimizations", &SerializableSingleValueColumn((), len))?;
-        map.end()
-    }
-}
-
-struct SerializableFrameTableAddressColumn<'a>(&'a [Option<u32>]);
-
-impl<'a> Serialize for SerializableFrameTableAddressColumn<'a> {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut seq = serializer.serialize_seq(Some(self.0.len()))?;
-        for address in self.0 {
-            match address {
-                Some(address) => seq.serialize_element(&address)?,
-                None => seq.serialize_element(&-1)?,
-            }
-        }
-        seq.end()
-    }
-}
-
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct InternalFrame {
-    pub location: InternalFrameLocation,
-    pub category_pair: CategoryPairHandle,
-    pub flags: FrameFlags,
-}
-
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub enum InternalFrameLocation {
-    UnknownAddress(u64),
-    AddressInLib(u32, GlobalLibIndex),
-    Label(ThreadInternalStringIndex),
-}