A |
| add [Loop_analysis.Binary] |
|
| add [State_builder.Hashtbl] |
Add a new binding.
|
| add [Set.S] |
add x s returns a set containing all elements of s,
plus x.
|
| add_loop_bound [Loop_analysis] |
|
| add_path_bounds [Slevel_analysis.Specific] |
|
| after [Region_analysis.Make] |
|
| all_nodes [Region_analysis_sig.Node.Graph] |
|
| analyze [Register] |
|
| analyze [Slevel_analysis] |
|
| analyze [Loop_analysis] |
|
B |
| binary_compare [Loop_analysis.Binary] |
|
| bottom [Loop_analysis.Store] |
|
| bottom [Loop_analysis.Binary] |
|
C |
| cardinal [Set.S] |
Return the number of elements of a set.
|
| choose [Set.S] |
Return one element of the given set, or raise Not_found if
the set is empty.
|
| clear [State_builder.Hashtbl] |
Clear the table.
|
| compare [Set.S] |
Total ordering between sets.
|
| compile_node [Slevel_analysis.Specific] |
|
| compile_node [Loop_analysis.Store] |
|
| compile_node [Region_analysis_sig.Node] |
|
| cond_compare [Loop_analysis.Binary] |
|
| copy [Region_analysis_sig.Node.Dict] |
|
| create [Region_analysis_sig.Node.Edge_Dict] |
|
| create [Region_analysis_sig.Node.Dict] |
|
D |
| diff [Set.S] |
Set difference.
|
| display_results [Slevel_analysis] |
|
| do_guard [Loop_analysis.Store] |
|
| do_instr [Loop_analysis.Store] |
|
| dominates [Region_analysis_sig.Node.DomTree] |
|
| domtree_postfix_iter [Region_analysis_sig.Node.DomTree] |
|
| dummy [Cil_datatype.Varinfo] |
|
E |
| elements [Set.S] |
Return the list of all elements of the given set.
|
| empty [Set.S] |
The empty set.
|
| entry_node [Region_analysis_sig.Node.Graph] |
|
| equal [Set.S] |
equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
| exists [Set.S] |
exists p s checks if at least one element of
the set satisfies the predicate p.
|
| exit_nodes [Region_analysis_sig.Node.Graph] |
|
F |
| filter [Set.S] |
filter p s returns the set of all elements in s
that satisfy predicate p.
|
| find [State_builder.Hashtbl] |
Return the current binding of the given key.
|
| find [Set.S] |
find x s returns the element of s equal to x (according
to Ord.compare), or raise Not_found if no such element
exists.
|
| find_all [State_builder.Hashtbl] |
Return the list of all data associated with the given key.
|
| fold [State_builder.Hashtbl] |
|
| fold [Set.S] |
fold f s a computes (f xN ... (f x2 (f x1 a))...),
where x1 ... xN are the elements of s, in increasing order.
|
| fold_sorted [State_builder.Hashtbl] |
|
| for_all [Set.S] |
for_all p s checks if all elements of the set
satisfy the predicate p.
|
G |
| get [Region_analysis_sig.Node.Edge_Dict] |
|
| get [Region_analysis_sig.Node.Dict] |
|
| get_range [Parameter_sig.Int] |
What is the possible range of values for this parameter.
|
I |
| incr [Parameter_sig.Int] |
Increment the integer.
|
| init [Loop_analysis.Store] |
|
| inter [Set.S] |
Set intersection.
|
| internal_pretty_code_ref [Cil_datatype.Varinfo] |
|
| is_empty [Set.S] |
Test whether a set is empty or not.
|
| iter [State_builder.Hashtbl] |
|
| iter [Region_analysis_sig.Node.Edge_Dict] |
|
| iter [Set.S] |
iter f s applies f in turn to all elements of s.
|
| iter [Region_analysis_sig.Node.Dict] |
|
| iter_preds [Region_analysis_sig.Node.Graph] |
|
| iter_sorted [State_builder.Hashtbl] |
|
| iter_succs [Region_analysis_sig.Node.Graph] |
|
J |
| join [Slevel_analysis.Specific] |
|
| join [Loop_analysis.Store] |
|
| join [Loop_analysis.Binary] |
|
| join [Region_analysis_sig.Node] |
|
| join2 [Slevel_analysis.Specific] |
|
| join2 [Loop_analysis.Store] |
|
| join2_mem [Loop_analysis.Store] |
|
| join2_stmts [Slevel_analysis.Specific] |
|
| join2_stmts [Loop_analysis.Store] |
|
| join_conds [Loop_analysis.Binary] |
|
K |
| kf [Slevel_analysis.Specific] |
|
L |
| length [State_builder.Hashtbl] |
Length of the table.
|
| load [Loop_analysis.Store] |
|
M |
| main [Register] |
|
| max_elt [Set.S] |
Same as Set.S.min_elt, but returns the largest element of the
given set.
|
| mem [State_builder.Hashtbl] |
|
| mem [Set.S] |
mem x s tests whether x belongs to the set s.
|
| memo [State_builder.Hashtbl] |
Memoization.
|
| min_elt [Set.S] |
Return the smallest element of the given set
(with respect to the Ord.compare ordering), or raise
Not_found if the set is empty.
|
| mu [Slevel_analysis.Specific] |
|
| mu [Loop_analysis.Store] |
|
| mu [Region_analysis_sig.Node] |
|
N |
| neg [Loop_analysis.Binary] |
|
| not_cond [Loop_analysis.Binary] |
|
O |
| of_list [Set.S] |
of_list l creates a set from a list of elements.
|
| off [Parameter_sig.Bool] |
Set the boolean to false.
|
| on [Parameter_sig.Bool] |
Set the boolean to true.
|
P |
| partition [Set.S] |
partition p s returns a pair of sets (s1, s2), where
s1 is the set of all the elements of s that satisfy the
predicate p, and s2 is the set of all the elements of
s that do not satisfy p.
|
| pretty [Loop_analysis.Store] |
|
| pretty [Loop_analysis.Binary] |
|
| pretty [Region_analysis_sig.Node] |
|
| pretty_cond [Loop_analysis.Binary] |
|
| pretty_conds [Loop_analysis.Binary] |
|
| pretty_ref [Cil_datatype.Varinfo] |
|
R |
| remove [State_builder.Hashtbl] |
|
| remove [Set.S] |
remove x s returns a set containing all elements of s,
except x.
|
| replace [State_builder.Hashtbl] |
Add a new binding.
|
S |
| self [Cil_datatype.Varinfo.Hptset] |
|
| set [Region_analysis_sig.Node.Edge_Dict] |
|
| set [Region_analysis_sig.Node.Dict] |
|
| set_range [Parameter_sig.Int] |
Set what is the possible range of values for this parameter.
|
| singleton [Set.S] |
singleton x returns the one-element set containing only x.
|
| split [Set.S] |
split x s returns a triple (l, present, r), where
l is the set of elements of s that are
strictly less than x;
r is the set of elements of s that are
strictly greater than x;
present is false if s contains no element equal to x,
or true if s contains an element equal to x.
|
| subset [Set.S] |
subset s1 s2 tests whether the set s1 is a subset of
the set s2.
|
T |
| transfer_cond [Loop_analysis.Binary] |
|
| transfer_exp [Loop_analysis.BINARY_SEMILATTICE] |
|
| transfer_exp [Loop_analysis.Binary] |
|
| transfer_lval [Loop_analysis.BINARY_SEMILATTICE] |
|
| transfer_lval [Loop_analysis.Binary] |
|
U |
| union [Set.S] |
Set union.
|