(* Goal (*Lemma halted_check:*) forall mu m1 m2 v1 v2 *)
(*       (MInj: Mem.inject (as_inj mu) m1 m2) *)
(*       (VInj: val_inject (locvisible_of mu) v1 v2) (WD: SM_wd mu), *)
(*       exists pubSrc' pubTgt' nu,  *)
(*         (pubSrc' = fun b => (locBlocksSrc mu b) && *)
(*                             (REACH m1 (exportedSrc mu (v1::nil)) b)) *)
(*         /\ *)
(*         (pubTgt' = fun b => (locBlocksTgt mu b) && *)
(*                             (REACH m2 (exportedTgt mu (v2::nil)) b)) *)
(*         /\ *)
(*         (nu = replace_locals mu pubSrc' pubTgt') *)
(*          /\ SM_wd nu /\ *)
(*         val_inject (shared_of nu) v1 v2 /\ *)
(*         Mem.inject (shared_of nu) m1 m2. (*/\ val_valid v2 m2*) *)
(* Proof. intros. eexists; eexists; eexists. *)
(*   split. reflexivity. *)
(*   split. reflexivity. *)
(*   split. reflexivity. *)
(*   split.  *)
(*       apply replace_locals_wd; trivial. *)
(*       intros. rewrite andb_true_iff in H. destruct H.  *)
(*       assert (VALS12: Forall2 (val_inject (as_inj mu)) (v1 :: nil) (v2 :: nil)). *)
(*         constructor. eapply val_inject_incr; try eassumption. *)
(*                       unfold locvisible_of, join; simpl. *)
(*                       intros b; intros. remember (foreign_of mu b).  *)
(*                       destruct o; apply eq_sym in Heqo. *)
(*                          destruct p. inv H1. apply foreign_in_all; eassumption. *)
(*                       apply local_in_all; eassumption. *)
(*         constructor. *)
(*       destruct (REACH_local_REACH _ WD _ _ (v1::nil) (v2::nil) MInj VALS12 _ H0 H) *)
(*         as [b2 [d1 [LOC12 R2]]]. *)
(*       exists b2, d1. rewrite LOC12, R2. *)
(*       destruct (local_locBlocks _ WD _ _ _ LOC12) as [_ [? _]]. *)
(*       rewrite H1. intuition. *)
(*       intros. apply andb_true_iff in H. intuition. *)
(*   rewrite replace_locals_shared.  *)
(*   split. inv VInj; try constructor. *)
(*          econstructor. *)
(*          unfold locvisible_of in H. *)
(*          apply joinI. *)
(*          destruct (joinD_Some _ _ _ _ _ H); clear H. *)
(*             left; eassumption. *)
(*          destruct H0. right. split; trivial. *)
(*          remember (locBlocksSrc mu b1 && REACH m1 (exportedSrc mu (Vptr b1 ofs1 :: nil)) b1) as d.  *)
(*               destruct d; apply eq_sym in Heqd. assumption. *)
(*          apply andb_false_iff in Heqd.  *)
(*               destruct (local_locBlocks _ WD _ _ _ H0) as [? [? [? [? ?]]]]. *)
(*               rewrite H1 in *. *)
(*               destruct Heqd; try discriminate. *)
(*               assert (REACH m1 (exportedSrc mu (Vptr b1 ofs1 :: nil)) b1 = true). *)
(*                 apply REACHAX. exists nil. constructor. *)
(*                 unfold exportedSrc, sharedSrc, getBlocks. simpl. *)
(*                  destruct (eq_block b1 b1). simpl. trivial. *)
(*                  exfalso. apply n; trivial. *)
(*               rewrite H7 in H6. inv H6. *)
(*            reflexivity. *)
(*     split. *)
(*          (*goal Mem.mem_inj*)  *)
(*            split; intros.  *)
(*            (*subgoal mi_perm*) *)
(*              apply halted_check_aux in H; trivial.  *)
(*              eapply MInj; try eassumption. *)
(*            (*subgoal mi_align*) *)
(*              apply halted_check_aux in H; trivial.  *)
(*              eapply MInj; try eassumption. *)
(*            (*subgoal mi_memval*) *)
(*              assert (X:= halted_check_aux _ _ _ _ _ _ WD H); trivial. *)
(*              assert (MV:= Mem.mi_memval _ _ _ (Mem.mi_inj _ _ _ MInj) _ _ _ _ X H0). clear X. *)
(*              inv MV; try econstructor; try reflexivity. *)
(*                    apply joinI. *)
(*                    remember (foreign_of mu b0) as f. *)
(*                    destruct f; apply eq_sym in Heqf. *)
(*                       destruct p. rewrite (foreign_in_all _ _ _ _ Heqf) in H3. left; trivial. *)
(*                    right. split; trivial. *)
(* (*THIS Need not hold - if we want to enforce that there are no *)
(* pointers to unknown, we can probably do so by adding *)
(*  the match_inject_clause:  *)
(*     match_validblocks: forall d j c1 m1 c2 m2,  *)
(*           match_state d j c1 m1 c2 m2 -> *)
(*           mem_inject (as_inj mu) m1 m2 /\ *)
(*           mem_inject (locvisible mu) m1 m2, *)
(*    or add an invariant reach_closed  *)
(* and /or tweaking match_norm. cf the Lemma halted_loc_check below. *)
(* *) *)
(* Qed. *)

Lemma REACH_load_vis: forall chunk m b i b1 ofs1
(LD: Mem.load chunk m b (Int.unsigned i) = Some (Vptr b1 ofs1))
mu (VIS: vis mu b = true),
REACH m (vis mu) b1 = true.