module type Partition =sig
..end
type
loop
Loops identifiers
type
state
The states being partitioned
type
store
The storage of a partition
type
propagation
Only contains states which needs to be propagated, i.e. states which have not been propagated yet
type
shadow
The shadow of a propagation remembers all the previous propagations ; shadows are useful before joins during descending sequences or to find if a transition is fireable
type
widening
Widening informations
val empty_store : stmt:Cil_types.stmt option -> store
val empty_propagation : unit -> propagation
val empty_shadow : unit -> shadow
val empty_widening : stmt:Cil_types.stmt option -> widening
val initial_propagation : state list ->
propagation
Build the initial propagation for the entry point of a function.
val pretty_store : Stdlib.Format.formatter -> store -> unit
val pretty_propagation : Stdlib.Format.formatter -> propagation -> unit
val expanded : store -> state list
val smashed : store ->
state Bottom.Type.or_bottom
val is_empty_store : store -> bool
val is_empty_propagation : propagation -> bool
val is_empty_shadow : shadow -> bool
val store_size : store -> int
val propagation_size : propagation -> int
val reset_store : store -> unit
val reset_propagation : propagation -> unit
val reset_shadow : shadow -> unit
val reset_widening : widening -> unit
val enter_loop : propagation ->
loop -> unit
val leave_loop : propagation ->
loop -> unit
val next_loop_iteration : propagation ->
loop -> unit
val clear_propagation : propagation -> unit
Remove all states from the propagation, leaving it empty as if it was just
created by empty_propagation
val transfer : (state list ->
state list) ->
propagation -> unit
Apply a transfer function to all the states of a propagation.
val merge : into:propagation ->
propagation -> unit
Merge two propagations together, modifying into
inplace. At the return
of the function, into
should contain all the states of both original
propagations, or an overapproximation of this union: joining two states
together inside the propagation is allowed.
val join : (propagation *
shadow)
list ->
store ->
propagation
Join all incoming propagations into the given store. Each propagation is paired with a shadow of the previous propagations on the same edge. This function returns a set of states which still need to be propagated past the store.
If a state from the propagations is included in another state which has already been propagated, it may be removed from the output propagation. Likewise, if a state from a propagation is included in a state from another propagation of the list (coming from another edge or iteration), it may also be removed.
This function also interprets partitioning annotations at the store vertex (slevel, splits, merges, ...) which will generally change the current partitioning.
val widen : store ->
widening ->
propagation -> bool
Widen a propagation at the position of the given store. The widening object keeps track of the previous widenings to ensure termination. The result is true when it is correct to end the propagation here, i.e. when the current propagation is only carrying states which are included into already propagated states.
Note that the propagation given to widen
*must* have been produced by
the join
on the same store.