Module `Mc_main`

val mc_man : string

val objdump_man : string

type error =

| Bad_user_input
| Bad_insn of Bap.Std.mem * int * int
| Create_mem of Core_kernel.Error.t
| No_input
| Invalid_base of string
| Trailing_data of int
| Inconsistency of Bap_core_theory.KB.conflict
| Unknown_format of string * string * string list
| No_formats_expected of string
| Disassembler_failed of Core_kernel.Error.t
| Loader_failed of Core_kernel.Error.t
| Target_must_be_unknown
| Encoding_must_be_unknown
| Triple_must_not_be_set
| Arch_must_not_be_set
| Backend_must_not_be_set
| Cpu_must_not_be_set
| Bits_must_not_be_set
| Order_must_not_be_set

type Bap_main.Extension.Error.t +=

| Fail of error

type output = [

| `insn
| `bil
| `bir
| `sema
| `kinds
| `size
| `invalid
| `addr
| `memory
| `knowledge

]

val compare_output : output -> output -> int

val all_of_output : output list

type target =

| Target of {
1. name : Bap_core_theory.Theory.Target.t;
2. encoding : Bap_core_theory.Theory.Language.t;
}
| Triple of {
1. name : string;
2. backend : string option;
3. cpu : string option;
4. order : Bap.Std.endian;
5. bits : int;
}

val fail : error -> ('a, Bap_main.Extension.Error.t) Core_kernel._result

val enabled : string

module Spec : sig ... end

module Dis = Bap.Std.Disasm_expert.Basic

val bad_insn : 
  Bap.Std.Addr.t ->
  ('a, 'b, 'c, 'd) Dis.state ->
  int ->
  ('e, Bap_main.Extension.Error.t) Core_kernel._result

val escape_0x : string -> string

val prepend_slash_x : string -> string

val to_binary : 
  ?map:(Core_kernel.String.t -> Core_kernel.String.t) ->
  Core_kernel.String.t ->
  (string, Bap_main.Extension.Error.t) Core_kernel.Result.t

to_binary ?escape s make a binary string from ascii representation, (e.g., "\x01\x02..."). Apply optional escape function for each byte

val read_input : 
  Base.string list ->
  (string, Bap_main.Extension.Error.t) Core_kernel._result

val endian : target -> Bap.Std.endian

val create_memory : 
  target ->
  Base.string ->
  Bap.Std.addr ->
  (Bap.Std.Memory.t, Bap_main.Extension.Error.t) Core_kernel._result

val print_kinds : 
  'a list ->
  ('b, Bap.Std.Disasm_expert.Basic.kinds) Dis.Insn.t ->
  unit

val new_insn : 
  target ->
  Bap.Std.mem ->
  Bap.Std.Disasm_expert.Basic.full_insn ->
  Bap_core_theory.Theory.program Bap_core_theory.KB.obj
    Bap_knowledge.Knowledge.t

val lift : 
  target ->
  Bap.Std.mem ->
  Bap.Std.Disasm_expert.Basic.full_insn ->
  (Bap.Std.Insn.t, Bap_main.Extension.Error.t) Core_kernel._result

val print_insn_size : 'a list -> Bap.Std.Memory.t -> unit

val print_insn_addr : 'a list -> Bap.Std.Memory.t -> unit

val print_insn_memory : 'a list -> Bap.Std.Memory.t -> unit

val print_knowledge : 'a list -> unit

val print_insn : string list -> Bap.Std.Insn.t -> unit

val print_bil : string list -> Bap.Std.Insn.t -> unit

val print_bir : string list -> Bap.Std.insn -> unit

val print_sema : string list -> 'a Bap_knowledge.Knowledge.value -> unit

val equal_output : output -> output -> bool

val is_enabled : Core_kernel.String.t list -> bool

val formats : (output, 'a list) Core_kernel.List.Assoc.t -> output -> 'a list

val print : 
  target ->
  Bap.Std.Memory.t ->
  Bap.Std.Disasm_expert.Basic.full_insn ->
  ([> `addr
   | `bil
   | `bir
   | `insn
   | `kinds
   | `knowledge
   | `memory
   | `sema
   | `size ] ->
    string list) ->
  (unit, Bap_main.Extension.Error.t) Base.Result.t

val bits : target -> int

val parse_base : 
  target ->
  string ->
  (Bap.Std.Word.t, Bap_main.Extension.Error.t) Core_kernel.Result.t

val create_disassembler : 
  target ->
  ((Dis.empty, Dis.empty) Dis.t, Bap_main.Extension.Error.t)
    Core_kernel.Result.t

val module_of_kind : [< `bil | `bir | `insn ] -> string

val validate_module : 
  [< `bil | `bir | `insn ] ->
  Core_kernel.String.t list ->
  (unit, error) Core_kernel.Result.t

val validate_formats : 
  ([< `addr
   | `bil
   | `bir
   | `insn
   | `invalid
   | `kinds
   | `knowledge
   | `memory
   | `sema
   | `size ]
   * Core_kernel.String.t list)
    list ->
  (unit, Bap_main.Extension.Error.t) Core_kernel.Result.t

val print_invalid : 'a -> unit

val run : 
  ?only_one:bool ->
  ?stop_on_error:bool ->
  ('a, 'b) Dis.t ->
  target ->
  Bap.Std.Memory.t ->
  ([> `addr
   | `bil
   | `bir
   | `insn
   | `invalid
   | `kinds
   | `knowledge
   | `memory
   | `sema
   | `size ] ->
    Core_kernel.String.t list) ->
  (int, Bap_main.Extension.Error.t) Core_kernel._result

val check_invariants : 
  (bool * (unit, 'a) Core_kernel.Result.t list) list ->
  (unit, 'a) Core_kernel.Result.t

val check : 
  ('a -> bool) ->
  'a ->
  error ->
  (unit, Bap_main.Extension.Error.t) Core_kernel._result

val target_must_be_unknown : 
  Bap_core_theory.Theory.Target.t ->
  (unit, Bap_main.Extension.Error.t) Core_kernel._result

val encoding_must_be_unknown : 
  Bap_core_theory.Theory.Language.t ->
  (unit, Bap_main.Extension.Error.t) Core_kernel._result

val triple_must_not_be_set : 
  'a option ->
  (unit, Bap_main.Extension.Error.t) Core_kernel._result

val arch_must_not_be_set : 
  'a option ->
  (unit, Bap_main.Extension.Error.t) Core_kernel._result

val backend_must_not_be_set : 
  'a option ->
  (unit, Bap_main.Extension.Error.t) Core_kernel._result

val cpu_must_not_be_set : 
  'a option ->
  (unit, Bap_main.Extension.Error.t) Core_kernel._result

val bits_must_not_be_set : 
  'a option ->
  (unit, Bap_main.Extension.Error.t) Core_kernel._result

val order_must_not_be_set : 
  'a option ->
  (unit, Bap_main.Extension.Error.t) Core_kernel._result

val compute_target : 
  (Bap_core_theory.Theory.Unit.t -> unit Bap_knowledge.Knowledge.t) ->
  target

val target_of_arch : string -> int option -> Bap.Std.endian option -> target

val make_triple : 
  ?bits:int ->
  ?order:Bap.Std.endian ->
  ?backend:string ->
  ?cpu:string ->
  string ->
  target

val make_target : 
  Bap_core_theory.Theory.Target.t ->
  Bap_core_theory.Theory.Language.t ->
  target

val parse_arch : 
  string option ->
  Bap_core_theory.Theory.Target.t ->
  Bap_core_theory.Theory.Language.t ->
  string option ->
  string option ->
  string option ->
  int option ->
  Bap.Std.endian option ->
  (target, Bap_main.Extension.Error.t) Base.Result.t

val format_info : (unit -> (string * 'a * 'b) list) -> string

val string_of_failure : error -> string

package bap-mc

Module Mc_main

Module `Mc_main`