Index of values


A
add [Computation.HASHTBL_OUTPUT]
Add a new binding.
add [CtrlDpds.Computer.StmtStartData]
add [CtrlDpds.States]
add [CtrlDpds.State]
add [CtrlDpds.S]
add [Build.Computer.StmtStartData]
add [Set.S]
add x s returns a set containing all elements of s, plus x.
add_dpd_in_g [Build]
add a dependency with the given label between the two nodes.
add_info_nodes [Annot]
add_init_state_input [State]
this one is very similar to add_loc_node except that we want to accumulate the nodes (exact = false) but nonetheless define under_outputs like (exact = true)
add_link [Lexical_successors]
Add a link prev -> next in the graph.
add_links [Lexical_successors]
Add links from each prev in prev_list to next.
add_loc_node [State]
add_node_and_custom_dpds [Sets]
add the node to the list.
add_node_in_list [Sets]
add the node in the list if it is not already in.
add_nodes_and_custom_dpds [Sets]
add_retres [Build.BuildPdg]
add_stmt_nodes [Sets]
all_rec_dpds [Sets]
all_related_nodes [Sets]
build a list of all the nodes that are related 'somehow' to the given nodes.
all_uses [Sets]
all_x_dpds [Sets]
gives the dpd_type dependencies of the node, and recursively, all the dependencies of those nodes (regardless to their kind)

B
bug [Macros]

C
call_ouputs [Build]
Add nodes for the call outputs, and add the dependencies according to from_table.
call_out_marks_to_called [Register]
call_out_marks_to_called [Marks]
we have a list of a call output marks, and we want to translate it into a list of marks on the called function nodes.
cardinal [Set.S]
Return the number of elements of a set.
cbug [Macros]
choose [Set.S]
Return one element of the given set, or raise Not_found if the set is empty.
clear [Computation.HASHTBL_OUTPUT]
Clear the table.
clear [CtrlDpds.Computer.StmtStartData]
clear [Build.Computer.StmtStartData]
combinePredecessors [Build.Computer]
Combine an old state with a new one at the point before 's'.
combineStmtStartData [CtrlDpds.Computer]
combineSuccessors [CtrlDpds.Computer]
compare [Set.S]
Total ordering between sets.
compute [Register]
compute [Lexical_successors]
Compute the lexical successor graph for function kf
compute [CtrlDpds]
Compute some information on the function in order to be able to compute the control dependencies later on
computeFirstPredecessor [Build.Computer]
Transforme the state before storing it at the point before 'stmt' when there is nothing stored yet.
compute_infos [CtrlDpds]
compute_on_infinite_traces [CtrlDpds]
compute_pdg [Build]
compute_pdg_for_f [Build]
Compute and return the PDG for the given function
copy [Build.Computer]
create [CtrlDpds.States]
create [Build.BuildPdg]
ctrl_dpds_infos [Build.Computer]
current_function [Build.Computer]
current_pdg [Build.Computer]
custom_related_nodes [Sets]

D
debug [CtrlDpds.Computer]
debug [Build.Computer]
degenerated [Build]
diff [CtrlDpds.S]
diff [Set.S]
Set difference.
direct_addr_dpds [Sets]
direct_addr_uses [Sets]
direct_ctrl_dpds [Sets]
direct_ctrl_uses [Sets]
direct_data_dpds [Sets]
direct_data_uses [Sets]
direct_dpds [Sets]
gives the list of nodes that the given node depends on, without looking at the kind of dependency.
direct_uses [Sets]
direct_x_dpds [Sets]
gives the list of nodes that the given node depends on, with a given kind of dependency.
direct_x_uses [Sets]
display [CtrlDpds]
doEdge [Build.Computer]
doGuard [Build.Computer]
doInstr [CtrlDpds.Computer]
doInstr [Build.Computer]
Compute the new state after 'instr' starting from state before 'state'.
doStmt [CtrlDpds.Computer]
doStmt [Build.Computer]
Called before processing the successors of the statements.

E
elements [CtrlDpds.S]
elements [Set.S]
Return the list of all elements of the given set.
empty [State]
empty [Marks.F_Proj]
empty [CtrlDpds.S]
empty [Set.S]
The empty set.
equal [CtrlDpds.State]
equal [CtrlDpds.S]
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.

F
filter [Set.S]
filter p s returns the set of all elements in s that satisfy predicate p.
filterStmt [CtrlDpds.Computer]
filterStmt [Build.Computer]
Whether to put this statement in the worklist.
filter_nodes [Sets]
we ignore z_part for the moment.
finalize_pdg [Build.BuildPdg]
find [Computation.HASHTBL_OUTPUT]
Return the current binding of the given key.
find [Lexical_successors]
find [CtrlDpds.Computer.StmtStartData]
find [CtrlDpds.States]
find [Build.Computer.StmtStartData]
find_all [Computation.HASHTBL_OUTPUT]
Return the list of all data associated with the given key.
find_all_input_nodes [Sets]
find_call_ctrl_node [Sets]
find_call_input_nodes [Sets]
find_call_num_input_node [Sets]
find_call_out_nodes_to_select [Sets]
find_call_output_node [Sets]
find_call_stmts [Sets]
find_code_annot_nodes [Annot]
find_decl_var_node [Sets]
find_entry_point_node [Sets]
find_fun_postcond_nodes [Annot]
find_fun_precond_nodes [Annot]
find_fun_variant_nodes [Annot]
find_in_nodes_to_select_for_this_call [Sets]
find_input_node [Sets]
find_label_node [Sets]
find_loc_nodes [Sets]
find_location_nodes_at_begin [Sets]
find_location_nodes_at_end [Sets]
find_location_nodes_at_stmt [Sets]
find_marks [Marks.F_Proj]
find_node [Sets]
find_nodes_all_addr_dpds [Sets]
find_nodes_all_ctrl_dpds [Sets]
find_nodes_all_data_dpds [Sets]
find_nodes_all_dpds [Sets]
find_nodes_all_x_dpds [Sets]
find_nodes_for_function_contract [Annot]
find_output_node [Sets]
find_output_nodes [Sets]
find_simple_stmt_nodes [Sets]
notice that there can be several nodes if the statement is a call.
find_stmt_and_blocks_nodes [Sets]
notice that there can be several nodes if the statement is a call.
find_stmt_node [Sets]
find_top_input_node [Sets]
fold [Computation.HASHTBL_OUTPUT]
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.
for_all [Set.S]
for_all p s checks if all elements of the set satisfy the predicate p.
funcExitData [CtrlDpds.Computer]

G
get_all_nodes [State]
get_both_dpds [Sets]
get_if_controled_stmts [CtrlDpds]
Compute the list of the statements that should have a control dependency on the given IF statement.
get_init_state [State]
get_init_state [Sets]
get_jump_controled_stmts [CtrlDpds]
let's find the statements which are depending on the jump statement (goto, break, continue, loop) =
PDB(jump,lex_suc) U (PDB(lex_suc,label) - lex_suc)
(see the document to know more about the applied algorithm).
get_kf [Build.BuildPdg]
get_last_state [State]
get_last_state [Sets]
get_loc_nodes [State]
get_loc_nodes_and_part [State]
returns pairs of (n, z_opt) where n is a node that computes a part of loc and z is the intersection between loc and the zone computed by the node.
get_lval_infos [Build]
gives needed informations about lval : = location + exact + dependencies + declarations
get_pdg_kf [Macros]
get_postdoms [CtrlDpds]
get_states [Build.BuildPdg]
get_stmt_state [State]
get_stmt_state [Sets]
go [CtrlDpds]

I
in_marks_to_caller [Register]
in_marks_to_caller [Marks]
compute the marks to propagate in the caller nodes from the marks of a function inputs in_marks.
inter [CtrlDpds.State]
inter [CtrlDpds.S]
inter [Set.S]
Set intersection.
is_call_to_f [Sets]
is_empty [Set.S]
Test whether a set is empty or not.
is_variadic [Build]
iter [Computation.HASHTBL_OUTPUT]
iter [CtrlDpds.Computer.StmtStartData]
iter [Build.Computer.StmtStartData]
iter [Set.S]
iter f s applies f in turn to all elements of s.

L
length [Computation.HASHTBL_OUTPUT]
Length of the table.
length [CtrlDpds.Computer.StmtStartData]
length [Build.Computer.StmtStartData]

M
main [Register]
make [State]
mark_and_propagate [Marks.F_Proj]
Add the marks to the pdg nodes and also apply all the produced requests to do the interprocedural propagation.
max_elt [Set.S]
Same as Set.S.min_elt, but returns the largest element of the given set.
mem [Computation.HASHTBL_OUTPUT]
mem [CtrlDpds.Computer.StmtStartData]
mem [Build.Computer.StmtStartData]
mem [Set.S]
mem x s tests whether x belongs to the set s.
memo [Computation.HASHTBL_OUTPUT]
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.

N
name [CtrlDpds.Computer]
name [Build.Computer]

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.
pd_b_but_not_a [CtrlDpds]
Compute the PDB(A,B) set used in the control dependencies algorithm.
pdg_name [Macros]
pretty [State]
pretty [Register]
pretty [CtrlDpds.Computer]
pretty [CtrlDpds.States]
pretty [CtrlDpds.State]
pretty [CtrlDpds.S]
pretty [Build.Computer]
pretty [Build.BuildPdg]
pretty_key [Register]
pretty_key [Print]
pretty_node [Register]
pretty_node [Macros]
print_dot [Register]
print_state [Build.BuildPdg]
process_args [Build]
Add a PDG node and its dependencies for each explicit call argument.
process_asgn [Build.BuildPdg]
process_asgn [Build]
process assignment
lval = exp;
Use the state at ki (before assign) and returns the new state (after assign).
process_block [Lexical_successors]
Process each statement in blk with no previous statement to begin with
process_block [Build.BuildPdg]
process_call [Build]
process call :
lvaloption = funcexp (argl);
Use the state at ki (before the call) and returns the new state (after the call).
process_call_args [Build.BuildPdg]
process_call_node [Build.BuildPdg]
process_call_ouput [Build.BuildPdg]
process_call_params [Build.BuildPdg]
Add a PDG node for each formal argument, and add its dependencies to the corresponding argument node.
process_call_return [Build.BuildPdg]
mix between process_call_ouput and process_asgn
process_code_annot [Build]
process_condition [Build]
Add a node in the PDG for the conditional statement, and register the statements that are control-dependent on it.
process_declarations [Build.BuildPdg]
process_entry_point [Build.BuildPdg]
process_jump [Build.BuildPdg]
process_jump_or_loop_stmt [Build]
let's add a node for e jump statement (goto, break, continue) and find the statements which are depending on it.
process_jump_with_exp [Build.BuildPdg]
process_return [Build]
return ret_exp; is equivalent to out0 = ret_exp; goto END; while a simple return; is only a goto END;.
process_skip [Build.BuildPdg]
process_skip [Build]
process_stmt [Lexical_successors]
Add links from prev_list to stmt, (ie.
process_tail [Lexical_successors]
Process each statement in tail (statement list) knowing that the first element of 'tail' is the successor of every statement in prev_list.

R
remove [Computation.HASHTBL_OUTPUT]
remove [CtrlDpds.S]
remove [Set.S]
remove x s returns a set containing all elements of s, except x.
replace [Computation.HASHTBL_OUTPUT]
Add a new binding.
replace [CtrlDpds.Computer.StmtStartData]
replace [Build.Computer.StmtStartData]

S
singleton [CtrlDpds.S]
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.
states [Build.Computer.StmtStartData]
stmt_can_reach [Build.Computer]
store_init_state [State]
store_last_state [State]
store_last_state [Build.BuildPdg]
subset [Set.S]
subset s1 s2 tests whether the set s1 is a subset of the set s2.

T
test_and_merge [State]
test_and_merge_states [Build.BuildPdg]
translate_in_marks [Register]
translate_in_marks [Marks]
some new input marks has been added in a called function.
translate_marks_to_prop [Register]
translate_marks_to_prop [Marks]
add_new_marks_to_rqs pdg new_marks other_rqs translates new_marks that were computed during intraprocedural propagation into requests, and add them to other_rqs.
translate_out_mark [Marks]

U
union [CtrlDpds.S]
union [Set.S]
Set union.
unsafe_find [Computation.HASHTBL_OUTPUT]
Unsafe version of find.

V
var_to_loc [Build]

Z
zone_info_nodes [Annot]