package bap-std

  1. Overview
  2. Docs
package bap-std
Legend:
Library
Module
Module type
Parameter
Class
Class type

Binary Image.

Type definitions

type t = image

image

val sexp_of_t : t -> Sexplib0.Sexp.t
type segment

segment

symbol

val bin_shape_segment : Core_kernel.Bin_prot.Shape.t
val __bin_read_segment__ : (int -> segment) Core_kernel.Bin_prot.Read.reader
val compare_segment : segment -> segment -> int
val sexp_of_segment : segment -> Sexplib0.Sexp.t
val segment_of_sexp : Sexplib0.Sexp.t -> segment
type symbol

symbol

val bin_shape_symbol : Core_kernel.Bin_prot.Shape.t
val __bin_read_symbol__ : (int -> symbol) Core_kernel.Bin_prot.Read.reader
val compare_symbol : symbol -> symbol -> int
val sexp_of_symbol : symbol -> Sexplib0.Sexp.t
val symbol_of_sexp : Sexplib0.Sexp.t -> symbol
type path = string

Constructing

constructing an image can result in actual image and a set (hopefully empty) of errors occurred in a process of decoding an image, that do not prevent us from actually creating an image. So, this information messages can be considered as warnings.

val create : ?backend:string -> path -> result

create ?backend filename creates an image of the file specified by the filename. If backend is not specified, then all availabe backends are used and their information is merged. If the information provided by all backends agree (i.e., there's no conflicting information), then image is returned. If backend is an explicit file path, then it is read as an OGRE file and used for loading. Otherwise, backend should be a name of one of the backends registered either with register_backend or register_loader. See available_backends for the list of available backends.

  • since 2.5.0 accepts backend accepts an explicit file path,

note a file path is explicit if it exists and Fn.non Filename.is_implicit.

val of_string : ?backend:string -> string -> result

of_string ?backend ~data creates an image from the specified data. See create for backend parameter.

val of_bigstring : ?backend:string -> Core_kernel.Bigstring.t -> result

of_bigstring ?backend ~data creates an image from the specified data. See create for backend parameter.

Attributes

val entry_point : t -> addr

entry_point addr is an address from which a kernel should start

val filename : t -> string option

filename image a name of file from which an image was loaded (if any)

val arch : t -> arch

arch image code architecture

val addr_size : t -> addr_size

addr_size image same as Arch.addr_size (Image.arch image)

val endian : t -> endian

endian image same as Arch.endian (Image.arch image)

Tables

val words : t -> size -> word table

words image size returns a mapping from addresses to words of the specified size. For example, Image.words img `r8 returns all bytes.

val segments : t -> segment table

segments image returns a mapping from addresses to segments

val symbols : t -> symbol table

symbols image returns a mapping from addresses to symbols

Tags

val segment : segment tag

tags a segment

val symbol : string tag

tags a symbol

val section : string tag

tags a section

val code_region : unit tag

tags a code region

val specification : Ogre.doc tag

an image specification in OGRE

val memory : t -> value memmap

returns memory, annotated with tags

Mappings

val memory_of_segment : t -> segment -> mem

memory_of_segment img seg returns a memory region occupied by the segment seg.

val memory_of_symbol : t -> symbol -> mem * mem seq

memory_of_symbol sym returns a sequence of memory regions that belong to the sym symbol. The sequence is represented as a pair, where the first element is the starting memory region, and the second elemnt is (a possible empty) sequence of the rest memory regions (in case if a symbol occupies a non-contigious region of memory).

val symbols_of_segment : t -> segment -> symbol seq

symbols_of_segment img seg all symbols that belong to the seg segment.

val segment_of_symbol : t -> symbol -> segment

segment_of_symbol image sym a segment to which sym belongs.

module Spec : sig ... end

Interface to the image specification.

module Segment : sig ... end

Image Segments. Segment is a contiguous region of memory that has permissions. The same as segment in ELF.

module Symbol : sig ... end

Symbol.

Backend Interface

module type Loader = sig ... end

An interface that a backend shall implement.

val register_loader : name:string -> (module Loader) -> unit

register_loader ~name backend registers new loader.

val find_loader : string -> (module Loader) option

find_loader name lookups the loader registered under the given name.

  • since 2.2.0
val available_backends : unit -> string list

lists all registered backends

val register_backend : name:string -> Backend.t -> [ `Ok | `Duplicate ]

register_backend ~name backend tries to register backend under the specified name.

  • deprecated

    use register_loader instead

Internals

Access to the low-level internals.

data image returns image data. Usually it is a memory mapped input file, or it is whatever was passed to of_[big]string.

val spec : t -> Ogre.doc

spec image returns the image specification.

  • since 1.3
module Scheme : sig ... end

A scheme of image specification.

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct