Module SlicingInternals


module SlicingInternals: sig .. end

Internals types

Internals type definitions should be hidden to the outside world, but it is not really possible to have abstract types since Slicing has to use Db.Slicing functions...


About the PDG

As the PDG is not defined here anymore, look at PdgTypes for more information about it.
type t_pdg_node = PdgTypes.Node.t 
Nodes of the PDG

About options



type t_level_option =
| DontSlice (*don't build slice for the function : ie. always call the source function.*)
| DontSliceButComputeMarks (*don't slice the called functions, but compute the marks for them*)
| MinNbSlice (*try to use existing slices, create at most one*)
| MaxNbSlice (*most precise slices (but merge slices with the same visibility, even if they don't have the same marks)*)
associate a level to each function in order to control how it will be specialized. This is only a hint used when the tool has to make a choice, but it doesn't forbid to the user to do whatever he wants (like building slices for a DontSlice function).

About function slice



type t_mark =
| Cav of PdgTypes.Dpd.t
| Spare
Kinds of elementary marks.
val compare_mark : t_mark -> t_mark -> int

type t_pdg_mark = {
   m1 : t_mark;
   m2 : t_mark;
}
Each PDG element has 2 marks to deal with interprocedural propagation
val t_pdg_mark_packed_descr : Structural_descr.pack
val compare_pdg_mark : t_pdg_mark -> t_pdg_mark -> int
type t_call_id = Cil_types.stmt 

type t_fct_info = {
   fi_kf : Cil_types.kernel_function;
   fi_def : Cil_types.fundec option;
   fi_project : t_project;
   mutable fi_top : t_pdg_mark option; (*indicates if the function is maked top (=> src visible)*)
   mutable fi_level_option : t_level_option; (*level of specialisation for this function*)
   mutable fi_init_marks : t_ff_marks option; (*the marks that must be in every slices of that function*)
   mutable fi_slices : t_fct_slice list; (*the list of the slices already computed for this function.*)
   mutable fi_next_ff_num : int; (*the number to assign to the next slice.*)
   mutable f_called_by : t_called_by; (*calls in slices that call source fct*)
}
Type for all the informations related to any function, even if we don't have its definition.
type t_called_by = (t_fct_slice * t_call_id) list 
to represent where a function is called.

type t_fct_slice = {
   ff_fct : t_fct_info;
   ff_id : int;
   mutable ff_marks : t_ff_marks;
   mutable ff_called_by : t_called_by;
}
Function slice : created as soon as there is a criterion to compute it, even if the slice itself hasn't been computed yet.

type t_fct_id =
| FctSrc of t_fct_info (*source function*)
| FctSliced of t_fct_slice (*sliced function*)
t_fct_id is used to identify either a source function or a sliced one.

type t_called_fct =
| CallSrc of t_fct_info option (*call the source function (might be unknown if the call uses pointer)*)
| CallSlice of t_fct_slice
type t_call_info = t_called_fct option 
information about a call in a slice which gives the function to call
type t_marks_index = (t_pdg_mark, t_call_info)
PdgIndex.FctIndex.t
main part of a slice = mapping between the function elements and information about them in the slice.
type t_ff_marks = PdgTypes.Pdg.t * t_marks_index 

type t_project = {
   name : string;
   application : Project.t;
   functions : t_fct_info Cil_datatype.Varinfo.Hashtbl.t;
   mutable actions : t_criterion list;
}
type t_appli_criterion =
| CaGlobalData of Locations.Zone.t (*select all that is necessary to compute the given location.*)
| CaCall of t_fct_info (*select all that is necessary to call the given function. Its application generates requests to add persistent selection to all the function callers.*)
| CaOther
Slicing criterion at the application level. When applied, they are translated into t_fct_criterion
type t_fct_base_criterion = t_pdg_mark PdgMarks.t_select 
Base criterion for the functions. These are the only one that can really generate function slices. All the other criterions are translated in more basic ones. Note that to build such a base criterion, the PDG has to be already computed.
type t_loc_point = Cil_types.stmt * Locations.Zone.t * bool 
Used to identify a location (zone) at a given program point. The boolean tell if the point is before (true) or after the statement

List of pdg nodes to be selected (see SlicingInternals.t_fct_user_crit)

type t_node_or_dpds =
| CwNode
| CwAddrDpds
| CwDataDpds
| CwCtrlDpds
t_node_or_dpds tells how we want to select nodes, or some of their dependencies (see SlicingInternals.t_fct_user_crit).

type t_fct_user_crit =
| CuSelect of t_pdg_mark PdgMarks.t_select
| CuTop of t_pdg_mark (*the function has probably no PDG, but we nonetheless give a mark to propagate*)
Tells which marks we want to put in the slice of a function

kinds of actions that can be apply to a function


type t_fct_crit =
| CcUserMark of t_fct_user_crit (*add marks to a slice*)
| CcChooseCall of t_call_id (*have to choose what function to call here.*)
| CcChangeCall of t_call_id * t_called_fct (*call the t_called_fct for the given call t_call_id*)
| CcMissingOutputs of t_call_id * t_pdg_mark PdgMarks.t_select
* bool
(*this call is affected to a function that doesn't compute enough outputs : we will have to choose between adding outputs to that slice, or call another one. The boolean tells if the modifications would change the visibility of some outputs.*)
| CcMissingInputs of t_call_id * t_pdg_mark PdgMarks.t_select
* bool
(*the function calls a slice that has been modified : and doesn't compute not enough inputs. We will have to choose between adding marks to this function, and call another slice. The boolean tells if the modifications would change the visibility of some inputs.*)
| CcPropagate of t_pdg_mark PdgMarks.t_select (*simply propagate the given marks*)
| CcExamineCalls of t_pdg_mark PdgMarks.t_info_called_outputs (*Slicing criterion for a function.*)

type t_fct_criterion = {
   cf_fct : t_fct_id; (*Identification of the RESULT of this filter. When it a a slice, it might be an existing slice that will be modified, or a new one will be created during application. When it is the source function, it means what the criterion has to be applied on each existing slice, and stored into the inititial marks of the function.*)
   cf_info : t_fct_crit;
}
A slicing criterion is either an application level criterion, or a function level one.

type t_criterion =
| CrAppli of t_appli_criterion
| CrFct of t_fct_criterion

Internals values


val create_sl_mark : m1:t_mark ->
m2:t_mark -> t_pdg_mark
Internal function allowing creation of slicing marks which can break their type invariant !
val dummy_t_pdg_mark : t_pdg_mark

For the journalization of these internals types


val dummy_t_project : t_project
The whole project.
val dummy_t_fct_info : t_fct_info
val dummy_t_marks_index : (t_pdg_mark, t_call_info)
PdgIndex.FctIndex.t
val dummy_t_ff_marks : PdgTypes.Pdg.t *
(t_pdg_mark, t_call_info)
PdgIndex.FctIndex.t
val dummy_t_fct_slice : t_fct_slice
val dummy_t_fct_user_crit : t_fct_user_crit