A |
adc_value [PdgTypes.Dpd] |
|
add [Hptmap.Make] |
add k d m returns a map whose bindings are all bindings in m , plus
a binding of the key k to the datum d .
|
add [PdgTypes.DpdZone] |
|
add [PdgTypes.Dpd] |
|
add [PdgIndex.FctIndex] |
store the information for the key.
|
add [State_builder.Hashtbl] |
Add a new binding.
|
add [Build.Computer.StmtStartData] |
|
add [Set.S] |
add x s returns a set containing all elements of s ,
plus x .
|
add_binding [Lmap_bitwise.Location_map_bitwise] |
|
add_dpd [PdgTypes.G] |
|
add_dpd_in_g [Build] |
add a dependency with the given label between the two nodes.
|
add_edge [PdgTypes.G] |
|
add_edge_one_dir [PdgTypes.G] |
|
add_elem [PdgTypes.G] |
|
add_impl_input [PdgIndex.Signature] |
|
add_in_ctrl [PdgIndex.Signature] |
|
add_in_list [PdgIndex.Signature] |
add a mapping between num and info in lst .
|
add_info [PdgIndex.Signature] |
|
add_info_call [PdgIndex.FctIndex] |
|
add_info_call_key [PdgIndex.FctIndex] |
|
add_info_sig_call [PdgIndex.FctIndex] |
|
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_input [PdgIndex.Signature] |
|
add_iset [Lmap_bitwise.Location_map_bitwise.LOffset] |
|
add_loc [PdgIndex.Signature] |
|
add_loc_node [Pdg_state] |
|
add_node [PdgTypes.G] |
|
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_node_one_dir [PdgTypes.G] |
|
add_node_to_select [PdgMarks] |
|
add_nodes_and_custom_dpds [Sets] |
|
add_or_replace [PdgIndex.FctIndex] |
|
add_out_ret [PdgIndex.Signature] |
|
add_output [PdgIndex.Signature] |
|
add_replace [PdgIndex.FctIndex] |
|
add_replace [PdgIndex.Signature] |
|
add_retres [Build.BuildPdg] |
|
add_stmt_nodes [Sets] |
|
add_to_select [PdgMarks] |
|
add_undef_in_to_select [PdgMarks] |
|
add_vertex [PdgTypes.G] |
|
all_uses [Sets] |
|
aux_iter_one_dir [PdgTypes.G] |
|
B |
bottom [PdgTypes.Pdg] |
|
bottom [PdgTypes.Dpd] |
|
bottom [Lmap_bitwise.Location_map_bitwise] |
|
bottom [Pdg_state] |
|
bottom_state [Build.BuildPdg] |
|
build_dot [PdgTypes.Pdg] |
build the PDG .dot file and put it in filename .
|
C |
cached_fold [Hptmap.Make] |
|
cached_map [Hptmap.Make] |
|
call_ctrl_key [PdgIndex.Key] |
|
call_from_id [PdgIndex.Key] |
|
call_input_key [PdgIndex.Key] |
|
call_key [PdgIndex.Key] |
|
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.
|
call_output_key [PdgIndex.Key] |
|
call_outret_key [PdgIndex.Key] |
|
call_topin_key [PdgIndex.Key] |
|
cardinal [Hptmap.Make] |
cardinal m returns m 's cardinal, that is, the number of keys it
binds, or, in other words, its domain's cardinal.
|
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.
|
clear [Build.Computer.StmtStartData] |
|
clear_caches [Hptmap.Make] |
Clear all the caches used internally by the functions of this module.
|
clear_caches [Lmap_bitwise.Location_map_bitwise] |
Clear the caches local to this module.
|
cmp_in_key [PdgIndex.Signature] |
InCtrl < InNum < InImpl
|
cmp_out_key [PdgIndex.Signature] |
OutRet < OutLoc
|
collapse [Lmap_bitwise.Location_map_bitwise.LOffset] |
|
combine [PdgMarks.Mark] |
combine is used during propagation.
|
combine [PdgTypes.Dpd] |
|
combinePredecessors [Build.Computer] |
Combine an old state with a new one at the point before 's'.
|
comp_prefixes [Hptmap.Make] |
|
compare [Set.S] |
Total ordering between sets.
|
compute [Register] |
|
compute [CtrlDpds.PdgPostdom] |
|
compute [CtrlDpds.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_pdg [Build] |
|
compute_pdg_for_f [Build] |
Compute and return the PDG for the given function
|
copy [Datatype.S] |
Deep copy: no possible sharing between x and copy x .
|
copy [PdgIndex.FctIndex] |
just copy the mapping
|
copy [PdgIndex.Signature] |
|
copy [Build.Computer] |
|
copy_paste [Lmap_bitwise.Location_map_bitwise] |
This function takes a function f to be applied to each bit of
the read slice.
|
create [PdgMarks.Fct] |
|
create [PdgMarks.F_Fct] |
|
create [PdgTypes.G] |
|
create [PdgIndex.FctIndex] |
|
create [Build.BuildPdg] |
|
ctrl_dpds_infos [Build.Computer] |
|
ctrl_no_preds [Build] |
Find the statements that are not reachable in CFG (no predecessors)
to add them as starting point of the dataflow analysis because we need to
process unreachable control statetemetns in order to have correct
control dependancies.
|
current_function [Build.Computer] |
|
current_pdg [Build.Computer] |
|
custom_related_nodes [Sets] |
|
D |
debug [Build.Computer] |
|
debug [Build] |
|
debug2 [Build] |
|
decl_var_key [PdgIndex.Key] |
|
default [PdgTypes.NodeSetLattice] |
|
default_edge_attributes [PdgTypes.Pdg.Printer] |
|
default_vertex_attributes [PdgTypes.Pdg.Printer] |
|
defaultall [PdgTypes.NodeSetLattice] |
|
degenerate [Lmap_bitwise.Location_map_bitwise.LOffset] |
|
degenerated [Build] |
|
deps [Register] |
|
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] |
|
dkey [Build] |
|
dkey [Pdg_state] |
|
dkey [CtrlDpds] |
|
doEdge [Build.Computer] |
|
doGuard [Build.Computer] |
|
doInstr [Build.Computer] |
Compute the new state after 'instr' starting from state before 'state'.
|
doStmt [Build.Computer] |
Called before processing the successors of the statements.
|
do_it_intersect [Hptmap.Make] |
|
dpd_zone [PdgTypes.DpdZone] |
|
dst [PdgTypes.Pdg.Printer.E] |
|
dst [PdgTypes.G.E] |
|
E |
edge_attributes [PdgTypes.Pdg.Printer] |
|
edge_dpd [PdgTypes.G] |
|
elem_key [PdgTypes.Node] |
|
elements [Set.S] |
Return the list of all elements of the given set.
|
empty [PdgMarks.Proj] |
|
empty [Hptmap.Make] |
|
empty [Lmap_bitwise.Location_map_bitwise.LOffset] |
|
empty [Lmap_bitwise.Location_map_bitwise] |
|
empty [PdgIndex.Signature] |
build a new, empty signature
|
empty [Marks.F_Proj] |
|
empty [Set.S] |
The empty set.
|
empty [Pdg_state] |
|
empty_state [Build.BuildPdg] |
|
empty_to_prop [PdgMarks.Fct] |
|
empty_to_prop [PdgMarks.F_Fct] |
|
entry_point [PdgIndex.Key] |
|
equal [PdgIndex.RKey] |
|
equal [Set.S] |
equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
equal_out_key [PdgIndex.Signature] |
|
equal_subtree [Hptmap.Make] |
|
exists [Set.S] |
exists p s checks if at least one element of
the set satisfies the predicate p .
|
F |
fi_descr [PdgTypes.Pdg] |
|
filter [Set.S] |
filter p s returns the set of all elements in s
that satisfy predicate p .
|
filterStmt [Build.Computer] |
Whether to put this statement in the worklist.
|
filter_base [Lmap_bitwise.Location_map_bitwise] |
|
filter_nodes [Sets] |
we ignore z_part for the moment.
|
finalize_pdg [Build.BuildPdg] |
|
find [Hptmap.Make] |
|
find [Lmap_bitwise.Location_map_bitwise] |
|
find [State_builder.Hashtbl] |
Return the current binding of the given key.
|
find [Build.Computer.StmtStartData] |
|
find [CtrlDpds.Lexical_successors] |
|
find_all [PdgIndex.FctIndex] |
same than find_info except for call statements for which it gives the
list of all the information in the signature of the call.
|
find_all [State_builder.Hashtbl] |
Return the list of all data associated with the given key.
|
find_all_info_sig_call [PdgIndex.FctIndex] |
|
find_all_input_nodes [Sets] |
|
find_base [Lmap_bitwise.Location_map_bitwise] |
|
find_call [PdgIndex.FctIndex] |
find the information stored for the call and its signature
|
find_call_ctrl_node [Sets] |
|
find_call_input_nodes [Sets] |
|
find_call_key [PdgIndex.FctIndex] |
|
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_dpd [PdgTypes.G] |
|
find_edge [PdgTypes.G] |
|
find_entry_point_node [Sets] |
|
find_fun_postcond_nodes [Annot] |
|
find_fun_precond_nodes [Annot] |
|
find_fun_variant_nodes [Annot] |
|
find_implicit_input [PdgIndex.Signature] |
try to find an exact match with loc.
|
find_in_ctrl [PdgIndex.Signature] |
|
find_in_info [PdgIndex.Signature] |
|
find_in_nodes_to_select_for_this_call [Sets] |
|
find_in_top [PdgIndex.Signature] |
|
find_info [PdgIndex.FctIndex] |
find the information stored for the key.
|
find_info [PdgIndex.Signature] |
|
find_info_call [PdgIndex.FctIndex] |
find the information stored for the call
|
find_info_call_key [PdgIndex.FctIndex] |
|
find_info_sig_call [PdgIndex.FctIndex] |
|
find_input [PdgIndex.Signature] |
|
find_input_node [Sets] |
|
find_label [PdgIndex.FctIndex] |
Similar to find_info for a label
|
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 [PdgMarks.Proj] |
|
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_out_info [PdgIndex.Signature] |
|
find_out_ret [PdgIndex.Signature] |
|
find_output [PdgIndex.Signature] |
|
find_output_node [Sets] |
|
find_output_nodes [Sets] |
|
find_prefix [Hptmap.Make] |
|
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 [Hptmap.Make] |
fold f m seed invokes f k d accu , in turn, for each binding from
key k to datum d in the map m .
|
fold [Lmap_bitwise.Location_map_bitwise.LOffset] |
|
fold [Lmap_bitwise.Location_map_bitwise] |
fold f m folds a function f on bindings in m .
|
fold [PdgIndex.FctIndex] |
|
fold [PdgIndex.Signature] |
|
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_all_inputs [PdgIndex.Signature] |
|
fold_all_outputs [PdgIndex.Signature] |
|
fold_base [Lmap_bitwise.Location_map_bitwise] |
|
fold_call_nodes [PdgTypes.Pdg] |
|
fold_calls [PdgIndex.FctIndex] |
|
fold_direct [PdgTypes.Pdg] |
|
fold_direct_codpds [PdgTypes.Pdg] |
|
fold_direct_dpds [PdgTypes.Pdg] |
|
fold_e_one_dir [PdgTypes.G] |
|
fold_fuse_same [Lmap_bitwise.Location_map_bitwise.LOffset] |
|
fold_fuse_same [Lmap_bitwise.Location_map_bitwise] |
Same behavior as fold , except if two disjoint ranges r1 and r2 of
a given base are mapped to the same value and boolean.
|
fold_impl_inputs [PdgIndex.Signature] |
|
fold_matching_impl_inputs [PdgIndex.Signature] |
|
fold_num_inputs [PdgIndex.Signature] |
|
fold_one_dir [PdgTypes.G] |
|
fold_outputs [PdgIndex.Signature] |
|
fold_pred_e [PdgTypes.G] |
|
fold_rev [Hptmap.Make] |
fold_rev performs exactly the same job as fold , but presents keys
to f in the opposite order.
|
fold_sorted [State_builder.Hashtbl] |
|
fold_succ_e [PdgTypes.G] |
|
for_all [Set.S] |
for_all p s checks if all elements of the set
satisfy the predicate p .
|
G |
generic_is_included [Hptmap.Make] |
|
generic_merge [Hptmap.Make] |
|
generic_symetric_existential_predicate [Hptmap.Make] |
|
get [CtrlDpds.PdgPostdom] |
|
get_all_direct [PdgTypes.Pdg] |
|
get_all_direct_codpds [PdgTypes.Pdg] |
|
get_all_direct_dpds [PdgTypes.Pdg] |
|
get_decl_nodes [Annot] |
|
get_graph [PdgTypes.Pdg] |
|
get_idx [PdgMarks.Fct] |
|
get_idx [PdgMarks.F_Fct] |
|
get_if_controled_stmts [CtrlDpds] |
Compute the list of the statements that should have a control dependency
on the given IF statement.
|
get_index [PdgTypes.Pdg] |
|
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) =
PDB(jump,lex_suc) U (PDB(lex_suc,label) - lex_suc)
(see the document to know more about the applied algorithm).
|
get_kf [PdgTypes.Pdg] |
|
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_loop_controled_stmts [CtrlDpds] |
Try to process while(1) S; LS: as L: S; goto L; LS:
|
get_lval_infos [Build] |
gives needed informations about lval :
= location + exact + dependencies + declarations
|
get_pdg_body [PdgTypes.Pdg] |
|
get_states [PdgTypes.Pdg] |
|
get_states [Build.BuildPdg] |
|
get_stmt_state [Sets] |
|
get_stmt_state [Pdg_state] |
|
get_subgraph [PdgTypes.Pdg.Printer] |
|
get_x_direct [PdgTypes.Pdg] |
|
get_x_direct_codpds [PdgTypes.Pdg] |
|
get_x_direct_dpds [PdgTypes.Pdg] |
|
get_x_direct_edges [PdgTypes.Pdg] |
gives the list of nodes that depend to the given node, with a given
kind of dependency if dpd_type is not None .
|
graph_attributes [PdgTypes.Pdg.Printer] |
|
H |
hash [PdgIndex.RKey] |
|
hash_debug [Hptmap.Make] |
|
hash_subtree [Hptmap.Make] |
|
I |
id [PdgTypes.Node] |
|
implicit_in_key [PdgIndex.Key] |
|
in_ctrl_key [PdgIndex.Signature] |
|
in_impl_key [PdgIndex.Signature] |
|
in_key [PdgIndex.Signature.Str_descr] |
|
in_key [PdgIndex.Signature] |
|
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 .
|
in_top_key [PdgIndex.Signature] |
|
inter [PdgTypes.Dpd] |
|
inter [Set.S] |
Set intersection.
|
intersect [PdgTypes.Dpd] |
|
is_addr [PdgTypes.Dpd] |
|
is_bottom [PdgMarks.Mark] |
used to test combine result (see below)
|
is_bottom [PdgTypes.Pdg] |
|
is_bottom [PdgTypes.Dpd] |
|
is_bottom [Lmap_bitwise.Location_map_bitwise] |
|
is_call_stmt [PdgIndex] |
|
is_ctrl [PdgTypes.Dpd] |
|
is_data [PdgTypes.Dpd] |
|
is_dpd [PdgTypes.DpdZone] |
|
is_dpd [PdgTypes.Dpd] |
|
is_empty [Hptmap.Make] |
is_empty m returns true if and only if the map m defines no
bindings at all.
|
is_empty [Lmap_bitwise.Location_map_bitwise.LOffset] |
|
is_empty [Lmap_bitwise.Location_map_bitwise] |
|
is_empty [Set.S] |
Test whether a set is empty or not.
|
is_included [PdgTypes.Dpd] |
|
is_included [Lmap_bitwise.Location_map_bitwise] |
|
is_singleton [Hptmap.Make] |
is_singleton m returns Some (k, d) if m is a singleton map
that maps k to d .
|
is_top [PdgTypes.Pdg] |
|
is_variadic [Build] |
|
iter [Hptmap.Make] |
|
iter [State_builder.Hashtbl] |
|
iter [Build.Computer.StmtStartData] |
|
iter [Set.S] |
iter f s applies f in turn to all elements of s .
|
iter_direct_codpds [PdgTypes.Pdg] |
|
iter_direct_dpds [PdgTypes.Pdg] |
|
iter_e_one_dir [PdgTypes.G] |
|
iter_edges_e [PdgTypes.Pdg.Printer] |
|
iter_edges_e [PdgTypes.G] |
|
iter_nodes [PdgTypes.Pdg] |
|
iter_pred_e [PdgTypes.G] |
|
iter_sorted [State_builder.Hashtbl] |
|
iter_succ_e [PdgTypes.G] |
|
iter_vertex [PdgTypes.Pdg.Printer] |
|
iter_vertex [PdgTypes.G] |
|
J |
join [Lmap_bitwise.Location_map_bitwise.LOffset] |
|
join [Lmap_bitwise.Location_map_bitwise] |
|
jump_controled_stmts [CtrlDpds] |
|
K |
key [PdgIndex.Signature.Str_descr] |
|
kind_and_zone [PdgTypes.DpdZone] |
|
L |
label [PdgTypes.G.E] |
|
label_key [PdgIndex.Key] |
|
length [PdgIndex.FctIndex] |
|
length [State_builder.Hashtbl] |
Length of the table.
|
length [Build.Computer.StmtStartData] |
|
M |
main [Register] |
|
make [PdgTypes.Pdg] |
make fundec graph states index
|
make [PdgTypes.DpdZone] |
|
make [PdgTypes.Dpd] |
|
make [PdgTypes.Node] |
|
make [Pdg_state] |
|
make_simple [PdgTypes.Dpd] |
|
map [Hptmap.Make] |
map f m returns the map obtained by composing the map m with the
function f ; that is, the map $k\mapsto f(m(k))$.
|
map [Lmap_bitwise.Location_map_bitwise.LOffset] |
|
map2 [Lmap_bitwise.Location_map_bitwise] |
like for fold , the boolean in bool * y indicates if it is possible
that the zone was not modified
|
map_and_merge [Lmap_bitwise.Location_map_bitwise] |
map_and_merge f m1 m2 maps f on values in m1 and add_exact
all elements of the mapped m1 to m2
|
mark_and_propagate [PdgMarks.Proj] |
|
mark_and_propagate [PdgMarks.Fct] |
|
mark_and_propagate [PdgMarks.F_Fct] |
|
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.
|
mark_to_prop_to_called_output [PdgMarks.Config] |
define how to translate a mark of a call output into a mark
to propagate in the called function.
|
mark_to_prop_to_caller_input [PdgMarks.Config] |
define how to translate an input mark of a function into a mark
to propagate in the callers.
|
max_binding [Hptmap.Make] |
|
max_elt [Set.S] |
Same as Set.S.min_elt , but returns the largest element of the
given set.
|
mem [Hptmap.Make] |
|
mem [State_builder.Hashtbl] |
|
mem [Build.Computer.StmtStartData] |
|
mem [Set.S] |
mem x s tests whether x belongs to the set s .
|
memo [State_builder.Hashtbl] |
Memoization.
|
merge [PdgMarks.Mark] |
merge two pieces of information
|
merge [PdgIndex.FctIndex] |
merge the two indexes using given functions merge_a and merge_b .
|
merge [PdgIndex.Signature] |
|
merge_info_calls [PdgIndex.FctIndex] |
|
min_binding [Hptmap.Make] |
|
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.
|
minus [PdgTypes.Dpd] |
|
mk_select_node [PdgMarks] |
|
mk_select_undef_zone [PdgMarks] |
|
mk_undef_in_key [PdgIndex.Signature] |
|
N |
name [Build.Computer] |
|
O |
out_from_key [PdgIndex.Key] |
this is for the nodes inside undefined functions
|
out_key [PdgIndex.Signature.Str_descr] |
|
out_key [PdgIndex.Signature] |
|
out_ret_key [PdgIndex.Signature] |
|
output [Register] |
|
output [Pdg_parameters] |
|
output_key [PdgIndex.Key] |
|
P |
param_key [PdgIndex.Key] |
|
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_debug [Build.Computer] |
|
pretty [PdgMarks.Mark] |
|
pretty [PdgTypes.DpdZone] |
|
pretty [PdgTypes.Dpd] |
|
pretty [PdgIndex.Signature] |
|
pretty [Register] |
|
pretty [Build.Computer] |
|
pretty [Pdg_state] |
|
pretty_bw [PdgTypes.Pdg] |
|
pretty_edge_label [PdgTypes.G] |
|
pretty_graph [PdgTypes.Pdg] |
|
pretty_in_key [PdgIndex.Signature] |
|
pretty_key [PdgIndex.Signature] |
|
pretty_list [PdgTypes.Node] |
|
pretty_node [PdgTypes.Node] |
|
pretty_node [PdgIndex.Key] |
|
pretty_node [Register] |
|
pretty_node [Build] |
|
pretty_out_key [PdgIndex.Signature] |
|
pretty_prefix [Hptmap.Make] |
|
pretty_td [PdgTypes.Dpd] |
|
pretty_with_part [PdgTypes.Node] |
|
pretty_with_type [Lmap_bitwise.Location_map_bitwise.LOffset] |
|
print_dot [Register] |
|
print_node [PdgTypes.Pdg.Printer] |
|
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_asm [Build.BuildPdg] |
|
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_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_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_loop_stmt [Build] |
Loop are processed like gotos because CIL transforms them into
while(true) body; which is equivalent to L : body ; goto L;
There is a small difference because we have to detect the case where
the goto L; would be unreachable (no real loop).
|
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_stmt_labels [Build.BuildPdg] |
|
process_unreachable [Build.BuildPdg] |
|
process_unreachable_call [Build.BuildPdg] |
|
R |
remove [Hptmap.Make] |
remove k m returns the map m deprived from any binding involving
k .
|
remove [State_builder.Hashtbl] |
|
remove [Set.S] |
remove x s returns a set containing all elements of s ,
except x .
|
remove_edge [PdgTypes.G] |
|
remove_edge_one_dir [PdgTypes.G] |
|
replace [State_builder.Hashtbl] |
Add a new binding.
|
replace [Build.Computer.StmtStartData] |
|
replace_dpd [PdgTypes.G] |
|
S |
self [Hptmap.Make] |
|
self [Hptset.Make] |
|
sgn [PdgIndex.FctIndex] |
get the information stored for the function signature
|
simple_add_dpd [PdgTypes.G] |
|
singleton [Hptmap.Make] |
singleton k d returns a map whose only binding is from k to d .
|
singleton [Set.S] |
singleton x returns the one-element set containing only x .
|
something_to_do [Register] |
|
split [Hptmap.Make] |
|
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 .
|
src [PdgTypes.Pdg.Printer.E] |
|
src [PdgTypes.G.E] |
|
states [Build.Computer.StmtStartData] |
|
stmt [PdgTypes.Node] |
|
stmt [PdgIndex.Key] |
|
stmt_can_reach [Build.Computer] |
used to optimize the order of the dataflow analysis.
|
stmt_init [Pdg_state] |
|
stmt_key [PdgIndex.Key] |
|
stmt_last [Pdg_state] |
|
store_init_state [Pdg_state] |
|
store_last_state [Build.BuildPdg] |
|
store_last_state [Pdg_state] |
|
structural_descr [PdgIndex.H] |
|
subset [Set.S] |
subset s1 s2 tests whether the set s1 is a subset of
the set s2 .
|
symetric_merge [Hptmap.Make] |
|
T |
t [PdgIndex.Signature.Str_descr] |
|
t_descr [PdgIndex.FctIndex] |
Structural destructor for unmarshaling
|
tag [Hptmap.Make] |
|
test_and_merge [Pdg_state] |
|
test_and_merge_states [Build.BuildPdg] |
|
top [PdgTypes.Pdg] |
|
top [PdgTypes.Dpd] |
|
top [Lmap_bitwise.Location_map_bitwise] |
|
top_input [PdgIndex.Key] |
|
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 |
uninitialize [Lmap_bitwise.Location_map_bitwise] |
binds the given variables to bottom, keeps the other unchanged.
|
union [Set.S] |
Set union.
|
V |
vertex_attributes [PdgTypes.Pdg.Printer] |
|
vertex_name [PdgTypes.Pdg.Printer] |
|
Z |
zone_info_nodes [Annot] |
|