package sail

You can search for identifiers within the package.

in-package search v0.2.0

package sail

sail
- Anf
- Ast
- Ast_util
  - BE
  - BESet
  - Bindings
  - Id
  - IdSet
  - KBindings
  - KOpt
  - KOptMap
  - KOptSet
  - Kid
  - KidSet
  - Kind
  - NC
  - NCMap
  - Nexp
  - NexpMap
  - NexpSet
  - Typ
  - TypMap
- Bitfield
- C_backend
- Cgen_backend
- Constant_fold
  - StringMap
- Constant_propagation
- Constant_propagation_mutrec
- Constraint
- Elf_loader
- Error_format
- Graph
  - Make
    
    Ord
  - OrderedType
  - S
- Initial_check
- Interactive
- Interpreter
- Jib
- Jib_compile
  - Config
  - Make
    
    C
- Jib_interactive
- Jib_ir
  - Flat_ir_config
  - Flat_ir_formatter
  - Ir_formatter
    
    Config
    
    Make
    
    C
  - StringMap
- Jib_optimize
- Jib_smt
  - EventMap
  - IntSet
  - Make_optimizer
    
    S
  - Sequence
- Jib_ssa
  - IntSet
- Jib_util
  - CT
  - CTMap
  - CTSet
  - Name
  - NameCT
  - NameCTMap
  - NameCTSet
  - NameMap
  - NameSet
  - UBindings
  - UId
- Latex
  - StringSet
- Lexer
  - M
- Manifest
- Monomorphise
- Nl_flow
- Ocaml_backend
- Optimize
- Parse_ast
- Parser
- Parser_combinators
- Pattern_completeness
- Pretty_print
- Pretty_print_common
- Pretty_print_coq
  - StringSet
- Pretty_print_lem
  - StringSet
- Pretty_print_sail
- Process_file
- Profile
- Property
  - Event
- Reporting
- Rewriter
- Rewrites
- Sail2_values
- Sail_lib
  - BitType
  - Mem
- Scattered
- Smtlib
- Spec_analysis
- Specialize
- State
- ToFromInterp_backend
- ToFromInterp_lib_bitlist
  - Make
    
    BitT
- ToFromInterp_lib_mword
- Type_check
  - Env
- Type_error
- Util
- Value
  - StringMap

Legend:
Library
Module
Module type
Parameter
Class
Class type

val symbol_generator : string -> (unit -> Ast.id) * (unit -> unit)

val instr_counter : int Stdlib.ref

val instr_number : unit -> int

val idecl : ?loc:Parse_ast.l -> Jib.ctyp -> Jib.name -> Jib.instr

val ireset : ?loc:Parse_ast.l -> Jib.ctyp -> Jib.name -> Jib.instr

val iinit : ?loc:Parse_ast.l -> Jib.ctyp -> Jib.name -> Jib.cval -> Jib.instr

val iif : 
  Parse_ast.l ->
  Jib.cval ->
  Jib.instr list ->
  Jib.instr list ->
  Jib.ctyp ->
  Jib.instr

val ifuncall : 
  ?loc:Parse_ast.l ->
  Jib.clexp ->
  (Ast.id * Jib.ctyp list) ->
  Jib.cval list ->
  Jib.instr

val iextern : 
  ?loc:Parse_ast.l ->
  Jib.clexp ->
  (Ast.id * Jib.ctyp list) ->
  Jib.cval list ->
  Jib.instr

val icall : 
  ?loc:Parse_ast.l ->
  Jib.clexp ->
  bool ->
  (Ast.id * Jib.ctyp list) ->
  Jib.cval list ->
  Jib.instr

val icopy : Parse_ast.l -> Jib.clexp -> Jib.cval -> Jib.instr

val iclear : ?loc:Parse_ast.l -> Jib.ctyp -> Jib.name -> Jib.instr

val ireturn : ?loc:Parse_ast.l -> Jib.cval -> Jib.instr

val iend : ?loc:Parse_ast.l -> unit -> Jib.instr

val iblock : ?loc:Parse_ast.l -> Jib.instr list -> Jib.instr

val itry_block : ?loc:Parse_ast.l -> Jib.instr list -> Jib.instr

val ithrow : Parse_ast.l -> Jib.cval -> Jib.instr

val icomment : ?loc:Parse_ast.l -> string -> Jib.instr

val ilabel : ?loc:Parse_ast.l -> string -> Jib.instr

val igoto : ?loc:Parse_ast.l -> string -> Jib.instr

val iundefined : ?loc:Parse_ast.l -> Jib.ctyp -> Jib.instr

val imatch_failure : ?loc:Parse_ast.l -> unit -> Jib.instr

val iraw : ?loc:Parse_ast.l -> string -> Jib.instr

val ijump : Parse_ast.l -> Jib.cval -> string -> Jib.instr

module Name : sig ... end

module NameSet : sig ... end

module NameMap : sig ... end

val current_exception : Jib.name

val have_exception : Jib.name

val throw_location : Jib.name

val return : Jib.name

val name : Ast.id -> Jib.name

val global : Ast.id -> Jib.name

val cval_rename : Jib.name -> Jib.name -> Jib.cval -> Jib.cval

val clexp_rename : Jib.name -> Jib.name -> Jib.clexp -> Jib.clexp

val instr_rename : Jib.name -> Jib.name -> Jib.instr -> Jib.instr

val string_of_name : 
  ?deref_current_exception:bool ->
  ?zencode:bool ->
  Jib.name ->
  string

val string_of_op : Jib.op -> string

val string_of_ctyp : Jib.ctyp -> string

val string_of_uid : (Ast.id * Jib.ctyp list) -> string

val full_string_of_ctyp : Jib.ctyp -> string

val string_of_value : Value2.vl -> string

val string_of_cval : Jib.cval -> string

val map_ctyp : (Jib.ctyp -> Jib.ctyp) -> Jib.ctyp -> Jib.ctyp

val ctyp_equal : Jib.ctyp -> Jib.ctyp -> bool

val ctyp_compare : Jib.ctyp -> Jib.ctyp -> int

module CT : sig ... end

module CTSet : sig ... end

module CTMap : sig ... end

module UId : sig ... end

module UBindings : sig ... end

val ctyp_unify : Jib.ctyp -> Jib.ctyp -> Jib.ctyp list

val ctyp_suprema : Jib.ctyp -> Jib.ctyp

val ctyp_ids : Jib.ctyp -> Ast_util.IdSet.t

val unpoly : Jib.cval -> Jib.cval

val is_polymorphic : Jib.ctyp -> bool

val cval_deps : Jib.cval -> NameSet.t

val clexp_deps : Jib.clexp -> NameSet.t * NameSet.t

val instr_deps : Jib.instr_aux -> NameSet.t * NameSet.t

module NameCT : sig ... end

module NameCTSet : sig ... end

module NameCTMap : sig ... end

val clexp_typed_writes : Jib.clexp -> NameCTSet.t

val instr_typed_writes : Jib.instr -> NameCTSet.t

val map_clexp_ctyp : (Jib.ctyp -> Jib.ctyp) -> Jib.clexp -> Jib.clexp

val map_cval_ctyp : (Jib.ctyp -> Jib.ctyp) -> Jib.cval -> Jib.cval

val map_instr_ctyp : (Jib.ctyp -> Jib.ctyp) -> Jib.instr -> Jib.instr

val map_instr : (Jib.instr -> Jib.instr) -> Jib.instr -> Jib.instr

val concatmap_instr : 
  (Jib.instr -> Jib.instr list) ->
  Jib.instr ->
  Jib.instr list

val iter_instr : (Jib.instr -> unit) -> Jib.instr -> unit

val cdef_map_instr : (Jib.instr -> Jib.instr) -> Jib.cdef -> Jib.cdef

val cdef_concatmap_instr : 
  (Jib.instr -> Jib.instr list) ->
  Jib.cdef ->
  Jib.cdef

val ctype_def_map_ctyp : 
  (Jib.ctyp -> Jib.ctyp) ->
  Jib.ctype_def ->
  Jib.ctype_def

val cdef_map_ctyp : (Jib.ctyp -> Jib.ctyp) -> Jib.cdef -> Jib.cdef

val map_instrs : (Jib.instr list -> Jib.instr list) -> Jib.instr -> Jib.instr

val map_instr_list : 
  (Jib.instr -> Jib.instr) ->
  Jib.instr list ->
  Jib.instr list

val map_instrs_list : 
  (Jib.instr list -> Jib.instr list) ->
  Jib.instr list ->
  Jib.instr list

val instr_ids : Jib.instr -> NameSet.t

val instr_reads : Jib.instr -> NameSet.t

val instr_writes : Jib.instr -> NameSet.t

val filter_instrs : (Jib.instr -> bool) -> Jib.instr list -> Jib.instr list

val label_counter : int Stdlib.ref

val label : string -> string

val infer_call : Jib.op -> Jib.cval list -> Jib.ctyp

val cval_ctyp : Jib.cval -> Jib.ctyp

val clexp_ctyp : Jib.clexp -> Jib.ctyp

val instr_ctyps : Jib.instr -> CTSet.t

val instrs_ctyps : Jib.instr list -> CTSet.t

val ctype_def_ctyps : Jib.ctype_def -> Jib.ctyp list

val cdef_ctyps : Jib.cdef -> CTSet.t

val c_ast_registers : 
  Jib.cdef list ->
  (Ast.id * Jib.ctyp * Jib.instr list) list

val instr_split_at : ('a -> bool) -> 'a list -> 'a list * 'a list

val instrs_rename : Jib.name -> Jib.name -> Jib.instr list -> Jib.instr list