Theory.Endianness
Defines how multibyte words are stored in the memory.
The number of variants are essentially infinite, given that there is an infinite number of variants of the byte and word sizes, but the two orderings are the most common: little and big endian. More orderings could be declared when necessary.
In the big endian ordering the most significant byte of the word is stored at the smallest address.
include KB.Enum.S with type t = endianness
type t = endianness
declare ?package name
declares a new element of the enumeration.
Fails if the name is already declared.
val declare : ?package:string -> string -> t
declare ?package name
declares a new element of the enumeration.
Fails if the name is already declared.
val read : ?package:string -> string -> t
read ?package name
reads the element from its textual representation.
Fails if the name doesn't represent a previously declared element of the enumeration.
If name
is unqualified then package
is used as the package name. The package
itself defaults to "user"
.
See also of_string s
from the Stringable
interface which is equal to read s
val name : t -> Bap_knowledge.Knowledge.Name.t
name x
is the name that corresponds to the element x
val unknown : t
unknown
is the placeholder for unknown element.
val is_unknown : t -> bool
is_unknown t
is true if t
is unknown
.
val domain : t Bap_knowledge.Knowledge.domain
domain
the type class implementing the domain structure.
Each enumeration type forms a flat domain with the unknown
element at the bottom.
val persistent : t Bap_knowledge.Knowledge.persistent
persistent
the persistance type class.
The enumeration types are persistent and are derived from the KB.Name.persistent
type class, i.e., they are represented as 63-bit numbers.
val hash : t -> int
the hash value of the enum
val members : unit -> t list
members ()
the list of all members of the enumeration type.
include Base.Comparable.S with type t := t
val comparator : (t, comparator_witness) Base__.Comparator.comparator
include Core_kernel.Binable.S with type t := t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
include Core_kernel.Pretty_printer.S with type t := t
val pp : Base__.Formatter.t -> t -> unit
val eb : endianness
In the big endian ordering the most significant byte of the word is stored at the smallest address.
val le : endianness
In the little endian ordering the least significant byte of the word is stored at the largest address.
val bi : endianness
In the bi-endian order the endianness is essentially unspecified and depends on the execution context, e.g., on the status register or memory page descriptor.