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
| Unknown_arch
| 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

type Bap_main.Extension.Error.t +=

| Fail of error

type output = [

| `insn
| `bil
| `bir
| `sema
| `kinds
| `size
| `invalid

]

val compare_output : output -> output -> 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 : Core_kernel.String.t -> Core_kernel.String.t

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 : 
  Core_kernel.String.t list ->
  (string, Bap_main.Extension.Error.t) Core_kernel._result

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

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

val new_insn : 
  Bap.Std.Arch.t ->
  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 : 
  Bap.Std.Arch.t ->
  Bap.Std.mem ->
  Bap.Std.Disasm_expert.Basic.full_insn ->
  (Bap_core_theory.Theory.Program.Semantics.t, Bap_main.Extension.Error.t)
    Core_kernel._result

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

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

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

val print_bir : string Core_kernel.List.t -> 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 : 
  Bap.Std.Arch.t ->
  Bap.Std.Memory.t ->
  Bap.Std.Disasm_expert.Basic.full_insn ->
  ([> `bil | `bir | `insn | `kinds | `sema | `size ] ->
    string Core_kernel.List.t) ->
  (unit, Bap_main.Extension.Error.t) Base.Result.t

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

val create_disassembler : 
  ?backend:string ->
  Bap.Std.Arch.t ->
  ((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 Core_kernel.List.t ->
  (unit, error) Core_kernel.Result.t

val validate_formats : 
  ([< `bil | `bir | `insn | `invalid | `kinds | `sema | `size ]
   * Core_kernel.String.t Core_kernel.List.t)
    Core_kernel.List.t ->
  (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 ->
  Bap.Std.Arch.t ->
  Bap.Std.Memory.t ->
  ([> `bil | `bir | `insn | `invalid | `kinds | `sema | `size ] ->
    Core_kernel.String.t Core_kernel.List.t) ->
  (int, Bap_main.Extension.Error.t) Core_kernel._result

val format_info : 
  (unit -> (Core_kernel.String.t * 'a * 'b) Core_kernel.List.t) ->
  Core_kernel.String.t

val string_of_failure : error -> string

package bap-mc

Module Mc_main

Module `Mc_main`