Index of values


_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]