Module `InferIR.Procdesc`

Per-procedure CFG

module NodeKey : sig ... end

module Node : sig ... end: node of the control flow graph

module IdMap : InferStdlib.PrettyPrintable.PPMap with type PPMap.key = Node.id: Map with node id keys.

module NodeHash : InferStdlib.IStd.Caml.Hashtbl.S with type NodeHash.key = Node.t: Hash table with nodes as keys.

module NodeMap : InferStdlib.IStd.Caml.Map.S with type NodeMap.key = Node.t: Map over nodes.

module NodeSet : InferStdlib.IStd.Caml.Set.S with type NodeSet.elt = Node.t: Set of nodes.

type t: proc description

val append_locals : t -> ProcAttributes.var_data list -> unit: append a list of new local variables to the existing list of local variables

val compute_distance_to_exit_node : t -> unit: Compute the distance of each node to the exit node, if not computed already

val create_node : t -> InferBase.Location.t -> Node.nodekind -> Sil.instr list -> Node.t: Create a new cfg node with the given location, kind, list of instructions, and add it to the procdesc.

val create_node_from_not_reversed : t -> InferBase.Location.t -> Node.nodekind -> Instrs.not_reversed_t -> Node.t
val fold_instrs : t -> init:'accum -> f:('accum -> Node.t -> Sil.instr -> 'accum) -> 'accum: fold over all nodes and their instructions

val find_map_instrs : t -> f:(Sil.instr -> 'a option) -> 'a option
val from_proc_attributes : ProcAttributes.t -> t: Use Cfg.create_proc_desc if you are adding a proc desc to a cfg

val get_access : t -> PredSymb.access: Return the visibility attribute

val get_attributes : t -> ProcAttributes.t: Get the attributes of the procedure.

val set_attributes : t -> ProcAttributes.t -> unit
val get_captured : t -> (Mangled.t * Typ.t) list: Return name and type of block's captured variables

val get_exit_node : t -> Node.t
val get_formals : t -> (Mangled.t * Typ.t) list: Return name and type of formal parameters

val get_pvar_formals : t -> (Pvar.t * Typ.t) list: Return pvar and type of formal parameters

val get_loc : t -> InferBase.Location.t: Return loc information for the procedure

val get_locals : t -> ProcAttributes.var_data list: Return name and type and attributes of local variables

val get_nodes : t -> Node.t list
val get_nodes_num : t -> int
val get_proc_name : t -> Typ.Procname.t
val get_ret_type : t -> Typ.t: Return the return type of the procedure and type string

val has_added_return_param : t -> bool
val get_ret_var : t -> Pvar.t
val get_start_node : t -> Node.t
val get_static_callees : t -> Typ.Procname.t list: get a list of unique static callees excluding self

val is_defined : t -> bool: Return true iff the procedure is defined, and not just declared

val is_java_synchronized : t -> bool: Return true if the procedure signature has the Java synchronized keyword

val iter_instrs : (Node.t -> Sil.instr -> unit) -> t -> unit: iterate over all nodes and their instructions

val replace_instrs : t -> f:(Node.t -> Sil.instr -> Sil.instr) -> bool: Map and replace the instructions to be executed. Returns true if at least one substitution occured.

val replace_instrs_by : t -> f:(Node.t -> Sil.instr -> Sil.instr array) -> bool: Like replace_instrs, but slower, and each instruction may be replaced by 0, 1, or more instructions.

val iter_nodes : (Node.t -> unit) -> t -> unit: iterate over all the nodes of a procedure

val fold_nodes : t -> init:'accum -> f:('accum -> Node.t -> 'accum) -> 'accum: fold over all the nodes of a procedure

val fold_slope_range : Node.t -> Node.t -> init:'accum -> f:('accum -> Node.t -> 'accum) -> 'accum: fold between two nodes or until we reach a branching structure

val set_succs_exn_only : Node.t -> Node.t list -> unit
val node_set_succs_exn : t -> Node.t -> Node.t list -> Node.t list -> unit: Set the successor nodes and exception nodes, and build predecessor links

val set_exit_node : t -> Node.t -> unit: Set the exit node of the procedure

val set_start_node : t -> Node.t -> unit
val get_wto : t -> Node.t WeakTopologicalOrder.Partition.t
val is_loop_head : t -> Node.t -> bool
val pp_signature : Stdlib.Format.formatter -> t -> unit
val pp_local : Stdlib.Format.formatter -> ProcAttributes.var_data -> unit
val is_specialized : t -> bool
val is_captured_pvar : t -> Pvar.t -> bool: true if pvar is a captured variable of a cpp lambda or obcj block

val is_captured_var : t -> Var.t -> bool: true if var is a captured variable of a cpp lambda or obcj block

val has_modify_in_block_attr : t -> Pvar.t -> bool
val is_connected : t -> (unit, [ `Join | `Other ]) InferStdlib.IStd.Result.t: checks whether a cfg for the given procdesc is connected or not

module SQLite : InferBase.SqliteUtils.Data with type t = t option: per-procedure CFGs are stored in the SQLite "procedures" table as NULL if the procedure has no CFG

val load : Typ.Procname.t -> t option