Module Legacy_partitioning.Make

module Make: State_partitioning.Partitioning 

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.