_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_base [Lmap_bitwise.Location_map_bitwise] | |
add_binding [Lmap_bitwise.Location_map_bitwise] | |
add_binding_loc [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_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
|
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] | |
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] | |
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] | |
empty [PdgIndex.Signature] |
build a new, empty signature
|
empty [Marks.F_Proj] | |
empty [Pdg_state] | |
empty_map [Lmap_bitwise.Location_map_bitwise] | |
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_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_check_missing [Hptmap.Make] |
Both
find key m and find_check_missing key m return the value
bound to key in m , or raise Not_found is key is unbound.
|
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] |
This function is useful where there are multiple distinct keys that
are equal for
Key.equal .
|
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] |
The following fold_* functions, as well as
Lmap_bitwise.Location_map_bitwise.map2 take arguments
of type map to force their user to handle the cases Top and Bottom
explicitly.
|
fold [PdgIndex.FctIndex] | |
fold [PdgIndex.Signature] | |
fold [State_builder.Hashtbl] | |
fold2_join_heterogeneous [Hptmap.Make] | fold2_join_heterogeneous ~cache ~empty_left ~empty_right ~both
~join ~empty m1 m2 iterates simultaneously on m1 and m2 .
|
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] |
Same behavior as
fold , except if two non-contiguous ranges r1 and
r2 of a given base are mapped to the same value.
|
fold_impl_inputs [PdgIndex.Signature] | |
fold_join_zone [Lmap_bitwise.Location_map_bitwise] | fold_join_zone ~both ~conv ~empty_map ~join ~empty z m folds over the
intervals present in z .
|
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] | |
imprecise_write_msg [Lmap_bitwise.Location_map_bitwise] | |
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] | |
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 [PdgIndex.Signature] | |
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 [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] | |
map' [Hptmap.Make] |
Same as
map , except if f k v returns None .
|
map2 [Lmap_bitwise.Location_map_bitwise] |
'map'-like function between two interval maps, implemented as a
simultaneous descent in both maps.
|
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_debug [PdgTypes.DpdZone] | |
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] | |
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_output [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
|
shape [Lmap_bitwise.Location_map_bitwise] | |
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] |
Same as
generic_merge , but we also assume that merge x y = merge y x
holds.
|
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] | |
V | |
vertex_attributes [PdgTypes.Pdg.Printer] | |
vertex_name [PdgTypes.Pdg.Printer] | |
Z | |
zone_info_nodes [Annot] |