[gen] Make wildcard edges only in diy7 and diycross7.

Author: Shale Xiong

gen/CArch_gen.ml

@@ -243,7 +243,7 @@ let pp_rmw compat = function
 
 let is_one_instruction _ = true
 
-let fold_rmw f r = let r = f Add r in  f Exch r
+let fold_rmw _b f r = let r = f Add r in  f Exch r
 
 let fold_rmw_compat f r = f Exch r
 

gen/CCompile_gen.ml

@@ -30,6 +30,7 @@ module type Config = sig
   val typ : TypBase.t
   val cpp : bool
   val docheck : bool
+  val wildcard : bool
 end
 
 module Make(O:Config) : Builder.S
@@ -54,6 +55,7 @@ module Make(O:Config) : Builder.S
           (struct
             let variant = O.variant
             let naturalsize = TypBase.get_size O.typ
+            let wildcard = O.wildcard
           end)
           (A)
 

gen/RISCVArch_gen.ml

@@ -104,15 +104,15 @@ module Make
      let k = f AcqRel k in
      k
 
-   let fold_rmw f k =
+   let fold_rmw _b f k =
      let fold1 f k = fold_mo f (f Rlx k) in
      fold1
        (fun m1 k -> fold1 (fun m2 k -> f (Atomic (m1,m2)) k) k)
        k
 
    let fold_non_mixed f k =
      let k = fold_mo (fun mo k -> f (MO mo) k) k in
-     fold_rmw f k
+     fold_rmw false f k
 
    let fold_atom f k =
      let k = fold_mixed f k in

gen/alt.ml

@@ -31,6 +31,7 @@ module type AltConfig = sig
   val variant : Variant_gen.t -> bool
   type fence
   val cumul : fence list Config.cumul
+  val wildcard : bool
 end
 
 module Make(C:Builder.S)
@@ -737,7 +738,7 @@ module Make(C:Builder.S)
     let fold_ie f k = f (Int) (f (Ext) k)
     let fold_dir f k = f Irr k (* expand later ! *)
     let fold_dir2 f = fold_dir (fun i1 k -> fold_dir (f i1) k)
-    let fold_sd = Code.fold_sd
+    let fold_sd = Code.fold_sd O.wildcard
     let fold_sd_dir2 f =
       fold_sd
         (fun sd -> fold_dir2 (fun d1 d2 -> f sd d1 d2))

gen/common/AArch64Arch_gen.ml

@@ -791,17 +791,17 @@ let fold_aop f r =
   let r = f A_CLR r in
   r
 
-let fold_rmw f r =
+let fold_rmw wildcard f r =
   let r = f LrSc r in
   let r = f Swp r in
   let r = f Cas r in
   let r = fold_aop (fun op r -> f (LdOp op) r) r in
   let r = fold_aop (fun op r -> f (StOp op) r) r in
-  let r = f AllAmo r in
+  let r = if wildcard then f AllAmo r else r in
   r
 
 let all_concrete_rmw =
-  fold_rmw ( fun rmw acc ->
+  fold_rmw false ( fun rmw acc ->
     if rmw <> AllAmo && rmw <> LrSc then rmw :: acc else acc
   ) []
 let expand_rmw rmw = match rmw with

gen/common/code.ml

@@ -129,11 +129,11 @@ let seq_sd sd1 sd2 =
   | Diff,_|_,Diff -> Diff
 
 let fold_ie f r = f Ext (f Int r)
-let fold_sd f r = f UnspecLoc (f Diff (f Same r))
-let fold_extr f r = f (Dir W) (f (Dir R) (f Irr r))
-let fold_sd_extr f = fold_sd (fun sd -> fold_extr (fun e -> f sd e))
-let fold_sd_extr_extr f =
-  fold_sd_extr (fun sd e1 -> fold_extr (fun e2 -> f sd e1 e2))
+let fold_sd wildcard f r = let r = if wildcard then (f UnspecLoc r) else r in f Diff (f Same r)
+let fold_extr wildcard f r = let r = if wildcard then (f Irr r) else r in f (Dir W) (f (Dir R) r)
+let fold_sd_extr wildcard f = fold_sd wildcard (fun sd -> fold_extr wildcard (fun e -> f sd e))
+let fold_sd_extr_extr wildcard f =
+  fold_sd_extr wildcard (fun sd e1 -> fold_extr wildcard (fun e2 -> f sd e1 e2))
 
 type check =
   | Default | Sc | Uni | Thin | Critical

gen/common/code.mli

@@ -70,10 +70,11 @@ val seq_sd : sd -> sd -> sd
 val is_same_loc : sd -> bool
 val is_both_loc : sd -> bool
 val fold_ie : (ie -> 'a -> 'a) -> 'a -> 'a
-val fold_extr : (extr -> 'a -> 'a) -> 'a -> 'a
-val fold_sd : (sd -> 'a -> 'a) -> 'a -> 'a
-val fold_sd_extr : (sd -> extr -> 'a -> 'a) -> 'a -> 'a
-val fold_sd_extr_extr : (sd -> extr -> extr -> 'a -> 'a) -> 'a -> 'a
+(* The first boolean indicates on wildcard syntax *)
+val fold_extr : bool -> (extr -> 'a -> 'a) -> 'a -> 'a
+val fold_sd : bool -> (sd -> 'a -> 'a) -> 'a -> 'a
+val fold_sd_extr : bool -> (sd -> extr -> 'a -> 'a) -> 'a -> 'a
+val fold_sd_extr_extr : bool -> (sd -> extr -> extr -> 'a -> 'a) -> 'a -> 'a
 
 type check =
   | Default | Sc | Uni | Thin | Critical | Free

gen/common/edge.ml

@@ -20,6 +20,7 @@ module Config =
   struct
     let variant _ = false
     let naturalsize = TypBase.get_size TypBase.default
+    let wildcard = false
   end
 
 let dbg = 0
@@ -35,6 +36,7 @@ module type S = sig
   type atom
   module PteVal : PteVal_gen.S with type pte_atom = atom
   type rmw
+  val wildcard : bool
 
   val pp_atom : atom -> string
   val tr_value : atom option -> Code.v -> Code.v
@@ -160,6 +162,7 @@ module
        sig
          val variant : Variant_gen.t -> bool
          val naturalsize : MachSize.sz
+         val wildcard : bool
        end)
     (F:Fence.S) : S
 with
@@ -175,6 +178,7 @@ and type rmw = F.rmw = struct
   let do_kvm =  Variant_gen.is_kvm Cfg.variant
   let do_disjoint = Cfg.variant Variant_gen.MixedDisjoint
   let do_strict_overlap = Cfg.variant Variant_gen.MixedStrictOverlap
+  let wildcard = Cfg.wildcard
 
   let debug = false
   open Code
@@ -389,24 +393,25 @@ let fold_tedges f r =
   let r = fold_ie (fun ie -> f (Rf ie)) r in
   let r = fold_ie (fun ie -> f (Fr ie)) r in
   let r = fold_ie (fun ie -> f (Ws ie)) r in
-  let r = F.fold_rmw (fun rmw -> f (Rmw rmw)) r in
-  let r = fold_sd_extr_extr (fun sd e1 e2 r -> f (Po (sd,e1,e2)) r) r in
+  let r = F.fold_rmw wildcard (fun rmw -> f (Rmw rmw)) r in
+  let r = fold_sd_extr_extr wildcard (fun sd e1 e2 r -> f (Po (sd,e1,e2)) r) r in
   let r = F.fold_all_fences (fun fe -> f (Insert fe)) r in
   let r = f Store r in
   let r =
     F.fold_all_fences
       (fun fe ->
-        fold_sd_extr_extr
+        fold_sd_extr_extr wildcard
           (fun sd e1 e2 -> f (Fenced (fe,sd,e1,e2)))) r in
   let r =
     F.fold_dpr
-      (fun dp -> fold_sd (fun sd -> f (Dp (dp,sd,Dir R)))) r in
+      (fun dp -> fold_sd wildcard (fun sd -> f (Dp (dp,sd,Dir R)))) r in
   let r =
     F.fold_dpw
-      (fun dp -> fold_sd (fun sd -> f (Dp (dp,sd,Dir W)))) r in
+      (fun dp -> fold_sd wildcard (fun sd -> f (Dp (dp,sd,Dir W)))) r in
   let r =
-    F.fold_dpw
-      (fun dp -> fold_sd (fun sd -> f (Dp (dp,sd,Irr)))) r in
+    if wildcard then F.fold_dpw
+      (fun dp -> fold_sd wildcard (fun sd -> f (Dp (dp,sd,Irr)))) r
+    else r in
   let r = f Id r in
   let r = f (Node R) (f (Node W) r) in
   let r = f Hat r in
@@ -586,7 +591,7 @@ let fold_tedges f r =
 
   let () =
    four_times_iter_edges false iter_edges;
-   fold_sd_extr_extr
+   fold_sd_extr_extr wildcard
       (fun sd e1 e2 () ->
         add_lxm_edge
           (pp_strong sd e1 e2) (plain_edge (Fenced (F.strong,sd,e1,e2)))) () ;
@@ -596,9 +601,10 @@ let fold_tedges f r =
         add_lxm_edge
           (pp_dp_default tag sd e)
           (plain_edge (Dp (dp,sd,e))) in
-    fold_sd
+    fold_sd wildcard
       (fun sd () ->
-        fill_opt "Dp" F.ddr_default sd Irr ;
+        if wildcard then fill_opt "Dp" F.ddr_default sd Irr ;
+        if wildcard then fill_opt "Ctrl" F.ctrlr_default sd Irr ;
         fill_opt "Dp" F.ddr_default sd (Dir R) ;
         fill_opt "Ctrl" F.ctrlr_default sd (Dir R) ;
         fill_opt "Dp" F.ddw_default sd (Dir W) ;

gen/common/rmw.mli

@@ -22,7 +22,8 @@ module type S = sig
 
   val pp_rmw : bool (* backward compatibility *) -> rmw -> string
   val is_one_instruction : rmw -> bool
-  val fold_rmw : (rmw -> 'a -> 'a) -> 'a -> 'a
+  (*  the first boolean indicates if including wildcard syntax *)
+  val fold_rmw : bool -> (rmw -> 'a -> 'a) -> 'a -> 'a
   (* Second round of fold, for rmw with back compatible name *)
   val fold_rmw_compat : (rmw -> 'a -> 'a) -> 'a -> 'a
   val applies_atom_rmw : rmw -> rmw_atom option -> rmw_atom option -> bool

gen/compileCommon.ml

@@ -24,6 +24,7 @@ module type Config = sig
   val hexa : bool
   val moreedges : bool
   val variant : Variant_gen.t -> bool
+  val wildcard : bool
 end
 
 module type S = sig
@@ -59,6 +60,7 @@ module Make(C:Config) (A:Arch_gen.S) = struct
       (struct
         let variant = C.variant
         let naturalsize = TypBase.get_size C.typ
+        let wildcard = C.wildcard
       end)
       (A)