Gible Seq Generation Proof

Defining a find block specification

Basically, it should be able to find the location of the block without using the find_block function, so that this is more useful for the proofs. There are various different types of options that could come up though:

1. The instruction is a standard instruction present inside of a basic block.

2. The instruction is a standard instruction which ends with a goto.

3. The instruction is a control-flow instruction.

For case number 1, there should exist a value in the list of instructions, such that the instructions match exactly, and the indices match as well. In the original code, this instruction must have been going from the current node to the node - 1.

For case number 2, there should be an instruction at the right index again, however, this time there will also be a goto instruction in the control-flow part of the basic block.

For case number 3, there should be a nop instruction in the basic block, and then the equivalent control-flow instruction ending the basic block.

In the end though, it seems like two cases are actually enough, as the last two cases are similar enough that they can be merged into one.

Definition all_max {A} (c: PTree.t A) p: Prop :=
  Forall (fun x => x <= p) (map fst (PTree.elements c)).

Definition offset (pc pc': positive): nat := Pos.to_nat pc' - Pos.to_nat pc.

Section CORRECTNESS.

  Context (prog : RTL.program).
  Context (tprog : GibleSeq.program).

  Let ge : RTL.genv := Globalenvs.Genv.globalenv prog.
  Let tge : genv := Globalenvs.Genv.globalenv tprog.

Matches the basic block that should be present in the state. This simulates the small step execution of the basic block from the big step semantics that are currently present.

Why does it not need to find the pc’ value using find_block?

It doesn’t have to find the value because it’s given as an input, and the finding is actually done at that higher level already.

(*  Variant match_bblock (tc: code) (pc pc': node): list instr -> Prop :=
    | match_bblock_intro :
      forall bb cf,
        tc ! pc' = Some (mk_bblock bb cf) ->
        match_bblock tc pc pc' (list_drop (offset pc pc') bb).*)

  Definition imm_succ (pc pc': node) : Prop := pc' = Pos.pred pc.

  Definition valid_succ (tc: code) (pc: node) : Prop := exists b, tc ! pc = Some b.

  Inductive match_block (c: RTL.code) (tc: code) (pc: node): SeqBB.t -> Prop :=
  (*
   * Basic Block Instructions
   *)
  | match_block_nop b pc':
    c ! pc = Some (RTL.Inop pc') ->
    match_block c tc pc' b ->
    match_block c tc pc (RBnop :: b)
  | match_block_op b op args dst pc':
    c ! pc = Some (RTL.Iop op args dst pc') ->
    match_block c tc pc' b ->
    match_block c tc pc (RBop None op args dst :: b)
  | match_block_load b chunk addr args dst pc':
    c ! pc = Some (RTL.Iload chunk addr args dst pc') ->
    match_block c tc pc' b ->
    match_block c tc pc (RBload None chunk addr args dst :: b)
  | match_block_store b chunk addr args src pc':
    c ! pc = Some (RTL.Istore chunk addr args src pc') ->
    match_block c tc pc' b ->
    match_block c tc pc (RBstore None chunk addr args src :: b)
  (*
   * Control flow instructions using goto
   *)
  | match_block_goto pc':
    c ! pc = Some (RTL.Inop pc') ->
    valid_succ tc pc' ->
    match_block c tc pc (RBnop :: RBexit None (RBgoto pc') :: nil)
  | match_block_op_cf pc' op args dst:
    c ! pc = Some (RTL.Iop op args dst pc') ->
    valid_succ tc pc' ->
    match_block c tc pc (RBop None op args dst :: RBexit None (RBgoto pc') :: nil)
  | match_block_load_cf pc' chunk addr args dst:
    c ! pc = Some (RTL.Iload chunk addr args dst pc') ->
    valid_succ tc pc' ->
    match_block c tc pc (RBload None chunk addr args dst :: RBexit None (RBgoto pc') :: nil)
  | match_block_store_cf pc' chunk addr args src:
    c ! pc = Some (RTL.Istore chunk addr args src pc') ->
    valid_succ tc pc' ->
    match_block c tc pc (RBstore None chunk addr args src :: RBexit None (RBgoto pc') :: nil)
  (*
   * Standard control flow instructions
   *)
  | match_block_call sig ident args dst pc' :
    c ! pc = Some (RTL.Icall sig ident args dst pc') ->
    valid_succ tc pc' ->
    match_block c tc pc (RBnop :: RBexit None (RBcall sig ident args dst pc') :: nil)
  | match_block_tailcall sig ident args :
    c ! pc = Some (RTL.Itailcall sig ident args) ->
    match_block c tc pc (RBnop :: RBexit None (RBtailcall sig ident args) :: nil)
  | match_block_builtin ident args dst pc' :
    c ! pc = Some (RTL.Ibuiltin ident args dst pc') ->
    valid_succ tc pc' ->
    match_block c tc pc (RBnop :: RBexit None (RBbuiltin ident args dst pc') :: nil)
  | match_block_cond cond args pct pcf :
    c ! pc = Some (RTL.Icond cond args pct pcf) ->
    valid_succ tc pct ->
    valid_succ tc pcf ->
    match_block c tc pc (RBnop :: RBexit None (RBcond cond args pct pcf) :: nil)
  | match_block_jumptable r ns :
    c ! pc = Some (RTL.Ijumptable r ns) ->
    Forall (valid_succ tc) ns ->
    match_block c tc pc (RBnop :: RBexit None (RBjumptable r ns) :: nil)
  | match_block_return r :
    c ! pc = Some (RTL.Ireturn r) ->
    match_block c tc pc (RBnop :: RBexit None (RBreturn r) :: nil)
  .

Match the code

The match_code predicate asserts that for any node in the original control-flow graph, there is now a basic block in the new control- and data-flow graph that contains the same instruction, but also that the whole basic block matches some sequence of instructions starting at the node that corresponds to the basic block.

  Definition match_code (c: RTL.code) (tc: code) : Prop :=
    forall pc b, tc ! pc = Some b -> match_block c tc pc b.

  Variant match_stackframe : RTL.stackframe -> stackframe -> Prop :=
    | match_stackframe_init :
      forall res f tf sp pc rs
        (TF: transl_function f = OK tf)
        (VALID: valid_succ tf.(fn_code) pc),
        match_stackframe (RTL.Stackframe res f sp pc rs)
                         (Stackframe res tf sp pc rs (PMap.init false)).

  Definition sem_extrap f pc sp in_s in_s' block :=
    forall out_s block2,
      SeqBB.step tge sp in_s block out_s ->
      f.(fn_code) ! pc = Some block2 ->
      SeqBB.step tge sp in_s' block2 out_s.

  Lemma match_block_exists_instr :
    forall c tc pc a,
      match_block c tc pc a ->
      exists i, c ! pc = Some i.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
forall (c : RTL.code) (tc : code) (pc : node)
  (a : SeqBB.t),
match_block c tc pc a ->
exists i : RTL.instruction, c ! pc = Some i
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
forall (c : RTL.code) (tc : code) 
  (pc : node) (a : SeqBB.t),
match_block c tc pc a ->
exists i : RTL.instruction, c ! pc = Some i inversion 1; eexists; eauto. Qed.

  Lemma match_block_not_nil :
    forall c tc pc a,
      match_block c tc pc a -> a <> nil.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
forall (c : RTL.code) (tc : code) (pc : node)
  (a : SeqBB.t), match_block c tc pc a -> a <> nil
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
forall (c : RTL.code) (tc : code) 
  (pc : node) (a : SeqBB.t),
match_block c tc pc a -> a <> nil inversion 1; crush. Qed.

Matching states

Initially, the idea was to define the match_states predicate normally to defines how to find the correct bb that should be executed, as well as the value of pc. However, this does not quite work when proving the equivalence of the translation from RTL to RTLBlock, because one cannot match one transition to a transition in RTLBlock. The alternative to this is to include a proof inside of the match_states that shows that the execution from the pc of the start of the basic block to the current point is the same as the whole execution (in one big step) of the basic block.

  Variant match_states : option SeqBB.t -> RTL.state -> state -> Prop :=
    | match_state :
      forall stk stk' f tf sp pc rs m pc0 b rs0 m0
        (TF: transl_function f = OK tf)
        (* TODO: I can remove the following [match_code]. *)
        (CODE: match_code f.(RTL.fn_code) tf.(fn_code))
        (BLOCK: exists b', tf.(fn_code) ! pc0 = Some b'
                           /\ match_block f.(RTL.fn_code) tf.(fn_code) pc b)
        (STK: Forall2 match_stackframe stk stk')
        (STARSIMU: star RTL.step ge (RTL.State stk f sp pc0 rs0 m0)
                                  E0 (RTL.State stk f sp pc rs m))
        (BB: sem_extrap tf pc0 sp (Iexec (mk_instr_state rs (PMap.init false) m))
                        (Iexec (mk_instr_state rs0 (PMap.init false) m0)) b),
        match_states (Some b) (RTL.State stk f sp pc rs m)
                     (State stk' tf sp pc0 rs0 (PMap.init false) m0)
    | match_callstate :
      forall cs cs' f tf args m
        (TF: transl_fundef f = OK tf)
        (STK: Forall2 match_stackframe cs cs'),
        match_states None (RTL.Callstate cs f args m) (Callstate cs' tf args m)
    | match_returnstate :
      forall cs cs' v m
        (STK: Forall2 match_stackframe cs cs'),
        match_states None (RTL.Returnstate cs v m) (Returnstate cs' v m)
  .

  Definition match_prog (p: RTL.program) (tp: GibleSeq.program) :=
    Linking.match_program (fun cu f tf => transl_fundef f = Errors.OK tf) eq p tp.

  Lemma transf_program_match:
    forall p tp, transl_program p = OK tp -> match_prog p tp.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
forall (p : RTL.program) (tp : program),
transl_program p = OK tp -> match_prog p tp
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
forall (p : RTL.program) (tp : program),
transl_program p = OK tp -> match_prog p tp
    intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
p: RTL.program
tp: program
H: transl_program p = OK tp
match_prog p tp unfold transl_program, match_prog.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
p: RTL.program
tp: program
H: transl_program p = OK tp
Linking.match_program
  (fun
     (_ : AST.program (AST.fundef RTL.function) unit)
     (f : AST.fundef RTL.function)
     (tf : AST.fundef function) =>
   transl_fundef f = OK tf) eq p tp
    eapply Linking.match_transform_partial_program; auto.
  Qed.

  Context (TRANSL : match_prog prog tprog).

  Lemma symbols_preserved:
    forall (s: AST.ident), Genv.find_symbol tge s = Genv.find_symbol ge s.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall s : ident,
Genv.find_symbol tge s = Genv.find_symbol ge s
  Proof using TRANSL.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall s : ident,
Genv.find_symbol tge s = Genv.find_symbol ge s intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: ident
Genv.find_symbol tge s = Genv.find_symbol ge s eapply (Genv.find_symbol_match TRANSL). Qed.

  Lemma senv_preserved:
    Senv.equiv (Genv.to_senv ge) (Genv.to_senv tge).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
Senv.equiv ge tge
  Proof using TRANSL.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
Senv.equiv ge tge intros; eapply (Genv.senv_transf_partial TRANSL). Qed.
  #[local] Hint Resolve senv_preserved : rtlbg.

  Lemma function_ptr_translated:
    forall b f,
      Genv.find_funct_ptr ge b = Some f ->
      exists tf, Genv.find_funct_ptr tge b = Some tf /\ transl_fundef f = OK tf.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (b : block) (f : RTL.fundef),
Genv.find_funct_ptr ge b = Some f ->
exists tf : fundef,
  Genv.find_funct_ptr tge b = Some tf /\
  transl_fundef f = OK tf
  Proof (Genv.find_funct_ptr_transf_partial TRANSL).

  Lemma sig_transl_function:
    forall (f: RTL.fundef) (tf: GibleSeq.fundef),
      transl_fundef f = OK tf ->
      GibleSeq.funsig tf = RTL.funsig f.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (f : RTL.fundef) (tf : fundef),
transl_fundef f = OK tf -> funsig tf = RTL.funsig f
  Proof using.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (f : RTL.fundef) (tf : fundef),
transl_fundef f = OK tf -> funsig tf = RTL.funsig f
    unfold transl_fundef.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (f : RTL.fundef) (tf : fundef),
transf_partial_fundef transl_function f = OK tf ->
funsig tf = RTL.funsig f unfold transf_partial_fundef.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (f : RTL.fundef) (tf : fundef),
match f with
| Internal f0 =>
    bind (transl_function f0)
      (fun f' : function => OK (Internal f'))
| External ef => OK (External ef)
end = OK tf -> funsig tf = RTL.funsig f
    intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
H: match f with
| Internal f =>
    bind (transl_function f)
      (fun f' : function => OK (Internal f'))
| External ef => OK (External ef)
end = OK tf
funsig tf = RTL.funsig f destruct_match.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
f0: RTL.function
Heqf0: f = Internal f0
H: bind (transl_function f0)
  (fun f' : function => OK (Internal f')) = 
OK tf
funsig tf = RTL.funsig (Internal f0)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
e: external_function
Heqf0: f = External e
H: OK (External e) = OK tf
funsig tf = RTL.funsig (External e) unfold bind in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
f0: RTL.function
Heqf0: f = Internal f0
H: match transl_function f0 with
| OK x => OK (Internal x)
| Error msg => Error msg
end = OK tf
funsig tf = RTL.funsig (Internal f0)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
e: external_function
Heqf0: f = External e
H: OK (External e) = OK tf
funsig tf = RTL.funsig (External e) destruct_match; try discriminate.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
f0: RTL.function
Heqf0: f = Internal f0
f1: function
Heqr: transl_function f0 = OK f1
H: OK (Internal f1) = OK tf
funsig tf = RTL.funsig (Internal f0)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
e: external_function
Heqf0: f = External e
H: OK (External e) = OK tf
funsig tf = RTL.funsig (External e)
    inv H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f0: RTL.function
f1: function
Heqr: transl_function f0 = OK f1
funsig (Internal f1) = RTL.funsig (Internal f0)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
e: external_function
Heqf0: f = External e
H: OK (External e) = OK tf
funsig tf = RTL.funsig (External e) unfold transl_function in Heqr.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f0: RTL.function
f1: function
Heqr: match partition f0 with
| OK f' =>
    if
     check_valid_node (fn_code f')
       (RTL.fn_entrypoint f0)
    then
     if
      forall_ptree
        (check_code (RTL.fn_code f0)
           (fn_code f')) 
        (fn_code f')
     then
      OK
        {|
          fn_sig := RTL.fn_sig f0;
          fn_params := RTL.fn_params f0;
          fn_stacksize := RTL.fn_stacksize f0;
          fn_code := fn_code f';
          fn_entrypoint := RTL.fn_entrypoint f0
        |}
     else
      Error (msg "check_present_blocks failed")
    else
     Error (msg "entrypoint does not exists")
| Error msg => Error msg
end = OK f1
funsig (Internal f1) = RTL.funsig (Internal f0)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
e: external_function
Heqf0: f = External e
H: OK (External e) = OK tf
funsig tf = RTL.funsig (External e)
    repeat (destruct_match; try discriminate).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f0: RTL.function
f1, f: function
Heqr0: partition f0 = OK f
Heqb: check_valid_node (fn_code f)
  (RTL.fn_entrypoint f0) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f0) (fn_code f))
  (fn_code f) = true
Heqr: OK
  {|
    fn_sig := RTL.fn_sig f0;
    fn_params := RTL.fn_params f0;
    fn_stacksize := RTL.fn_stacksize f0;
    fn_code := fn_code f;
    fn_entrypoint := RTL.fn_entrypoint f0
  |} = OK f1
funsig (Internal f1) = RTL.funsig (Internal f0)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
e: external_function
Heqf0: f = External e
H: OK (External e) = OK tf
funsig tf = RTL.funsig (External e) inv Heqr.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f0: RTL.function
f: function
Heqr0: partition f0 = OK f
Heqb: check_valid_node (fn_code f)
  (RTL.fn_entrypoint f0) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f0) (fn_code f))
  (fn_code f) = true
funsig
  (Internal
     {|
       fn_sig := RTL.fn_sig f0;
       fn_params := RTL.fn_params f0;
       fn_stacksize := RTL.fn_stacksize f0;
       fn_code := fn_code f;
       fn_entrypoint := RTL.fn_entrypoint f0
     |}) = RTL.funsig (Internal f0)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
e: external_function
Heqf0: f = External e
H: OK (External e) = OK tf
funsig tf = RTL.funsig (External e) auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.fundef
tf: fundef
e: external_function
Heqf0: f = External e
H: OK (External e) = OK tf
funsig tf = RTL.funsig (External e)
    inv H; auto.
  Qed.

  Definition measure (b: option SeqBB.t): nat :=
    match b with
    | None => 0
    | Some b' => 1 + length b'
    end.

  Lemma check_valid_node_correct :
    forall a b, check_valid_node a b = true -> valid_succ a b.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (a : code) (b : node),
check_valid_node a b = true -> valid_succ a b
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (a : code) (b : node),
check_valid_node a b = true -> valid_succ a b
    intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
a: code
b: node
H: check_valid_node a b = true
valid_succ a b unfold valid_succ, check_valid_node in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
a: code
b: node
H: match a ! b with
| Some _ => true
| None => false
end = true
exists b0 : SeqBB.t, a ! b = Some b0
    destruct_match; try discriminate; eauto.
  Qed.

  Lemma transl_entrypoint_exists :
    forall f tf,
      transl_function f = OK tf ->
      valid_succ (fn_code tf) (fn_entrypoint tf).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (f : RTL.function) (tf : function),
transl_function f = OK tf ->
valid_succ (fn_code tf) (fn_entrypoint tf)
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (f : RTL.function) (tf : function),
transl_function f = OK tf ->
valid_succ (fn_code tf) (fn_entrypoint tf)
    unfold transl_function; intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.function
tf: function
H: match partition f with
| OK f' =>
    if
     check_valid_node (fn_code f')
       (RTL.fn_entrypoint f)
    then
     if
      forall_ptree
        (check_code (RTL.fn_code f) (fn_code f'))
        (fn_code f')
     then
      OK
        {|
          fn_sig := RTL.fn_sig f;
          fn_params := RTL.fn_params f;
          fn_stacksize := RTL.fn_stacksize f;
          fn_code := fn_code f';
          fn_entrypoint := RTL.fn_entrypoint f
        |}
     else
      Error (msg "check_present_blocks failed")
    else Error (msg "entrypoint does not exists")
| Error msg => Error msg
end = OK tf
valid_succ (fn_code tf) (fn_entrypoint tf)
    repeat (destruct_match; try discriminate; []).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.function
tf, f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
H: OK
  {|
    fn_sig := RTL.fn_sig f;
    fn_params := RTL.fn_params f;
    fn_stacksize := RTL.fn_stacksize f;
    fn_code := fn_code f0;
    fn_entrypoint := RTL.fn_entrypoint f
  |} = OK tf
valid_succ (fn_code tf) (fn_entrypoint tf) inv H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.function
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
valid_succ
  (fn_code
     {|
       fn_sig := RTL.fn_sig f;
       fn_params := RTL.fn_params f;
       fn_stacksize := RTL.fn_stacksize f;
       fn_code := fn_code f0;
       fn_entrypoint := RTL.fn_entrypoint f
     |})
  (fn_entrypoint
     {|
       fn_sig := RTL.fn_sig f;
       fn_params := RTL.fn_params f;
       fn_stacksize := RTL.fn_stacksize f;
       fn_code := fn_code f0;
       fn_entrypoint := RTL.fn_entrypoint f
     |}) simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.function
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
valid_succ (fn_code f0) (RTL.fn_entrypoint f)
    eauto using check_valid_node_correct.
  Qed.

  Lemma ceq_eq :
    forall A a (b: A) c,
      ceq a b c = true ->
      b = c.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (A : Type)
  (a : forall a b : A, {a = b} + {a <> b}) (b c : A),
ceq a b c = true -> b = c
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (A : Type)
  (a : forall a b : A, {a = b} + {a <> b}) (b c : A),
ceq a b c = true -> b = c
    intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
A: Type
a: forall a b : A, {a = b} + {a <> b}
b, c: A
H: ceq a b c = true
b = c unfold ceq in H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
A: Type
a: forall a b : A, {a = b} + {a <> b}
b, c: A
H: (if a b c then true else false) = true
b = c destruct_match; try discriminate.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
A: Type
a: forall a b : A, {a = b} + {a <> b}
b, c: A
e: b = c
Heqs: a b c = left e
H: true = true
b = c auto.
  Qed.

  Ltac unfold_ands :=
    repeat match goal with
           | H: _ && _ = true |- _ => apply andb_prop in H
           | H: _ /\ _ |- _ => inv H
           | H: ceq _ _ _ = true |- _ => apply ceq_eq in H; subst
           end.

  Lemma transl_match_code' :
    forall c tc b pc,
      check_code c tc pc b = true ->
      match_block c tc pc b.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (c : RTL.code) (tc : code) (b : SeqBB.t)
  (pc : node),
check_code c tc pc b = true -> match_block c tc pc b
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (c : RTL.code) (tc : code) (b : SeqBB.t)
  (pc : node),
check_code c tc pc b = true -> match_block c tc pc b
    induction b; [crush|].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
pc: node
H: match c ! pc with
| Some (RTL.Inop _) | _ => false
end = true
match_block c tc pc nil
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
forall pc : node,
check_code c tc pc (a :: b) = true ->
match_block c tc pc (a :: b)
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
pc: node
H: match c ! pc with
| Some (RTL.Inop _) | _ => false
end = true
match_block c tc pc nil repeat (destruct_match; try discriminate).
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
forall pc : node,
check_code c tc pc (a :: b) = true ->
match_block c tc pc (a :: b) intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
H: check_code c tc pc (a :: b) = true
match_block c tc pc (a :: b)
      unfold check_code in H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
H: match c ! pc with
| Some (RTL.Inop pc'') =>
    match a with
    | RBnop =>
        match b with
        | RBop _ _ _ _ :: _ :: _ |
          RBload _ _ _ _ _ :: _ :: _ |
          RBstore _ _ _ _ _ :: _ :: _ |
          RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
          RBexit None (RBjumptable _ _) :: _ :: _ =>
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op' args' dst' pc''0) =>
                   match b with
                   | RBop None op args dst :: nil |
                     RBop None op args dst
                     :: RBnop :: nil |
                     RBop None op args dst
                     :: RBop _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBexit (Some _) _ :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op args dst
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op args dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op args dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBop None op args dst
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBop None op args dst
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk' addr' args'
                  dst' pc''0) =>
                   match b with
                   | RBload None chunk addr args
                     dst :: nil |
                     RBload None chunk addr args
                     dst :: 
                     RBnop :: nil |
                     RBload None chunk addr args
                     dst :: 
                     RBop _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk addr args
                     dst
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBload None chunk addr args
                     dst
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBload None chunk addr args
                     dst
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk' addr' args'
                  src' pc''0) =>
                   match b with
                   | RBstore None chunk addr args
                     src :: nil |
                     RBstore None chunk addr args
                     src :: 
                     RBnop :: nil |
                     RBstore None chunk addr args
                     src :: 
                     RBop _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk addr args
                     src
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk addr args
                     src
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq src src'
                   | RBstore None chunk addr args
                     src
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args' dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r0) args dst pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r0) args dst pc')
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args' dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args dst pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args dst pc')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inl r0) args) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args') :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args args'
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args') :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inr r0) args) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args') :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args args'
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args' n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args args' &&
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args' n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r0 ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r0 r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r0)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r0 r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | RBnop :: _ :: _ |
          RBsetpred _ _ _ _ :: _ :: _ |
          RBexit (Some _) _ :: _ :: _ |
          RBexit None (RBtailcall _ _ _) :: _ :: _ |
          RBexit None (RBbuiltin _ _ _ _)
          :: _ :: _ |
          RBexit None (RBcond _ _ _ _) :: _ :: _ |
          RBexit None (RBreturn _) :: _ :: _ =>
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op' args' dst' pc''0) =>
                   match b with
                   | RBop None op args dst :: nil |
                     RBop None op args dst
                     :: RBnop :: nil |
                     RBop None op args dst
                     :: RBop _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBexit (Some _) _ :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op args dst
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op args dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op args dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBop None op args dst
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBop None op args dst
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk' addr' args'
                  dst' pc''0) =>
                   match b with
                   | RBload None chunk addr args
                     dst :: nil |
                     RBload None chunk addr args
                     dst :: 
                     RBnop :: nil |
                     RBload None chunk addr args
                     dst :: 
                     RBop _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk addr args
                     dst
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBload None chunk addr args
                     dst
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBload None chunk addr args
                     dst
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk' addr' args'
                  src' pc''0) =>
                   match b with
                   | RBstore None chunk addr args
                     src :: nil |
                     RBstore None chunk addr args
                     src :: 
                     RBnop :: nil |
                     RBstore None chunk addr args
                     src :: 
                     RBop _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk addr args
                     src
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk addr args
                     src
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq src src'
                   | RBstore None chunk addr args
                     src
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args' dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args dst pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args dst pc')
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args' dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args dst pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args dst pc')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inl r) args) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args') :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args args'
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args') :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inr r) args) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args') :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args args'
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args' n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args args' &&
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args' n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | RBexit None (RBgoto pc') :: nil =>
            check_valid_node tc pc' &&
            ceq peq pc' pc''
        | RBexit None (RBgoto pc') :: _ :: _ =>
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op' args' dst' pc''0) =>
                   match b with
                   | RBop None op args dst :: nil |
                     RBop None op args dst
                     :: RBnop :: nil |
                     RBop None op args dst
                     :: RBop _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op args dst
                     :: RBexit (Some _) _ :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op args dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op args dst
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op args dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op args dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBop None op args dst
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBop None op args dst
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk' addr' args'
                  dst' pc''0) =>
                   match b with
                   | RBload None chunk addr args
                     dst :: nil |
                     RBload None chunk addr args
                     dst :: 
                     RBnop :: nil |
                     RBload None chunk addr args
                     dst :: 
                     RBop _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk addr args
                     dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk addr args
                     dst
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args
                     dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBload None chunk addr args
                     dst
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBload None chunk addr args
                     dst
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk' addr' args'
                  src' pc''0) =>
                   match b with
                   | RBstore None chunk addr args
                     src :: nil |
                     RBstore None chunk addr args
                     src :: 
                     RBnop :: nil |
                     RBstore None chunk addr args
                     src :: 
                     RBop _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk addr args
                     src
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk addr args
                     src
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args
                     src
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk addr args
                     src
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq src src'
                   | RBstore None chunk addr args
                     src
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args args' &&
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args' dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args dst pc'0)
                        :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args dst pc'0)
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args' dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args dst pc'0)
                        :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args args' &&
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args dst pc'0)
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inl r) args) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args') :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args args'
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args') :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inr r) args) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args') :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args args'
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args' n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args args' &&
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args' n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | _ => false
        end
    | _ => false
    end
| Some (RTL.Iop op' args' dst' pc'') =>
    match a with
    | RBop None op args dst =>
        match b with
        | RBop _ _ _ _ :: _ :: _ |
          RBload _ _ _ _ _ :: _ :: _ |
          RBstore _ _ _ _ _ :: _ :: _ |
          RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
          RBexit None (RBjumptable _ _) :: _ :: _ =>
            ceq operation_eq op op' &&
            ceq list_pos_eq args args' &&
            ceq peq dst dst' &&
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op'0 args'0 dst'0 pc''0) =>
                   match b with
                   | RBop None op0 args0 dst0
                     :: nil |
                     RBop None op0 args0 dst0
                     :: RBnop :: nil |
                     RBop None op0 args0 dst0
                     :: RBop _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit (Some _) _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op0 args0 dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op0 op'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBop None op0 args0 dst0
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq operation_eq op0 op'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBop None op0 args0 dst0
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq operation_eq op0 op'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk' addr' args'0
                  dst'0 pc''0) =>
                   match b with
                   | RBload None chunk addr args0
                     dst0 :: nil |
                     RBload None chunk addr args0
                     dst0 :: 
                     RBnop :: nil |
                     RBload None chunk addr args0
                     dst0 :: 
                     RBop _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk addr args0
                     dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBload None chunk addr args0
                     dst0
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBload None chunk addr args0
                     dst0
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk' addr' args'0
                  src' pc''0) =>
                   match b with
                   | RBstore None chunk addr args0
                     src :: nil |
                     RBstore None chunk addr args0
                     src :: 
                     RBnop :: nil |
                     RBstore None chunk addr args0
                     src :: 
                     RBop _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk addr args0
                     src
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk addr args0
                     src
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src'
                   | RBstore None chunk addr args0
                     src
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r0) args0 dst0 pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r0) args0 dst0 pc')
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig 
                  (inl r0) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig 
                  (inr r0) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args0 n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r0 ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r0 r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r0)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r0 r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | RBnop :: _ :: _ |
          RBsetpred _ _ _ _ :: _ :: _ |
          RBexit (Some _) _ :: _ :: _ |
          RBexit None (RBtailcall _ _ _) :: _ :: _ |
          RBexit None (RBbuiltin _ _ _ _)
          :: _ :: _ |
          RBexit None (RBcond _ _ _ _) :: _ :: _ |
          RBexit None (RBreturn _) :: _ :: _ =>
            ceq operation_eq op op' &&
            ceq list_pos_eq args args' &&
            ceq peq dst dst' &&
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op'0 args'0 dst'0 pc''0) =>
                   match b with
                   | RBop None op0 args0 dst0
                     :: nil |
                     RBop None op0 args0 dst0
                     :: RBnop :: nil |
                     RBop None op0 args0 dst0
                     :: RBop _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit (Some _) _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op0 args0 dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op0 op'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBop None op0 args0 dst0
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq operation_eq op0 op'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBop None op0 args0 dst0
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq operation_eq op0 op'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk' addr' args'0
                  dst'0 pc''0) =>
                   match b with
                   | RBload None chunk addr args0
                     dst0 :: nil |
                     RBload None chunk addr args0
                     dst0 :: 
                     RBnop :: nil |
                     RBload None chunk addr args0
                     dst0 :: 
                     RBop _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk addr args0
                     dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBload None chunk addr args0
                     dst0
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBload None chunk addr args0
                     dst0
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk' addr' args'0
                  src' pc''0) =>
                   match b with
                   | RBstore None chunk addr args0
                     src :: nil |
                     RBstore None chunk addr args0
                     src :: 
                     RBnop :: nil |
                     RBstore None chunk addr args0
                     src :: 
                     RBop _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk addr args0
                     src
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk addr args0
                     src
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src'
                   | RBstore None chunk addr args0
                     src
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst0 pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst0 pc')
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inl r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inr r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args0 n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | RBexit None (RBgoto pc') :: nil =>
            check_valid_node tc pc' &&
            ceq peq pc' pc'' &&
            ceq operation_eq op op' &&
            ceq list_pos_eq args args' &&
            ceq peq dst dst'
        | RBexit None (RBgoto pc') :: _ :: _ =>
            ceq operation_eq op op' &&
            ceq list_pos_eq args args' &&
            ceq peq dst dst' &&
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op'0 args'0 dst'0 pc''0) =>
                   match b with
                   | RBop None op0 args0 dst0
                     :: nil |
                     RBop None op0 args0 dst0
                     :: RBnop :: nil |
                     RBop None op0 args0 dst0
                     :: RBop _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit (Some _) _ :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op0 args0 dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op0 args0 dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op0 args0 dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op0 op'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBop None op0 args0 dst0
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq operation_eq op0 op'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBop None op0 args0 dst0
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op0 op'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk' addr' args'0
                  dst'0 pc''0) =>
                   match b with
                   | RBload None chunk addr args0
                     dst0 :: nil |
                     RBload None chunk addr args0
                     dst0 :: 
                     RBnop :: nil |
                     RBload None chunk addr args0
                     dst0 :: 
                     RBop _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk addr args0
                     dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk addr args0
                     dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk addr args0
                     dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBload None chunk addr args0
                     dst0
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBload None chunk addr args0
                     dst0
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk' addr' args'0
                  src' pc''0) =>
                   match b with
                   | RBstore None chunk addr args0
                     src :: nil |
                     RBstore None chunk addr args0
                     src :: 
                     RBnop :: nil |
                     RBstore None chunk addr args0
                     src :: 
                     RBop _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk addr args0
                     src
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk addr args0
                     src
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk addr args0
                     src
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk addr args0
                     src
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src'
                   | RBstore None chunk addr args0
                     src
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk
                        chunk' &&
                       ceq addressing_eq addr
                        addr' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst0 pc'0)
                        :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst0 pc'0)
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc'0)
                        :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc'0)
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inl r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inr r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args0 n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | _ => false
        end
    | _ => false
    end
| Some (RTL.Iload chunk' addr' args' dst' pc'') =>
    match a with
    | RBload None chunk addr args dst =>
        match b with
        | RBop _ _ _ _ :: _ :: _ |
          RBload _ _ _ _ _ :: _ :: _ |
          RBstore _ _ _ _ _ :: _ :: _ |
          RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
          RBexit None (RBjumptable _ _) :: _ :: _ =>
            ceq memory_chunk_eq chunk chunk' &&
            ceq addressing_eq addr addr' &&
            ceq list_pos_eq args args' &&
            ceq peq dst dst' &&
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op' args'0 dst'0 pc''0) =>
                   match b with
                   | RBop None op args0 dst0
                     :: nil |
                     RBop None op args0 dst0
                     :: RBnop :: nil |
                     RBop None op args0 dst0
                     :: RBop _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBexit (Some _) _ :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op args0 dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBop None op args0 dst0
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBop None op args0 dst0
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk'0 addr'0 args'0
                  dst'0 pc''0) =>
                   match b with
                   | RBload None chunk0 addr0
                     args0 dst0 :: nil |
                     RBload None chunk0 addr0
                     args0 dst0 :: 
                     RBnop :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBop _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk0 addr0
                     args0 dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk'0 addr'0 args'0
                  src' pc''0) =>
                   match b with
                   | RBstore None chunk0 addr0
                     args0 src :: nil |
                     RBstore None chunk0 addr0
                     args0 src :: 
                     RBnop :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBop _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk0 addr0
                     args0 src
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src'
                   | RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r0) args0 dst0 pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r0) args0 dst0 pc')
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig 
                  (inl r0) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig 
                  (inr r0) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args0 n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r0 ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r0 r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r0)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r0 r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | RBnop :: _ :: _ |
          RBsetpred _ _ _ _ :: _ :: _ |
          RBexit (Some _) _ :: _ :: _ |
          RBexit None (RBtailcall _ _ _) :: _ :: _ |
          RBexit None (RBbuiltin _ _ _ _)
          :: _ :: _ |
          RBexit None (RBcond _ _ _ _) :: _ :: _ |
          RBexit None (RBreturn _) :: _ :: _ =>
            ceq memory_chunk_eq chunk chunk' &&
            ceq addressing_eq addr addr' &&
            ceq list_pos_eq args args' &&
            ceq peq dst dst' &&
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op' args'0 dst'0 pc''0) =>
                   match b with
                   | RBop None op args0 dst0
                     :: nil |
                     RBop None op args0 dst0
                     :: RBnop :: nil |
                     RBop None op args0 dst0
                     :: RBop _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBexit (Some _) _ :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op args0 dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBop None op args0 dst0
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBop None op args0 dst0
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk'0 addr'0 args'0
                  dst'0 pc''0) =>
                   match b with
                   | RBload None chunk0 addr0
                     args0 dst0 :: nil |
                     RBload None chunk0 addr0
                     args0 dst0 :: 
                     RBnop :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBop _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk0 addr0
                     args0 dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk'0 addr'0 args'0
                  src' pc''0) =>
                   match b with
                   | RBstore None chunk0 addr0
                     args0 src :: nil |
                     RBstore None chunk0 addr0
                     args0 src :: 
                     RBnop :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBop _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk0 addr0
                     args0 src
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src'
                   | RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst0 pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst0 pc')
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inl r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inr r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args0 n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | RBexit None (RBgoto pc') :: nil =>
            check_valid_node tc pc' &&
            ceq peq pc' pc'' &&
            ceq memory_chunk_eq chunk chunk' &&
            ceq addressing_eq addr addr' &&
            ceq list_pos_eq args args' &&
            ceq peq dst dst'
        | RBexit None (RBgoto pc') :: _ :: _ =>
            ceq memory_chunk_eq chunk chunk' &&
            ceq addressing_eq addr addr' &&
            ceq list_pos_eq args args' &&
            ceq peq dst dst' &&
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op' args'0 dst'0 pc''0) =>
                   match b with
                   | RBop None op args0 dst0
                     :: nil |
                     RBop None op args0 dst0
                     :: RBnop :: nil |
                     RBop None op args0 dst0
                     :: RBop _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op args0 dst0
                     :: RBexit (Some _) _ :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op args0 dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op args0 dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBop None op args0 dst0
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBop None op args0 dst0
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk'0 addr'0 args'0
                  dst'0 pc''0) =>
                   match b with
                   | RBload None chunk0 addr0
                     args0 dst0 :: nil |
                     RBload None chunk0 addr0
                     args0 dst0 :: 
                     RBnop :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBop _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk0 addr0
                     args0 dst0
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | RBload None chunk0 addr0
                     args0 dst0
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBload None chunk0 addr0
                     args0 dst0
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk'0 addr'0 args'0
                  src' pc''0) =>
                   match b with
                   | RBstore None chunk0 addr0
                     args0 src :: nil |
                     RBstore None chunk0 addr0
                     args0 src :: 
                     RBnop :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBop _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk0 addr0
                     args0 src
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk0 addr0
                     args0 src
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src'
                   | RBstore None chunk0 addr0
                     args0 src
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq src src' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst0 pc'0)
                        :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst0 pc'0)
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args'0 dst'0 pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc'0)
                        :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq dst0 dst'0
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst0 pc'0)
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inl r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inr r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args0 n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | _ => false
        end
    | _ => false
    end
| Some (RTL.Istore chunk' addr' args' src' pc'') =>
    match a with
    | RBstore None chunk addr args src =>
        match b with
        | RBop _ _ _ _ :: _ :: _ |
          RBload _ _ _ _ _ :: _ :: _ |
          RBstore _ _ _ _ _ :: _ :: _ |
          RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
          RBexit None (RBjumptable _ _) :: _ :: _ =>
            ceq memory_chunk_eq chunk chunk' &&
            ceq addressing_eq addr addr' &&
            ceq list_pos_eq args args' &&
            ceq peq src src' &&
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op' args'0 dst' pc''0) =>
                   match b with
                   | RBop None op args0 dst :: nil |
                     RBop None op args0 dst
                     :: RBnop :: nil |
                     RBop None op args0 dst
                     :: RBop _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBexit (Some _) _ :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op args0 dst
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBop None op args0 dst
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBop None op args0 dst
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk'0 addr'0 args'0
                  dst' pc''0) =>
                   match b with
                   | RBload None chunk0 addr0
                     args0 dst :: nil |
                     RBload None chunk0 addr0
                     args0 dst :: 
                     RBnop :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBop _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk0 addr0
                     args0 dst
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk'0 addr'0 args'0
                  src'0 pc''0) =>
                   match b with
                   | RBstore None chunk0 addr0
                     args0 src0 :: nil |
                     RBstore None chunk0 addr0
                     args0 src0 :: 
                     RBnop :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBop _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk0 addr0
                     args0 src0
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq src0 src'0 &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq src0 src'0
                   | RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq src0 src'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args'0 dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r0) args0 dst pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r0) args0 dst pc')
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args'0 dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst pc')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig 
                  (inl r0) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig 
                  (inr r0) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r0 r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args0 n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r0 ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r0 r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r0)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r0 r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | RBnop :: _ :: _ |
          RBsetpred _ _ _ _ :: _ :: _ |
          RBexit (Some _) _ :: _ :: _ |
          RBexit None (RBtailcall _ _ _) :: _ :: _ |
          RBexit None (RBbuiltin _ _ _ _)
          :: _ :: _ |
          RBexit None (RBcond _ _ _ _) :: _ :: _ |
          RBexit None (RBreturn _) :: _ :: _ =>
            ceq memory_chunk_eq chunk chunk' &&
            ceq addressing_eq addr addr' &&
            ceq list_pos_eq args args' &&
            ceq peq src src' &&
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op' args'0 dst' pc''0) =>
                   match b with
                   | RBop None op args0 dst :: nil |
                     RBop None op args0 dst
                     :: RBnop :: nil |
                     RBop None op args0 dst
                     :: RBop _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBexit (Some _) _ :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op args0 dst
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBop None op args0 dst
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBop None op args0 dst
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk'0 addr'0 args'0
                  dst' pc''0) =>
                   match b with
                   | RBload None chunk0 addr0
                     args0 dst :: nil |
                     RBload None chunk0 addr0
                     args0 dst :: 
                     RBnop :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBop _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk0 addr0
                     args0 dst
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk'0 addr'0 args'0
                  src'0 pc''0) =>
                   match b with
                   | RBstore None chunk0 addr0
                     args0 src0 :: nil |
                     RBstore None chunk0 addr0
                     args0 src0 :: 
                     RBnop :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBop _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk0 addr0
                     args0 src0
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq src0 src'0 &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None 
                        (RBgoto pc') :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq src0 src'0
                   | RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None 
                        (RBgoto pc') :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq src0 src'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args'0 dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst pc')
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args'0 dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst pc')
                        :: nil =>
                       check_valid_node tc pc' &&
                       ceq peq pc' pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst pc')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inl r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inr r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args0 n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | RBexit None (RBgoto pc') :: nil =>
            check_valid_node tc pc' &&
            ceq peq pc' pc'' &&
            ceq memory_chunk_eq chunk chunk' &&
            ceq addressing_eq addr addr' &&
            ceq list_pos_eq args args' &&
            ceq peq src src'
        | RBexit None (RBgoto pc') :: _ :: _ =>
            ceq memory_chunk_eq chunk chunk' &&
            ceq addressing_eq addr addr' &&
            ceq list_pos_eq args args' &&
            ceq peq src src' &&
            (fix check_code
               (c : RTL.code) 
               (tc : code) 
               (pc : node) 
               (b : SeqBB.t) {struct b} : bool :=
               match c ! pc with
               | Some (RTL.Inop pc''0) =>
                   match b with
                   | RBnop
                     :: (RBnop :: _ :: _) as b' |
                     RBnop
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBnop
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBnop
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | RBnop
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0
                   | RBnop
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iop op' args'0 dst' pc''0) =>
                   match b with
                   | RBop None op args0 dst :: nil |
                     RBop None op args0 dst
                     :: RBnop :: nil |
                     RBop None op args0 dst
                     :: RBop _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBop None op args0 dst
                     :: RBexit (Some _) _ :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBop None op args0 dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBop None op args0 dst
                     :: (RBnop :: _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBop None op args0 dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBop None op args0 dst
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBop None op args0 dst
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq operation_eq op op' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Iload chunk'0 addr'0 args'0
                  dst' pc''0) =>
                   match b with
                   | RBload None chunk0 addr0
                     args0 dst :: nil |
                     RBload None chunk0 addr0
                     args0 dst :: 
                     RBnop :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBop _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBload _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBstore _ _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBsetpred _ _ _ _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit (Some _) _ :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBload None chunk0 addr0
                     args0 dst
                     :: (RBnop :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | RBload None chunk0 addr0
                     args0 dst
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBload None chunk0 addr0
                     args0 dst
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst' &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Istore chunk'0 addr'0 args'0
                  src'0 pc''0) =>
                   match b with
                   | RBstore None chunk0 addr0
                     args0 src0 :: nil |
                     RBstore None chunk0 addr0
                     args0 src0 :: 
                     RBnop :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBop _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBload _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBstore _ _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBsetpred _ _ _ _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit (Some _) _ :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBcall _ _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBtailcall _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBbuiltin _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBcond _ _ _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None
                        (RBjumptable _ _) :: nil |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None 
                        (RBreturn _) :: nil =>
                       false
                   | RBstore None chunk0 addr0
                     args0 src0
                     :: (RBnop :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBop _ _ _ _ :: _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBload _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBstore _ _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBsetpred _ _ _ _
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit 
                        (Some _) _ :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBcall _ _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBtailcall _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBbuiltin _ _ _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBcond _ _ _ _) :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None
                        (RBjumptable _ _)
                        :: 
                        _ :: _) as b' |
                     RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None 
                        (RBreturn _) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq src0 src'0 &&
                       check_code c tc pc''0 b'
                   | RBstore None chunk0 addr0
                     args0 src0
                     :: RBexit None 
                        (RBgoto pc'0) :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq src0 src'0
                   | RBstore None chunk0 addr0
                     args0 src0
                     :: (RBexit None 
                        (RBgoto pc'0) :: 
                        _ :: _) as b' =>
                       ceq memory_chunk_eq chunk0
                        chunk'0 &&
                       ceq addressing_eq addr0
                        addr'0 &&
                       ceq list_pos_eq args0
                        args'0 &&
                       ceq peq src0 src'0 &&
                       check_code c tc pc''0 b'
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inl r') args'0 dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst pc'0)
                        :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inl r) args0 dst pc'0)
                        :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inr _) _ _ _)
                        :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Icall sig' 
                  (inr i') args'0 dst' pc''0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcall sig (inl _) _ _ _)
                        :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst pc'0)
                        :: nil =>
                       check_valid_node tc pc'0 &&
                       ceq peq pc'0 pc''0 &&
                       ceq signature_eq sig sig' &&
                       ceq peq i i' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq dst dst'
                   | RBnop
                     :: RBexit None
                        (RBcall sig 
                        (inr i) args0 dst pc'0)
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inl r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl r') args'0) :: 
                        _ :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr _) _) :: _ => false
                   | _ => false
                   end
               | Some
                 (RTL.Itailcall sig (inr r) args0) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inl _) _) :: _ => false
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: nil =>
                       ceq signature_eq sig sig' &&
                       ceq peq r r' &&
                       ceq list_pos_eq args0
                        args'0
                   | RBnop
                     :: RBexit None
                        (RBtailcall sig' 
                        (inr r') args'0) :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Icond cond args0 n1 n2) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: nil =>
                       check_valid_node tc n1 &&
                       check_valid_node tc n2 &&
                       ceq condition_eq cond cond' &&
                       ceq list_pos_eq args0
                        args'0 && 
                       ceq peq n1 n1' &&
                       ceq peq n2 n2'
                   | RBnop
                     :: RBexit None
                        (RBcond cond' args'0 n1'
                        n2') :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ijumptable r ns) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: nil =>
                       ceq peq r r' &&
                       ceq list_pos_eq ns ns' &&
                       forallb
                        (check_valid_node tc) ns
                   | RBnop
                     :: RBexit None
                        (RBjumptable r' ns')
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn (Some r)) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: nil => 
                       ceq peq r r'
                   | RBnop
                     :: RBexit None
                        (RBreturn (Some r'))
                        :: 
                        _ :: _ => false
                   | _ => false
                   end
               | Some (RTL.Ireturn None) =>
                   match b with
                   | RBnop
                     :: RBexit None
                        (RBreturn None) :: nil =>
                       true
                   | _ => false
                   end
               | _ => false
               end) c tc pc'' b
        | _ => false
        end
    | _ => false
    end
| Some (RTL.Icall sig' (inl r') args' dst' pc'') =>
    match a with
    | RBnop =>
        match b with
        | RBexit None
          (RBcall sig (inl r) args dst pc') :: nil =>
            check_valid_node tc pc' &&
            ceq peq pc' pc'' &&
            ceq signature_eq sig sig' &&
            ceq peq r r' &&
            ceq list_pos_eq args args' &&
            ceq peq dst dst'
        | RBexit None
          (RBcall sig (inl r) args dst pc')
          :: _ :: _ => false
        | RBexit None (RBcall sig (inr _) _ _ _)
          :: _ => false
        | _ => false
        end
    | _ => false
    end
| Some (RTL.Icall sig' (inr i') args' dst' pc'') =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBcall sig (inl _) _ _ _)
          :: _ => false
        | RBexit None
          (RBcall sig (inr i) args dst pc') :: nil =>
            check_valid_node tc pc' &&
            ceq peq pc' pc'' &&
            ceq signature_eq sig sig' &&
            ceq peq i i' &&
            ceq list_pos_eq args args' &&
            ceq peq dst dst'
        | RBexit None
          (RBcall sig (inr i) args dst pc')
          :: _ :: _ => false
        | _ => false
        end
    | _ => false
    end
| Some (RTL.Itailcall sig (inl r) args) =>
    match a with
    | RBnop =>
        match b with
        | RBexit None
          (RBtailcall sig' (inl r') args') :: nil =>
            ceq signature_eq sig sig' &&
            ceq peq r r' &&
            ceq list_pos_eq args args'
        | RBexit None
          (RBtailcall sig' (inl r') args')
          :: _ :: _ => false
        | RBexit None (RBtailcall sig' (inr _) _)
          :: _ => false
        | _ => false
        end
    | _ => false
    end
| Some (RTL.Itailcall sig (inr r) args) =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBtailcall sig' (inl _) _)
          :: _ => false
        | RBexit None
          (RBtailcall sig' (inr r') args') :: nil =>
            ceq signature_eq sig sig' &&
            ceq peq r r' &&
            ceq list_pos_eq args args'
        | RBexit None
          (RBtailcall sig' (inr r') args')
          :: _ :: _ => false
        | _ => false
        end
    | _ => false
    end
| Some (RTL.Icond cond args n1 n2) =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBcond cond' args' n1' n2')
          :: nil =>
            check_valid_node tc n1 &&
            check_valid_node tc n2 &&
            ceq condition_eq cond cond' &&
            ceq list_pos_eq args args' &&
            ceq peq n1 n1' && 
            ceq peq n2 n2'
        | RBexit None (RBcond cond' args' n1' n2')
          :: _ :: _ => false
        | _ => false
        end
    | _ => false
    end
| Some (RTL.Ijumptable r ns) =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBjumptable r' ns') :: nil =>
            ceq peq r r' && ceq list_pos_eq ns ns' &&
            forallb (check_valid_node tc) ns
        | RBexit None (RBjumptable r' ns')
          :: _ :: _ => false
        | _ => false
        end
    | _ => false
    end
| Some (RTL.Ireturn (Some r)) =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBreturn (Some r')) :: nil =>
            ceq peq r r'
        | RBexit None (RBreturn (Some r'))
          :: _ :: _ => false
        | _ => false
        end
    | _ => false
    end
| Some (RTL.Ireturn None) =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBreturn None) :: nil =>
            true
        | _ => false
        end
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b)
      do 2 (destruct_match; try discriminate); subst; fold check_code in H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
n: RTL.node
Heqo: c ! pc = Some (RTL.Inop n)
H: match a with
| RBnop =>
    match b with
    | RBnop :: _ :: _ | RBop _ _ _ _ :: _ :: _ |
      RBload _ _ _ _ _ :: _ :: _ |
      RBstore _ _ _ _ _ :: _ :: _ |
      RBsetpred _ _ _ _ :: _ :: _ |
      RBexit (Some _) _ :: _ :: _ |
      RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
      RBexit None (RBtailcall _ _ _) :: _ :: _ |
      RBexit None (RBbuiltin _ _ _ _) :: _ :: _ |
      RBexit None (RBcond _ _ _ _) :: _ :: _ |
      RBexit None (RBjumptable _ _) :: _ :: _ |
      RBexit None (RBreturn _) :: _ :: _ =>
        check_code c tc n b
    | RBexit None (RBgoto pc') :: nil =>
        check_valid_node tc pc' && ceq peq pc' n
    | RBexit None (RBgoto pc') :: _ :: _ =>
        check_code c tc n b
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
o: Op.operation
l: list reg
r: reg
n: RTL.node
Heqo: c ! pc = Some (RTL.Iop o l r n)
H: match a with
| RBop None op args dst =>
    match b with
    | RBnop :: _ :: _ | RBop _ _ _ _ :: _ :: _ |
      RBload _ _ _ _ _ :: _ :: _ |
      RBstore _ _ _ _ _ :: _ :: _ |
      RBsetpred _ _ _ _ :: _ :: _ |
      RBexit (Some _) _ :: _ :: _ |
      RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
      RBexit None (RBtailcall _ _ _) :: _ :: _ |
      RBexit None (RBbuiltin _ _ _ _) :: _ :: _ |
      RBexit None (RBcond _ _ _ _) :: _ :: _ |
      RBexit None (RBjumptable _ _) :: _ :: _ |
      RBexit None (RBreturn _) :: _ :: _ =>
        ceq operation_eq op o &&
        ceq list_pos_eq args l && 
        ceq peq dst r && 
        check_code c tc n b
    | RBexit None (RBgoto pc') :: nil =>
        check_valid_node tc pc' && ceq peq pc' n &&
        ceq operation_eq op o &&
        ceq list_pos_eq args l && 
        ceq peq dst r
    | RBexit None (RBgoto pc') :: _ :: _ =>
        ceq operation_eq op o &&
        ceq list_pos_eq args l && 
        ceq peq dst r && 
        check_code c tc n b
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
m: memory_chunk
a0: Op.addressing
l: list reg
r: reg
n: RTL.node
Heqo: c ! pc = Some (RTL.Iload m a0 l r n)
H: match a with
| RBload None chunk addr args dst =>
    match b with
    | RBnop :: _ :: _ | RBop _ _ _ _ :: _ :: _ |
      RBload _ _ _ _ _ :: _ :: _ |
      RBstore _ _ _ _ _ :: _ :: _ |
      RBsetpred _ _ _ _ :: _ :: _ |
      RBexit (Some _) _ :: _ :: _ |
      RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
      RBexit None (RBtailcall _ _ _) :: _ :: _ |
      RBexit None (RBbuiltin _ _ _ _) :: _ :: _ |
      RBexit None (RBcond _ _ _ _) :: _ :: _ |
      RBexit None (RBjumptable _ _) :: _ :: _ |
      RBexit None (RBreturn _) :: _ :: _ =>
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq dst r && 
        check_code c tc n b
    | RBexit None (RBgoto pc') :: nil =>
        check_valid_node tc pc' && ceq peq pc' n &&
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq dst r
    | RBexit None (RBgoto pc') :: _ :: _ =>
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq dst r && 
        check_code c tc n b
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
m: memory_chunk
a0: Op.addressing
l: list reg
r: reg
n: RTL.node
Heqo: c ! pc = Some (RTL.Istore m a0 l r n)
H: match a with
| RBstore None chunk addr args src =>
    match b with
    | RBnop :: _ :: _ | RBop _ _ _ _ :: _ :: _ |
      RBload _ _ _ _ _ :: _ :: _ |
      RBstore _ _ _ _ _ :: _ :: _ |
      RBsetpred _ _ _ _ :: _ :: _ |
      RBexit (Some _) _ :: _ :: _ |
      RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
      RBexit None (RBtailcall _ _ _) :: _ :: _ |
      RBexit None (RBbuiltin _ _ _ _) :: _ :: _ |
      RBexit None (RBcond _ _ _ _) :: _ :: _ |
      RBexit None (RBjumptable _ _) :: _ :: _ |
      RBexit None (RBreturn _) :: _ :: _ =>
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq src r && 
        check_code c tc n b
    | RBexit None (RBgoto pc') :: nil =>
        check_valid_node tc pc' && ceq peq pc' n &&
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq src r
    | RBexit None (RBgoto pc') :: _ :: _ =>
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq src r && 
        check_code c tc n b
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
s: signature
s0: (reg + ident)%type
l: list reg
r: reg
n: RTL.node
Heqo: c ! pc = Some (RTL.Icall s s0 l r n)
H: match s0 with
| inl r' =>
    match a with
    | RBnop =>
        match b with
        | RBexit None
          (RBcall sig (inl r0) args dst pc')
          :: nil =>
            check_valid_node tc pc' &&
            ceq peq pc' n &&
            ceq signature_eq sig s &&
            ceq peq r0 r' &&
            ceq list_pos_eq args l &&
            ceq peq dst r
        | RBexit None
          (RBcall sig (inl r0) args dst pc')
          :: _ :: _ => false
        | RBexit None (RBcall sig (inr _) _ _ _)
          :: _ => false
        | _ => false
        end
    | _ => false
    end
| inr i' =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBcall sig (inl _) _ _ _)
          :: _ => false
        | RBexit None
          (RBcall sig (inr i) args dst pc') :: nil =>
            check_valid_node tc pc' &&
            ceq peq pc' n &&
            ceq signature_eq sig s && 
            ceq peq i i' && 
            ceq list_pos_eq args l &&
            ceq peq dst r
        | RBexit None
          (RBcall sig (inr i) args dst pc')
          :: _ :: _ => false
        | _ => false
        end
    | _ => false
    end
end = true
match_block c tc pc (a :: b)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
s: signature
s0: (reg + ident)%type
l: list reg
Heqo: c ! pc = Some (RTL.Itailcall s s0 l)
H: match s0 with
| inl r =>
    match a with
    | RBnop =>
        match b with
        | RBexit None
          (RBtailcall sig' (inl r') args') :: nil =>
            ceq signature_eq s sig' &&
            ceq peq r r' &&
            ceq list_pos_eq l args'
        | RBexit None
          (RBtailcall sig' (inl r') args')
          :: _ :: _ => false
        | RBexit None (RBtailcall sig' (inr _) _)
          :: _ => false
        | _ => false
        end
    | _ => false
    end
| inr r =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBtailcall sig' (inl _) _)
          :: _ => false
        | RBexit None
          (RBtailcall sig' (inr r') args') :: nil =>
            ceq signature_eq s sig' &&
            ceq peq r r' &&
            ceq list_pos_eq l args'
        | RBexit None
          (RBtailcall sig' (inr r') args')
          :: _ :: _ => false
        | _ => false
        end
    | _ => false
    end
end = true
match_block c tc pc (a :: b)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
c0: Op.condition
l: list reg
n, n0: RTL.node
Heqo: c ! pc = Some (RTL.Icond c0 l n n0)
H: match a with
| RBnop =>
    match b with
    | RBexit None (RBcond cond' args' n1' n2')
      :: nil =>
        check_valid_node tc n &&
        check_valid_node tc n0 &&
        ceq condition_eq c0 cond' &&
        ceq list_pos_eq l args' && 
        ceq peq n n1' && 
        ceq peq n0 n2'
    | RBexit None (RBcond cond' args' n1' n2')
      :: _ :: _ => false
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
r: reg
l: list RTL.node
Heqo: c ! pc = Some (RTL.Ijumptable r l)
H: match a with
| RBnop =>
    match b with
    | RBexit None (RBjumptable r' ns') :: nil =>
        ceq peq r r' && ceq list_pos_eq l ns' &&
        forallb (check_valid_node tc) l
    | RBexit None (RBjumptable r' ns') :: _ :: _ =>
        false
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
o: option reg
Heqo: c ! pc = Some (RTL.Ireturn o)
H: match o with
| Some r =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBreturn (Some r')) :: nil =>
            ceq peq r r'
        | RBexit None (RBreturn (Some r'))
          :: _ :: _ => false
        | _ => false
        end
    | _ => false
    end
| None =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBreturn None) :: nil =>
            true
        | _ => false
        end
    | _ => false
    end
end = true
match_block c tc pc (a :: b)
      +
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
n: RTL.node
Heqo: c ! pc = Some (RTL.Inop n)
H: match a with
| RBnop =>
    match b with
    | RBnop :: _ :: _ | RBop _ _ _ _ :: _ :: _ |
      RBload _ _ _ _ _ :: _ :: _ |
      RBstore _ _ _ _ _ :: _ :: _ |
      RBsetpred _ _ _ _ :: _ :: _ |
      RBexit (Some _) _ :: _ :: _ |
      RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
      RBexit None (RBtailcall _ _ _) :: _ :: _ |
      RBexit None (RBbuiltin _ _ _ _) :: _ :: _ |
      RBexit None (RBcond _ _ _ _) :: _ :: _ |
      RBexit None (RBjumptable _ _) :: _ :: _ |
      RBexit None (RBreturn _) :: _ :: _ =>
        check_code c tc n b
    | RBexit None (RBgoto pc') :: nil =>
        check_valid_node tc pc' && ceq peq pc' n
    | RBexit None (RBgoto pc') :: _ :: _ =>
        check_code c tc n b
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b) repeat (destruct_match; try discriminate); try solve [econstructor; eauto].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
i: instr
l: list instr
o: option pred_op
c0: cf_instr
Heqo0: o = None
n0: node
Heqc1: c0 = RBgoto n0
Heqi0: i = RBexit None (RBgoto n0)
Heql0: l = nil
Heql: b = RBexit None (RBgoto n0) :: nil
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n0) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n0) :: nil)
pc: node
n: RTL.node
Heqo: c ! pc = Some (RTL.Inop n)
Heqi: a = RBnop
H: check_valid_node tc n0 && ceq peq n0 n = true
match_block c tc pc
  (RBnop :: RBexit None (RBgoto n0) :: nil)
        unfold_ands.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n: RTL.node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n) :: nil)
pc: node
Heqo: c ! pc = Some (RTL.Inop n)
H0: check_valid_node tc n = true
match_block c tc pc
  (RBnop :: RBexit None (RBgoto n) :: nil)
        eapply match_block_goto; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n: RTL.node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n) :: nil)
pc: node
Heqo: c ! pc = Some (RTL.Inop n)
H0: check_valid_node tc n = true
valid_succ tc n eauto using check_valid_node_correct.
      +
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
o: Op.operation
l: list reg
r: reg
n: RTL.node
Heqo: c ! pc = Some (RTL.Iop o l r n)
H: match a with
| RBop None op args dst =>
    match b with
    | RBnop :: _ :: _ | RBop _ _ _ _ :: _ :: _ |
      RBload _ _ _ _ _ :: _ :: _ |
      RBstore _ _ _ _ _ :: _ :: _ |
      RBsetpred _ _ _ _ :: _ :: _ |
      RBexit (Some _) _ :: _ :: _ |
      RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
      RBexit None (RBtailcall _ _ _) :: _ :: _ |
      RBexit None (RBbuiltin _ _ _ _) :: _ :: _ |
      RBexit None (RBcond _ _ _ _) :: _ :: _ |
      RBexit None (RBjumptable _ _) :: _ :: _ |
      RBexit None (RBreturn _) :: _ :: _ =>
        ceq operation_eq op o &&
        ceq list_pos_eq args l && 
        ceq peq dst r && 
        check_code c tc n b
    | RBexit None (RBgoto pc') :: nil =>
        check_valid_node tc pc' && ceq peq pc' n &&
        ceq operation_eq op o &&
        ceq list_pos_eq args l && 
        ceq peq dst r
    | RBexit None (RBgoto pc') :: _ :: _ =>
        ceq operation_eq op o &&
        ceq list_pos_eq args l && 
        ceq peq dst r && 
        check_code c tc n b
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b) repeat (destruct_match; try discriminate); subst; try solve [unfold_ands; econstructor; eauto].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n0: node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n0) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n0) :: nil)
pc: node
o: Op.operation
l: list reg
r: reg
n: RTL.node
Heqo: c ! pc = Some (RTL.Iop o l r n)
o1: Op.operation
l0: list reg
r0: reg
H: check_valid_node tc n0 && ceq peq n0 n &&
ceq operation_eq o1 o && 
ceq list_pos_eq l0 l && ceq peq r0 r = true
match_block c tc pc
  (RBop None o1 l0 r0
   :: RBexit None (RBgoto n0) :: nil)
        unfold_ands.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n: RTL.node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n) :: nil)
pc: node
o: Op.operation
l: list reg
r: reg
Heqo: c ! pc = Some (RTL.Iop o l r n)
H: check_valid_node tc n = true
match_block c tc pc
  (RBop None o l r :: RBexit None (RBgoto n) :: nil)
        eapply match_block_op_cf; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n: RTL.node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n) :: nil)
pc: node
o: Op.operation
l: list reg
r: reg
Heqo: c ! pc = Some (RTL.Iop o l r n)
H: check_valid_node tc n = true
valid_succ tc n eauto using check_valid_node_correct.
      +
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
m: memory_chunk
a0: Op.addressing
l: list reg
r: reg
n: RTL.node
Heqo: c ! pc = Some (RTL.Iload m a0 l r n)
H: match a with
| RBload None chunk addr args dst =>
    match b with
    | RBnop :: _ :: _ | RBop _ _ _ _ :: _ :: _ |
      RBload _ _ _ _ _ :: _ :: _ |
      RBstore _ _ _ _ _ :: _ :: _ |
      RBsetpred _ _ _ _ :: _ :: _ |
      RBexit (Some _) _ :: _ :: _ |
      RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
      RBexit None (RBtailcall _ _ _) :: _ :: _ |
      RBexit None (RBbuiltin _ _ _ _) :: _ :: _ |
      RBexit None (RBcond _ _ _ _) :: _ :: _ |
      RBexit None (RBjumptable _ _) :: _ :: _ |
      RBexit None (RBreturn _) :: _ :: _ =>
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq dst r && 
        check_code c tc n b
    | RBexit None (RBgoto pc') :: nil =>
        check_valid_node tc pc' && ceq peq pc' n &&
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq dst r
    | RBexit None (RBgoto pc') :: _ :: _ =>
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq dst r && 
        check_code c tc n b
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b) repeat (destruct_match; try discriminate); subst; try solve [unfold_ands; econstructor; eauto].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n0: node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n0) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n0) :: nil)
pc: node
m: memory_chunk
a0: Op.addressing
l: list reg
r: reg
n: RTL.node
Heqo: c ! pc = Some (RTL.Iload m a0 l r n)
m0: memory_chunk
a1: Op.addressing
l0: list reg
r0: reg
H: check_valid_node tc n0 && ceq peq n0 n &&
ceq memory_chunk_eq m0 m &&
ceq addressing_eq a1 a0 && 
ceq list_pos_eq l0 l && ceq peq r0 r = true
match_block c tc pc
  (RBload None m0 a1 l0 r0
   :: RBexit None (RBgoto n0) :: nil)
        unfold_ands.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n: RTL.node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n) :: nil)
pc: node
m: memory_chunk
a0: Op.addressing
l: list reg
r: reg
Heqo: c ! pc = Some (RTL.Iload m a0 l r n)
H0: check_valid_node tc n = true
match_block c tc pc
  (RBload None m a0 l r
   :: RBexit None (RBgoto n) :: nil)
        eapply match_block_load_cf; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n: RTL.node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n) :: nil)
pc: node
m: memory_chunk
a0: Op.addressing
l: list reg
r: reg
Heqo: c ! pc = Some (RTL.Iload m a0 l r n)
H0: check_valid_node tc n = true
valid_succ tc n eauto using check_valid_node_correct.
      +
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
m: memory_chunk
a0: Op.addressing
l: list reg
r: reg
n: RTL.node
Heqo: c ! pc = Some (RTL.Istore m a0 l r n)
H: match a with
| RBstore None chunk addr args src =>
    match b with
    | RBnop :: _ :: _ | RBop _ _ _ _ :: _ :: _ |
      RBload _ _ _ _ _ :: _ :: _ |
      RBstore _ _ _ _ _ :: _ :: _ |
      RBsetpred _ _ _ _ :: _ :: _ |
      RBexit (Some _) _ :: _ :: _ |
      RBexit None (RBcall _ _ _ _ _) :: _ :: _ |
      RBexit None (RBtailcall _ _ _) :: _ :: _ |
      RBexit None (RBbuiltin _ _ _ _) :: _ :: _ |
      RBexit None (RBcond _ _ _ _) :: _ :: _ |
      RBexit None (RBjumptable _ _) :: _ :: _ |
      RBexit None (RBreturn _) :: _ :: _ =>
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq src r && 
        check_code c tc n b
    | RBexit None (RBgoto pc') :: nil =>
        check_valid_node tc pc' && ceq peq pc' n &&
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq src r
    | RBexit None (RBgoto pc') :: _ :: _ =>
        ceq memory_chunk_eq chunk m &&
        ceq addressing_eq addr a0 &&
        ceq list_pos_eq args l && 
        ceq peq src r && 
        check_code c tc n b
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b) repeat (destruct_match; try discriminate); subst; try solve [unfold_ands; econstructor; eauto].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n0: node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n0) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n0) :: nil)
pc: node
m: memory_chunk
a0: Op.addressing
l: list reg
r: reg
n: RTL.node
Heqo: c ! pc = Some (RTL.Istore m a0 l r n)
m0: memory_chunk
a1: Op.addressing
l0: list reg
r0: reg
H: check_valid_node tc n0 && ceq peq n0 n &&
ceq memory_chunk_eq m0 m &&
ceq addressing_eq a1 a0 && 
ceq list_pos_eq l0 l && ceq peq r0 r = true
match_block c tc pc
  (RBstore None m0 a1 l0 r0
   :: RBexit None (RBgoto n0) :: nil)
        unfold_ands.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n: RTL.node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n) :: nil)
pc: node
m: memory_chunk
a0: Op.addressing
l: list reg
r: reg
Heqo: c ! pc = Some (RTL.Istore m a0 l r n)
H0: check_valid_node tc n = true
match_block c tc pc
  (RBstore None m a0 l r
   :: RBexit None (RBgoto n) :: nil)
        eapply match_block_store_cf; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n: RTL.node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBgoto n) :: nil) = true ->
match_block c tc pc
  (RBexit None (RBgoto n) :: nil)
pc: node
m: memory_chunk
a0: Op.addressing
l: list reg
r: reg
Heqo: c ! pc = Some (RTL.Istore m a0 l r n)
H0: check_valid_node tc n = true
valid_succ tc n eauto using check_valid_node_correct.
      +
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
s: signature
s0: (reg + ident)%type
l: list reg
r: reg
n: RTL.node
Heqo: c ! pc = Some (RTL.Icall s s0 l r n)
H: match s0 with
| inl r' =>
    match a with
    | RBnop =>
        match b with
        | RBexit None
          (RBcall sig (inl r0) args dst pc')
          :: nil =>
            check_valid_node tc pc' &&
            ceq peq pc' n &&
            ceq signature_eq sig s &&
            ceq peq r0 r' &&
            ceq list_pos_eq args l &&
            ceq peq dst r
        | RBexit None
          (RBcall sig (inl r0) args dst pc')
          :: _ :: _ => false
        | RBexit None (RBcall sig (inr _) _ _ _)
          :: _ => false
        | _ => false
        end
    | _ => false
    end
| inr i' =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBcall sig (inl _) _ _ _)
          :: _ => false
        | RBexit None
          (RBcall sig (inr i) args dst pc') :: nil =>
            check_valid_node tc pc' &&
            ceq peq pc' n &&
            ceq signature_eq sig s && 
            ceq peq i i' && 
            ceq list_pos_eq args l &&
            ceq peq dst r
        | RBexit None
          (RBcall sig (inr i) args dst pc')
          :: _ :: _ => false
        | _ => false
        end
    | _ => false
    end
end = true
match_block c tc pc (a :: b) repeat (destruct_match; try discriminate); subst; try solve [unfold_ands; econstructor; eauto].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
s1: signature
l1: list reg
r1: reg
n0: node
r2: reg
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBcall s1 (inl r2) l1 r1 n0)
   :: nil) = true ->
match_block c tc pc
  (RBexit None (RBcall s1 (inl r2) l1 r1 n0)
   :: nil)
pc: node
s: signature
l: list reg
r: reg
n: RTL.node
r0: reg
Heqo: c ! pc = Some (RTL.Icall s (inl r0) l r n)
H: check_valid_node tc n0 && ceq peq n0 n &&
ceq signature_eq s1 s && 
ceq peq r2 r0 && ceq list_pos_eq l1 l &&
ceq peq r1 r = true
match_block c tc pc
  (RBnop
   :: RBexit None (RBcall s1 (inl r2) l1 r1 n0) :: nil)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
s1: signature
l1: list reg
r0: reg
n0: node
i1: ident
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBcall s1 (inr i1) l1 r0 n0)
   :: nil) = true ->
match_block c tc pc
  (RBexit None (RBcall s1 (inr i1) l1 r0 n0)
   :: nil)
pc: node
s: signature
l: list reg
r: reg
n: RTL.node
i: ident
Heqo: c ! pc = Some (RTL.Icall s (inr i) l r n)
H: check_valid_node tc n0 && ceq peq n0 n &&
ceq signature_eq s1 s && 
ceq peq i1 i && ceq list_pos_eq l1 l &&
ceq peq r0 r = true
match_block c tc pc
  (RBnop
   :: RBexit None (RBcall s1 (inr i1) l1 r0 n0) :: nil)
        unfold_ands.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n: RTL.node
s: signature
r0: reg
l: list reg
r: reg
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBcall s (inl r0) l r n) :: nil) =
true ->
match_block c tc pc
  (RBexit None (RBcall s (inl r0) l r n) :: nil)
pc: node
Heqo: c ! pc = Some (RTL.Icall s (inl r0) l r n)
H0: check_valid_node tc n = true
match_block c tc pc
  (RBnop
   :: RBexit None (RBcall s (inl r0) l r n) :: nil)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
s1: signature
l1: list reg
r0: reg
n0: node
i1: ident
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBcall s1 (inr i1) l1 r0 n0)
   :: nil) = true ->
match_block c tc pc
  (RBexit None (RBcall s1 (inr i1) l1 r0 n0)
   :: nil)
pc: node
s: signature
l: list reg
r: reg
n: RTL.node
i: ident
Heqo: c ! pc = Some (RTL.Icall s (inr i) l r n)
H: check_valid_node tc n0 && ceq peq n0 n &&
ceq signature_eq s1 s && 
ceq peq i1 i && ceq list_pos_eq l1 l &&
ceq peq r0 r = true
match_block c tc pc
  (RBnop
   :: RBexit None (RBcall s1 (inr i1) l1 r0 n0) :: nil) eapply match_block_call; eauto using check_valid_node_correct.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
s1: signature
l1: list reg
r0: reg
n0: node
i1: ident
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBcall s1 (inr i1) l1 r0 n0)
   :: nil) = true ->
match_block c tc pc
  (RBexit None (RBcall s1 (inr i1) l1 r0 n0)
   :: nil)
pc: node
s: signature
l: list reg
r: reg
n: RTL.node
i: ident
Heqo: c ! pc = Some (RTL.Icall s (inr i) l r n)
H: check_valid_node tc n0 && ceq peq n0 n &&
ceq signature_eq s1 s && 
ceq peq i1 i && ceq list_pos_eq l1 l &&
ceq peq r0 r = true
match_block c tc pc
  (RBnop
   :: RBexit None (RBcall s1 (inr i1) l1 r0 n0) :: nil)
        unfold_ands.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
n: RTL.node
s: signature
i: ident
l: list reg
r: reg
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBcall s (inr i) l r n) :: nil) =
true ->
match_block c tc pc
  (RBexit None (RBcall s (inr i) l r n) :: nil)
pc: node
Heqo: c ! pc = Some (RTL.Icall s (inr i) l r n)
H0: check_valid_node tc n = true
match_block c tc pc
  (RBnop
   :: RBexit None (RBcall s (inr i) l r n) :: nil) eapply match_block_call; eauto using check_valid_node_correct.
      +
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
s: signature
s0: (reg + ident)%type
l: list reg
Heqo: c ! pc = Some (RTL.Itailcall s s0 l)
H: match s0 with
| inl r =>
    match a with
    | RBnop =>
        match b with
        | RBexit None
          (RBtailcall sig' (inl r') args') :: nil =>
            ceq signature_eq s sig' &&
            ceq peq r r' &&
            ceq list_pos_eq l args'
        | RBexit None
          (RBtailcall sig' (inl r') args')
          :: _ :: _ => false
        | RBexit None (RBtailcall sig' (inr _) _)
          :: _ => false
        | _ => false
        end
    | _ => false
    end
| inr r =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBtailcall sig' (inl _) _)
          :: _ => false
        | RBexit None
          (RBtailcall sig' (inr r') args') :: nil =>
            ceq signature_eq s sig' &&
            ceq peq r r' &&
            ceq list_pos_eq l args'
        | RBexit None
          (RBtailcall sig' (inr r') args')
          :: _ :: _ => false
        | _ => false
        end
    | _ => false
    end
end = true
match_block c tc pc (a :: b) repeat (destruct_match; try discriminate); subst; try solve [unfold_ands; econstructor; eauto].
      +
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
c0: Op.condition
l: list reg
n, n0: RTL.node
Heqo: c ! pc = Some (RTL.Icond c0 l n n0)
H: match a with
| RBnop =>
    match b with
    | RBexit None (RBcond cond' args' n1' n2')
      :: nil =>
        check_valid_node tc n &&
        check_valid_node tc n0 &&
        ceq condition_eq c0 cond' &&
        ceq list_pos_eq l args' && 
        ceq peq n n1' && 
        ceq peq n0 n2'
    | RBexit None (RBcond cond' args' n1' n2')
      :: _ :: _ => false
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b) repeat (destruct_match; try discriminate); subst; try solve [unfold_ands; econstructor; eauto].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
c2: Op.condition
l1: list reg
n1, n2: node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBcond c2 l1 n1 n2) :: nil) =
true ->
match_block c tc pc
  (RBexit None (RBcond c2 l1 n1 n2) :: nil)
pc: node
c0: Op.condition
l: list reg
n, n0: RTL.node
Heqo: c ! pc = Some (RTL.Icond c0 l n n0)
H: check_valid_node tc n && check_valid_node tc n0 &&
ceq condition_eq c0 c2 && 
ceq list_pos_eq l l1 && ceq peq n n1 &&
ceq peq n0 n2 = true
match_block c tc pc
  (RBnop :: RBexit None (RBcond c2 l1 n1 n2) :: nil)
        unfold_ands.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
c2: Op.condition
l1: list reg
n1, n2: node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBcond c2 l1 n1 n2) :: nil) =
true ->
match_block c tc pc
  (RBexit None (RBcond c2 l1 n1 n2) :: nil)
pc: node
Heqo: c ! pc = Some (RTL.Icond c2 l1 n1 n2)
H0: check_valid_node tc n1 = true
H5: check_valid_node tc n2 = true
match_block c tc pc
  (RBnop :: RBexit None (RBcond c2 l1 n1 n2) :: nil) eapply match_block_cond; eauto using check_valid_node_correct.
      +
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
r: reg
l: list RTL.node
Heqo: c ! pc = Some (RTL.Ijumptable r l)
H: match a with
| RBnop =>
    match b with
    | RBexit None (RBjumptable r' ns') :: nil =>
        ceq peq r r' && ceq list_pos_eq l ns' &&
        forallb (check_valid_node tc) l
    | RBexit None (RBjumptable r' ns') :: _ :: _ =>
        false
    | _ => false
    end
| _ => false
end = true
match_block c tc pc (a :: b) repeat (destruct_match; try discriminate); subst; try solve [unfold_ands; econstructor; eauto].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
r0: reg
l1: list node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBjumptable r0 l1) :: nil) =
true ->
match_block c tc pc
  (RBexit None (RBjumptable r0 l1) :: nil)
pc: node
r: reg
l: list RTL.node
Heqo: c ! pc = Some (RTL.Ijumptable r l)
H: ceq peq r r0 && ceq list_pos_eq l l1 &&
forallb (check_valid_node tc) l = true
match_block c tc pc
  (RBnop :: RBexit None (RBjumptable r0 l1) :: nil)
        unfold_ands.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
r0: reg
l1: list node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBjumptable r0 l1) :: nil) =
true ->
match_block c tc pc
  (RBexit None (RBjumptable r0 l1) :: nil)
pc: node
H1: forallb (check_valid_node tc) l1 = true
Heqo: c ! pc = Some (RTL.Ijumptable r0 l1)
match_block c tc pc
  (RBnop :: RBexit None (RBjumptable r0 l1) :: nil) eapply match_block_jumptable; eauto using check_valid_node_correct.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
r0: reg
l1: list node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBjumptable r0 l1) :: nil) =
true ->
match_block c tc pc
  (RBexit None (RBjumptable r0 l1) :: nil)
pc: node
H1: forallb (check_valid_node tc) l1 = true
Heqo: c ! pc = Some (RTL.Ijumptable r0 l1)
Forall (valid_succ tc) l1
        apply Forall_forall; intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
r0: reg
l1: list node
IHb: forall pc : node,
check_code c tc pc
  (RBexit None (RBjumptable r0 l1) :: nil) =
true ->
match_block c tc pc
  (RBexit None (RBjumptable r0 l1) :: nil)
pc: node
H1: forallb (check_valid_node tc) l1 = true
Heqo: c ! pc = Some (RTL.Ijumptable r0 l1)
x: node
H: In x l1
valid_succ tc x eapply forallb_forall in H1; eauto using check_valid_node_correct.
      +
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
c: RTL.code
tc: code
a: instr
b: list instr
IHb: forall pc : node,
check_code c tc pc b = true ->
match_block c tc pc b
pc: node
o: option reg
Heqo: c ! pc = Some (RTL.Ireturn o)
H: match o with
| Some r =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBreturn (Some r')) :: nil =>
            ceq peq r r'
        | RBexit None (RBreturn (Some r'))
          :: _ :: _ => false
        | _ => false
        end
    | _ => false
    end
| None =>
    match a with
    | RBnop =>
        match b with
        | RBexit None (RBreturn None) :: nil =>
            true
        | _ => false
        end
    | _ => false
    end
end = true
match_block c tc pc (a :: b) repeat (destruct_match; try discriminate); subst; try solve [unfold_ands; econstructor; eauto].
  Qed.

  Lemma transl_match_code :
    forall f tf,
      transl_function f = OK tf ->
      match_code f.(RTL.fn_code) tf.(fn_code).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (f : RTL.function) (tf : function),
transl_function f = OK tf ->
match_code (RTL.fn_code f) (fn_code tf)
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (f : RTL.function) (tf : function),
transl_function f = OK tf ->
match_code (RTL.fn_code f) (fn_code tf)
    unfold transl_function; intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.function
tf: function
H: match partition f with
| OK f' =>
    if
     check_valid_node (fn_code f')
       (RTL.fn_entrypoint f)
    then
     if
      forall_ptree
        (check_code (RTL.fn_code f) (fn_code f'))
        (fn_code f')
     then
      OK
        {|
          fn_sig := RTL.fn_sig f;
          fn_params := RTL.fn_params f;
          fn_stacksize := RTL.fn_stacksize f;
          fn_code := fn_code f';
          fn_entrypoint := RTL.fn_entrypoint f
        |}
     else
      Error (msg "check_present_blocks failed")
    else Error (msg "entrypoint does not exists")
| Error msg => Error msg
end = OK tf
match_code (RTL.fn_code f) (fn_code tf)
    repeat (destruct_match; try discriminate; []).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.function
tf, f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
H: OK
  {|
    fn_sig := RTL.fn_sig f;
    fn_params := RTL.fn_params f;
    fn_stacksize := RTL.fn_stacksize f;
    fn_code := fn_code f0;
    fn_entrypoint := RTL.fn_entrypoint f
  |} = OK tf
match_code (RTL.fn_code f) (fn_code tf) inv H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.function
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
match_code (RTL.fn_code f)
  (fn_code
     {|
       fn_sig := RTL.fn_sig f;
       fn_params := RTL.fn_params f;
       fn_stacksize := RTL.fn_stacksize f;
       fn_code := fn_code f0;
       fn_entrypoint := RTL.fn_entrypoint f
     |}) simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.function
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
match_code (RTL.fn_code f) (fn_code f0)
    unfold match_code; intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.function
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
pc: positive
b: SeqBB.t
H: (fn_code f0) ! pc = Some b
match_block (RTL.fn_code f) (fn_code f0) pc b
    eapply forall_ptree_true in Heqb0; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.function
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
pc: positive
b: SeqBB.t
H: (fn_code f0) ! pc = Some b
Heqb0: check_code (RTL.fn_code f) (fn_code f0) pc b =
true
match_block (RTL.fn_code f) (fn_code f0) pc b
    unfold check_code in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
f: RTL.function
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
pc: positive
b: SeqBB.t
H: (fn_code f0) ! pc = Some b
Heqb0: (fix check_code
   (c : RTL.code) (tc : code) 
   (pc : node) (b : SeqBB.t) {struct b} :
     bool :=
   match c ! pc with
   | Some (RTL.Inop pc'') =>
       match b with
       | RBnop :: (RBnop :: _ :: _) as b' |
         RBnop
         :: (RBop _ _ _ _ :: _ :: _) as b' |
         RBnop
         :: (RBload _ _ _ _ _ :: _ :: _) as b' |
         RBnop
         :: (RBstore _ _ _ _ _ :: _ :: _) as b' |
         RBnop
         :: (RBsetpred _ _ _ _ :: _ :: _) as b' |
         RBnop
         :: (RBexit (Some _) _ :: _ :: _) as b' |
         RBnop
         :: (RBexit None 
             (RBcall _ _ _ _ _) :: 
             _ :: _) as b' |
         RBnop
         :: (RBexit None 
             (RBtailcall _ _ _) :: 
             _ :: _) as b' |
         RBnop
         :: (RBexit None 
             (RBbuiltin _ _ _ _) :: 
             _ :: _) as b' |
         RBnop
         :: (RBexit None 
             (RBcond _ _ _ _) :: 
             _ :: _) as b' |
         RBnop
         :: (RBexit None 
             (RBjumptable _ _) :: 
             _ :: _) as b' |
         RBnop
         :: (RBexit None 
             (RBreturn _) :: 
             _ :: _) as b' =>
           check_code c tc pc'' b'
       | RBnop
         :: RBexit None (RBgoto pc') :: nil =>
           check_valid_node tc pc' &&
           ceq peq pc' pc''
       | RBnop
         :: (RBexit None 
             (RBgoto pc') :: 
             _ :: _) as b' =>
           check_code c tc pc'' b'
       | _ => false
       end
   | Some (RTL.Iop op' args' dst' pc'') =>
       match b with
       | RBop None op args dst :: nil |
         RBop None op args dst :: RBnop :: nil |
         RBop None op args dst
         :: RBop _ _ _ _ :: nil |
         RBop None op args dst
         :: RBload _ _ _ _ _ :: nil |
         RBop None op args dst
         :: RBstore _ _ _ _ _ :: nil |
         RBop None op args dst
         :: RBsetpred _ _ _ _ :: nil |
         RBop None op args dst
         :: RBexit (Some _) _ :: nil |
         RBop None op args dst
         :: RBexit None (RBcall _ _ _ _ _)
            :: nil |
         RBop None op args dst
         :: RBexit None (RBtailcall _ _ _)
            :: nil |
         RBop None op args dst
         :: RBexit None (RBbuiltin _ _ _ _)
            :: nil |
         RBop None op args dst
         :: RBexit None (RBcond _ _ _ _)
            :: nil |
         RBop None op args dst
         :: RBexit None (RBjumptable _ _)
            :: nil |
         RBop None op args dst
         :: RBexit None (RBreturn _) :: nil =>
           false
       | RBop None op args dst
         :: (RBnop :: _ :: _) as b' |
         RBop None op args dst
         :: (RBop _ _ _ _ :: _ :: _) as b' |
         RBop None op args dst
         :: (RBload _ _ _ _ _ :: _ :: _) as b' |
         RBop None op args dst
         :: (RBstore _ _ _ _ _ :: _ :: _) as b' |
         RBop None op args dst
         :: (RBsetpred _ _ _ _ :: _ :: _) as b' |
         RBop None op args dst
         :: (RBexit (Some _) _ :: _ :: _) as b' |
         RBop None op args dst
         :: (RBexit None 
             (RBcall _ _ _ _ _) :: 
             _ :: _) as b' |
         RBop None op args dst
         :: (RBexit None 
             (RBtailcall _ _ _) :: 
             _ :: _) as b' |
         RBop None op args dst
         :: (RBexit None 
             (RBbuiltin _ _ _ _) :: 
             _ :: _) as b' |
         RBop None op args dst
         :: (RBexit None 
             (RBcond _ _ _ _) :: 
             _ :: _) as b' |
         RBop None op args dst
         :: (RBexit None 
             (RBjumptable _ _) :: 
             _ :: _) as b' |
         RBop None op args dst
         :: (RBexit None 
             (RBreturn _) :: 
             _ :: _) as b' =>
           ceq operation_eq op op' &&
           ceq list_pos_eq args args' &&
           ceq peq dst dst' &&
           check_code c tc pc'' b'
       | RBop None op args dst
         :: RBexit None (RBgoto pc') :: nil =>
           check_valid_node tc pc' &&
           ceq peq pc' pc'' &&
           ceq operation_eq op op' &&
           ceq list_pos_eq args args' &&
           ceq peq dst dst'
       | RBop None op args dst
         :: (RBexit None 
             (RBgoto pc') :: 
             _ :: _) as b' =>
           ceq operation_eq op op' &&
           ceq list_pos_eq args args' &&
           ceq peq dst dst' &&
           check_code c tc pc'' b'
       | _ => false
       end
   | Some
     (RTL.Iload chunk' addr' args' dst' pc'') =>
       match b with
       | RBload None chunk addr args dst
         :: nil |
         RBload None chunk addr args dst
         :: RBnop :: nil |
         RBload None chunk addr args dst
         :: RBop _ _ _ _ :: nil |
         RBload None chunk addr args dst
         :: RBload _ _ _ _ _ :: nil |
         RBload None chunk addr args dst
         :: RBstore _ _ _ _ _ :: nil |
         RBload None chunk addr args dst
         :: RBsetpred _ _ _ _ :: nil |
         RBload None chunk addr args dst
         :: RBexit (Some _) _ :: nil |
         RBload None chunk addr args dst
         :: RBexit None (RBcall _ _ _ _ _)
            :: nil |
         RBload None chunk addr args dst
         :: RBexit None (RBtailcall _ _ _)
            :: nil |
         RBload None chunk addr args dst
         :: RBexit None (RBbuiltin _ _ _ _)
            :: nil |
         RBload None chunk addr args dst
         :: RBexit None (RBcond _ _ _ _)
            :: nil |
         RBload None chunk addr args dst
         :: RBexit None (RBjumptable _ _)
            :: nil |
         RBload None chunk addr args dst
         :: RBexit None (RBreturn _) :: nil =>
           false
       | RBload None chunk addr args dst
         :: (RBnop :: _ :: _) as b' |
         RBload None chunk addr args dst
         :: (RBop _ _ _ _ :: _ :: _) as b' |
         RBload None chunk addr args dst
         :: (RBload _ _ _ _ _ :: _ :: _) as b' |
         RBload None chunk addr args dst
         :: (RBstore _ _ _ _ _ :: _ :: _) as b' |
         RBload None chunk addr args dst
         :: (RBsetpred _ _ _ _ :: _ :: _) as b' |
         RBload None chunk addr args dst
         :: (RBexit (Some _) _ :: _ :: _) as b' |
         RBload None chunk addr args dst
         :: (RBexit None 
             (RBcall _ _ _ _ _) :: 
             _ :: _) as b' |
         RBload None chunk addr args dst
         :: (RBexit None 
             (RBtailcall _ _ _) :: 
             _ :: _) as b' |
         RBload None chunk addr args dst
         :: (RBexit None 
             (RBbuiltin _ _ _ _) :: 
             _ :: _) as b' |
         RBload None chunk addr args dst
         :: (RBexit None 
             (RBcond _ _ _ _) :: 
             _ :: _) as b' |
         RBload None chunk addr args dst
         :: (RBexit None 
             (RBjumptable _ _) :: 
             _ :: _) as b' |
         RBload None chunk addr args dst
         :: (RBexit None 
             (RBreturn _) :: 
             _ :: _) as b' =>
           ceq memory_chunk_eq chunk chunk' &&
           ceq addressing_eq addr addr' &&
           ceq list_pos_eq args args' &&
           ceq peq dst dst' &&
           check_code c tc pc'' b'
       | RBload None chunk addr args dst
         :: RBexit None (RBgoto pc') :: nil =>
           check_valid_node tc pc' &&
           ceq peq pc' pc'' &&
           ceq memory_chunk_eq chunk chunk' &&
           ceq addressing_eq addr addr' &&
           ceq list_pos_eq args args' &&
           ceq peq dst dst'
       | RBload None chunk addr args dst
         :: (RBexit None 
             (RBgoto pc') :: 
             _ :: _) as b' =>
           ceq memory_chunk_eq chunk chunk' &&
           ceq addressing_eq addr addr' &&
           ceq list_pos_eq args args' &&
           ceq peq dst dst' &&
           check_code c tc pc'' b'
       | _ => false
       end
   | Some
     (RTL.Istore chunk' addr' args' src' pc'') =>
       match b with
       | RBstore None chunk addr args src
         :: nil |
         RBstore None chunk addr args src
         :: RBnop :: nil |
         RBstore None chunk addr args src
         :: RBop _ _ _ _ :: nil |
         RBstore None chunk addr args src
         :: RBload _ _ _ _ _ :: nil |
         RBstore None chunk addr args src
         :: RBstore _ _ _ _ _ :: nil |
         RBstore None chunk addr args src
         :: RBsetpred _ _ _ _ :: nil |
         RBstore None chunk addr args src
         :: RBexit (Some _) _ :: nil |
         RBstore None chunk addr args src
         :: RBexit None (RBcall _ _ _ _ _)
            :: nil |
         RBstore None chunk addr args src
         :: RBexit None (RBtailcall _ _ _)
            :: nil |
         RBstore None chunk addr args src
         :: RBexit None (RBbuiltin _ _ _ _)
            :: nil |
         RBstore None chunk addr args src
         :: RBexit None (RBcond _ _ _ _)
            :: nil |
         RBstore None chunk addr args src
         :: RBexit None (RBjumptable _ _)
            :: nil |
         RBstore None chunk addr args src
         :: RBexit None (RBreturn _) :: nil =>
           false
       | RBstore None chunk addr args src
         :: (RBnop :: _ :: _) as b' |
         RBstore None chunk addr args src
         :: (RBop _ _ _ _ :: _ :: _) as b' |
         RBstore None chunk addr args src
         :: (RBload _ _ _ _ _ :: _ :: _) as b' |
         RBstore None chunk addr args src
         :: (RBstore _ _ _ _ _ :: _ :: _) as b' |
         RBstore None chunk addr args src
         :: (RBsetpred _ _ _ _ :: _ :: _) as b' |
         RBstore None chunk addr args src
         :: (RBexit (Some _) _ :: _ :: _) as b' |
         RBstore None chunk addr args src
         :: (RBexit None 
             (RBcall _ _ _ _ _) :: 
             _ :: _) as b' |
         RBstore None chunk addr args src
         :: (RBexit None 
             (RBtailcall _ _ _) :: 
             _ :: _) as b' |
         RBstore None chunk addr args src
         :: (RBexit None 
             (RBbuiltin _ _ _ _) :: 
             _ :: _) as b' |
         RBstore None chunk addr args src
         :: (RBexit None 
             (RBcond _ _ _ _) :: 
             _ :: _) as b' |
         RBstore None chunk addr args src
         :: (RBexit None 
             (RBjumptable _ _) :: 
             _ :: _) as b' |
         RBstore None chunk addr args src
         :: (RBexit None 
             (RBreturn _) :: 
             _ :: _) as b' =>
           ceq memory_chunk_eq chunk chunk' &&
           ceq addressing_eq addr addr' &&
           ceq list_pos_eq args args' &&
           ceq peq src src' &&
           check_code c tc pc'' b'
       | RBstore None chunk addr args src
         :: RBexit None (RBgoto pc') :: nil =>
           check_valid_node tc pc' &&
           ceq peq pc' pc'' &&
           ceq memory_chunk_eq chunk chunk' &&
           ceq addressing_eq addr addr' &&
           ceq list_pos_eq args args' &&
           ceq peq src src'
       | RBstore None chunk addr args src
         :: (RBexit None 
             (RBgoto pc') :: 
             _ :: _) as b' =>
           ceq memory_chunk_eq chunk chunk' &&
           ceq addressing_eq addr addr' &&
           ceq list_pos_eq args args' &&
           ceq peq src src' &&
           check_code c tc pc'' b'
       | _ => false
       end
   | Some
     (RTL.Icall sig' (inl r') args' dst' pc'') =>
       match b with
       | RBnop
         :: RBexit None
            (RBcall sig (inl r) args dst pc')
            :: nil =>
           check_valid_node tc pc' &&
           ceq peq pc' pc'' &&
           ceq signature_eq sig sig' &&
           ceq peq r r' &&
           ceq list_pos_eq args args' &&
           ceq peq dst dst'
       | RBnop
         :: RBexit None
            (RBcall sig (inl r) args dst pc')
            :: _ :: _ => false
       | RBnop
         :: RBexit None
            (RBcall sig (inr _) _ _ _) :: _ =>
           false
       | _ => false
       end
   | Some
     (RTL.Icall sig' (inr i') args' dst' pc'') =>
       match b with
       | RBnop
         :: RBexit None
            (RBcall sig (inl _) _ _ _) :: _ =>
           false
       | RBnop
         :: RBexit None
            (RBcall sig (inr i) args dst pc')
            :: nil =>
           check_valid_node tc pc' &&
           ceq peq pc' pc'' &&
           ceq signature_eq sig sig' &&
           ceq peq i i' &&
           ceq list_pos_eq args args' &&
           ceq peq dst dst'
       | RBnop
         :: RBexit None
            (RBcall sig (inr i) args dst pc')
            :: _ :: _ => false
       | _ => false
       end
   | Some (RTL.Itailcall sig (inl r) args) =>
       match b with
       | RBnop
         :: RBexit None
            (RBtailcall sig' (inl r') args')
            :: nil =>
           ceq signature_eq sig sig' &&
           ceq peq r r' &&
           ceq list_pos_eq args args'
       | RBnop
         :: RBexit None
            (RBtailcall sig' (inl r') args')
            :: _ :: _ => false
       | RBnop
         :: RBexit None
            (RBtailcall sig' (inr _) _) :: _ =>
           false
       | _ => false
       end
   | Some (RTL.Itailcall sig (inr r) args) =>
       match b with
       | RBnop
         :: RBexit None
            (RBtailcall sig' (inl _) _) :: _ =>
           false
       | RBnop
         :: RBexit None
            (RBtailcall sig' (inr r') args')
            :: nil =>
           ceq signature_eq sig sig' &&
           ceq peq r r' &&
           ceq list_pos_eq args args'
       | RBnop
         :: RBexit None
            (RBtailcall sig' (inr r') args')
            :: _ :: _ => false
       | _ => false
       end
   | Some (RTL.Icond cond args n1 n2) =>
       match b with
       | RBnop
         :: RBexit None
            (RBcond cond' args' n1' n2')
            :: nil =>
           check_valid_node tc n1 &&
           check_valid_node tc n2 &&
           ceq condition_eq cond cond' &&
           ceq list_pos_eq args args' &&
           ceq peq n1 n1' && 
           ceq peq n2 n2'
       | RBnop
         :: RBexit None
            (RBcond cond' args' n1' n2')
            :: _ :: _ => false
       | _ => false
       end
   | Some (RTL.Ijumptable r ns) =>
       match b with
       | RBnop
         :: RBexit None (RBjumptable r' ns')
            :: nil =>
           ceq peq r r' &&
           ceq list_pos_eq ns ns' &&
           forallb (check_valid_node tc) ns
       | RBnop
         :: RBexit None (RBjumptable r' ns')
            :: _ :: _ => false
       | _ => false
       end
   | Some (RTL.Ireturn (Some r)) =>
       match b with
       | RBnop
         :: RBexit None (RBreturn (Some r'))
            :: nil => ceq peq r r'
       | RBnop
         :: RBexit None (RBreturn (Some r'))
            :: _ :: _ => false
       | _ => false
       end
   | Some (RTL.Ireturn None) =>
       match b with
       | RBnop
         :: RBexit None (RBreturn None) :: nil =>
           true
       | _ => false
       end
   | _ => false
   end) (RTL.fn_code f) (fn_code f0) pc b =
true
match_block (RTL.fn_code f) (fn_code f0) pc b
    eauto using transl_match_code'.
  Qed.

  Lemma transl_initial_states :
    forall s1, RTL.initial_state prog s1 ->
      exists s2, GibleSeq.initial_state tprog s2 /\ match_states None s1 s2.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall s1 : RTL.state,
RTL.initial_state prog s1 ->
exists s2 : state,
  initial_state tprog s2 /\ match_states None s1 s2
  Proof using TRANSL.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall s1 : RTL.state,
RTL.initial_state prog s1 ->
exists s2 : state,
  initial_state tprog s2 /\ match_states None s1 s2
    induction 1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
exists s2 : state,
  initial_state tprog s2 /\
  match_states None (RTL.Callstate nil f nil m0) s2
    exploit function_ptr_translated; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
(exists tf : fundef,
   Genv.find_funct_ptr tge b = Some tf /\
   transl_fundef f = OK tf) ->
exists s2 : state,
  initial_state tprog s2 /\
  match_states None (RTL.Callstate nil f nil m0) s2 intros [tf [A B]].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
exists s2 : state,
  initial_state tprog s2 /\
  match_states None (RTL.Callstate nil f nil m0) s2
    do 2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
initial_state tprog ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
match_states None (RTL.Callstate nil f nil m0) ?s2 simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
initial_state tprog ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
match_states None (RTL.Callstate nil f nil m0) ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
Genv.init_mem tprog = Some ?m0
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
Genv.find_symbol (Genv.globalenv tprog)
  (prog_main tprog) = Some ?b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
Genv.find_funct_ptr (Genv.globalenv tprog) ?b =
Some ?f
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
funsig ?f = signature_main
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
match_states None (RTL.Callstate nil f nil m0)
  (Callstate nil ?f nil ?m0)
    apply (Genv.init_mem_transf_partial TRANSL); eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
Genv.find_symbol (Genv.globalenv tprog)
  (prog_main tprog) = Some ?b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
Genv.find_funct_ptr (Genv.globalenv tprog) ?b =
Some ?f
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
funsig ?f = signature_main
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
match_states None (RTL.Callstate nil f nil m0)
  (Callstate nil ?f nil m0)
    replace (prog_main tprog) with (prog_main prog).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
Genv.find_symbol (Genv.globalenv tprog)
  (prog_main prog) = Some ?b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
prog_main prog = prog_main tprog
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
Genv.find_funct_ptr (Genv.globalenv tprog) ?b =
Some ?f
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
funsig ?f = signature_main
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
match_states None (RTL.Callstate nil f nil m0)
  (Callstate nil ?f nil m0) rewrite symbols_preserved; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
prog_main prog = prog_main tprog
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
Genv.find_funct_ptr (Genv.globalenv tprog) b = Some ?f
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
funsig ?f = signature_main
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
match_states None (RTL.Callstate nil f nil m0)
  (Callstate nil ?f nil m0)
    symmetry; eapply Linking.match_program_main; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
Genv.find_funct_ptr (Genv.globalenv tprog) b = Some ?f
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
funsig ?f = signature_main
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
match_states None (RTL.Callstate nil f nil m0)
  (Callstate nil ?f nil m0) eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
funsig tf = signature_main
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
match_states None (RTL.Callstate nil f nil m0)
  (Callstate nil tf nil m0)
    erewrite sig_transl_function; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
match_states None (RTL.Callstate nil f nil m0)
  (Callstate nil tf nil m0) constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
transl_fundef f = OK tf
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
Forall2 match_stackframe nil nil auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
b: block
f: RTL.fundef
m0: mem
ge0:= Genv.globalenv prog: Genv.t RTL.fundef unit
H: Genv.init_mem prog = Some m0
H0: Genv.find_symbol ge0 (prog_main prog) = Some b
H1: Genv.find_funct_ptr ge0 b = Some f
H2: RTL.funsig f = signature_main
tf: fundef
A: Genv.find_funct_ptr tge b = Some tf
B: transl_fundef f = OK tf
Forall2 match_stackframe nil nil auto.
  Qed.

  Lemma transl_final_states :
    forall s1 s2 r b,
      match_states b s1 s2 ->
      RTL.final_state s1 r ->
      GibleSeq.final_state s2 r.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s1 : RTL.state) (s2 : state)
  (r : Integers.Int.int) (b : option SeqBB.t),
match_states b s1 s2 ->
RTL.final_state s1 r -> final_state s2 r
  Proof using.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s1 : RTL.state) (s2 : state)
  (r : Integers.Int.int) (b : option SeqBB.t),
match_states b s1 s2 ->
RTL.final_state s1 r -> final_state s2 r
    inversion 2; crush.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s1: RTL.state
s2: state
r: Integers.Int.int
b: option SeqBB.t
H: match_states b s1 s2
H0: RTL.final_state s1 r
r0: Integers.Int.int
m: mem
H1: RTL.Returnstate nil (Vint r0) m = s1
H2: r0 = r
final_state s2 r subst.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s2: state
r: Integers.Int.int
b: option SeqBB.t
m: mem
H: match_states b (RTL.Returnstate nil (Vint r) m) s2
H0: RTL.final_state (RTL.Returnstate nil (Vint r) m)
  r
final_state s2 r inv H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
r: Integers.Int.int
m: mem
H0: RTL.final_state (RTL.Returnstate nil (Vint r) m)
  r
cs': list stackframe
STK: Forall2 match_stackframe nil cs'
final_state (Returnstate cs' (Vint r) m) r inv STK.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
r: Integers.Int.int
m: mem
H0: RTL.final_state (RTL.Returnstate nil (Vint r) m)
  r
final_state (Returnstate nil (Vint r) m) r econstructor.
  Qed.

  Lemma hd_nth_equiv:
    forall A n (l: list A), hd_error (list_drop n l) = nth_error l n.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (A : Type) (n : nat) (l : list A),
hd_error (list_drop n l) = nth_error l n
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (A : Type) (n : nat) (l : list A),
hd_error (list_drop n l) = nth_error l n induction n; destruct l; crush. Qed.

  Lemma hd_error_Some_exists:
    forall A (l: list A) n, hd_error l = Some n -> l = n :: tl l.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (A : Type) (l : list A) (n : A),
hd_error l = Some n -> l = n :: tl l
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (A : Type) (l : list A) (n : A),
hd_error l = Some n -> l = n :: tl l induction l; crush. Qed.

  Definition imm_succ_dec pc pc' : {imm_succ pc pc'} + {~ imm_succ pc pc'}.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
pc, pc': node
{imm_succ pc pc'} + {~ imm_succ pc pc'}
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
pc, pc': node
{imm_succ pc pc'} + {~ imm_succ pc pc'}
    unfold imm_succ.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
pc, pc': node
{pc' = Pos.pred pc} + {pc' <> Pos.pred pc} pose proof peq.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
pc, pc': node
H: forall x y : positive, {x = y} + {x <> y}
{pc' = Pos.pred pc} + {pc' <> Pos.pred pc}
    decide equality.
  Defined.

  Lemma imm_succ_refl pc : imm_succ pc (Pos.pred pc).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
pc: node
imm_succ pc (Pos.pred pc)
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
pc: node
imm_succ pc (Pos.pred pc) unfold imm_succ; auto. Qed.

  Lemma imm_succ_refl2 pc : imm_succ (Pos.succ pc) pc.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
pc: positive
imm_succ (Pos.succ pc) pc
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
pc: positive
imm_succ (Pos.succ pc) pc unfold imm_succ; auto using Pos.pred_succ. Qed.

  Lemma sim_star :
    forall s1 b t s,
      (exists b' s2,
        star step tge s1 t s2 /\ ltof _ measure b' b
        /\ match_states b' s s2) ->
      exists b' s2,
        (plus step tge s1 t s2 \/
           star step tge s1 t s2 /\ ltof _ measure b' b) /\
          match_states b' s s2.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s1 : state) (b : option SeqBB.t) (t : trace)
  (s : RTL.state),
(exists (b' : option SeqBB.t) (s2 : state),
   star step tge s1 t s2 /\
   ltof (option SeqBB.t) measure b' b /\
   match_states b' s s2) ->
exists (b' : option SeqBB.t) (s2 : state),
  (plus step tge s1 t s2 \/
   star step tge s1 t s2 /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' s s2
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s1 : state) (b : option SeqBB.t) (t : trace)
  (s : RTL.state),
(exists (b' : option SeqBB.t) (s2 : state),
   star step tge s1 t s2 /\
   ltof (option SeqBB.t) measure b' b /\
   match_states b' s s2) ->
exists (b' : option SeqBB.t) (s2 : state),
  (plus step tge s1 t s2 \/
   star step tge s1 t s2 /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' s s2 intros; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s1: state
b: option SeqBB.t
t: trace
s: RTL.state
x: option SeqBB.t
x0: state
H0: star step tge s1 t x0
H: ltof (option SeqBB.t) measure x b
H2: match_states x s x0
exists (b' : option SeqBB.t) (s2 : state),
  (plus step tge s1 t s2 \/
   star step tge s1 t s2 /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' s s2 do 3 econstructor; eauto. Qed.

  Lemma sim_plus :
    forall s1 b t s,
      (exists b' s2, plus step tge s1 t s2 /\ match_states b' s s2) ->
      exists b' s2,
        (plus step tge s1 t s2 \/
           star step tge s1 t s2 /\ ltof _ measure b' b) /\
          match_states b' s s2.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s1 : state) (b : option SeqBB.t) (t : trace)
  (s : RTL.state),
(exists (b' : option SeqBB.t) (s2 : state),
   plus step tge s1 t s2 /\ match_states b' s s2) ->
exists (b' : option SeqBB.t) (s2 : state),
  (plus step tge s1 t s2 \/
   star step tge s1 t s2 /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' s s2
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s1 : state) (b : option SeqBB.t) (t : trace)
  (s : RTL.state),
(exists (b' : option SeqBB.t) (s2 : state),
   plus step tge s1 t s2 /\ match_states b' s s2) ->
exists (b' : option SeqBB.t) (s2 : state),
  (plus step tge s1 t s2 \/
   star step tge s1 t s2 /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' s s2 intros; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s1: state
b: option SeqBB.t
t: trace
s: RTL.state
x: option SeqBB.t
x0: state
H0: plus step tge s1 t x0
H1: match_states x s x0
exists (b' : option SeqBB.t) (s2 : state),
  (plus step tge s1 t s2 \/
   star step tge s1 t s2 /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' s s2 do 3 econstructor; eauto. Qed.

  Lemma transl_Inop_correct:
    forall s f sp pc rs m pc',
      (RTL.fn_code f) ! pc = Some (RTL.Inop pc') ->
      forall b s2, match_states b (RTL.State s f sp pc rs m) s2 ->
        exists b' s2',
          (plus step tge s2 E0 s2'
           \/ star step tge s2 E0 s2' /\ ltof _ measure b' b)
          /\ match_states b' (RTL.State s f sp pc' rs m) s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : RTL.regset)
  (m : mem) (pc' : RTL.node),
(RTL.fn_code f) ! pc = Some (RTL.Inop pc') ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : RTL.regset)
  (m : mem) (pc' : RTL.node),
(RTL.fn_code f) ! pc = Some (RTL.Inop pc') ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    intros * H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H0: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: match_code (RTL.fn_code f) (fn_code tf)
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H3: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    unfold match_code in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H0: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H3: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    match goal with H: match_block _ _ _ _ |- _ => inv H end; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some (RBnop :: b))) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H0: match_states
  (Some
     (RBnop :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: valid_succ (fn_code tf) pc'
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some (RBnop :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some (RBnop :: b))) /\
  match_states b' (RTL.State s f sp pc' rs m) s2' apply sim_star.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  star step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  ltof (option SeqBB.t) measure b' (Some (RBnop :: b)) /\
  match_states b' (RTL.State s f sp pc' rs m) s2
      do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
star step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
ltof (option SeqBB.t) measure ?b' (Some (RBnop :: b)) /\
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 eapply star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
ltof (option SeqBB.t) measure ?b' (Some (RBnop :: b)) /\
match_states ?b' (RTL.State s f sp pc' rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
ltof (option SeqBB.t) measure ?b' (Some (RBnop :: b))
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
match_states ?b' (RTL.State s f sp pc' rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
      instantiate (1 := Some b); unfold ltof; auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
match_states (Some b) (RTL.State s f sp pc' rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)

      constructor; try eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
exists b' : SeqBB.t,
  (fn_code tf) ! pc1 = Some b' /\
  match_block (RTL.fn_code f) (fn_code tf) pc' b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc' rs m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc' rs m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b
      eapply star_right; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
RTL.step ge (RTL.State s f sp pc rs m) ?t2
  (RTL.State s f sp pc' rs m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
E0 = E0 ** ?t2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b
      eapply RTL.exec_Inop; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
E0 = E0 ** E0
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBnop :: b)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b

      unfold sem_extrap in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: b) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) b out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H0: match_states (Some (RBnop :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: b) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc' b
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
out_s: istate
block2: SeqBB.t
H3: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) b out_s
H5: (fn_code tf) ! pc1 = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s inv H3.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H7: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H9: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H8: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
      eapply BB.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H7: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H9: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H7: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H9: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H8: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H7: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H9: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) RBnop (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H7: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H9: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp 
  (Iexec ?state') (i :: instrs) 
  (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H7: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H9: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H8: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H7: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H9: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (i :: instrs) (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H7: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H9: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H8: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
      econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H7: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H9: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H8: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H0: match_states (Some (RBnop :: i :: instrs))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
block2: SeqBB.t
H5: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H8: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
      inv H4; inv H8.
    }
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H0: match_states
  (Some
     (RBnop :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: valid_succ (fn_code tf) pc'
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some (RBnop :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H0: match_states
  (Some
     (RBnop :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: valid_succ (fn_code tf) pc'
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some (RBnop :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b' (RTL.State s f sp pc' rs m) s2' apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H0: match_states
  (Some
     (RBnop :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: valid_succ (fn_code tf) pc'
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp pc' rs m) s2
      inv H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: valid_succ (fn_code tf) pc'
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
BLOCK: exists b' : SeqBB.t,
  (fn_code tf) ! pc1 = Some b' /\
  match_block (RTL.fn_code f) 
    (fn_code tf) pc
    (RBnop :: RBexit None (RBgoto pc') :: nil)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp pc' rs m) s2 simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H4: valid_succ (fn_code tf) pc'
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp pc' rs m) s2
      unfold valid_succ in *; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp pc' rs m) s2
      do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
plus step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
(fn_code tf) ! pc1 = Some ?bb
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) ?bb
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2
      eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) x
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2
      eapply BB; [| eassumption ].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2
      econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) RBnop (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp 
  (Iexec ?state') (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 eapply exec_RBterm.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBgoto pc'))
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
truthy
  (is_ps
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBgoto pc') E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2
      constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBgoto pc') E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2
      econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m)
  (State stk' tf sp pc' rs (PMap.init false) m)

      econstructor; try eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
exists b' : SeqBB.t,
  (fn_code tf) ! pc' = Some b' /\
  match_block (RTL.fn_code f) (fn_code tf) pc' ?b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
star RTL.step ge (RTL.State s f sp pc' rs m) E0
  (RTL.State s f sp pc' rs m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) ?b eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
star RTL.step ge (RTL.State s f sp pc' rs m) E0
  (RTL.State s f sp pc' rs m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0
      eapply star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0
      unfold sem_extrap.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s ->
(fn_code tf) ! pc' = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
out_s: istate
block2: SeqBB.t
H4: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s
H6: (fn_code tf) ! pc' = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s setoid_rewrite H6 in H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H2: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
Learn: Learnt H
TF0: transl_function f = OK tf
CODE0: match_code (RTL.fn_code f) (fn_code tf)
STK0: Forall2 match_stackframe s stk'
STARSIMU0: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB0: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) 
  (fn_code tf) pc
  (RBnop :: RBexit None (RBgoto pc') :: nil)
Learn0: Learnt H2
x0: SeqBB.t
out_s: istate
block2: SeqBB.t
H0: Some block2 = Some x0
H4: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s
H6: (fn_code tf) ! pc' = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s
      crush.
    }
  Qed.

  Lemma eval_op_eq:
    forall (sp0 : Values.val) (op : Op.operation) (vl : list Values.val) m,
      Op.eval_operation ge sp0 op vl m = Op.eval_operation tge sp0 op vl m.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (sp0 : val) (op : Op.operation) (vl : list val)
  (m : mem),
Op.eval_operation ge sp0 op vl m =
Op.eval_operation tge sp0 op vl m
  Proof using TRANSL.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (sp0 : val) (op : Op.operation) (vl : list val)
  (m : mem),
Op.eval_operation ge sp0 op vl m =
Op.eval_operation tge sp0 op vl m
    intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
sp0: val
op: Op.operation
vl: list val
m: mem
Op.eval_operation ge sp0 op vl m =
Op.eval_operation tge sp0 op vl m
    destruct op; auto; unfold Op.eval_operation, Genv.symbol_address, Op.eval_addressing32;
    [| destruct a; unfold Genv.symbol_address ];
    try rewrite symbols_preserved; auto.
  Qed.

  Lemma eval_addressing_eq:
    forall sp addr vl,
      Op.eval_addressing ge sp addr vl = Op.eval_addressing tge sp addr vl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (sp : val) (addr : Op.addressing)
  (vl : list val),
Op.eval_addressing ge sp addr vl =
Op.eval_addressing tge sp addr vl
  Proof using TRANSL.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (sp : val) (addr : Op.addressing)
  (vl : list val),
Op.eval_addressing ge sp addr vl =
Op.eval_addressing tge sp addr vl
    intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
sp: val
addr: Op.addressing
vl: list val
Op.eval_addressing ge sp addr vl =
Op.eval_addressing tge sp addr vl
    destruct addr;
      unfold Op.eval_addressing, Op.eval_addressing32;
      unfold Genv.symbol_address;
      try rewrite symbols_preserved; auto.
  Qed.

  Lemma transl_Iop_correct_nj:
    forall s f sp pc rs m op args res pc' v stk' tf pc1 rs1 m1 b x,
      (RTL.fn_code f) ! pc = Some (RTL.Iop op args res pc') ->
      Op.eval_operation ge sp op rs ## args m = Some v ->
      transl_function f = OK tf ->
      (forall pc0 b0,
          (fn_code tf) ! pc0 = Some b0 -> match_block (RTL.fn_code f) (fn_code tf) pc0 b0) ->
      Forall2 match_stackframe s stk' ->
      star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0 (RTL.State s f sp pc rs m) ->
      sem_extrap tf pc1 sp (Iexec {| is_rs := rs; is_ps := PMap.init false; is_mem := m |})
                 (Iexec {| is_rs := rs1; is_ps := PMap.init false; is_mem := m1 |}) (RBop None op args res :: b) ->
      (fn_code tf) ! pc1 = Some x ->
      match_block (RTL.fn_code f) (fn_code tf) pc' b ->
      exists b' s2',
        star step tge (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0 s2'
        /\ ltof _ measure b' (Some (RBop None op args res :: b))
        /\ match_states b' (RTL.State s f sp pc' rs # res <- v m) s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (op : Op.operation) (args : list reg)
  (res0 : reg) (pc' : RTL.node) (v : val)
  (stk' : list stackframe) (tf : function)
  (pc1 : RTL.node) (rs1 : RTL.regset) (m1 : mem)
  (b : list instr) (x : SeqBB.t),
(RTL.fn_code f) ! pc = Some (RTL.Iop op args res0 pc') ->
Op.eval_operation ge sp op rs ## args m = Some v ->
transl_function f = OK tf ->
(forall (pc0 : positive) (b0 : SeqBB.t),
 (fn_code tf) ! pc0 = Some b0 ->
 match_block (RTL.fn_code f) (fn_code tf) pc0 b0) ->
Forall2 match_stackframe s stk' ->
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m) ->
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res0 :: b) ->
(fn_code tf) ! pc1 = Some x ->
match_block (RTL.fn_code f) (fn_code tf) pc' b ->
exists (b' : option SeqBB.t) (s2' : state),
  star step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2' /\
  ltof (option SeqBB.t) measure b'
    (Some (RBop None op args res0 :: b)) /\
  match_states b'
    (RTL.State s f sp pc' rs # res0 <- v m) s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (op : Op.operation) (args : list reg)
  (res0 : reg) (pc' : RTL.node) (v : val)
  (stk' : list stackframe) (tf : function)
  (pc1 : RTL.node) (rs1 : RTL.regset) (m1 : mem)
  (b : list instr) (x : SeqBB.t),
(RTL.fn_code f) ! pc = Some (RTL.Iop op args res0 pc') ->
Op.eval_operation ge sp op rs ## args m = Some v ->
transl_function f = OK tf ->
(forall (pc0 : positive) (b0 : SeqBB.t),
 (fn_code tf) ! pc0 = Some b0 ->
 match_block (RTL.fn_code f) (fn_code tf) pc0 b0) ->
Forall2 match_stackframe s stk' ->
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m) ->
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res0 :: b) ->
(fn_code tf) ! pc1 = Some x ->
match_block (RTL.fn_code f) (fn_code tf) pc' b ->
exists (b' : option SeqBB.t) (s2' : state),
  star step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2' /\
  ltof (option SeqBB.t) measure b'
    (Some (RBop None op args res0 :: b)) /\
  match_states b'
    (RTL.State s f sp pc' rs # res0 <- v m) s2'
    intros * IOP EVAL TR MATCHB STK STAR BB INCODE MATCHB2.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
exists (b' : option SeqBB.t) (s2' : state),
  star step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2' /\
  ltof (option SeqBB.t) measure b'
    (Some (RBop None op args res :: b)) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2'
    do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
star step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
ltof (option SeqBB.t) measure 
  ?b' (Some (RBop None op args res :: b)) /\
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2' eapply star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
ltof (option SeqBB.t) measure ?b'
  (Some (RBop None op args res :: b)) /\
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
ltof (option SeqBB.t) measure ?b'
  (Some (RBop None op args res :: b))
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
    instantiate (1 := Some b); unfold ltof; auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
match_states (Some b)
  (RTL.State s f sp pc' rs # res <- v m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)

    constructor; try eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
exists b' : SeqBB.t,
  (fn_code tf) ! pc1 = Some b' /\
  match_block (RTL.fn_code f) (fn_code tf) pc' b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc' rs # res <- v m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc' rs # res <- v m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b
    eapply star_right; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
RTL.step ge (RTL.State s f sp pc rs m) ?t2
  (RTL.State s f sp pc' rs # res <- v m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
E0 = E0 ** ?t2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b
    eapply RTL.exec_Iop; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
E0 = E0 ** E0
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b

    unfold sem_extrap in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: b) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) b out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
b: list instr
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: b) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' b
out_s: istate
block2: SeqBB.t
H: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) b out_s
H0: (fn_code tf) ! pc1 = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s inv H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H3: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
    eapply BB.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H3: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res) (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp 
  (Iexec ?state') (i :: instrs) 
  (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H3: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
Op.eval_operation tge sp op rs ## args m = Some ?v
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # res <- ?v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (i :: instrs) (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H3: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
    rewrite <- eval_op_eq; eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (i :: instrs) (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H3: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
    constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (i :: instrs) (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H3: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H2: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H4: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H3: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
IOP: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
EVAL: Op.eval_operation ge sp op rs ## args m =
Some v
TR: transl_function f = OK tf
MATCHB: forall (pc0 : positive) (b0 : SeqBB.t),
(fn_code tf) ! pc0 = Some b0 ->
match_block (RTL.fn_code f) 
  (fn_code tf) pc0 b0
STK: Forall2 match_stackframe s stk'
STAR: star RTL.step ge (RTL.State s f sp pc1 rs1 m1)
  E0 (RTL.State s f sp pc rs m)
i: instr
instrs: list instr
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
INCODE: (fn_code tf) ! pc1 = Some x
MATCHB2: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
block2: SeqBB.t
H0: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H3: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
    inv MATCHB2; inv H3.
  Qed.

  Lemma transl_Iop_correct_j:
    forall s f sp pc rs m op args res pc' v stk' tf pc1 rs1 m1 x,
      (RTL.fn_code f) ! pc = Some (RTL.Iop op args res pc') ->
      Op.eval_operation ge sp op rs ## args m = Some v ->
      transl_function f = OK tf ->
      (forall (pc0 : positive) (b : SeqBB.t),
          (fn_code tf) ! pc0 = Some b -> match_block (RTL.fn_code f) (fn_code tf) pc0 b) ->
      Forall2 match_stackframe s stk' ->
      star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0 (RTL.State s f sp pc rs m) ->
      sem_extrap tf pc1 sp (Iexec {| is_rs := rs; is_ps := PMap.init false; is_mem := m |})
                 (Iexec {| is_rs := rs1; is_ps := PMap.init false; is_mem := m1 |}) (RBop None op args res :: RBexit None (RBgoto pc') :: nil) ->
      (fn_code tf) ! pc1 = Some x ->
      valid_succ (fn_code tf) pc' ->
      exists b' s2,
        plus step tge (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0 s2 /\
          match_states b' (RTL.State s f sp pc' rs # res <- v m) s2.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (op : Op.operation) (args : list reg)
  (res0 : reg) (pc' : RTL.node) (v : val)
  (stk' : list stackframe) (tf : function)
  (pc1 : RTL.node) (rs1 : RTL.regset) (m1 : mem)
  (x : SeqBB.t),
(RTL.fn_code f) ! pc = Some (RTL.Iop op args res0 pc') ->
Op.eval_operation ge sp op rs ## args m = Some v ->
transl_function f = OK tf ->
(forall (pc0 : positive) (b : SeqBB.t),
 (fn_code tf) ! pc0 = Some b ->
 match_block (RTL.fn_code f) (fn_code tf) pc0 b) ->
Forall2 match_stackframe s stk' ->
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m) ->
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res0
   :: RBexit None (RBgoto pc') :: nil) ->
(fn_code tf) ! pc1 = Some x ->
valid_succ (fn_code tf) pc' ->
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp pc' rs # res0 <- v m) s2
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (op : Op.operation) (args : list reg)
  (res0 : reg) (pc' : RTL.node) (v : val)
  (stk' : list stackframe) (tf : function)
  (pc1 : RTL.node) (rs1 : RTL.regset) (m1 : mem)
  (x : SeqBB.t),
(RTL.fn_code f) ! pc = Some (RTL.Iop op args res0 pc') ->
Op.eval_operation ge sp op rs ## args m = Some v ->
transl_function f = OK tf ->
(forall (pc0 : positive) (b : SeqBB.t),
 (fn_code tf) ! pc0 = Some b ->
 match_block (RTL.fn_code f) (fn_code tf) pc0 b) ->
Forall2 match_stackframe s stk' ->
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m) ->
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res0
   :: RBexit None (RBgoto pc') :: nil) ->
(fn_code tf) ! pc1 = Some x ->
valid_succ (fn_code tf) pc' ->
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp pc' rs # res0 <- v m) s2
    intros * H H0 TF CODE STK STARSIMU BB H3 H7.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H7: valid_succ (fn_code tf) pc'
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2
    inv H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H7: valid_succ (fn_code tf) pc'
H2: Op.eval_operation ge sp op rs ## args m = Some v
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2 simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H7: valid_succ (fn_code tf) pc'
H2: Op.eval_operation ge sp op rs ## args m = Some v
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2
    unfold valid_succ in H7; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2
    do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
plus step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
(fn_code tf) ! pc1 = Some ?bb
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) ?bb
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2
    eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) x
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2


    eapply BB; [| eassumption ].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBop None op args res) (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp 
  (Iexec ?state') (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
Op.eval_operation tge sp op rs ## args m = Some ?v
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # res <- ?v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2
    rewrite <- eval_op_eq; eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2 constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2
    eapply exec_RBterm.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBgoto pc'))
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
truthy
  (is_ps
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs # res <- v
     (PMap.init false) m) 
  (RBgoto pc') E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs # res <- v
     (PMap.init false) m) (RBgoto pc') E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m) 
  ?s2
    constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # res <- v m)
  (State stk' tf sp pc' rs # res <- v
     (PMap.init false) m)

    econstructor; try eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
exists b' : SeqBB.t,
  (fn_code tf) ! pc' = Some b' /\
  match_block (RTL.fn_code f) (fn_code tf) pc' ?b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
star RTL.step ge
  (RTL.State s f sp pc' rs # res <- v m) E0
  (RTL.State s f sp pc' rs # res <- v m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) ?b eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
star RTL.step ge
  (RTL.State s f sp pc' rs # res <- v m) E0
  (RTL.State s f sp pc' rs # res <- v m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0
    eapply star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0
    unfold sem_extrap.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s ->
(fn_code tf) ! pc' = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
out_s: istate
block2: SeqBB.t
H1: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s
H4: (fn_code tf) ! pc' = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s setoid_rewrite H0 in H4.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
stk': list stackframe
tf: function
pc1: RTL.node
rs1: RTL.regset
m1: mem
x: SeqBB.t
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
TF: transl_function f = OK tf
CODE: forall (pc0 : positive) (b : SeqBB.t),
(fn_code tf) ! pc0 = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc0 b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
H3: (fn_code tf) ! pc1 = Some x
H2: Op.eval_operation ge sp op rs ## args m = Some v
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
out_s: istate
block2: SeqBB.t
H1: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s
H4: Some x0 = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # res <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s
    crush.
  Qed.

  Lemma transl_Iop_correct:
    forall s f sp pc rs m op args res pc' v,
      (RTL.fn_code f) ! pc = Some (RTL.Iop op args res pc') ->
      Op.eval_operation ge sp op rs##args m = Some v ->
      forall b s2, match_states b (RTL.State s f sp pc rs m) s2 ->
        exists b' s2',
          (plus step tge s2 E0 s2'
           \/ star step tge s2 E0 s2' /\ ltof _ measure b' b)
          /\ match_states b' (RTL.State s f sp pc' (rs # res <- v) m) s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (op : Op.operation) (args : list reg)
  (res : reg) (pc' : RTL.node) (v : val),
(RTL.fn_code f) ! pc = Some (RTL.Iop op args res pc') ->
Op.eval_operation ge sp op rs ## args m = Some v ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (op : Op.operation) (args : list reg)
  (res : reg) (pc' : RTL.node) (v : val),
(RTL.fn_code f) ! pc = Some (RTL.Iop op args res pc') ->
Op.eval_operation ge sp op rs ## args m = Some v ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2'
    intros * H H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: match_code (RTL.fn_code f) (fn_code tf)
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2'
    unfold match_code in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2'
    match goal with H: match_block _ _ _ _ |- _ => inv H end; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H1: match_states (Some (RBop None op args res :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc' b
H2: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some (RBop None op args res :: b))) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBop None op args res
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: valid_succ (fn_code tf) pc'
H2: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
Learn: Learnt H
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some
        (RBop None op args res
         :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2'
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H1: match_states (Some (RBop None op args res :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBop None op args res :: b)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc' b
H2: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some (RBop None op args res :: b))) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2' apply sim_star; eapply transl_Iop_correct_nj; eassumption. }
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBop None op args res
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: valid_succ (fn_code tf) pc'
H2: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some
        (RBop None op args res
         :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2'
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBop None op args res
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: valid_succ (fn_code tf) pc'
H2: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some
        (RBop None op args res
         :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2' apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBop None op args res
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBop None op args res
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: valid_succ (fn_code tf) pc'
H2: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2 eapply transl_Iop_correct_j; eassumption. }
  Qed.

  Lemma transl_Iload_correct:
    forall s f sp pc rs m chunk addr args dst pc' a v,
      (RTL.fn_code f) ! pc = Some (RTL.Iload chunk addr args dst pc') ->
      Op.eval_addressing ge sp addr rs##args = Some a ->
      Mem.loadv chunk m a = Some v ->
      forall b s2, match_states b (RTL.State s f sp pc rs m) s2 ->
        exists b' s2',
          (plus step tge s2 E0 s2'
           \/ star step tge s2 E0 s2' /\ ltof _ measure b' b)
          /\ match_states b' (RTL.State s f sp pc' (rs # dst <- v) m) s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (chunk : memory_chunk)
  (addr : Op.addressing) (args : list reg) (dst : reg)
  (pc' : RTL.node) (a v : val),
(RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc') ->
Op.eval_addressing ge sp addr rs ## args = Some a ->
Mem.loadv chunk m a = Some v ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (chunk : memory_chunk)
  (addr : Op.addressing) (args : list reg) (dst : reg)
  (pc' : RTL.node) (a v : val),
(RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc') ->
Op.eval_addressing ge sp addr rs ## args = Some a ->
Mem.loadv chunk m a = Some v ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2'
    intros * H H0 H1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: match_code (RTL.fn_code f) (fn_code tf)
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2'
    unfold match_code in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2'
    match goal with H: match_block _ _ _ _ |- _ => inv H end; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some (RBload None chunk addr args dst :: b))) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some
        (RBload None chunk addr args dst
         :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2'
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some (RBload None chunk addr args dst :: b))) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2' apply sim_star.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  star step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  ltof (option SeqBB.t) measure b'
    (Some (RBload None chunk addr args dst :: b)) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2
      do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
star step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
ltof (option SeqBB.t) measure 
  ?b' (Some (RBload None chunk addr args dst :: b)) /\
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2 eapply star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
ltof (option SeqBB.t) measure ?b'
  (Some (RBload None chunk addr args dst :: b)) /\
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
ltof (option SeqBB.t) measure ?b'
  (Some (RBload None chunk addr args dst :: b))
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
      instantiate (1 := Some b); unfold ltof; auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
match_states (Some b)
  (RTL.State s f sp pc' rs # dst <- v m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)

      constructor; try eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
exists b' : SeqBB.t,
  (fn_code tf) ! pc1 = Some b' /\
  match_block (RTL.fn_code f) (fn_code tf) pc' b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc' rs # dst <- v m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc' rs # dst <- v m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b
      eapply star_right; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
RTL.step ge (RTL.State s f sp pc rs m) ?t2
  (RTL.State s f sp pc' rs # dst <- v m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
E0 = E0 ** ?t2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b
      eapply RTL.exec_Iload; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
E0 = E0 ** E0
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBload None chunk addr args dst :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b

      unfold sem_extrap in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBload None chunk addr args dst :: b)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) b out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBload None chunk addr args dst :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBload None chunk addr args dst :: b)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
out_s: istate
block2: SeqBB.t
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) b out_s
H7: (fn_code tf) ! pc1 = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s inv H5.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
      eapply BB.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBload None chunk addr args dst)
  (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp 
  (Iexec ?state') (i :: instrs) 
  (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
Op.eval_addressing tge sp addr rs ## args = Some a
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (i :: instrs) (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
      rewrite <- eval_addressing_eq; eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (i :: instrs) (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (i :: instrs) (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
      econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst :: i :: instrs)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
      inv H6; inv H10.
    }
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some
        (RBload None chunk addr args dst
         :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2'
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some
        (RBload None chunk addr args dst
         :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2' apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2
      inv H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2 simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2
      unfold valid_succ in H6; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2
      do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
plus step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
(fn_code tf) ! pc1 = Some ?bb
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) ?bb
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2
      eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) x
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2

      eapply BB; [| eassumption ].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBload None chunk addr args dst)
  (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp 
  (Iexec ?state') (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
Op.eval_addressing tge sp addr rs ## args = Some a
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2
      rewrite <- eval_addressing_eq; eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2 constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2
      eapply exec_RBterm.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBgoto pc'))
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
truthy
  (is_ps
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs # dst <- v
     (PMap.init false) m) 
  (RBgoto pc') E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs # dst <- v
     (PMap.init false) m) (RBgoto pc') E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m) 
  ?s2
      constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' rs # dst <- v m)
  (State stk' tf sp pc' rs # dst <- v
     (PMap.init false) m)

      econstructor; try eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
exists b' : SeqBB.t,
  (fn_code tf) ! pc' = Some b' /\
  match_block (RTL.fn_code f) (fn_code tf) pc' ?b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
star RTL.step ge
  (RTL.State s f sp pc' rs # dst <- v m) E0
  (RTL.State s f sp pc' rs # dst <- v m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) ?b eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
star RTL.step ge
  (RTL.State s f sp pc' rs # dst <- v m) E0
  (RTL.State s f sp pc' rs # dst <- v m)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0
      eapply star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0
      unfold sem_extrap.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s ->
(fn_code tf) ! pc' = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
out_s: istate
block2: SeqBB.t
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s
H6: (fn_code tf) ! pc' = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s setoid_rewrite H0 in H6.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H1: Mem.loadv chunk m a = Some v
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBload None chunk addr args dst
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBload None chunk addr args dst
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
out_s: istate
block2: SeqBB.t
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s
H6: Some x0 = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # dst <- v;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s
      crush.
    }
  Qed.

  Lemma transl_Istore_correct:
    forall s f sp pc rs m chunk addr args src pc' a m',
      (RTL.fn_code f) ! pc = Some (RTL.Istore chunk addr args src pc') ->
      Op.eval_addressing ge sp addr rs##args = Some a ->
      Mem.storev chunk m a rs#src = Some m' ->
      forall b s2, match_states b (RTL.State s f sp pc rs m) s2 ->
        exists b' s2',
          (plus step tge s2 E0 s2'
           \/ star step tge s2 E0 s2' /\ ltof _ measure b' b)
          /\ match_states b' (RTL.State s f sp pc' rs m') s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (chunk : memory_chunk)
  (addr : Op.addressing) (args : list reg) (src : reg)
  (pc' : RTL.node) (a : val) (m' : mem),
(RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc') ->
Op.eval_addressing ge sp addr rs ## args = Some a ->
Mem.storev chunk m a rs # src = Some m' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m') s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (chunk : memory_chunk)
  (addr : Op.addressing) (args : list reg) (src : reg)
  (pc' : RTL.node) (a : val) (m' : mem),
(RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc') ->
Op.eval_addressing ge sp addr rs ## args = Some a ->
Mem.storev chunk m a rs # src = Some m' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m') s2'
    intros * H H0 H1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m') s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: match_code (RTL.fn_code f) (fn_code tf)
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b' (RTL.State s f sp pc' rs m') s2'
    unfold match_code in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b' (RTL.State s f sp pc' rs m') s2'
    match goal with H: match_block _ _ _ _ |- _ => inv H end; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some (RBstore None chunk addr args src :: b))) /\
  match_states b' (RTL.State s f sp pc' rs m') s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some
        (RBstore None chunk addr args src
         :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b' (RTL.State s f sp pc' rs m') s2'
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some (RBstore None chunk addr args src :: b))) /\
  match_states b' (RTL.State s f sp pc' rs m') s2' apply sim_star.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  star step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  ltof (option SeqBB.t) measure b'
    (Some (RBstore None chunk addr args src :: b)) /\
  match_states b' (RTL.State s f sp pc' rs m') s2
      do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
star step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
ltof (option SeqBB.t) measure 
  ?b' (Some (RBstore None chunk addr args src :: b)) /\
match_states ?b' (RTL.State s f sp pc' rs m') ?s2 eapply star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
ltof (option SeqBB.t) measure ?b'
  (Some (RBstore None chunk addr args src :: b)) /\
match_states ?b' (RTL.State s f sp pc' rs m')
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
ltof (option SeqBB.t) measure ?b'
  (Some (RBstore None chunk addr args src :: b))
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
match_states ?b' (RTL.State s f sp pc' rs m')
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
      instantiate (1 := Some b); unfold ltof; auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
match_states (Some b) (RTL.State s f sp pc' rs m')
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)

      constructor; try eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
exists b' : SeqBB.t,
  (fn_code tf) ! pc1 = Some b' /\
  match_block (RTL.fn_code f) (fn_code tf) pc' b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc' rs m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
star RTL.step ge (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc' rs m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b
      eapply star_right; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
RTL.step ge (RTL.State s f sp pc rs m) ?t2
  (RTL.State s f sp pc' rs m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
E0 = E0 ** ?t2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b
      eapply RTL.exec_Istore; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
E0 = E0 ** E0
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) (RBstore None chunk addr args src :: b)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b

      unfold sem_extrap in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBstore None chunk addr args src :: b)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) b out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
b: SeqBB.t
H2: match_states
  (Some (RBstore None chunk addr args src :: b))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBstore None chunk addr args src :: b)
  out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) (fn_code tf) pc' b
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
out_s: istate
block2: SeqBB.t
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) b out_s
H7: (fn_code tf) ! pc1 = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s inv H5.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
      eapply BB.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src :: i :: instrs)
  (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBstore None chunk addr args src)
  (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp 
  (Iexec ?state') (i :: instrs) 
  (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
Op.eval_addressing tge sp addr rs ## args = Some a
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) (i :: instrs) (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
      rewrite <- eval_addressing_eq; eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) (i :: instrs) (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) (i :: instrs) (Iterm state'' cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
      econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state', state'': instr_state
cf: cf_instr
H9: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iexec state')
H11: step_list (step_instr tge) sp 
  (Iexec state') instrs (Iterm state'' cf)
(fn_code tf) ! pc1 = Some block2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf) auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
i: instr
instrs: list instr
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: i :: instrs)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: i :: instrs) out_s ->
(fn_code tf) ! pc1 = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 out_s
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: match_block (RTL.fn_code f) 
  (fn_code tf) pc' (i :: instrs)
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
block2: SeqBB.t
H7: (fn_code tf) ! pc1 = Some block2
state': instr_state
cf: cf_instr
H10: step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) i (Iterm state' cf)
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) block2 (Iterm state' cf)
      inv H6; inv H10.
    }
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some
        (RBstore None chunk addr args src
         :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b' (RTL.State s f sp pc' rs m') s2'
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b'
     (Some
        (RBstore None chunk addr args src
         :: RBexit None (RBgoto pc') :: nil))) /\
  match_states b' (RTL.State s f sp pc' rs m') s2' apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp pc' rs m') s2
      inv H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp pc' rs m') s2 simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp pc' rs m') s2
      unfold valid_succ in H6; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp pc' rs m') s2
      do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
plus step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
(fn_code tf) ! pc1 = Some ?bb
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) ?bb
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2
      eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) x
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2

      eapply BB; [| eassumption ].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBstore None chunk addr args src)
  (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp 
  (Iexec ?state') (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
Op.eval_addressing tge sp addr rs ## args = Some a
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2
      rewrite <- eval_addressing_eq; eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
truthy (PMap.init false) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2 constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) (RBexit None (RBgoto pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2
      eapply exec_RBterm.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) (RBexit None (RBgoto pc'))
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
truthy
  (is_ps
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m')
  (RBgoto pc') E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m')
  (RBgoto pc') E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m') ?s2
      constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m')
  (State stk' tf sp pc' rs (PMap.init false) m')

      econstructor; try eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
exists b' : SeqBB.t,
  (fn_code tf) ! pc' = Some b' /\
  match_block (RTL.fn_code f) (fn_code tf) pc' ?b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
star RTL.step ge (RTL.State s f sp pc' rs m') E0
  (RTL.State s f sp pc' rs m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) ?b eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
star RTL.step ge (RTL.State s f sp pc' rs m') E0
  (RTL.State s f sp pc' rs m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0
      eapply star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0
      unfold sem_extrap.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0 out_s ->
(fn_code tf) ! pc' = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) block2 out_s intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
out_s: istate
block2: SeqBB.t
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0 out_s
H6: (fn_code tf) ! pc' = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) block2 out_s setoid_rewrite H0 in H6.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H1: Mem.storev chunk m a rs # src = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBstore None chunk addr args src
      :: RBexit None (RBgoto pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBstore None chunk addr args src
   :: RBexit None (RBgoto pc') :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
Learn: Learnt H
H7: Op.eval_addressing ge sp addr rs ## args = Some a
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
out_s: istate
block2: SeqBB.t
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0 out_s
H6: Some x0 = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) block2 out_s
      crush.
    }
  Qed.

  Lemma functions_translated:
    forall (v: Values.val) (f: RTL.fundef),
      Genv.find_funct ge v = Some f ->
      exists tf,
        Genv.find_funct tge v = Some tf /\ transl_fundef f = Errors.OK tf.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (v : val) (f : RTL.fundef),
Genv.find_funct ge v = Some f ->
exists tf : fundef,
  Genv.find_funct tge v = Some tf /\
  transl_fundef f = OK tf
  Proof using TRANSL.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (v : val) (f : RTL.fundef),
Genv.find_funct ge v = Some f ->
exists tf : fundef,
  Genv.find_funct tge v = Some tf /\
  transl_fundef f = OK tf
    intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
v: val
f: RTL.fundef
H: Genv.find_funct ge v = Some f
exists tf : fundef,
  Genv.find_funct tge v = Some tf /\
  transl_fundef f = OK tf exploit (Genv.find_funct_match TRANSL); eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
v: val
f: RTL.fundef
H: Genv.find_funct ge v = Some f
(exists
   (cunit : AST.program (AST.fundef RTL.function) unit) 
 (tf : AST.fundef function),
   Genv.find_funct (Genv.globalenv tprog) v = Some tf /\
   transl_fundef f = OK tf /\
   Linking.linkorder cunit prog) ->
exists tf : fundef,
  Genv.find_funct tge v = Some tf /\
  transl_fundef f = OK tf
    intros (cu & tf & P & Q & R); exists tf; auto.
  Qed.

  Lemma find_function_translated:
    forall ros rs rs' f,
      (forall x, rs !! x = rs' !! x) ->
      RTL.find_function ge ros rs = Some f ->
      exists tf, find_function tge ros rs' = Some tf
                 /\ transl_fundef f = OK tf.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (ros : reg + ident) (rs rs' : PMap.t val)
  (f : RTL.fundef),
(forall x : positive, rs # x = rs' # x) ->
RTL.find_function ge ros rs = Some f ->
exists tf : fundef,
  find_function tge ros rs' = Some tf /\
  transl_fundef f = OK tf
  Proof using TRANSL.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (ros : reg + ident) (rs rs' : PMap.t val)
  (f : RTL.fundef),
(forall x : positive, rs # x = rs' # x) ->
RTL.find_function ge ros rs = Some f ->
exists tf : fundef,
  find_function tge ros rs' = Some tf /\
  transl_fundef f = OK tf
    Ltac ffts := match goal with
                 | [ H: forall _, Val.lessdef _ _, r: Registers.reg |- _ ] =>
                   specialize (H r); inv H
                 | [ H: Vundef = ?r, H1: Genv.find_funct _ ?r = Some _ |- _ ] =>
                   rewrite <- H in H1
                 | [ H: Genv.find_funct _ Vundef = Some _ |- _] => solve [inv H]
                 | _ => solve [exploit functions_translated; eauto]
                 end.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (ros : reg + ident) (rs rs' : PMap.t val)
  (f : RTL.fundef),
(forall x : positive, rs # x = rs' # x) ->
RTL.find_function ge ros rs = Some f ->
exists tf : fundef,
  find_function tge ros rs' = Some tf /\
  transl_fundef f = OK tf
    destruct ros; simplify; try rewrite <- H;
    [| rewrite symbols_preserved; destruct_match;
      try (apply function_ptr_translated); crush ];
    intros;
    repeat ffts.
  Qed.

  Lemma transl_Icall_correct:
    forall s f sp pc rs m sig ros args res pc' fd,
      (RTL.fn_code f) ! pc = Some (RTL.Icall sig ros args res pc') ->
      RTL.find_function ge ros rs = Some fd ->
      RTL.funsig fd = sig ->
      forall b s2, match_states b (RTL.State s f sp pc rs m) s2 ->
        exists b' s2',
          (plus step tge s2 E0 s2' \/ star step tge s2 E0 s2' /\ ltof _ measure b' b) /\
            match_states b' (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s) fd rs ## args m) s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : RTL.regset)
  (m : mem) (sig : signature) (ros : reg + ident)
  (args : list reg) (res : reg) (pc' : RTL.node)
  (fd : RTL.fundef),
(RTL.fn_code f) ! pc =
Some (RTL.Icall sig ros args res pc') ->
RTL.find_function ge ros rs = Some fd ->
RTL.funsig fd = sig ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : RTL.regset)
  (m : mem) (sig : signature) (ros : reg + ident)
  (args : list reg) (res : reg) (pc' : RTL.node)
  (fd : RTL.fundef),
(RTL.fn_code f) ! pc =
Some (RTL.Icall sig ros args res pc') ->
RTL.find_function ge ros rs = Some fd ->
RTL.funsig fd = sig ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2'
    intros * H H0 H1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
sig: signature
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall sig ros args res pc')
H0: RTL.find_function ge ros rs = Some fd
H1: RTL.funsig fd = sig
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
H0: RTL.find_function ge ros rs = Some fd
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: match_code (RTL.fn_code f) (fn_code tf)
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2'
    unfold match_code in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
H0: RTL.find_function ge ros rs = Some fd
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2'
    match goal with H: match_block _ _ _ _ |- _ => inv H end; simplify;
    apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
H0: RTL.find_function ge ros rs = Some fd
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: valid_succ (fn_code tf) pc'
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2
    inv H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: valid_succ (fn_code tf) pc'
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2 simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: valid_succ (fn_code tf) pc'
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2
    unfold valid_succ in H5; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2
    exploit find_function_translated; eauto; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2
    do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
plus step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m) ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m) ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
(fn_code tf) ! pc1 = Some ?bb
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) ?bb
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m) ?s2
    eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) x
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m) ?s2

    eapply BB; [| eassumption ].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m) ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) RBnop (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_list (step_instr tge) sp 
  (Iexec ?state')
  (RBexit None
     (RBcall (RTL.funsig fd) ros args res pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m) ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBexit None
     (RBcall (RTL.funsig fd) ros args res pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m) ?s2
    constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBexit None
     (RBcall (RTL.funsig fd) ros args res pc'))
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m) ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
truthy
  (is_ps
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBcall (RTL.funsig fd) ros args res pc') E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m) ?s2 constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBcall (RTL.funsig fd) ros args res pc') E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m) ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
funsig x1 = RTL.funsig fd
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m)
  (Callstate
     (Stackframe res tf sp pc' rs (PMap.init false)
      :: stk') x1 rs ## args m)
    apply sig_transl_function; auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_states ?b'
  (RTL.Callstate (RTL.Stackframe res f sp pc' rs :: s)
     fd rs ## args m)
  (Callstate
     (Stackframe res tf sp pc' rs (PMap.init false)
      :: stk') x1 rs ## args m)

    econstructor; try eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
Forall2 match_stackframe
  (RTL.Stackframe res f sp pc' rs :: s)
  (Stackframe res tf sp pc' rs (PMap.init false)
   :: stk')
    constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
match_stackframe (RTL.Stackframe res f sp pc' rs)
  (Stackframe res tf sp pc' rs (PMap.init false))
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
Forall2 match_stackframe s stk' constructor; auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
valid_succ (fn_code tf) pc'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
Forall2 match_stackframe s stk'
    unfold valid_succ; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcall (RTL.funsig fd) ros args res
              pc') :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBcall (RTL.funsig fd) ros args res pc')
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icall (RTL.funsig fd) ros args res pc')
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: SeqBB.t
H0: (fn_code tf) ! pc' = Some x0
x1: fundef
H4: find_function tge ros rs = Some x1
H7: transl_fundef fd = OK x1
Forall2 match_stackframe s stk' auto.
  Qed.

  Lemma transl_Itailcall_correct:
    forall s f stk pc rs m sig ros args fd m',
      (RTL.fn_code f) ! pc = Some (RTL.Itailcall sig ros args) ->
      RTL.find_function ge ros rs = Some fd ->
      RTL.funsig fd = sig ->
      Mem.free m stk 0 (RTL.fn_stacksize f) = Some m' ->
      forall b s2,
        match_states b (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs m) s2 ->
        exists b' s2',
          (plus step tge s2 E0 s2' \/ star step tge s2 E0 s2' /\ ltof (option SeqBB.t) measure b' b) /\
            match_states b' (RTL.Callstate s fd rs ## args m') s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (stk : block) (pc : positive) (rs : RTL.regset)
  (m : mem) (sig : signature) (ros : reg + ident)
  (args : list reg) (fd : RTL.fundef) (m' : mem),
(RTL.fn_code f) ! pc =
Some (RTL.Itailcall sig ros args) ->
RTL.find_function ge ros rs = Some fd ->
RTL.funsig fd = sig ->
Mem.free m stk 0 (RTL.fn_stacksize f) = Some m' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs
     m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (stk : block) (pc : positive) (rs : RTL.regset)
  (m : mem) (sig : signature) (ros : reg + ident)
  (args : list reg) (fd : RTL.fundef) (m' : mem),
(RTL.fn_code f) ! pc =
Some (RTL.Itailcall sig ros args) ->
RTL.find_function ge ros rs = Some fd ->
RTL.funsig fd = sig ->
Mem.free m stk 0 (RTL.fn_stacksize f) = Some m' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs
     m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2'
    intros * H H0 H1 H2.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
sig: signature
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall sig ros args)
H0: RTL.find_function ge ros rs = Some fd
H1: RTL.funsig fd = sig
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs
     m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H0: RTL.find_function ge ros rs = Some fd
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states (Some b0)
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: match_code (RTL.fn_code f) (fn_code tf)
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf (Vptr stk Integers.Ptrofs.zero)
        pc1 rs1 (PMap.init false) m1) E0 s2' \/
   star step tge
     (State stk' tf (Vptr stk Integers.Ptrofs.zero)
        pc1 rs1 (PMap.init false) m1) E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2'
    unfold match_code in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H0: RTL.find_function ge ros rs = Some fd
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states (Some b0)
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf (Vptr stk Integers.Ptrofs.zero)
        pc1 rs1 (PMap.init false) m1) E0 s2' \/
   star step tge
     (State stk' tf (Vptr stk Integers.Ptrofs.zero)
        pc1 rs1 (PMap.init false) m1) E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2'
    match goal with H: match_block _ _ _ _ |- _ => inv H end; simplify;
    apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H0: RTL.find_function ge ros rs = Some fd
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
       rs1 (PMap.init false) m1) E0 s2 /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2
    inv H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
       rs1 (PMap.init false) m1) E0 s2 /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2 simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
       rs1 (PMap.init false) m1) E0 s2 /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2
    unfold valid_succ in H6; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
       rs1 (PMap.init false) m1) E0 s2 /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2
    exploit find_function_translated; eauto; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
       rs1 (PMap.init false) m1) E0 s2 /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2
    do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
plus step tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 (PMap.init false) m1) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 (PMap.init false) m1) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
(fn_code tf) ! pc1 = Some ?bb
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
SeqBB.step tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) ?bb
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     ?rs' ?pr' ?m') ?cf E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  ?s2
    eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
SeqBB.step tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) x
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     ?rs' ?pr' ?m') ?cf E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  ?s2

    eapply BB; [| eassumption ].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
SeqBB.step tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     ?rs' ?pr' ?m') ?cf E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_instr tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) RBnop (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_list (step_instr tge)
  (Vptr stk Integers.Ptrofs.zero) 
  (Iexec ?state')
  (RBexit None (RBtailcall (RTL.funsig fd) ros args)
   :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     ?rs' ?pr' ?m') ?cf E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_list (step_instr tge)
  (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBexit None (RBtailcall (RTL.funsig fd) ros args)
   :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     ?rs' ?pr' ?m') ?cf E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  ?s2
    constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_instr tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBexit None (RBtailcall (RTL.funsig fd) ros args))
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     ?rs' ?pr' ?m') ?cf E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
truthy
  (is_ps
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     rs (PMap.init false) m)
  (RBtailcall (RTL.funsig fd) ros args) E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  ?s2 constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     rs (PMap.init false) m)
  (RBtailcall (RTL.funsig fd) ros args) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
funsig x0 = RTL.funsig fd
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
Mem.free m stk 0 (fn_stacksize tf) = Some ?m'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  (Callstate stk' x0 rs ## args ?m')
    apply sig_transl_function; auto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
Mem.free m stk 0 (fn_stacksize tf) = Some ?m'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  (Callstate stk' x0 rs ## args ?m')

    assert (fn_stacksize tf = RTL.fn_stacksize f).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
fn_stacksize tf = RTL.fn_stacksize f
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
H5: fn_stacksize tf = RTL.fn_stacksize f
Mem.free m stk 0 (fn_stacksize tf) = Some ?m'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  (Callstate stk' x0 rs ## args ?m')
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
fn_stacksize tf = RTL.fn_stacksize f unfold transl_function in TF.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: match partition f with
| OK f' =>
    if
     check_valid_node (fn_code f')
       (RTL.fn_entrypoint f)
    then
     if
      forall_ptree
        (check_code (RTL.fn_code f) (fn_code f'))
        (fn_code f')
     then
      OK
        {|
          fn_sig := RTL.fn_sig f;
          fn_params := RTL.fn_params f;
          fn_stacksize := RTL.fn_stacksize f;
          fn_code := fn_code f';
          fn_entrypoint := RTL.fn_entrypoint f
        |}
     else
      Error (msg "check_present_blocks failed")
    else Error (msg "entrypoint does not exists")
| Error msg => Error msg
end = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
fn_stacksize tf = RTL.fn_stacksize f
      repeat (destruct_match; try discriminate; []).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
TF: OK
  {|
    fn_sig := RTL.fn_sig f;
    fn_params := RTL.fn_params f;
    fn_stacksize := RTL.fn_stacksize f;
    fn_code := fn_code f0;
    fn_entrypoint := RTL.fn_entrypoint f
  |} = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
fn_stacksize tf = RTL.fn_stacksize f
      inv TF; auto. }
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
H5: fn_stacksize tf = RTL.fn_stacksize f
Mem.free m stk 0 (fn_stacksize tf) = Some ?m'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  (Callstate stk' x0 rs ## args ?m')
    rewrite H5.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
H5: fn_stacksize tf = RTL.fn_stacksize f
Mem.free m stk 0 (RTL.fn_stacksize f) = Some ?m'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  (Callstate stk' x0 rs ## args ?m') eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H3: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBtailcall (RTL.funsig fd) ros args)
         :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None
        (RBtailcall (RTL.funsig fd) ros args)
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall (RTL.funsig fd) ros args)
Learn: Learnt H
H6: RTL.find_function ge ros rs = Some fd
x0: fundef
H0: find_function tge ros rs = Some x0
H7: transl_fundef fd = OK x0
match_states ?b' (RTL.Callstate s fd rs ## args m')
  (Callstate stk' x0 rs ## args m')

    econstructor; try eassumption.
  Qed.

  Lemma transl_Ibuiltin_correct:
    forall s f sp pc rs m ef args res pc' vargs t vres m',
      (RTL.fn_code f) ! pc = Some (RTL.Ibuiltin ef args res pc') ->
      eval_builtin_args ge (fun r : positive => rs # r) sp m args vargs ->
      external_call ef ge vargs m t vres m' ->
      forall b s2,
        match_states b (RTL.State s f sp pc rs m) s2 ->
        exists b' s2',
          (plus step tge s2 t s2' \/ star step tge s2 t s2' /\ ltof _ measure b' b) /\
            match_states b' (RTL.State s f sp pc' (regmap_setres res vres rs) m') s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (ef : external_function)
  (args : list (builtin_arg reg))
  (res : builtin_res reg) (pc' : RTL.node)
  (vargs : list val) (t : trace) (vres : val)
  (m' : mem),
(RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc') ->
eval_builtin_args ge (fun r : positive => rs # r) sp m
  args vargs ->
external_call ef ge vargs m t vres m' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' (regmap_setres res vres rs)
       m') s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (ef : external_function)
  (args : list (builtin_arg reg))
  (res : builtin_res reg) (pc' : RTL.node)
  (vargs : list val) (t : trace) (vres : val)
  (m' : mem),
(RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc') ->
eval_builtin_args ge (fun r : positive => rs # r) sp m
  args vargs ->
external_call ef ge vargs m t vres m' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' (regmap_setres res vres rs)
       m') s2'
    intros * H H0 H1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' (regmap_setres res vres rs)
       m') s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: match_code (RTL.fn_code f) (fn_code tf)
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1) t
     s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1) t
     s2' /\ ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b'
    (RTL.State s f sp pc' (regmap_setres res vres rs)
       m') s2'
    unfold match_code in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1) t
     s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1) t
     s2' /\ ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b'
    (RTL.State s f sp pc' (regmap_setres res vres rs)
       m') s2'
    match goal with H: match_block _ _ _ _ |- _ => inv H end; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1) t
     s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1) t
     s2' /\
   ltof (option SeqBB.t) measure b'
     (Some
        (RBnop
         :: RBexit None (RBbuiltin ef args res pc')
            :: nil))) /\
  match_states b'
    (RTL.State s f sp pc' (regmap_setres res vres rs)
       m') s2'
    eapply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) t
    s2 /\
  match_states b'
    (RTL.State s f sp pc' (regmap_setres res vres rs)
       m') s2
    unfold valid_succ in H6; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) t
    s2 /\
  match_states b'
    (RTL.State s f sp pc' (regmap_setres res vres rs)
       m') s2
    do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
plus step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) t
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) t
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
(fn_code tf) ! pc1 = Some ?bb
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) ?bb
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf t ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  ?s2
    eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) x
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf t ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  ?s2

    eapply BB; [| eassumption ].
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf t ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) RBnop (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp 
  (Iexec ?state')
  (RBexit None (RBbuiltin ef args res pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf t ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBexit None (RBbuiltin ef args res pc') :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf t ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  ?s2
    constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBbuiltin ef args res pc'))
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf t ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
truthy
  (is_ps
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBbuiltin ef args res pc') t 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  ?s2 constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBbuiltin ef args res pc') t ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
eval_builtin_args tge (fun r : positive => rs # r) sp
  m args ?vargs
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
external_call ef tge ?vargs m t ?vres ?m'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  (State stk' tf sp pc' (regmap_setres res ?vres rs)
     (PMap.init false) ?m')
    eauto using eval_builtin_args_preserved, symbols_preserved.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
external_call ef tge vargs m t ?vres ?m'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  (State stk' tf sp pc' (regmap_setres res ?vres rs)
     (PMap.init false) ?m')
    eauto using external_call_symbols_preserved, senv_preserved.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b'
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  (State stk' tf sp pc' (regmap_setres res vres rs)
     (PMap.init false) m')

    econstructor; try eassumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
exists b' : SeqBB.t,
  (fn_code tf) ! pc' = Some b' /\
  match_block (RTL.fn_code f) (fn_code tf) pc' ?b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
star RTL.step ge
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  E0
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) ?b eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
star RTL.step ge
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
  E0
  (RTL.State s f sp pc' (regmap_setres res vres rs) m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0
    eapply star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0
    unfold sem_extrap.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
forall (out_s : istate) (block2 : SeqBB.t),
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0 out_s ->
(fn_code tf) ! pc' = Some block2 ->
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) block2 out_s intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
out_s: istate
block2: SeqBB.t
H6: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0 out_s
H7: (fn_code tf) ! pc' = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) block2 out_s setoid_rewrite H5 in H7.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBbuiltin ef args res pc')
         :: nil)) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBbuiltin ef args res pc')
      :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
out_s: istate
block2: SeqBB.t
H6: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0 out_s
H7: Some x0 = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := regmap_setres res vres rs;
       is_ps := PMap.init false;
       is_mem := m'
     |}) block2 out_s crush.
  Qed.

  Lemma init_regs_equiv :
    forall b a, init_regs a b = RTL.init_regs a b.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (b : list reg) (a : list val),
init_regs a b = RTL.init_regs a b
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (b : list reg) (a : list val),
init_regs a b = RTL.init_regs a b induction b; crush. Qed.

  Lemma transl_initcall_correct:
    forall s f args m m' stk,
      Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk) ->
      forall b s2,
        match_states b (RTL.Callstate s (Internal f) args m) s2 ->
        exists b' s2',
          (plus step tge s2 E0 s2' \/ star step tge s2 E0 s2' /\ ltof (option SeqBB.t) measure b' b) /\
            match_states b'
                         (RTL.State s f (Vptr stk Integers.Ptrofs.zero) (RTL.fn_entrypoint f) (RTL.init_regs args (RTL.fn_params f)) m') s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (args : list val) (m : mem) (m' : Mem.mem')
  (stk : block),
Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk) ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.Callstate s (Internal f) args m)
  s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (args : list val) (m : mem) (m' : Mem.mem')
  (stk : block),
Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk) ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.Callstate s (Internal f) args m)
  s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2'
    intros * H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.Callstate s (Internal f) args m)
  s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
tf: AST.fundef function
H0: match_states None
  (RTL.Callstate s (Internal f) args m)
  (Callstate cs' tf args m)
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) = 
OK tf
STK: Forall2 match_stackframe s cs'
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge (Callstate cs' tf args m) E0 s2' \/
   star step tge (Callstate cs' tf args m) E0 s2' /\
   ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2'
    monadInv TF.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
H0: match_states None
  (RTL.Callstate s (Internal f) args m)
  (Callstate cs' (Internal x) args m)
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge (Callstate cs' (Internal x) args m)
     E0 s2' \/
   star step tge (Callstate cs' (Internal x) args m)
     E0 s2' /\ ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2' inv H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: transl_fundef (Internal f) = OK (Internal x)
STK0: Forall2 match_stackframe s cs'
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge (Callstate cs' (Internal x) args m)
     E0 s2' \/
   star step tge (Callstate cs' (Internal x) args m)
     E0 s2' /\ ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2'
    pose proof (transl_match_code _ _ EQ).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: transl_fundef (Internal f) = OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge (Callstate cs' (Internal x) args m)
     E0 s2' \/
   star step tge (Callstate cs' (Internal x) args m)
     E0 s2' /\ ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2'
    pose proof (transl_entrypoint_exists _ _ EQ).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: transl_fundef (Internal f) = OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
H1: valid_succ (fn_code x) (fn_entrypoint x)
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge (Callstate cs' (Internal x) args m)
     E0 s2' \/
   star step tge (Callstate cs' (Internal x) args m)
     E0 s2' /\ ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2' unfold valid_succ in H1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: transl_fundef (Internal f) = OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
H1: exists b : SeqBB.t,
  (fn_code x) ! (fn_entrypoint x) = Some b
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge (Callstate cs' (Internal x) args m)
     E0 s2' \/
   star step tge (Callstate cs' (Internal x) args m)
     E0 s2' /\ ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2'
    simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge (Callstate cs' (Internal x) args m)
     E0 s2' \/
   star step tge (Callstate cs' (Internal x) args m)
     E0 s2' /\ ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2'
    apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge (Callstate cs' (Internal x) args m) E0
    s2 /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2 do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
plus step tge (Callstate cs' (Internal x) args m) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m') 
  ?s2
    assert (fn_stacksize x = RTL.fn_stacksize f).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
fn_stacksize x = RTL.fn_stacksize f
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_stacksize x = RTL.fn_stacksize f
plus step tge (Callstate cs' (Internal x) args m) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m') 
  ?s2
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
fn_stacksize x = RTL.fn_stacksize f unfold transl_function in EQ.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: match partition f with
| OK f' =>
    if
     check_valid_node (fn_code f')
       (RTL.fn_entrypoint f)
    then
     if
      forall_ptree
        (check_code (RTL.fn_code f) (fn_code f'))
        (fn_code f')
     then
      OK
        {|
          fn_sig := RTL.fn_sig f;
          fn_params := RTL.fn_params f;
          fn_stacksize := RTL.fn_stacksize f;
          fn_code := fn_code f';
          fn_entrypoint := RTL.fn_entrypoint f
        |}
     else
      Error (msg "check_present_blocks failed")
    else Error (msg "entrypoint does not exists")
| Error msg => Error msg
end = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
fn_stacksize x = RTL.fn_stacksize f
      repeat (destruct_match; try discriminate; []).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
EQ: OK
  {|
    fn_sig := RTL.fn_sig f;
    fn_params := RTL.fn_params f;
    fn_stacksize := RTL.fn_stacksize f;
    fn_code := fn_code f0;
    fn_entrypoint := RTL.fn_entrypoint f
  |} = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
fn_stacksize x = RTL.fn_stacksize f
      inv EQ; auto. }
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_stacksize x = RTL.fn_stacksize f
plus step tge (Callstate cs' (Internal x) args m) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m') 
  ?s2
    apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_stacksize x = RTL.fn_stacksize f
step tge (Callstate cs' (Internal x) args m) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m') 
  ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_stacksize x = RTL.fn_stacksize f
Mem.alloc m 0 (fn_stacksize x) = (?m', ?stk)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
  (State cs' x (Vptr ?stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     (PMap.init false) ?m')
    rewrite H1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_stacksize x = RTL.fn_stacksize f
Mem.alloc m 0 (RTL.fn_stacksize f) = (?m', ?stk)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
  (State cs' x (Vptr ?stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     (PMap.init false) ?m') eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
  (State cs' x (Vptr stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     (PMap.init false) m')

    assert (fn_entrypoint x = RTL.fn_entrypoint f).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
fn_entrypoint x = RTL.fn_entrypoint f
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
  (State cs' x (Vptr stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     (PMap.init false) m')
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
fn_entrypoint x = RTL.fn_entrypoint f unfold transl_function in EQ.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: match partition f with
| OK f' =>
    if
     check_valid_node (fn_code f')
       (RTL.fn_entrypoint f)
    then
     if
      forall_ptree
        (check_code (RTL.fn_code f) (fn_code f'))
        (fn_code f')
     then
      OK
        {|
          fn_sig := RTL.fn_sig f;
          fn_params := RTL.fn_params f;
          fn_stacksize := RTL.fn_stacksize f;
          fn_code := fn_code f';
          fn_entrypoint := RTL.fn_entrypoint f
        |}
     else
      Error (msg "check_present_blocks failed")
    else Error (msg "entrypoint does not exists")
| Error msg => Error msg
end = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
fn_entrypoint x = RTL.fn_entrypoint f
      repeat (destruct_match; try discriminate; []).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
EQ: OK
  {|
    fn_sig := RTL.fn_sig f;
    fn_params := RTL.fn_params f;
    fn_stacksize := RTL.fn_stacksize f;
    fn_code := fn_code f0;
    fn_entrypoint := RTL.fn_entrypoint f
  |} = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
fn_entrypoint x = RTL.fn_entrypoint f
      inv EQ; auto. }
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
  (State cs' x (Vptr stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     (PMap.init false) m')
    assert (fn_params x = RTL.fn_params f).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
fn_params x = RTL.fn_params f
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
  (State cs' x (Vptr stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     (PMap.init false) m')
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
fn_params x = RTL.fn_params f unfold transl_function in EQ.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: match partition f with
| OK f' =>
    if
     check_valid_node (fn_code f')
       (RTL.fn_entrypoint f)
    then
     if
      forall_ptree
        (check_code (RTL.fn_code f) (fn_code f'))
        (fn_code f')
     then
      OK
        {|
          fn_sig := RTL.fn_sig f;
          fn_params := RTL.fn_params f;
          fn_stacksize := RTL.fn_stacksize f;
          fn_code := fn_code f';
          fn_entrypoint := RTL.fn_entrypoint f
        |}
     else
      Error (msg "check_present_blocks failed")
    else Error (msg "entrypoint does not exists")
| Error msg => Error msg
end = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
fn_params x = RTL.fn_params f
      repeat (destruct_match; try discriminate; []).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
EQ: OK
  {|
    fn_sig := RTL.fn_sig f;
    fn_params := RTL.fn_params f;
    fn_stacksize := RTL.fn_stacksize f;
    fn_code := fn_code f0;
    fn_entrypoint := RTL.fn_entrypoint f
  |} = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
fn_params x = RTL.fn_params f
      inv EQ; auto. }
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: match_code (RTL.fn_code f) (fn_code x)
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
  (State cs' x (Vptr stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     (PMap.init false) m')
    unfold match_code in H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
  (State cs' x (Vptr stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     (PMap.init false) m')
    pose proof (H0 _ _ H2).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
match_states ?b'
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
  (State cs' x (Vptr stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     (PMap.init false) m')
    econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
exists b' : SeqBB.t,
  (fn_code x) ! (fn_entrypoint x) = Some b' /\
  match_block (RTL.fn_code f) (fn_code x)
    (RTL.fn_entrypoint f) ?b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
star RTL.step ge
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     m') E0
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
sem_extrap x (fn_entrypoint x)
  (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := RTL.init_regs args (RTL.fn_params f);
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := init_regs args (fn_params x);
       is_ps := PMap.init false;
       is_mem := m'
     |}) ?b
    rewrite <- H1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
exists b' : SeqBB.t,
  (fn_code x) ! (fn_entrypoint x) = Some b' /\
  match_block (RTL.fn_code f) (fn_code x)
    (fn_entrypoint x) ?b
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
star RTL.step ge
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     m') E0
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
sem_extrap x (fn_entrypoint x)
  (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := RTL.init_regs args (RTL.fn_params f);
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := init_regs args (fn_params x);
       is_ps := PMap.init false;
       is_mem := m'
     |}) ?b eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
star RTL.step ge
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (fn_entrypoint x) (init_regs args (fn_params x))
     m') E0
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
sem_extrap x (fn_entrypoint x)
  (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := RTL.init_regs args (RTL.fn_params f);
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := init_regs args (fn_params x);
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0
    rewrite H1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
star RTL.step ge
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (init_regs args (fn_params x)) m') E0
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
sem_extrap x (fn_entrypoint x)
  (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := RTL.init_regs args (RTL.fn_params f);
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := init_regs args (fn_params x);
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0
    rewrite init_regs_equiv.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
star RTL.step ge
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (fn_params x)) m') E0
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
sem_extrap x (fn_entrypoint x)
  (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := RTL.init_regs args (RTL.fn_params f);
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := init_regs args (fn_params x);
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0 rewrite H3.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
star RTL.step ge
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m') E0
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     (RTL.fn_entrypoint f)
     (RTL.init_regs args (RTL.fn_params f)) m')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
sem_extrap x (fn_entrypoint x)
  (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := RTL.init_regs args (RTL.fn_params f);
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := init_regs args (fn_params x);
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0 eapply star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
sem_extrap x (fn_entrypoint x)
  (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := RTL.init_regs args (RTL.fn_params f);
       is_ps := PMap.init false;
       is_mem := m'
     |})
  (Iexec
     {|
       is_rs := init_regs args (fn_params x);
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0
    unfold sem_extrap; intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
x0: SeqBB.t
H2: (fn_code x) ! (fn_entrypoint x) = Some x0
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) x0
out_s: istate
block2: SeqBB.t
H5: SeqBB.step tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs :=
         RTL.init_regs args (RTL.fn_params f);
       is_ps := PMap.init false;
       is_mem := m'
     |}) x0 out_s
H6: (fn_code x) ! (fn_entrypoint x) = Some block2
SeqBB.step tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := init_regs args (fn_params x);
       is_ps := PMap.init false;
       is_mem := m'
     |}) block2 out_s
    setoid_rewrite H2 in H6; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
block2: SeqBB.t
out_s: istate
H5: SeqBB.step tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs :=
         RTL.init_regs args (RTL.fn_params f);
       is_ps := PMap.init false;
       is_mem := m'
     |}) block2 out_s
H2: (fn_code x) ! (fn_entrypoint x) = Some block2
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) block2
SeqBB.step tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := init_regs args (fn_params x);
       is_ps := PMap.init false;
       is_mem := m'
     |}) block2 out_s
    rewrite H3.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
cs': list stackframe
x: function
STK: Forall2 match_stackframe s cs'
EQ: transl_function f = OK x
TF: bind (transl_function f)
  (fun f' : function => OK (Internal f')) =
OK (Internal x)
STK0: Forall2 match_stackframe s cs'
H0: forall (pc : positive) (b : SeqBB.t),
(fn_code x) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code x) pc b
block2: SeqBB.t
out_s: istate
H5: SeqBB.step tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs :=
         RTL.init_regs args (RTL.fn_params f);
       is_ps := PMap.init false;
       is_mem := m'
     |}) block2 out_s
H2: (fn_code x) ! (fn_entrypoint x) = Some block2
H1: fn_entrypoint x = RTL.fn_entrypoint f
H3: fn_params x = RTL.fn_params f
H4: match_block (RTL.fn_code f) 
  (fn_code x) (fn_entrypoint x) block2
SeqBB.step tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := init_regs args (RTL.fn_params f);
       is_ps := PMap.init false;
       is_mem := m'
     |}) block2 out_s eauto.
  Qed.

  Lemma transl_externalcall_correct:
    forall s ef args res t m m',
      external_call ef ge args m t res m' ->
      forall b s2,
        match_states b (RTL.Callstate s (External ef) args m) s2 ->
        exists b' s2',
          (plus step tge s2 t s2' \/ star step tge s2 t s2' /\ ltof (option SeqBB.t) measure b' b) /\
            match_states b' (RTL.Returnstate s res m') s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe)
  (ef : external_function) (args : list val)
  (res : val) (t : trace) (m m' : mem),
external_call ef ge args m t res m' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.Callstate s (External ef) args m)
  s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.Returnstate s res m') s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe)
  (ef : external_function) (args : list val)
  (res : val) (t : trace) (m m' : mem),
external_call ef ge args m t res m' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.Callstate s (External ef) args m)
  s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.Returnstate s res m') s2'
    intros * H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
ef: external_function
args: list val
res: val
t: trace
m, m': mem
H: external_call ef ge args m t res m'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.Callstate s (External ef) args m)
  s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.Returnstate s res m') s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
ef: external_function
args: list val
res: val
t: trace
m, m': mem
H: external_call ef ge args m t res m'
cs': list stackframe
tf: AST.fundef function
H0: match_states None
  (RTL.Callstate s (External ef) args m)
  (Callstate cs' tf args m)
TF: OK (External ef) = OK tf
STK: Forall2 match_stackframe s cs'
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge (Callstate cs' tf args m) t s2' \/
   star step tge (Callstate cs' tf args m) t s2' /\
   ltof (option SeqBB.t) measure b' None) /\
  match_states b' (RTL.Returnstate s res m') s2'
    inv TF.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
ef: external_function
args: list val
res: val
t: trace
m, m': mem
H: external_call ef ge args m t res m'
cs': list stackframe
H0: match_states None
  (RTL.Callstate s (External ef) args m)
  (Callstate cs' (External ef) args m)
STK: Forall2 match_stackframe s cs'
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge (Callstate cs' (External ef) args m)
     t s2' \/
   star step tge (Callstate cs' (External ef) args m)
     t s2' /\ ltof (option SeqBB.t) measure b' None) /\
  match_states b' (RTL.Returnstate s res m') s2'
    apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
ef: external_function
args: list val
res: val
t: trace
m, m': mem
H: external_call ef ge args m t res m'
cs': list stackframe
H0: match_states None
  (RTL.Callstate s (External ef) args m)
  (Callstate cs' (External ef) args m)
STK: Forall2 match_stackframe s cs'
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge (Callstate cs' (External ef) args m) t
    s2 /\
  match_states b' (RTL.Returnstate s res m') s2 do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
ef: external_function
args: list val
res: val
t: trace
m, m': mem
H: external_call ef ge args m t res m'
cs': list stackframe
H0: match_states None
  (RTL.Callstate s (External ef) args m)
  (Callstate cs' (External ef) args m)
STK: Forall2 match_stackframe s cs'
plus step tge (Callstate cs' (External ef) args m) t
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
ef: external_function
args: list val
res: val
t: trace
m, m': mem
H: external_call ef ge args m t res m'
cs': list stackframe
H0: match_states None
  (RTL.Callstate s (External ef) args m)
  (Callstate cs' (External ef) args m)
STK: Forall2 match_stackframe s cs'
match_states ?b' (RTL.Returnstate s res m') ?s2
    apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
ef: external_function
args: list val
res: val
t: trace
m, m': mem
H: external_call ef ge args m t res m'
cs': list stackframe
H0: match_states None
  (RTL.Callstate s (External ef) args m)
  (Callstate cs' (External ef) args m)
STK: Forall2 match_stackframe s cs'
step tge (Callstate cs' (External ef) args m) t ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
ef: external_function
args: list val
res: val
t: trace
m, m': mem
H: external_call ef ge args m t res m'
cs': list stackframe
H0: match_states None
  (RTL.Callstate s (External ef) args m)
  (Callstate cs' (External ef) args m)
STK: Forall2 match_stackframe s cs'
match_states ?b' (RTL.Returnstate s res m') ?s2
    econstructor; eauto using external_call_symbols_preserved, senv_preserved.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
ef: external_function
args: list val
res: val
t: trace
m, m': mem
H: external_call ef ge args m t res m'
cs': list stackframe
H0: match_states None
  (RTL.Callstate s (External ef) args m)
  (Callstate cs' (External ef) args m)
STK: Forall2 match_stackframe s cs'
match_states ?b' (RTL.Returnstate s res m')
  (Returnstate cs' res m')
    econstructor; eauto.
  Qed.

  Lemma transl_returnstate_correct:
    forall res f sp pc rs s vres m b s2,
      match_states b (RTL.Returnstate (RTL.Stackframe res f sp pc rs :: s) vres m) s2 ->
      exists b' s2',
        (plus step tge s2 E0 s2' \/ star step tge s2 E0 s2' /\ ltof (option SeqBB.t) measure b' b) /\
          match_states b' (RTL.State s f sp pc rs # res <- vres m) s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (res : reg) (f : RTL.function) (sp : val)
  (pc : RTL.node) (rs : RTL.regset)
  (s : list RTL.stackframe) (vres : val) (m : mem)
  (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.Returnstate
     (RTL.Stackframe res f sp pc rs :: s) vres m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (res : reg) (f : RTL.function) (sp : val)
  (pc : RTL.node) (rs : RTL.regset)
  (s : list RTL.stackframe) (vres : val) (m : mem)
  (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.Returnstate
     (RTL.Stackframe res f sp pc rs :: s) vres m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2'
    intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
b: option SeqBB.t
s2: state
H: match_states b
  (RTL.Returnstate
     (RTL.Stackframe res f sp pc rs :: s) vres m)
  s2
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2'
    inv H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
cs': list stackframe
STK: Forall2 match_stackframe
  (RTL.Stackframe res f sp pc rs :: s) cs'
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge (Returnstate cs' vres m) E0 s2' \/
   star step tge (Returnstate cs' vres m) E0 s2' /\
   ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2' inv STK.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
y: stackframe
l': list stackframe
H1: match_stackframe (RTL.Stackframe res f sp pc rs)
  y
H3: Forall2 match_stackframe s l'
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge (Returnstate (y :: l') vres m) E0 s2' \/
   star step tge (Returnstate (y :: l') vres m) E0 s2' /\
   ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2' inv H1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
VALID: valid_succ (fn_code tf) pc
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' \/
   star step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' /\
   ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2'
    pose proof (transl_match_code _ _ TF).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
VALID: valid_succ (fn_code tf) pc
H: match_code (RTL.fn_code f) (fn_code tf)
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' \/
   star step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' /\
   ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2'
    unfold valid_succ in VALID.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
VALID: exists b : SeqBB.t, (fn_code tf) ! pc = Some b
H: match_code (RTL.fn_code f) (fn_code tf)
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' \/
   star step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' /\
   ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2' simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
H: match_code (RTL.fn_code f) (fn_code tf)
x: SeqBB.t
H0: (fn_code tf) ! pc = Some x
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' \/
   star step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' /\
   ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2'
    unfold match_code in H.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
H: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
x: SeqBB.t
H0: (fn_code tf) ! pc = Some x
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' \/
   star step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' /\
   ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2'
    pose proof (H _ _ H0).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
H: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
x: SeqBB.t
H0: (fn_code tf) ! pc = Some x
H1: match_block (RTL.fn_code f) (fn_code tf) pc x
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' \/
   star step tge
     (Returnstate
        (Stackframe res tf sp pc rs (PMap.init false)
         :: l') vres m) E0 s2' /\
   ltof (option SeqBB.t) measure b' None) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2'
    apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
H: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
x: SeqBB.t
H0: (fn_code tf) ! pc = Some x
H1: match_block (RTL.fn_code f) (fn_code tf) pc x
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (Returnstate
       (Stackframe res tf sp pc rs (PMap.init false)
        :: l') vres m) E0 s2 /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2 do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
H: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
x: SeqBB.t
H0: (fn_code tf) ! pc = Some x
H1: match_block (RTL.fn_code f) (fn_code tf) pc x
plus step tge
  (Returnstate
     (Stackframe res tf sp pc rs (PMap.init false)
      :: l') vres m) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
H: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
x: SeqBB.t
H0: (fn_code tf) ! pc = Some x
H1: match_block (RTL.fn_code f) (fn_code tf) pc x
match_states ?b'
  (RTL.State s f sp pc rs # res <- vres m) 
  ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
H: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
x: SeqBB.t
H0: (fn_code tf) ! pc = Some x
H1: match_block (RTL.fn_code f) (fn_code tf) pc x
step tge
  (Returnstate
     (Stackframe res tf sp pc rs (PMap.init false)
      :: l') vres m) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
H: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
x: SeqBB.t
H0: (fn_code tf) ! pc = Some x
H1: match_block (RTL.fn_code f) (fn_code tf) pc x
match_states ?b'
  (RTL.State s f sp pc rs # res <- vres m) 
  ?s2
    constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
H: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
x: SeqBB.t
H0: (fn_code tf) ! pc = Some x
H1: match_block (RTL.fn_code f) (fn_code tf) pc x
match_states ?b'
  (RTL.State s f sp pc rs # res <- vres m)
  (State l' tf sp pc rs # res <- vres
     (PMap.init false) m) constructor; eauto using star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
H: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
x: SeqBB.t
H0: (fn_code tf) ! pc = Some x
H1: match_block (RTL.fn_code f) (fn_code tf) pc x
sem_extrap tf pc sp
  (Iexec
     {|
       is_rs := rs # res <- vres;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs # res <- vres;
       is_ps := PMap.init false;
       is_mem := m
     |}) x
    unfold sem_extrap; intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
l': list stackframe
H3: Forall2 match_stackframe s l'
tf: function
TF: transl_function f = OK tf
H: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
x: SeqBB.t
H0: (fn_code tf) ! pc = Some x
H1: match_block (RTL.fn_code f) (fn_code tf) pc x
out_s: istate
block2: SeqBB.t
H2: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # res <- vres;
       is_ps := PMap.init false;
       is_mem := m
     |}) x out_s
H4: (fn_code tf) ! pc = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs # res <- vres;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s
    setoid_rewrite H0 in H4; crush.
  Qed.

  Lemma transl_Icond_correct:
    forall s f sp pc rs m cond args ifso ifnot b pc',
      (RTL.fn_code f) ! pc = Some (RTL.Icond cond args ifso ifnot) ->
      Op.eval_condition cond rs ## args m = Some b ->
      pc' = (if b then ifso else ifnot) ->
      forall b0 s2,
        match_states b0 (RTL.State s f sp pc rs m) s2 ->
        exists b' s2',
          (plus step tge s2 E0 s2' \/ star step tge s2 E0 s2' /\ ltof (option SeqBB.t) measure b' b0) /\
            match_states b' (RTL.State s f sp pc' rs m) s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (cond : Op.condition) (args : list reg)
  (ifso ifnot : RTL.node) (b : bool) (pc' : RTL.node),
(RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot) ->
Op.eval_condition cond rs ## args m = Some b ->
pc' = (if b then ifso else ifnot) ->
forall (b0 : option SeqBB.t) (s2 : state),
match_states b0 (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b0) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (cond : Op.condition) (args : list reg)
  (ifso ifnot : RTL.node) (b : bool) (pc' : RTL.node),
(RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot) ->
Op.eval_condition cond rs ## args m = Some b ->
pc' = (if b then ifso else ifnot) ->
forall (b0 : option SeqBB.t) (s2 : state),
match_states b0 (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b0) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    intros * H H0 H1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
b: bool
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
H0: Op.eval_condition cond rs ## args m = Some b
H1: pc' = (if b then ifso else ifnot)
forall (b0 : option SeqBB.t) (s2 : state),
match_states b0 (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b0) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
b: bool
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
H0: Op.eval_condition cond rs ## args m = Some b
b1: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b1) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: match_code (RTL.fn_code f) (fn_code tf)
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b1
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc b1
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b1)) /\
  match_states b'
    (RTL.State s f sp (if b then ifso else ifnot) rs m)
    s2'
    unfold match_code in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
b: bool
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
H0: Op.eval_condition cond rs ## args m = Some b
b1: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b1) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b1
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc b1
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b1)) /\
  match_states b'
    (RTL.State s f sp (if b then ifso else ifnot) rs m)
    s2'
    match goal with H: match_block _ _ _ _ |- _ => inv H end; simplify;
    apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
b: bool
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
H0: Op.eval_condition cond rs ## args m = Some b
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: valid_succ (fn_code tf) ifso
H6: valid_succ (fn_code tf) ifnot
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp (if b then ifso else ifnot) rs m)
    s2
    inv H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
b: bool
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: valid_succ (fn_code tf) ifso
H6: valid_succ (fn_code tf) ifnot
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some b
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp (if b then ifso else ifnot) rs m)
    s2 simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
b: bool
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H5: valid_succ (fn_code tf) ifso
H6: valid_succ (fn_code tf) ifnot
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some b
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp (if b then ifso else ifnot) rs m)
    s2
    unfold valid_succ in *; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
b: bool
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some b
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b'
    (RTL.State s f sp (if b then ifso else ifnot) rs m)
    s2
    destruct b.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp ifso rs m) s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
exists (b' : option SeqBB.t) 
(s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp ifnot rs m) s2
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp ifso rs m) s2 do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
plus step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifso rs m) ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifso rs m) ?s2
      econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) x
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifso rs m) ?s2

      eapply BB.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifso rs m) ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) RBnop (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_list (step_instr tge) sp 
  (Iexec ?state')
  (RBexit None (RBcond cond args ifso ifnot) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifso rs m) ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBexit None (RBcond cond args ifso ifnot) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifso rs m) ?s2
      eapply exec_RBterm.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBcond cond args ifso ifnot))
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifso rs m) ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
truthy
  (is_ps
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBcond cond args ifso ifnot) E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifso rs m) ?s2 constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBcond cond args ifso ifnot) E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifso rs m) ?s2 assumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBcond cond args ifso ifnot) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifso rs m) ?s2
      econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifso rs m)
  (State stk' tf sp ifso rs (PMap.init false) m)
      constructor; eauto using star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
sem_extrap tf ifso sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x1
      unfold sem_extrap; intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
out_s: istate
block2: SeqBB.t
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x1 out_s
H6: (fn_code tf) ! ifso = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s setoid_rewrite H4 in H6.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
out_s: istate
block2: SeqBB.t
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x1 out_s
H6: Some x1 = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s inv H6.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some true
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
block2: SeqBB.t
out_s: istate
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s
H4: (fn_code tf) ! ifso = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s auto.
    }
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp ifnot rs m) s2
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp ifnot rs m) s2 do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
plus step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifnot rs m) ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifnot rs m) ?s2
      econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) x
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifnot rs m) ?s2
      eapply BB.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifnot rs m) ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) RBnop (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_list (step_instr tge) sp 
  (Iexec ?state')
  (RBexit None (RBcond cond args ifso ifnot) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifnot rs m) ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBexit None (RBcond cond args ifso ifnot) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifnot rs m) ?s2
      eapply exec_RBterm.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBcond cond args ifso ifnot))
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifnot rs m) ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
truthy
  (is_ps
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBcond cond args ifso ifnot) E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifnot rs m) ?s2 constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBcond cond args ifso ifnot) E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifnot rs m) ?s2 assumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBcond cond args ifso ifnot) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifnot rs m) ?s2
      econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
match_states ?b' (RTL.State s f sp ifnot rs m)
  (State stk' tf sp ifnot rs (PMap.init false) m)
      constructor; eauto using star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
sem_extrap tf ifnot sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0
      unfold sem_extrap; intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
out_s: istate
block2: SeqBB.t
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s
H6: (fn_code tf) ! ifnot = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s setoid_rewrite H0 in H6.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
x0: SeqBB.t
H0: (fn_code tf) ! ifnot = Some x0
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
out_s: istate
block2: SeqBB.t
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s
H6: Some x0 = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s inv H6.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None
           (RBcond cond args ifso ifnot) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBcond cond args ifso ifnot)
      :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H1: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
Learn: Learnt H
H7: Op.eval_condition cond rs ## args m = Some false
block2: SeqBB.t
out_s: istate
H5: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s
H0: (fn_code tf) ! ifnot = Some block2
x1: SeqBB.t
H4: (fn_code tf) ! ifso = Some x1
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s auto.
    }
  Qed.

  Lemma transl_Ijumptable_correct:
    forall s f sp pc rs m arg tbl n pc',
      (RTL.fn_code f) ! pc = Some (RTL.Ijumptable arg tbl) ->
      rs # arg = Vint n ->
      list_nth_z tbl (Integers.Int.unsigned n) = Some pc' ->
      forall b s2,
        match_states b (RTL.State s f sp pc rs m) s2 ->
        exists b' s2',
          (plus step tge s2 E0 s2' \/ star step tge s2 E0 s2' /\ ltof (option SeqBB.t) measure b' b) /\
            match_states b' (RTL.State s f sp pc' rs m) s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (arg : reg) (tbl : list RTL.node)
  (n : Integers.Int.int) (pc' : RTL.node),
(RTL.fn_code f) ! pc = Some (RTL.Ijumptable arg tbl) ->
rs # arg = Vint n ->
list_nth_z tbl (Integers.Int.unsigned n) = Some pc' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (sp : val) (pc : positive) (rs : Regmap.t val)
  (m : mem) (arg : reg) (tbl : list RTL.node)
  (n : Integers.Int.int) (pc' : RTL.node),
(RTL.fn_code f) ! pc = Some (RTL.Ijumptable arg tbl) ->
rs # arg = Vint n ->
list_nth_z tbl (Integers.Int.unsigned n) = Some pc' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    intros * H H0 H1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: match_code (RTL.fn_code f) (fn_code tf)
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    unfold match_code in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states (Some b0) (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H5: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' \/
   star step tge
     (State stk' tf sp pc1 rs1 (PMap.init false) m1)
     E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
    match goal with H: match_block _ _ _ _ |- _ => inv H end; simplify;
    apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: Forall (valid_succ (fn_code tf)) tbl
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp pc' rs m) s2
    eapply Forall_forall with (x:=pc') in H6; eauto using list_nth_z_in.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H6: valid_succ (fn_code tf) pc'
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp pc' rs m) s2
    unfold valid_succ in H6; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
    s2 /\
  match_states b' (RTL.State s f sp pc' rs m) s2
    do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
plus step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step tge
  (State stk' tf sp pc1 rs1 (PMap.init false) m1) E0
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2
    econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) x
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 eapply BB.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (RBnop :: RBexit None (RBjumptable arg tbl) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2
    econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) RBnop (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp 
  (Iexec ?state')
  (RBexit None (RBjumptable arg tbl) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_list (step_instr tge) sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBjumptable arg tbl) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 eapply exec_RBterm.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_instr tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBjumptable arg tbl))
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge (State stk' tf sp pc1 ?rs' ?pr' ?m')
  ?cf E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2
    econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
truthy
  (is_ps
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBjumptable arg tbl) E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBjumptable arg tbl) E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2 assumption.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
step_cf_instr tge
  (State stk' tf sp pc1 rs (PMap.init false) m)
  (RBjumptable arg tbl) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m) ?s2
    econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
match_states ?b' (RTL.State s f sp pc' rs m)
  (State stk' tf sp pc' rs (PMap.init false) m)

    constructor; eauto using star_refl.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
sem_extrap tf pc' sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0
    unfold sem_extrap; intros.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
out_s: istate
block2: SeqBB.t
H6: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s
H7: (fn_code tf) ! pc' = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s setoid_rewrite H5 in H7.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
x0: SeqBB.t
H5: (fn_code tf) ! pc' = Some x0
out_s: istate
block2: SeqBB.t
H6: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) x0 out_s
H7: Some x0 = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s inv H7.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H2: match_states
  (Some
     (RBnop
      :: RBexit None (RBjumptable arg tbl) :: nil))
  (RTL.State s f sp pc rs m)
  (State stk' tf sp pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f sp pc1 rs1 m1) E0
  (RTL.State s f sp pc rs m)
BB: sem_extrap tf pc1 sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop
   :: RBexit None (RBjumptable arg tbl) :: nil)
x: SeqBB.t
H4: (fn_code tf) ! pc1 = Some x
H3: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
Learn: Learnt H
block2: SeqBB.t
out_s: istate
H6: SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s
H5: (fn_code tf) ! pc' = Some block2
SeqBB.step tge sp
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) block2 out_s auto.
  Qed.

  Lemma transl_Ireturn_correct:
    forall s f stk pc rs m or m',
      (RTL.fn_code f) ! pc = Some (RTL.Ireturn or) ->
      Mem.free m stk 0 (RTL.fn_stacksize f) = Some m' ->
      forall b s2,
        match_states b (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs m) s2 ->
        exists b' s2',
          (plus step tge s2 E0 s2' \/ star step tge s2 E0 s2' /\ ltof (option SeqBB.t) measure b' b) /\
            match_states b' (RTL.Returnstate s (regmap_optget or Vundef rs) m') s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (stk : block) (pc : positive) (rs : RTL.regset)
  (m : mem) (or0 : option reg) (m' : mem),
(RTL.fn_code f) ! pc = Some (RTL.Ireturn or0) ->
Mem.free m stk 0 (RTL.fn_stacksize f) = Some m' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs
     m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.Returnstate s (regmap_optget or0 Vundef rs)
       m') s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s : list RTL.stackframe) (f : RTL.function)
  (stk : block) (pc : positive) (rs : RTL.regset)
  (m : mem) (or0 : option reg) (m' : mem),
(RTL.fn_code f) ! pc = Some (RTL.Ireturn or0) ->
Mem.free m stk 0 (RTL.fn_stacksize f) = Some m' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs
     m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.Returnstate s (regmap_optget or0 Vundef rs)
       m') s2'
    intros * H H0.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs
     m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.Returnstate s (regmap_optget or Vundef rs) m')
    s2'
    inversion 1; subst; simplify.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states (Some b0)
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: match_code (RTL.fn_code f) (fn_code tf)
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf (Vptr stk Integers.Ptrofs.zero)
        pc1 rs1 (PMap.init false) m1) E0 s2' \/
   star step tge
     (State stk' tf (Vptr stk Integers.Ptrofs.zero)
        pc1 rs1 (PMap.init false) m1) E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b'
    (RTL.Returnstate s (regmap_optget or Vundef rs) m')
    s2'
    unfold match_code in *.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
b0: SeqBB.t
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states (Some b0)
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) b0
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H4: match_block (RTL.fn_code f) (fn_code tf) pc b0
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge
     (State stk' tf (Vptr stk Integers.Ptrofs.zero)
        pc1 rs1 (PMap.init false) m1) E0 s2' \/
   star step tge
     (State stk' tf (Vptr stk Integers.Ptrofs.zero)
        pc1 rs1 (PMap.init false) m1) E0 s2' /\
   ltof (option SeqBB.t) measure b' (Some b0)) /\
  match_states b'
    (RTL.Returnstate s (regmap_optget or Vundef rs) m')
    s2'
    match goal with H: match_block _ _ _ _ |- _ => inv H end; simplify;
    apply sim_plus.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
       rs1 (PMap.init false) m1) E0 s2 /\
  match_states b'
    (RTL.Returnstate s (regmap_optget or Vundef rs) m')
    s2
    assert (fn_stacksize tf = RTL.fn_stacksize f).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
fn_stacksize tf = RTL.fn_stacksize f
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
exists (b' : option SeqBB.t) 
(s2 : state),
  plus step tge
    (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
       rs1 (PMap.init false) m1) E0 s2 /\
  match_states b'
    (RTL.Returnstate s (regmap_optget or Vundef rs) m')
    s2
    {
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
fn_stacksize tf = RTL.fn_stacksize f unfold transl_function in TF.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: match partition f with
| OK f' =>
    if
     check_valid_node (fn_code f')
       (RTL.fn_entrypoint f)
    then
     if
      forall_ptree
        (check_code (RTL.fn_code f) (fn_code f'))
        (fn_code f')
     then
      OK
        {|
          fn_sig := RTL.fn_sig f;
          fn_params := RTL.fn_params f;
          fn_stacksize := RTL.fn_stacksize f;
          fn_code := fn_code f';
          fn_entrypoint := RTL.fn_entrypoint f
        |}
     else
      Error (msg "check_present_blocks failed")
    else Error (msg "entrypoint does not exists")
| Error msg => Error msg
end = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
fn_stacksize tf = RTL.fn_stacksize f
      repeat (destruct_match; try discriminate; []).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
f0: function
Heqr: partition f = OK f0
Heqb: check_valid_node (fn_code f0)
  (RTL.fn_entrypoint f) = true
Heqb0: forall_ptree
  (check_code (RTL.fn_code f) (fn_code f0))
  (fn_code f0) = true
TF: OK
  {|
    fn_sig := RTL.fn_sig f;
    fn_params := RTL.fn_params f;
    fn_stacksize := RTL.fn_stacksize f;
    fn_code := fn_code f0;
    fn_entrypoint := RTL.fn_entrypoint f
  |} = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
fn_stacksize tf = RTL.fn_stacksize f
      inv TF; auto. }
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
exists (b' : option SeqBB.t) (s2 : state),
  plus step tge
    (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
       rs1 (PMap.init false) m1) E0 s2 /\
  match_states b'
    (RTL.Returnstate s (regmap_optget or Vundef rs) m')
    s2
    do 3 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
plus step tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 (PMap.init false) m1) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  ?s2 apply plus_one.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 (PMap.init false) m1) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  ?s2 econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
SeqBB.step tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |}) x
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     ?rs' ?pr' ?m') ?cf E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  ?s2
    eapply BB.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
SeqBB.step tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBnop :: RBexit None (RBreturn or) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     ?rs' ?pr' ?m') ?cf E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  ?s2
    econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_instr tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) RBnop (Iexec ?state')
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_list (step_instr tge)
  (Vptr stk Integers.Ptrofs.zero) 
  (Iexec ?state') (RBexit None (RBreturn or) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     ?rs' ?pr' ?m') ?cf E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  ?s2 econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_list (step_instr tge)
  (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBreturn or) :: nil)
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     ?rs' ?pr' ?m') ?cf E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  ?s2 eapply exec_RBterm.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_instr tge (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) (RBexit None (RBreturn or))
  (Iterm
     {| is_rs := ?rs'; is_ps := ?pr'; is_mem := ?m' |}
     ?cf)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     ?rs' ?pr' ?m') ?cf E0 
  ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  ?s2
    econstructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
truthy
  (is_ps
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |}) None
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     rs (PMap.init false) m) 
  (RBreturn or) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  ?s2 constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
(fn_code tf) ! pc1 = Some x
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     rs (PMap.init false) m) 
  (RBreturn or) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  ?s2 eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
step_cf_instr tge
  (State stk' tf (Vptr stk Integers.Ptrofs.zero) pc1
     rs (PMap.init false) m) (RBreturn or) E0 ?s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  ?s2
    econstructor; eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
Mem.free m stk 0 (fn_stacksize tf) = Some ?m'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  (Returnstate stk' (regmap_optget or Vundef rs) ?m')
    rewrite H4.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
Mem.free m stk 0 (RTL.fn_stacksize f) = Some ?m'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  (Returnstate stk' (regmap_optget or Vundef rs) ?m') eauto.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
stk': list stackframe
tf: function
pc1: positive
rs1: RTL.regset
m1: mem
H1: match_states
  (Some
     (RBnop :: RBexit None (RBreturn or) :: nil))
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
     pc rs m)
  (State stk' tf (Vptr stk Integers.Ptrofs.zero)
     pc1 rs1 (PMap.init false) m1)
TF: transl_function f = OK tf
CODE: forall (pc : positive) (b : SeqBB.t),
(fn_code tf) ! pc = Some b ->
match_block (RTL.fn_code f) (fn_code tf) pc b
STK: Forall2 match_stackframe s stk'
STARSIMU: star RTL.step ge
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc1
     rs1 m1) E0
  (RTL.State s f
     (Vptr stk Integers.Ptrofs.zero) pc rs
     m)
BB: sem_extrap tf pc1 (Vptr stk Integers.Ptrofs.zero)
  (Iexec
     {|
       is_rs := rs;
       is_ps := PMap.init false;
       is_mem := m
     |})
  (Iexec
     {|
       is_rs := rs1;
       is_ps := PMap.init false;
       is_mem := m1
     |})
  (RBnop :: RBexit None (RBreturn or) :: nil)
x: SeqBB.t
H3: (fn_code tf) ! pc1 = Some x
H2: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
Learn: Learnt H
H4: fn_stacksize tf = RTL.fn_stacksize f
match_states ?b'
  (RTL.Returnstate s (regmap_optget or Vundef rs) m')
  (Returnstate stk' (regmap_optget or Vundef rs) m')
    constructor; eauto.
  Qed.

  Lemma transl_correct:
    forall s1 t s1',
      RTL.step ge s1 t s1' ->
      forall b s2, match_states b s1 s2 ->
        exists b' s2',
          (plus step tge s2 t s2' \/
             (star step tge s2 t s2' /\ ltof _ measure b' b))
          /\ match_states b' s1' s2'.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s1 : RTL.state) (t : trace) (s1' : RTL.state),
RTL.step ge s1 t s1' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b s1 s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' s1' s2'
  Proof.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s1 : RTL.state) (t : trace) (s1' : RTL.state),
RTL.step ge s1 t s1' ->
forall (b : option SeqBB.t) (s2 : state),
match_states b s1 s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' s1' s2'
    induction 1.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m') s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
sig: signature
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall sig ros args res pc')
H0: RTL.find_function ge ros rs = Some fd
H1: RTL.funsig fd = sig
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
sig: signature
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall sig ros args)
H0: RTL.find_function ge ros rs = Some fd
H1: RTL.funsig fd = sig
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs
     m) s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' 
       (regmap_setres res vres rs) m') s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
b: bool
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
H0: Op.eval_condition cond rs ## args m = Some b
H1: pc' = (if b then ifso else ifnot)
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs
     m) s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.Returnstate s (regmap_optget or Vundef rs) m')
    s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.Callstate s (Internal f) args m)
  s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
ef: external_function
args: list val
res: val
t: trace
m, m': mem
H: external_call ef ge args m t res m'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.Callstate s (External ef) args m)
  s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.Returnstate s res m') s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.Returnstate
     (RTL.Stackframe res f sp pc rs :: s) vres m) s2 ->
exists (b' : option SeqBB.t) 
(s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2'
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
pc': RTL.node
H: (RTL.fn_code f) ! pc = Some (RTL.Inop pc')
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2' eauto using transl_Inop_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
op: Op.operation
args: list reg
res: reg
pc': RTL.node
v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iop op args res pc')
H0: Op.eval_operation ge sp op rs ## args m = Some v
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' rs # res <- v m) s2' eauto using transl_Iop_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
dst: reg
pc': RTL.node
a, v: val
H: (RTL.fn_code f) ! pc =
Some (RTL.Iload chunk addr args dst pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.loadv chunk m a = Some v
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' rs # dst <- v m) s2' eauto using transl_Iload_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
chunk: memory_chunk
addr: Op.addressing
args: list reg
src: reg
pc': RTL.node
a: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Istore chunk addr args src pc')
H0: Op.eval_addressing ge sp addr rs ## args = Some a
H1: Mem.storev chunk m a rs # src = Some m'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m') s2' eauto using transl_Istore_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: RTL.regset
m: mem
sig: signature
ros: (reg + ident)%type
args: list reg
res: reg
pc': RTL.node
fd: RTL.fundef
H: (RTL.fn_code f) ! pc =
Some (RTL.Icall sig ros args res pc')
H0: RTL.find_function ge ros rs = Some fd
H1: RTL.funsig fd = sig
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.Callstate
       (RTL.Stackframe res f sp pc' rs :: s) fd
       rs ## args m) s2' eauto using transl_Icall_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
sig: signature
ros: (reg + ident)%type
args: list reg
fd: RTL.fundef
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Itailcall sig ros args)
H0: RTL.find_function ge ros rs = Some fd
H1: RTL.funsig fd = sig
H2: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs
     m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.Callstate s fd rs ## args m')
    s2' eauto using transl_Itailcall_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
ef: external_function
args: list (builtin_arg reg)
res: builtin_res reg
pc': RTL.node
vargs: list val
t: trace
vres: val
m': mem
H: (RTL.fn_code f) ! pc =
Some (RTL.Ibuiltin ef args res pc')
H0: eval_builtin_args ge (fun r : positive => rs # r)
  sp m args vargs
H1: external_call ef ge vargs m t vres m'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc' (regmap_setres res vres rs)
       m') s2' eauto using transl_Ibuiltin_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
cond: Op.condition
args: list reg
ifso, ifnot: RTL.node
b: bool
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Icond cond args ifso ifnot)
H0: Op.eval_condition cond rs ## args m = Some b
H1: pc' = (if b then ifso else ifnot)
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2' eauto using transl_Icond_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
sp: val
pc: positive
rs: Regmap.t val
m: mem
arg: reg
tbl: list RTL.node
n: Integers.Int.int
pc': RTL.node
H: (RTL.fn_code f) ! pc =
Some (RTL.Ijumptable arg tbl)
H0: rs # arg = Vint n
H1: list_nth_z tbl (Integers.Int.unsigned n) =
Some pc'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.State s f sp pc rs m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.State s f sp pc' rs m) s2' eauto using transl_Ijumptable_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
stk: block
pc: positive
rs: RTL.regset
m: mem
or: option reg
m': mem
H: (RTL.fn_code f) ! pc = Some (RTL.Ireturn or)
H0: Mem.free m stk 0 (RTL.fn_stacksize f) = Some m'
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.State s f (Vptr stk Integers.Ptrofs.zero) pc rs
     m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.Returnstate s (regmap_optget or Vundef rs) m')
    s2' eauto using transl_Ireturn_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
f: RTL.function
args: list val
m: mem
m': Mem.mem'
stk: block
H: Mem.alloc m 0 (RTL.fn_stacksize f) = (m', stk)
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.Callstate s (Internal f) args m)
  s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f (Vptr stk Integers.Ptrofs.zero)
       (RTL.fn_entrypoint f)
       (RTL.init_regs args (RTL.fn_params f)) m') s2' eauto using transl_initcall_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
s: list RTL.stackframe
ef: external_function
args: list val
res: val
t: trace
m, m': mem
H: external_call ef ge args m t res m'
forall (b : option SeqBB.t) (s2 : state),
match_states b (RTL.Callstate s (External ef) args m)
  s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 t s2' \/
   star step tge s2 t s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b' (RTL.Returnstate s res m') s2' eauto using transl_externalcall_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
res: reg
f: RTL.function
sp: val
pc: RTL.node
rs: RTL.regset
s: list RTL.stackframe
vres: val
m: mem
forall (b : option SeqBB.t) (s2 : state),
match_states b
  (RTL.Returnstate
     (RTL.Stackframe res f sp pc rs :: s) vres m) s2 ->
exists (b' : option SeqBB.t) (s2' : state),
  (plus step tge s2 E0 s2' \/
   star step tge s2 E0 s2' /\
   ltof (option SeqBB.t) measure b' b) /\
  match_states b'
    (RTL.State s f sp pc rs # res <- vres m) s2' eauto using transl_returnstate_correct.
  Qed.

  Theorem transf_program_correct:
    forward_simulation (RTL.semantics prog) (GibleSeq.semantics tprog).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forward_simulation (RTL.semantics prog)
  (semantics tprog)
  Proof using TRANSL.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forward_simulation (RTL.semantics prog)
  (semantics tprog)
    eapply (Forward_simulation
              (L1:=RTL.semantics prog)
              (L2:=GibleSeq.semantics tprog)
              (ltof _ measure) match_states).
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
fsim_properties (RTL.semantics prog) (semantics tprog)
  (option SeqBB.t) (ltof (option SeqBB.t) measure)
  match_states
    constructor.
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
well_founded (ltof (option SeqBB.t) measure)
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall s1 : Smallstep.state (RTL.semantics prog),
Smallstep.initial_state (RTL.semantics prog) s1 ->
exists
  (i : option SeqBB.t) (s2 : 
                        Smallstep.state
                        (semantics tprog)),
  Smallstep.initial_state (semantics tprog) s2 /\
  match_states i s1 s2
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (i : option SeqBB.t)
  (s1 : Smallstep.state (RTL.semantics prog))
  (s2 : Smallstep.state (semantics tprog))
  (r : Integers.Int.int),
match_states i s1 s2 ->
Smallstep.final_state (RTL.semantics prog) s1 r ->
Smallstep.final_state (semantics tprog) s2 r
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s1 : Smallstep.state (RTL.semantics prog))
  (t : trace)
  (s1' : Smallstep.state (RTL.semantics prog)),
Step (RTL.semantics prog) s1 t s1' ->
forall (i : option SeqBB.t)
  (s2 : Smallstep.state (semantics tprog)),
match_states i s1 s2 ->
exists
  (i' : option SeqBB.t) (s2' : 
                        Smallstep.state
                        (semantics tprog)),
  (Plus (semantics tprog) s2 t s2' \/
   Star (semantics tprog) s2 t s2' /\
   ltof (option SeqBB.t) measure i' i) /\
  match_states i' s1' s2'
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall id : ident,
Senv.public_symbol (symbolenv (semantics tprog)) id =
Senv.public_symbol (symbolenv (RTL.semantics prog)) id
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
well_founded (ltof (option SeqBB.t) measure) apply well_founded_ltof.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall s1 : Smallstep.state (RTL.semantics prog),
Smallstep.initial_state (RTL.semantics prog) s1 ->
exists
  (i : option SeqBB.t) (s2 : Smallstep.state
                               (semantics tprog)),
  Smallstep.initial_state (semantics tprog) s2 /\
  match_states i s1 s2 eauto using transl_initial_states.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (i : option SeqBB.t)
  (s1 : Smallstep.state (RTL.semantics prog))
  (s2 : Smallstep.state (semantics tprog))
  (r : Integers.Int.int),
match_states i s1 s2 ->
Smallstep.final_state (RTL.semantics prog) s1 r ->
Smallstep.final_state (semantics tprog) s2 r intros; eapply transl_final_states; eauto.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall (s1 : Smallstep.state (RTL.semantics prog))
  (t : trace)
  (s1' : Smallstep.state (RTL.semantics prog)),
Step (RTL.semantics prog) s1 t s1' ->
forall (i : option SeqBB.t)
  (s2 : Smallstep.state (semantics tprog)),
match_states i s1 s2 ->
exists
  (i' : option SeqBB.t) (s2' : Smallstep.state
                                 (semantics tprog)),
  (Plus (semantics tprog) s2 t s2' \/
   Star (semantics tprog) s2 t s2' /\
   ltof (option SeqBB.t) measure i' i) /\
  match_states i' s1' s2' eapply transl_correct.
    -
prog: RTL.program
tprog: program
ge:= Genv.globalenv prog: RTL.genv
tge:= Genv.globalenv tprog: genv
TRANSL: match_prog prog tprog
forall id : ident,
Senv.public_symbol (symbolenv (semantics tprog)) id =
Senv.public_symbol (symbolenv (RTL.semantics prog)) id apply senv_preserved.
  Qed.

End CORRECTNESS.