Index of values


A
adc_value [PdgTypes.Dpd]
add [PdgTypes.DpdZone]
add [Hashtbl.S]
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 [PdgIndex.FctIndex]
store the information for the key.
add [PdgTypes.Dpd]
add [Hptmap.Make]
add [Inthash]
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_in_top [PdgIndex.Signature]
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.Signature]
add_replace [PdgIndex.FctIndex]
add_retres [Build.BuildPdg]
add_stmt_nodes [Sets]
add_to_select [PdgMarks]
add_undef_in_to_select [PdgMarks]
add_vertex [PdgTypes.G]
all_rec_dpds [Sets]
all_related_nodes [Sets]
build a list of all the nodes that are related 'somehow' to the given nodes.
all_uses [Sets]
all_x_dpds [Sets]
gives the dpd_type dependencies of the node, and recursively, all the dependencies of those nodes (regardless to their kind)
aux_iter_one_dir [PdgTypes.G]

B
bottom [PdgTypes.Pdg]
bottom [PdgTypes.Dpd]
build_dot [PdgTypes.Pdg]
build the PDG .dot file and put it in filename.
build_dot_file [PdgTypes.Pdg]
build the .dot file and put it in pdg function name.dot

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 [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 [Hashtbl.S]
clear [State_builder.Hashtbl]
Clear the table.
clear [Build.Computer.StmtStartData]
clear [Inthash]
cmp_in_key [PdgIndex.Signature]
InCtrl < InNum < InImpl
cmp_out_key [PdgIndex.Signature]
OutRet < OutLoc
collapse [Lmap_bitwise.Location_map_bitwise.LOffset]
combine [PdgMarks.T_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 [Hptmap.Make]
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 [Hashtbl.S]
copy [PdgIndex.Signature]
copy [Build.Computer]
copy [PdgIndex.FctIndex]
just copy the mapping
copy [Inthash]
copy_into [Inthash]
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.T_Fct]
create [PdgMarks.F_Fct]
create [Hashtbl.S]
create [Build.BuildPdg]
create [PdgIndex.FctIndex]
create [PdgTypes.G]
create [Inthash]
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 [PdgIndex]
debug [Build.Computer]
debug [Build]
debug2 [Build]
decl_var_key [PdgIndex.Key]
default [PdgTypes.DpdZone]
default [PdgTypes.NodeSetLattice]
default [PdgTypes.Dpd]
default_edge_attributes [PdgTypes.Pdg.Printer]
default_vertex_attributes [PdgTypes.Pdg.Printer]
defaultall [PdgTypes.NodeSetLattice]
degenerated [Build]
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.
dpd_zone [PdgTypes.DpdZone]
dst [PdgTypes.Pdg.Printer.E]
dst [PdgTypes.G.E]

E
edge_attributes [PdgTypes.Pdg.Printer]
edge_dpd [PdgTypes.G]
edge_end [PdgTypes.Pdg]
elem_id [PdgTypes.Node]
elem_key [PdgTypes.Node]
elements [Set.S]
Return the list of all elements of the given set.
empty [PdgMarks.T_Proj]
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 [Hptmap.Make]
empty [Pdg_state]
empty_state [Build.BuildPdg]
empty_to_prop [PdgMarks.T_Fct]
empty_to_prop [PdgMarks.F_Fct]
entry_point [PdgIndex.Key]
equal [Set.S]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal_key [PdgIndex.Signature]
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
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 [Lmap_bitwise.Location_map_bitwise]
find [Hashtbl.S]
find [State_builder.Hashtbl]
Return the current binding of the given key.
find [Build.Computer.StmtStartData]
find [Hptmap.Make]
find [Inthash]
find [CtrlDpds.Lexical_successors]
find_all [Hashtbl.S]
find_all [State_builder.Hashtbl]
Return the list of all data associated with the given key.
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 [Inthash]
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_sig [PdgIndex.FctIndex]
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.Signature]
find_info [PdgIndex.FctIndex]
find the information stored for the key.
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_intervs [Lmap_bitwise.Location_map_bitwise.LOffset]
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.T_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_or_unchanged [Lmap_bitwise.Location_map_bitwise]
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 [Lmap_bitwise.Location_map_bitwise.LOffset]
fold [Lmap_bitwise.Location_map_bitwise]
fold f m folds a function f on bindings in m.
fold [Hashtbl.S]
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 [PdgIndex.FctIndex]
fold [Hptmap.Make]
fold [Inthash]
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_e_one_dir [PdgTypes.G]
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 [PdgTypes.G]
fold_pred_e [PdgTypes.G]
fold_succ [PdgTypes.G]
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_all_direct_edges [PdgTypes.Pdg]
get_all_nodes [Pdg_state]
get_both_dpds [Sets]
get_decl_nodes [Annot]
get_graph [PdgTypes.Pdg]
get_idx [PdgMarks.T_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.
graph_attributes [PdgTypes.Pdg.Printer]

H
hash_debug [Hptmap.Make]
hash_subtree [Hptmap.Make]
hkey [PdgIndex.Hkey]

I
id [PdgTypes.G.V]
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 [Set.S]
Set intersection.
inter [PdgTypes.Dpd]
intersect [PdgTypes.Dpd]
is_addr [PdgTypes.Dpd]
is_bottom [PdgMarks.T_Mark]
used to test combine result (see below)
is_bottom [PdgTypes.Pdg]
is_bottom [PdgTypes.Dpd]
is_call_stmt [PdgIndex]
is_call_to_f [Sets]
is_ctrl [PdgTypes.Dpd]
is_data [PdgTypes.Dpd]
is_dpd [PdgTypes.DpdZone]
is_dpd [PdgTypes.Dpd]
is_empty [Lmap_bitwise.Location_map_bitwise.LOffset]
is_empty [Set.S]
Test whether a set is empty or not.
is_empty [Hptmap.Make]
is_included [Lmap_bitwise.Location_map_bitwise]
is_included [PdgTypes.Dpd]
is_singleton [Hptmap.Make]
is_top [PdgTypes.Pdg]
is_variadic [Build]
iter [Hashtbl.S]
iter [State_builder.Hashtbl]
iter [Build.Computer.StmtStartData]
iter [Set.S]
iter f s applies f in turn to all elements of s.
iter [Hptmap.Make]
iter [Inthash]
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_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 [PdgTypes.Node]
key [PdgIndex.Hkey]
key [PdgIndex.Signature.Str_descr]
kind_and_zone [PdgTypes.DpdZone]

L
label [PdgTypes.G.E]
label_key [PdgIndex.Key]
length [Hashtbl.S]
length [State_builder.Hashtbl]
Length of the table.
length [Build.Computer.StmtStartData]
length [PdgIndex.FctIndex]
length [Inthash]

M
main [Register]
make [PdgTypes.Pdg]
make fundec graph states index
make [PdgTypes.DpdZone]
make [PdgTypes.Node]
make [PdgTypes.Dpd]
make [Pdg_state]
make_simple [PdgTypes.Dpd]
map [Lmap_bitwise.Location_map_bitwise.LOffset]
map [Hptmap.Make]
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.T_Proj]
mark_and_propagate [PdgMarks.T_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.T_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.T_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 [Hashtbl.S]
mem [State_builder.Hashtbl]
mem [Build.Computer.StmtStartData]
mem [Set.S]
mem x s tests whether x belongs to the set s.
mem [Hptmap.Make]
mem [Inthash]
memo [State_builder.Hashtbl]
Memoization.
memoize [Inthash]
merge [PdgMarks.T_Mark]
merge two pieces of information
merge [PdgIndex.Signature]
merge [PdgIndex.FctIndex]
merge the two indexes using given functions merge_a and merge_b.
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]
next [State_builder.Counter]
Increments the counter and returns a fresh value
node_set_of_list [Sets]

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_loc [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]
pred [PdgTypes.G]
pretty [PdgMarks.T_Mark]
pretty [PdgTypes.DpdZone]
pretty [PdgIndex.Signature]
pretty [Register]
pretty [Build.Computer]
pretty [Build.BuildPdg]
pretty [PdgTypes.Dpd]
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 [Register]
pretty_node [PdgIndex.Key]
pretty_node [Build]
pretty_nodes [PdgTypes.Node]
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_id [PdgTypes.Node]
print_state [Build.BuildPdg]
process_args [Build]
Add a PDG node and its dependencies for each explicit call argument.
process_asgn [Build.BuildPdg]
process_asgn [Build]
process assignment
lval = exp;
Use the state at ki (before assign) and returns the new state (after assign).
process_block [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_unreachable [Build.BuildPdg]
process_unreachable_call [Build.BuildPdg]

R
remove [Hashtbl.S]
remove [State_builder.Hashtbl]
remove [Set.S]
remove x s returns a set containing all elements of s, except x.
remove [Hptmap.Make]
remove [Inthash]
remove_all [Inthash]
remove_edge [PdgTypes.G]
remove_edge_one_dir [PdgTypes.G]
replace [Hashtbl.S]
replace [State_builder.Hashtbl]
Add a new binding.
replace [Build.Computer.StmtStartData]
replace [Inthash]
replace_dpd [PdgTypes.G]

S
self [Hptset.Make]
self [State_builder.Counter]
self [Hptmap.Make]
sgn [PdgIndex.FctIndex]
get the information stored for the function signature
simple_add_dpd [PdgTypes.G]
singleton [Set.S]
singleton x returns the one-element set containing only x.
split [Set.S]
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
split [Hptmap.Make]
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_key [PdgIndex.Key]
store_init_state [Pdg_state]
store_last_state [Build.BuildPdg]
store_last_state [Pdg_state]
subset [Set.S]
subset s1 s2 tests whether the set s1 is a subset of the set s2.
succ [PdgTypes.G]
symetric_merge [Hptmap.Make]

T
t [PdgIndex.Signature.Str_descr]
t_call_id_packed_descr [PdgIndex.Key]
t_descr [PdgIndex.FctIndex]
Structural destructor for unmarshaling
t_fi_descr [PdgTypes.Pdg]
tag [PdgTypes.DpdZone]
tag [Lmap_bitwise.Location_map_bitwise.LOffset]
tag [PdgTypes.NodeSetLattice]
tag [Hptmap.Make]
test_and_merge [Pdg_state]
test_and_merge_states [Build.BuildPdg]
tolist [Inthash]
top [PdgTypes.Pdg]
top [PdgTypes.Dpd]
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_locals [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]