Module dump 

Heap dump module for rune. After a successful bootstrap in which elisp code is converted to bytecode, the VM heap memory can be serialized to a rune.pdmp file, and subsequent runs can avoid bootstrapping and just load rune.pdmp instead.

The idea is based on emacs’ portable dumper (pdump) which replaced the older unexec. However, this pdmp format is a somewhat human-readable text format and makes no attempt to have any compatibility with unexec or pdump. https://lwn.net/Articles/707619/ https://github.com/emacs-mirror/emacs/blob/master/src/pdumper.h

Structs

DumpFile 🔒

Deserialized contents of a .pdmp file.

DumpState 🔒

DumpedBinding 🔒

An entry in the env section: a variable binding from symbol to value.

DumpedSymbol 🔒

An entry in the symbol table section: name -> (symbol object id, optional function object id)

Enums

DumpedObject 🔒

A serialized representation of a single GC object, decoupled from live pointers. Children are referenced by ObjId rather than raw addresses.

Functions

dump_to_file 🔒

escape_str 🔒

extract_field 🔒

Extract value between key and delim (or end of string).

fmt_id_list 🔒

load_dump 🔒

parse_binding_line 🔒

Parse @{sym_id} = @{val_id}.

parse_bytefn 🔒

parse_dump 🔒

parse_field_ref 🔒

Parse prefix{id} from the start of s.

parse_hex_bytes 🔒

parse_object_line 🔒

Parse @{id} {type} {fields...} into (ObjId, DumpedObject).

parse_quoted_string 🔒

Parse "escaped string" and return the unescaped content.

parse_quoted_string_rest 🔒

Parse "escaped string" rest... returning (unescaped, rest).

parse_ref 🔒

Parse @{id} returning the id.

parse_ref_list 🔒

Parse space-separated @id @id ... list.

parse_symbol_line 🔒

Parse "name" -> @{id} or "name" -> @{id} func=@{fid}.

subr_registry 🔒

Registry mapping SubrFn names to their static references. Used by the loader to reconstruct function pointers from dump files. We serialize the name since Rust fn pointer names can’t be serialized, and look it up here on load.

Type Aliases

ObjId 🔒

Unique id for each object pointer, used to handle cycles and sharing.