package binsec

You can search for identifiers within the package.

in-package search v0.2.0

Semantic analysis of binary executables

Install

Dune Dependency

binsec.github.io Readme Changelog LGPL-2.1-or-later License Edit opam file Versions (18)

Authors

Maintainers

B

BINSEC <binsec@saxifrage.saclay.cea.fr>

Sources

binsec-0.6.0.tbz

sha256=e9101e68d317c837d5cff9608c6fba2127dd31ef6373b9b90806780c1d80bb52

sha512=c01af277239b8cc84fb904c301897f7d2388a8c850c7cb6a53acb8a4f8d51115c8a595c5517843d076421a76f4b2becb16e722b4c90f19a8fa208cce5f3ba274

doc/binsec/Binsec/Term/index.html

Module `Binsec.Term`

type size = int

type 'a interval = 'a Interval.t = {

lo : 'a;
hi : 'a;

}

type endianness = Machine.endianness =

| LittleEndian
| BigEndian

type unary =

| U

and binary =

| B

type _ operator =

| Not : unary operator
| Sext : size -> unary operator
| Uext : size -> unary operator
| Restrict : int interval -> unary operator
| Plus : binary operator
| Minus : _ operator
| Mul : binary operator
| Udiv : binary operator
| Umod : binary operator
| Sdiv : binary operator
| Smod : binary operator
| Or : binary operator
| And : binary operator
| Xor : binary operator
| Concat : binary operator
| Lsl : binary operator
| Lsr : binary operator
| Asr : binary operator
| Rol : binary operator
| Ror : binary operator
| Eq : binary operator
| Diff : binary operator
| Ule : binary operator
| Ult : binary operator
| Uge : binary operator
| Ugt : binary operator
| Sle : binary operator
| Slt : binary operator
| Sge : binary operator
| Sgt : binary operator

val pp_op : Format.formatter -> _ operator -> unit

module Bv : sig ... end

type cst =

| C

and loc =

| L

and exp =

| E

type (_, _, 'a, 'b) t = private

| Var : {
1. hash : int;
2. size : size;
3. name : string;
4. label : 'a;
} -> (exp, _, 'a, _) t
| Load : {
1. hash : int;
2. len : size;
3. dir : endianness;
4. addr : (exp, exp, 'a, 'b) t;
5. label : 'b;
} -> (exp, _, 'a, 'b) t
| Cst : Bitvector.t -> (_, exp, _, _) t
| Unary : {
1. hash : int;
2. size : size;
3. f : unary operator;
4. x : (exp, exp, 'a, 'b) t;
} -> (exp, exp, 'a, 'b) t
| Binary : {
1. hash : int;
2. size : size;
3. f : binary operator;
4. x : (exp, exp, 'a, 'b) t;
5. y : (exp, exp, 'a, 'b) t;
} -> (exp, exp, 'a, 'b) t
| Ite : {
1. hash : int;
2. size : size;
3. c : (exp, exp, 'a, 'b) t;
4. t : (exp, exp, 'a, 'b) t;
5. e : (exp, exp, 'a, 'b) t;
} -> (exp, exp, 'a, 'b) t

module type S = sig ... end

module Make
  (A : Sigs.HASHABLE)
  (B : Sigs.HASHABLE) : 
  S with type a := A.t and type b := B.t

val to_exp : (_, _, 'a, 'b) t -> (exp, exp, 'a, 'b) t

Conversion

*

val to_loc : (_, _, 'a, 'b) t -> (exp, loc, 'a, 'b) t option

val to_loc_exn : (_, _, 'a, 'b) t -> (exp, loc, 'a, 'b) t

val to_cst : (_, _, _, _) t -> (cst, exp, _, _) t option

val to_cst_exn : (_, _, _, _) t -> (cst, exp, _, _) t

val pp : Format.formatter -> (_, _, _, _) t -> unit

Debug

*