TP4 OK

src/cfg_dead_assign.ml

@@ -19,6 +19,12 @@ let dead_assign_elimination_fun ({ cfgfunbody; _ } as f: cfg_fun) =
     Hashtbl.map (fun (n: int) (m: cfg_node) ->
         match m with
            (* TODO *)
+        |Cassign (var,e,i) -> 
+          begin 
+            match Hashtbl.find_option (live_cfg_fun f ) i with
+            | Some set_of_var -> if Set.mem var set_of_var  then m else (changed:= true ; (Cnop i ))
+            | None -> (changed:= true ; Cnop i)
+          end
         | _ -> m
       ) cfgfunbody in
   ({ f with cfgfunbody }, !changed )
@@ -28,7 +34,8 @@ let dead_assign_elimination_fun ({ cfgfunbody; _ } as f: cfg_fun) =
 let rec iter_dead_assign_elimination_fun f =
   let f, c = dead_assign_elimination_fun f in
    (* TODO *)
-   f
+   if c then iter_dead_assign_elimination_fun f
+   else f
 
 let dead_assign_elimination_gdef = function
     Gfun f -> Gfun (iter_dead_assign_elimination_fun f)

src/cfg_liveness.ml

@@ -4,24 +4,39 @@ open Cfg
 (* Analyse de vivacité *)
 
 (* [vars_in_expr e] renvoie l'ensemble des variables qui apparaissent dans [e]. *)
-let rec vars_in_expr (e: expr) =
+let rec vars_in_expr (e: expr) : string Set.t = (*Type de sortie rajouté par moi*)
    (* TODO *)
-   Set.empty
-
-(* [live_cfg_node node live_after] renvoie l'ensemble des variables vivantes
-   avant un nœud [node], étant donné l'ensemble [live_after] des variables
-   vivantes après ce nœud. *)
-let live_cfg_node (node: cfg_node) (live_after: string Set.t) =
-   (* TODO *)
-   live_after
+   match e with 
+   | Ebinop (b,e1,e2) -> Set.union (vars_in_expr e1)  (vars_in_expr e2)
+   | Eunop (u,e) -> vars_in_expr e
+   | Eint i -> Set.empty
+   | Evar s -> Set.singleton s
 
 (* [live_after_node cfg n] renvoie l'ensemble des variables vivantes après le
    nœud [n] dans un CFG [cfg]. [lives] est l'état courant de l'analyse,
    c'est-à-dire une table dont les clés sont des identifiants de nœuds du CFG et
    les valeurs sont les ensembles de variables vivantes avant chaque nœud. *)
-let live_after_node cfg n (lives: (int, string Set.t) Hashtbl.t) : string Set.t =
+   let live_after_node cfg n (lives: (int, string Set.t) Hashtbl.t) : string Set.t =
+      (* TODO *)
+      Set.fold ((fun x acc-> 
+         match Hashtbl.find_option lives x with 
+         | Some set -> Set.union acc set
+         | None -> acc
+         )  )  (succs cfg n ) Set.empty
+
+
+(* [live_cfg_node node live_after] renvoie l'ensemble des variables vivantes
+   avant un nœud [node], étant donné l'ensemble [live_after] des variables
+   vivantes après ce nœud. *)
+let live_cfg_node (node: cfg_node) (live_after: string Set.t) =
    (* TODO *)
-   Set.empty
+   match node with 
+   | Cassign (s, e, i) -> Set.union (vars_in_expr e) (Set.diff live_after (Set.singleton s))
+   | Creturn e -> vars_in_expr e
+   | Cprint (e,i) -> Set.union (vars_in_expr e) live_after
+   | Ccmp (e,i1,i2) -> Set.union (vars_in_expr e) live_after
+   | Cnop i -> Set.empty
+   
 
 (* [live_cfg_nodes cfg lives] effectue une itération du calcul de point fixe.
 
@@ -31,7 +46,16 @@ let live_after_node cfg n (lives: (int, string Set.t) Hashtbl.t) : string Set.t
    nœud a changé). *)
 let live_cfg_nodes cfg (lives : (int, string Set.t) Hashtbl.t) =
    (* TODO *)
-   false
+   List.fold (fun acc (node_int, node) -> 
+      let list_out = live_after_node cfg node_int lives in
+      let list_in = live_cfg_node node list_out in
+      match (Hashtbl.find_option lives node_int) with
+      |Some list_of_nodes -> 
+         if Set.equal list_in list_of_nodes then acc
+         else 
+            (Hashtbl.replace lives node_int list_in ; true)
+      |None -> Hashtbl.replace lives node_int list_in ; true)
+       false (List.sort compare @@ Hashtbl.to_list cfg) 
 
 (* [live_cfg_fun f] calcule l'ensemble des variables vivantes avant chaque nœud
    du CFG en itérant [live_cfg_nodes] jusqu'à ce qu'un point fixe soit atteint.
@@ -39,4 +63,7 @@ let live_cfg_nodes cfg (lives : (int, string Set.t) Hashtbl.t) =
 let live_cfg_fun (f: cfg_fun) : (int, string Set.t) Hashtbl.t =
   let lives = Hashtbl.create 17 in
      (* TODO *)
- lives
+     let rec boucle_while_cachee cfg = if live_cfg_nodes cfg lives 
+      then boucle_while_cachee cfg
+   else lives in
+   boucle_while_cachee f.cfgfunbody
\ No newline at end of file