A | |
add [State_builder.Hashtbl] |
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 [Inthash] | |
add_dpd_in_g [Build] |
add a dependency with the given label between the two nodes.
|
add_init_state_input [Pdg_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 [Pdg_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 [State_builder.Hashtbl] |
Clear the table.
|
clear [CtrlDpds.Computer.StmtStartData] | |
clear [Build.Computer.StmtStartData] | |
clear [Inthash] | |
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] | |
copy [Inthash] | |
copy_into [Inthash] | |
create [CtrlDpds.States] | |
create [Build.BuildPdg] | |
create [Inthash] | |
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 [Pdg_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 [State_builder.Hashtbl] |
Return the current binding of the given key.
|
find [Lexical_successors] | |
find [CtrlDpds.Computer.StmtStartData] | |
find [CtrlDpds.States] | |
find [Build.Computer.StmtStartData] | |
find [Inthash] | |
find_all [State_builder.Hashtbl] |
Return the list of all data associated with the given key.
|
find_all [Inthash] | |
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 [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 [Inthash] | |
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 [Pdg_state] | |
get_both_dpds [Sets] | |
get_decl_nodes [Annot] | |
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 [Sets] | |
get_init_state [Pdg_state] | |
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 [Sets] | |
get_last_state [Pdg_state] | |
get_loc_nodes [Pdg_state] | |
get_loc_nodes_and_part [Pdg_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 [Sets] | |
get_stmt_state [Pdg_state] | |
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 [State_builder.Hashtbl] | |
iter [CtrlDpds.Computer.StmtStartData] | |
iter [Build.Computer.StmtStartData] | |
iter [Set.S] | iter f s applies f in turn to all elements of s .
|
iter [Inthash] | |
L | |
length [State_builder.Hashtbl] |
Length of the table.
|
length [CtrlDpds.Computer.StmtStartData] | |
length [Build.Computer.StmtStartData] | |
length [Inthash] | |
M | |
main [Register] | |
make [Pdg_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 [State_builder.Hashtbl] | |
mem [CtrlDpds.Computer.StmtStartData] | |
mem [Build.Computer.StmtStartData] | |
mem [Set.S] | mem x s tests whether x belongs to the set s .
|
mem [Inthash] | |
memo [State_builder.Hashtbl] |
Memoization.
|
memoize [Inthash] | |
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 [Register] | |
pretty [Pdg_state] | |
pretty [CtrlDpds.Computer] | |
pretty [CtrlDpds.States] | |
pretty [CtrlDpds.State] | |
pretty [CtrlDpds.S] | |
pretty [Build.Computer] | |
pretty [Build.BuildPdg] | |
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 [State_builder.Hashtbl] | |
remove [CtrlDpds.S] | |
remove [Set.S] | remove x s returns a set containing all elements of s ,
except x .
|
remove [Inthash] | |
remove_all [Inthash] | |
replace [State_builder.Hashtbl] |
Add a new binding.
|
replace [CtrlDpds.Computer.StmtStartData] | |
replace [Build.Computer.StmtStartData] | |
replace [Inthash] | |
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 [Pdg_state] | |
store_last_state [Pdg_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 [Pdg_state] | |
test_and_merge_states [Build.BuildPdg] | |
tolist [Inthash] | |
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.
|
Z | |
zone_info_nodes [Annot] |