|
_pretty [Build] |
|
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_binding [Lmap_bitwise.Location_map_bitwise] |
|
add_blk_ctrl_dpds [Build] |
|
add_ctrl_dpd [Build] |
|
add_ctrl_dpds [Build] |
Process and clear pdg.ctrl_dpds which contains a mapping between the
statements and the control dependencies that have to be added to the
statement nodes.
|
add_decl_dpd [Build] |
|
add_decl_dpds [Build] |
add a dependency on the variable declaration.
|
add_dpd [PdgTypes.G] |
|
add_dpd_goto_label [Build] |
|
add_dpd_in_g [Build] |
add a dependency with the given label between the two nodes.
|
add_dpd_switch_cases [Build] |
|
add_dpds [Build] |
add_dpds pdg v dpd_kind state loc
add 'dpd_kind' dependencies from node n to each element
which are stored for loc in state
|
add_edge [PdgTypes.G] |
|
add_edge_one_dir [PdgTypes.G] |
|
add_elem [PdgTypes.G] |
|
add_elem [Build] |
add a node to the PDG, but if it is associated with a stmt,
check before if it doesn't exist already (useful for loops).
|
add_from [Build] |
|
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_label [Build] |
|
add_label_and_dpd [Build] |
|
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] |
add a node corresponding to the returned value.
|
add_stmt_nodes [Sets] |
|
add_to_select [PdgMarks] |
|
add_undef_in_to_select [PdgMarks] |
|
add_vertex [PdgTypes.G] |
|
add_z_dpd [Build] |
|
all_uses [Sets] |
|
aux_iter_one_dir [PdgTypes.G] |
|
B |
binary_predicate [Hptmap.Make] |
Same functionality as generic_predicate but with a different signature.
|
bottom [PdgTypes.Pdg] |
|
bottom [PdgTypes.Dpd] |
|
bottom [Build.Computer] |
|
bottom [Pdg_state] |
|
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 [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.
|
clear [State_builder.Hashtbl] |
Clear the table.
|
clear_caches [Hptmap.Make] |
Clear all the persistent 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] |
|
compositional_bool [Hptmap.Make] |
Value of the compositional boolean associated to the tree, as computed
by the Compositional_bool argument of the functor.
|
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
|
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_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_call_output_node [Build] |
|
create_fun_output_node [Build] |
|
create_lval_node [Build] |
creates a node for lval : caller has to add dpds about the right part
|
create_pdg_build [Build] |
create an empty build pdg for the function
|
ctrl_call_node [Build] |
|
ctrl_dpds_infos [Build.Computer] |
|
current_function [Build.Computer] |
|
current_pdg [Build.Computer] |
|
custom_related_nodes [Sets] |
|
D |
debug [Build] |
|
debug2 [Build] |
|
decide_fast_inclusion [Hptmap.Make] |
Function suitable for the decide_fast argument of binary_predicate ,
when testing for inclusion of the first map into the second.
|
decide_fast_intersection [Hptmap.Make] |
Function suitable for the decide_fast argument of
symmetric_binary_predicate when testing for a non-empty intersection
between two maps.
|
decl_var [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] |
|
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] |
|
doInstr [Build.Computer] |
Compute the new state after 'instr' starting from state before 'state'.
|
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] |
|
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 [Pdg_state] |
|
empty_to_prop [PdgMarks.Fct] |
|
empty_to_prop [PdgMarks.F_Fct] |
|
entry_point [PdgIndex.Key] |
|
equal [PdgIndex.RKey] |
|
equal_out_key [PdgIndex.Signature] |
|
exists [Hptmap.Make] |
|
F |
fi_descr [PdgTypes.Pdg] |
|
filter_base [Lmap_bitwise.Location_map_bitwise] |
|
filter_nodes [Sets] |
we ignore z_part for the moment.
|
finalize_pdg [Build] |
to call then the building process is over :
add the control dependencies in the graph.
|
find [Hptmap.Make] |
|
find [Lmap_bitwise.Location_map_bitwise] |
|
find [State_builder.Hashtbl] |
Return the current binding of the given key.
|
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_key [Hptmap.Make] |
|
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_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_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 [Hptmap.Make] |
|
from_shape [Hptmap.Make] |
Build an entire map from another map indexed by the same keys.
|
G |
generic_merge [Hptmap.Make] |
Merge of two trees, parameterized by a merge function.
|
generic_predicate [Hptmap.Make] |
generic_is_included e (cache_name, cache_size) ~decide_fast
~decide_fst ~decide_snd ~decide_both t1 t2 decides whether some
relation holds between t1 and t2 .
|
generic_symmetric_predicate [Hptmap.Make] |
Same as generic_predicate , but for a symmetric relation.
|
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_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_stmt_state [Sets] |
|
get_stmt_state [Pdg_state] |
|
get_subgraph [PdgTypes.Pdg.Printer] |
|
get_var_base [Build] |
|
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 [Hptmap.Make] |
|
hash [PdgIndex.RKey] |
|
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 [Marks] |
compute the marks to propagate in the caller nodes from the marks of
a function inputs in_marks .
|
in_top_key [PdgIndex.Signature] |
|
init [Build.Computer] |
|
inter [PdgTypes.Dpd] |
|
inter_with_shape [Hptmap.Make] |
inter_with_shape s m keeps only the elements of m that are also
bound in the map s .
|
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_included [PdgTypes.Dpd] |
|
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_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 [Build.Computer] |
|
join_and_is_included [Build.Computer] |
|
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.
|
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] |
|
map' [Hptmap.Make] |
Same as map , except if f k v returns None .
|
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 [FCSet.S] |
Same as , but returns the largest element of the
given set.
|
mem [Hptmap.Make] |
|
mem [State_builder.Hashtbl] |
|
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 [FCSet.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_jump_node [Build] |
|
mk_select_node [PdgMarks] |
|
mk_select_undef_zone [PdgMarks] |
|
mk_undef_in_key [PdgIndex.Signature] |
|
N |
nearest_elt_ge [FCSet.S] |
nearest_elt_ge v s returns the smallest element of s that is
bigger or equal to v .
|
nearest_elt_le [FCSet.S] |
nearest_elt_le v s returns the largest element of s that is
smaller or equal to v .
|
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] |
|
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_generic_printer [Lmap_bitwise.Location_map_bitwise] |
|
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_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] |
|
process_args [Build] |
Add a PDG node and its dependencies for each explicit call argument.
|
process_asgn [Build] |
process assignment lval = exp;
Use the state at ki (before assign)
and returns the new state (after assign).
|
process_asm [Build] |
for asm: similar to process_skip , except that we emit a warning
|
process_block [Build] |
|
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] |
|
process_call_ouput [Build] |
|
process_call_params [Build] |
Add a PDG node for each formal argument,
and add its dependencies to the corresponding argument node.
|
process_call_return [Build] |
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] |
|
process_entry_point [Build] |
|
process_jump [Build] |
Add a node for a stmt that is a jump.
|
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] |
like process_jump but also add data dependencies on the datas and their
declarations.
|
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_other_inputs [Build] |
part of finalize_pdg : add missing inputs
and build a state with the new nodes to find them back when searching for
undefined zones.
|
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] |
for skip statement : we want to add a node in the PDG in ordrer to be able
to store information (like marks) about this statement later on
|
process_stmt_labels [Build] |
|
R |
remove [Hptmap.Make] |
remove k m returns the map m deprived from any binding involving
k .
|
remove [State_builder.Hashtbl] |
|
remove_edge [PdgTypes.G] |
|
remove_edge_one_dir [PdgTypes.G] |
|
replace [State_builder.Hashtbl] |
Add a new binding.
|
replace_dpd [PdgTypes.G] |
|
S |
self [Hptmap.Make] |
|
self [Hptset.Make] |
|
sgn [PdgIndex.FctIndex] |
get the information stored for the function signature
|
shape [Hptmap.Make] |
Export the map as a value suitable for functions inter_with_shape
and from_shape
|
simple_add_dpd [PdgTypes.G] |
|
singleton [Hptmap.Make] |
singleton k d returns a map whose only binding is from k to d .
|
something_to_do [Register] |
|
split [Hptmap.Make] |
|
src [PdgTypes.Pdg.Printer.E] |
|
src [PdgTypes.G.E] |
|
stmt [PdgTypes.Node] |
|
stmt [PdgIndex.Key] |
|
stmt_init [Pdg_state] |
|
stmt_key [PdgIndex.Key] |
|
stmt_last [Pdg_state] |
|
store_ctrl_dpds [Build] |
The control dependencies are stored : they will be added at the end
by finalize_pdg
|
store_init_state [Pdg_state] |
|
store_last_state [Pdg_state] |
|
structural_descr [PdgIndex.H] |
|
symmetric_binary_predicate [Hptmap.Make] |
Same as binary_predicate , but for a symmetric relation.
|
symmetric_inter [Hptmap.Make] |
Intersection of two trees, parameterized by a function which must verify
inter x y == inter y x and inter x Empty == Empty .
|
symmetric_merge [Hptmap.Make] |
Merge of two trees, parameterized by a merge function which is supposed
to verify merge x y == merge y x , merge x x == x , and which must
be pure (as an internal cache is used).
|
T |
t [PdgIndex.Signature.Str_descr] |
|
t_descr [PdgIndex.FctIndex] |
Structural destructor for unmarshaling
|
test_and_merge [Pdg_state] |
Kind of 'join' of the two states
but test before if the new state is included in ~old.
|
top [PdgTypes.Pdg] |
|
top [PdgTypes.Dpd] |
|
top_input [PdgIndex.Key] |
|
transfer_stmt [Build.Computer] |
Called before processing the successors of the statements.
|
translate_in_marks [Marks] |
some new input marks has been added in a called function.
|
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.
|
V |
vertex_attributes [PdgTypes.Pdg.Printer] |
|
vertex_name [PdgTypes.Pdg.Printer] |
|
Z |
zone_info_nodes [Annot] |
|