Module Marks


module Marks: sig .. end
when we first compute marks to select outputs, we don't immediately propagate input marks to the calls, because some calls may be useless and we don't want to compute their inputs. We will check calls later on. But when we select annotations, we want to preserve all the calls that can lead to them : so, we propagate...

val debug : int -> ('a, Format.formatter, unit) Pervasives.format -> 'a
val fatal : ('a, Format.formatter, unit, 'b) Pervasives.format4 -> 'a
module BoolMark: sig .. end
val call_in_to_check : (Db.Pdg.t * Cil_types.stmt option * PdgMarks.t_select_elem *
(bool * BoolMark.prop_mode))
list Pervasives.ref
when we first compute marks to select outputs, we don't immediately propagate input marks to the calls, because some calls may be useless and we don't want to compute their inputs. We will check calls later on. But when we select annotations, we want to preserve all the calls that can lead to them : so, we propagate...
module Config: sig .. end
module ProjBoolMarks: Pdg.Register.F_Proj(Config)
type t_proj = ProjBoolMarks.t 
type t_fct = ProjBoolMarks.t_fct 
val get_marks : ProjBoolMarks.t ->
Kernel_function.t -> ProjBoolMarks.t_fct option
val mark_visible : 'a -> 'b * 'c -> 'b
val key_visible : (bool * 'a, 'b) PdgIndex.FctIndex.t -> PdgIndex.Key.t -> bool
val call_visible : (bool * 'a, 'b) PdgIndex.FctIndex.t -> Cil_types.stmt -> bool
the call is visible if its control node is visible
val all_keys_visible : (bool * 'a, 'b) PdgIndex.FctIndex.t -> PdgIndex.Key.t list -> bool
val select_pdg_elements : ProjBoolMarks.t ->
PdgTypes.Pdg.t -> ProjBoolMarks.t_mark PdgMarks.t_select -> unit
val add_pdg_selection : (Db.Pdg.t * 'a list) list -> Db.Pdg.t -> 'a -> (Db.Pdg.t * 'a list) list
val process_call_inputs : ProjBoolMarks.t -> unit
proj contains some function marks and !call_in_to_check is a list of call input marks to propagate when the call is visible. These marks come from the called function selection, but they are not automatically propagated because when a function is visible it doesn't mean that all the calls to that function are visible.

So we first split the todo list (!call_in_to_check) into the nodes to mark which correspond to inputs of visible calls and the others that do not yet correspond to visible call but we keep them because it can happen later

val add_node_to_select : bool ->
(bool * BoolMark.prop_mode) PdgMarks.t_select ->
Locations.Zone.t option ->
PdgTypes.Node.t -> (bool * BoolMark.prop_mode) PdgMarks.t_select
val add_nodes_and_undef_to_select : bool ->
PdgTypes.Node.t list * PdgTypes.Node.t list *
((PdgTypes.Node.t * Locations.Zone.t option) list * Locations.Zone.t option) ->
(bool * BoolMark.prop_mode) PdgMarks.t_select ->
(bool * BoolMark.prop_mode) PdgMarks.t_select
class annot_visitor : filter:(Cil_types.code_annotation -> bool) -> Db.Pdg.t -> object .. end
used to visit all the annotations of a given function and to find the PDG nodes to select so that the reachable annotations can be visible
val select_all_outputs : ProjBoolMarks.t -> Db_types.kernel_function -> unit
val select_annotations : select_annot:bool ->
select_slice_pragma:bool -> ProjBoolMarks.t -> unit
val select_entry_point : ProjBoolMarks.t -> Db_types.kernel_function -> unit
val finalize : ProjBoolMarks.t -> unit
val select_usefull_things : select_annot:bool ->
select_slice_pragma:bool -> Kernel_function.t -> ProjBoolMarks.t