Index of values


A
adc_value [PdgTypes.Dpd]
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_dpd [PdgTypes.G]
add_elem [PdgTypes.G]
add_info_call [PdgIndex.FctIndex]
add_info_call_key [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_loc_node [Pdg_state]
add_node_to_select [PdgMarks]
add_or_replace [PdgIndex.FctIndex]
add_to_select [PdgMarks]
add_undef_in_to_select [PdgMarks]
all_uses [Sets]

B
bottom [PdgTypes.Pdg]
bottom [PdgTypes.Dpd]
bottom [Pdg_state]
build_dot [PdgTypes.Pdg]
build the PDG .dot file and put it in filename.

C
call_ctrl_key [PdgIndex.Key]
call_from_id [PdgIndex.Key]
call_input_key [PdgIndex.Key]
call_key [PdgIndex.Key]
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]
clear [State_builder.Hashtbl]
Clear the table.
clear_caches [Lmap_bitwise.Location_map_bitwise]
Clear the caches local to this module.
clear_caches [Hptset.S]
Clear all the caches used internally by the functions of 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]
compare [PdgTypes.Dpd]
compute [Register]
compute [CtrlDpds]
Compute some information on the function in order to be able to compute the control dependencies later on
compute_for_kf [Register]
compute_pdg [Build]
contains_single_elt [Hptset.S]
copy [PdgIndex.FctIndex]
just copy the mapping
create [PdgMarks.Fct]
create [PdgTypes.G]
create [PdgIndex.FctIndex]
custom_related_nodes [Sets]

D
decl_var_key [PdgIndex.Key]
default [PdgTypes.NodeSetLattice]
default_edge_attributes [PdgTypes.Pdg.Printer]
default_vertex_attributes [PdgTypes.Pdg.Printer]
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]
direct dependencies only: This means the nodes that have an edge to the given node.
direct_uses [Sets]
dst [PdgTypes.G.E]

E
edge_attributes [PdgTypes.Pdg.Printer]
elem_key [PdgTypes.Node]
empty [PdgMarks.Proj]
empty [Lmap_bitwise.Location_map_bitwise]
empty [PdgIndex.Signature]
build a new, empty signature
empty [Pdg_state]
empty_map [Lmap_bitwise.Location_map_bitwise]
empty_to_prop [PdgMarks.Fct]
entry_point [PdgIndex.Key]
equal [PdgTypes.Dpd]
equal_out_key [PdgIndex.Signature]
exists [Parameter_sig.Set]
Is there some element satisfying the given predicate?

F
filter_base [Lmap_bitwise.Location_map_bitwise]
find [Lmap_bitwise.Location_map_bitwise]
find [State_builder.Hashtbl]
Return the current binding of 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 [State_builder.Hashtbl]
Return the list of all data associated with the given key.
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_code_annot_nodes [Annot]
find_decl_var_node [Sets]
find_entry_point_node [Sets]
find_fun_postcond_nodes [Annot]
find_fun_precond_nodes [Annot]
find_fun_variant_nodes [Annot]
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_input [PdgIndex.Signature]
find_input_node [Sets]
find_label [PdgIndex.FctIndex]
Similar to find_info for a label
find_label_node [Sets]
find_location_nodes_at_begin [Sets]
find_location_nodes_at_end [Sets]
find_location_nodes_at_stmt [Sets]
find_marks [PdgMarks.Proj]
find_nodes_all_addr_dpds [Sets]
find_nodes_all_ctrl_dpds [Sets]
find_nodes_all_data_dpds [Sets]
find_nodes_all_dpds [Sets]
find_out_info [PdgIndex.Signature]
find_out_ret [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 [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 [Hptset.S]
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_codpds [PdgTypes.Pdg]
fold_direct_dpds [PdgTypes.Pdg]
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_sorted [State_builder.Hashtbl]
from_shape [Hptset.S]
Build a set from another elt-indexed map or set.

G
get_all_direct_codpds [PdgTypes.Pdg]
get_all_direct_dpds [PdgTypes.Pdg]
get_function_name [Parameter_sig.String]
returns the given argument only if it is a valid function name (see Parameter_customize.get_c_ified_functions for more information), and abort otherwise.
get_idx [PdgMarks.Fct]
get_if_controlled_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 [Pdg_state]
get_jump_controlled_stmts [CtrlDpds]
Compute the list of the statements that should have a control dependency on the given jump statement.
get_kf [PdgTypes.Pdg]
get_last_state [Pdg_state]
get_loc_nodes [Pdg_state]
get_loop_controlled_stmts [CtrlDpds]
Try to process while(1) SLS as LS; goto LLS
get_plain_string [Parameter_sig.String]
always return the argument, even if the argument is not a function name.
get_possible_values [Parameter_sig.String]
What are the acceptable values for this parameter.
get_states [PdgTypes.Pdg]
get_stmt_state [Pdg_state]
get_subgraph [PdgTypes.Pdg.Printer]
get_x_direct_codpds [PdgTypes.Pdg]
get_x_direct_dpds [PdgTypes.Pdg]
graph_attributes [PdgTypes.Pdg.Printer]

I
id [PdgTypes.Node]
implicit_in_key [PdgIndex.Key]
imprecise_write_msg [Lmap_bitwise.Location_map_bitwise]
in_marks_to_caller [Marks]
in_marks_to_caller translate the input information part returned by mark_and_propagate into (node, mark) list related to a call.
inter [PdgTypes.Dpd]
intersect [PdgTypes.Dpd]
intersects [Hptset.S]
intersects s1 s2 returns true if and only if s1 and s2 have an element in common
is_addr [PdgTypes.Dpd]
is_bottom [PdgMarks.Mark]
used to test combine result (see below)
is_bottom [PdgTypes.Pdg]
is_bottom [Lmap_bitwise.Location_map_bitwise]
is_bottom [PdgTypes.Dpd]
is_ctrl [PdgTypes.Dpd]
is_data [PdgTypes.Dpd]
is_dpd [PdgTypes.Dpd]
is_empty [Lmap_bitwise.Location_map_bitwise]
is_included [PdgTypes.Dpd]
is_top [PdgTypes.Pdg]
iter [State_builder.Hashtbl]
iter_direct_codpds [PdgTypes.Pdg]
iter_direct_dpds [PdgTypes.Pdg]
iter_edges_e [PdgTypes.Pdg.Printer]
iter_nodes [PdgTypes.Pdg]
iter_sorted [State_builder.Hashtbl]
iter_vertex [PdgTypes.Pdg.Printer]

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.Dpd]
make [Pdg_state]
map [Lmap_bitwise.Location_map_bitwise]
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_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.
mem [State_builder.Hashtbl]
mem [Parameter_sig.Set]
Does the given element belong to the set?
memo [State_builder.Hashtbl]
Memoization.
merge [PdgMarks.Mark]
merge two pieces of information
merge [Hptset.S]
merge [PdgIndex.FctIndex]
merge the two indexes using given functions merge_a and merge_b.
minus [PdgTypes.Dpd]
mk_select_node [PdgMarks]
mk_select_undef_zone [PdgMarks]
mk_undef_in_key [PdgIndex.Signature]

O
off [Parameter_sig.Bool]
Set the boolean to false.
on [Parameter_sig.Bool]
Set the boolean to true.
out_from_key [PdgIndex.Key]
this is for the nodes inside undefined functions
output [Register]
output [Parameter_sig.With_output]
To be used by the plugin to output the results of the option in a controlled way.
output_key [PdgIndex.Key]

P
param_key [PdgIndex.Key]
pretty [PdgMarks.Mark]
pretty [PdgTypes.Dpd]
pretty [PdgIndex.Signature]
pretty [Register]
pretty [Pdg_state]
pretty_bw [PdgTypes.Pdg]
pretty_debug [Lmap_bitwise.Location_map_bitwise]
pretty_debug [Hptset.S]
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 [Register]
pretty_out_key [PdgIndex.Signature]
pretty_td [PdgTypes.Dpd]
pretty_with_part [PdgTypes.Node]
print_dot [Register]

R
remove [State_builder.Hashtbl]
remove_base [Lmap_bitwise.Location_map_bitwise]
replace [State_builder.Hashtbl]
Add a new binding.

S
set_output_dependencies [Parameter_sig.With_output]
Set the dependencies for the output of the option.
set_possible_values [Parameter_sig.String]
Set what are the acceptable values for this parameter.
sgn [PdgIndex.FctIndex]
get the information stored for the function signature
shape [Lmap_bitwise.Location_map_bitwise]
shape [Hptset.S]
Export the shape of the set.
something_to_do [Register]
src [PdgTypes.G.E]
stmt [PdgTypes.Node]
stmt [PdgIndex.Key]
stmt_key [PdgIndex.Key]
store_init_state [Pdg_state]
store_last_state [Pdg_state]

T
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]
translate_in_marks [Marks]
translate the input information part returned by mark_and_propagate using in_marks_to_caller for each call.
translate_marks_to_prop [Marks]
use both translate_in_marks and call_out_marks_to_called to translate the information provided by mark_and_propagate info selection on other functions.

V
vertex_attributes [PdgTypes.Pdg.Printer]
vertex_name [PdgTypes.Pdg.Printer]