statement stringlengths 1 2.09k | proof stringlengths 0 22.1k | type stringclasses 25
values | symbolic_name stringlengths 1 49 | library stringclasses 14
values | filename stringclasses 212
values | imports listlengths 0 63 | deps listlengths 0 64 | docstring stringlengths 0 1.82k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
indexed_memory_access_label:
forall insn sz base ofs k,
(forall ad, nolabel (insn ad)) ->
tail_nolabel k (indexed_memory_access insn sz base ofs k). | Proof.
unfold indexed_memory_access; intros. destruct offset_representable.
TailNoLabel.
eapply tail_nolabel_trans; TailNoLabel.
Qed. | Remark | indexed_memory_access_label | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"TailNoLabel",
"indexed_memory_access",
"nolabel",
"offset_representable",
"tail_nolabel",
"tail_nolabel_trans"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
loadind_label:
forall base ofs ty dst k c,
loadind base ofs ty dst k = OK c -> tail_nolabel k c. | Proof.
unfold loadind; intros.
destruct ty, (preg_of dst); inv H; apply indexed_memory_access_label; intros; exact I.
Qed. | Remark | loadind_label | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"indexed_memory_access_label",
"inv",
"loadind",
"preg_of",
"tail_nolabel"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
storeind_label:
forall src base ofs ty k c,
storeind src base ofs ty k = OK c -> tail_nolabel k c. | Proof.
unfold storeind; intros.
destruct ty, (preg_of src); inv H; apply indexed_memory_access_label; intros; exact I.
Qed. | Remark | storeind_label | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"indexed_memory_access_label",
"inv",
"preg_of",
"storeind",
"tail_nolabel"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
loadptr_label:
forall base ofs dst k, tail_nolabel k (loadptr base ofs dst k). | Proof.
intros. apply indexed_memory_access_label. unfold nolabel; auto.
Qed. | Remark | loadptr_label | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"indexed_memory_access_label",
"loadptr",
"nolabel",
"tail_nolabel"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
storeptr_label:
forall src base ofs k, tail_nolabel k (storeptr src base ofs k). | Proof.
intros. apply indexed_memory_access_label. unfold nolabel; auto.
Qed. | Remark | storeptr_label | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"indexed_memory_access_label",
"nolabel",
"storeptr",
"tail_nolabel"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
make_epilogue_label:
forall f k, tail_nolabel k (make_epilogue f k). | Proof.
unfold make_epilogue; intros. eapply tail_nolabel_trans. apply loadptr_label. TailNoLabel.
Qed. | Remark | make_epilogue_label | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"TailNoLabel",
"loadptr_label",
"make_epilogue",
"tail_nolabel",
"tail_nolabel_trans"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_instr_label:
forall f i ep k c,
transl_instr f i ep k = OK c ->
match i with Mlabel lbl => c = Plabel lbl :: k | _ => tail_nolabel k c end. | Proof.
unfold transl_instr; intros; destruct i; TailNoLabel.
- eapply loadind_label; eauto.
- eapply storeind_label; eauto.
- destruct ep. eapply loadind_label; eauto.
eapply tail_nolabel_trans. apply loadptr_label. eapply loadind_label; eauto.
- eapply transl_op_label; eauto.
- eapply transl_load_label; eauto.
-... | Lemma | transl_instr_label | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"TailNoLabel",
"loadind_label",
"loadptr_label",
"make_epilogue_label",
"monadInv",
"storeind_label",
"tail_nolabel",
"tail_nolabel_trans",
"transl_cond_branch_label",
"transl_instr",
"transl_load_label",
"transl_op_label",
"transl_store_label"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_instr_label':
forall lbl f i ep k c,
transl_instr f i ep k = OK c ->
find_label lbl c = if Mach.is_label lbl i then Some k else find_label lbl k. | Proof.
intros. exploit transl_instr_label; eauto.
destruct i; try (intros [A B]; apply B).
intros. subst c. simpl. auto.
Qed. | Lemma | transl_instr_label' | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"exploit",
"find_label",
"is_label",
"transl_instr",
"transl_instr_label"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_code_label:
forall lbl f c ep tc,
transl_code f c ep = OK tc ->
match Mach.find_label lbl c with
| None => find_label lbl tc = None
| Some c' => exists tc', find_label lbl tc = Some tc' /\ transl_code f c' false = OK tc'
end. | Proof.
induction c; simpl; intros.
inv H. auto.
monadInv H. rewrite (transl_instr_label' lbl _ _ _ _ _ EQ0).
generalize (Mach.is_label_correct lbl a).
destruct (Mach.is_label lbl a); intros.
subst a. simpl in EQ. exists x; auto.
eapply IHc; eauto.
Qed. | Lemma | transl_code_label | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"find_label",
"inv",
"is_label",
"is_label_correct",
"monadInv",
"transl_code",
"transl_instr_label'"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_find_label:
forall lbl f tf,
transf_function f = OK tf ->
match Mach.find_label lbl f.(Mach.fn_code) with
| None => find_label lbl tf.(fn_code) = None
| Some c => exists tc, find_label lbl tf.(fn_code) = Some tc /\ transl_code f c false = OK tc
end. | Proof.
intros. monadInv H. destruct (zlt Ptrofs.max_unsigned (list_length_z x.(fn_code))); inv EQ0.
monadInv EQ. simpl. rewrite transl_code'_transl_code in EQ0.
eapply transl_code_label; eauto.
Qed. | Lemma | transl_find_label | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"find_label",
"inv",
"list_length_z",
"max_unsigned",
"monadInv",
"transf_function",
"transl_code",
"transl_code'_transl_code",
"transl_code_label",
"zlt"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
find_label_goto_label:
forall f tf lbl rs m c' b ofs,
Genv.find_funct_ptr ge b = Some (Internal f) ->
transf_function f = OK tf ->
rs PC = Vptr b ofs ->
Mach.find_label lbl f.(Mach.fn_code) = Some c' ->
exists tc', exists rs',
goto_label tf lbl rs m = Next rs' m
/\ transl_code_at_pc ge (rs' PC) b f c... | Proof.
intros. exploit (transl_find_label lbl f tf); eauto. rewrite H2.
intros [tc [A B]].
exploit label_pos_code_tail; eauto. instantiate (1 := 0).
intros [pos' [P [Q R]]].
exists tc; exists (rs#PC <- (Vptr b (Ptrofs.repr pos'))).
split. unfold goto_label. rewrite P. rewrite H1. auto.
split. rewrite Preg... | Lemma | find_label_goto_label | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"Genv",
"exploit",
"find_funct_ptr",
"find_label",
"ge",
"goto_label",
"gso",
"gss",
"label_pos_code_tail",
"repr",
"transf_function",
"transf_function_no_overflow",
"transl_code_at_pc",
"transl_find_label",
"unsigned_repr"
] | A valid branch in a piece of Mach code translates to a valid ``go to''
transition in the generated Asm code. | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
return_address_exists:
forall f sg ros c, is_tail (Mcall sg ros :: c) f.(Mach.fn_code) ->
exists ra, return_address_offset f c ra. | Proof.
intros. eapply Asmgenproof0.return_address_exists; eauto.
- intros. exploit transl_instr_label; eauto.
destruct i; try (intros [A B]; apply A). intros. subst c0. repeat constructor.
- intros. monadInv H0.
destruct (zlt Ptrofs.max_unsigned (list_length_z x.(fn_code))); inv EQ0. monadInv EQ.
rewrite transl... | Lemma | return_address_exists | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"exploit",
"inv",
"is_tail",
"list_length_z",
"max_unsigned",
"monadInv",
"return_address_offset",
"transf_function_no_overflow",
"transl_code'_transl_code",
"transl_instr_label",
"zlt"
] | Existence of return addresses | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
match_states: Mach.state -> Asm.state -> Prop | :=
| match_states_intro:
forall s fb sp c ep ms m m' rs f tf tc
(STACKS: match_stack ge s)
(FIND: Genv.find_funct_ptr ge fb = Some (Internal f))
(MEXT: Mem.extends m m')
(AT: transl_code_at_pc ge (rs PC) fb f c ep tf tc)
(AG: agree ms sp rs)
(DXP: ep = true -> rs#... | Inductive | match_states | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"Genv",
"agree",
"extends",
"find_funct_ptr",
"ge",
"match_stack",
"parent_ra",
"parent_sp",
"state",
"transl_code_at_pc",
"zero"
] | Semantic preservation is proved using simulation diagrams
of the following form.
<<
st1 --------------- st2
| |
t| *|t
| |
v v
st1'--------------- st2'
>>
The invariant is the ... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
exec_straight_steps:
forall s fb f rs1 i c ep tf tc m1' m2 m2' sp ms2,
match_stack ge s ->
Mem.extends m2 m2' ->
Genv.find_funct_ptr ge fb = Some (Internal f) ->
transl_code_at_pc ge (rs1 PC) fb f (i :: c) ep tf tc ->
(forall k c (TR: transl_instr f i ep k = OK c),
exists rs2,
exec_straight tge tf... | Proof.
intros. inversion H2. subst. monadInv H7.
exploit H3; eauto. intros [rs2 [A [B C]]].
exists (State rs2 m2'); split.
eapply exec_straight_exec; eauto.
econstructor; eauto. eapply exec_straight_at; eauto.
Qed. | Lemma | exec_straight_steps | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"E0",
"Genv",
"agree",
"exec_straight",
"exec_straight_at",
"exec_straight_exec",
"exploit",
"extends",
"find_funct_ptr",
"ge",
"it1_is_parent",
"match_stack",
"match_states",
"monadInv",
"parent_sp",
"plus",
"step",
"tge",
"transl_code_at_pc",
"transl_instr"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_straight_steps_goto:
forall s fb f rs1 i c ep tf tc m1' m2 m2' sp ms2 lbl c',
match_stack ge s ->
Mem.extends m2 m2' ->
Genv.find_funct_ptr ge fb = Some (Internal f) ->
Mach.find_label lbl f.(Mach.fn_code) = Some c' ->
transl_code_at_pc ge (rs1 PC) fb f (i :: c) ep tf tc ->
it1_is_parent ep i = false... | Proof.
intros. inversion H3. subst. monadInv H9.
exploit H5; eauto. intros [jmp [k' [rs2 [A [B C]]]]].
generalize (functions_transl _ _ _ H7 H8); intro FN.
generalize (transf_function_no_overflow _ _ H8); intro NOOV.
exploit exec_straight_steps_2; eauto.
intros [ofs' [PC2 CT2]].
exploit find_label_goto_la... | Lemma | exec_straight_steps_goto | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"E0",
"Genv",
"agree",
"agree_exten",
"exec_instr",
"exec_straight",
"exec_straight_steps_1",
"exec_straight_steps_2",
"exploit",
"extends",
"find_funct_ptr",
"find_instr_tail",
"find_label",
"find_label_goto_label",
"functions_transl",
"ge",
"goto_label",
"it1_is_parent",
"match... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_straight_opt_steps_goto:
forall s fb f rs1 i c ep tf tc m1' m2 m2' sp ms2 lbl c',
match_stack ge s ->
Mem.extends m2 m2' ->
Genv.find_funct_ptr ge fb = Some (Internal f) ->
Mach.find_label lbl f.(Mach.fn_code) = Some c' ->
transl_code_at_pc ge (rs1 PC) fb f (i :: c) ep tf tc ->
it1_is_parent ep i = f... | Proof.
intros. inversion H3. subst. monadInv H9.
exploit H5; eauto. intros [jmp [k' [rs2 [A [B C]]]]].
generalize (functions_transl _ _ _ H7 H8); intro FN.
generalize (transf_function_no_overflow _ _ H8); intro NOOV.
inv A.
- exploit find_label_goto_label; eauto.
intros [tc' [rs3 [GOTO [AT' OTH]]]].
exist... | Lemma | exec_straight_opt_steps_goto | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"E0",
"Genv",
"agree",
"agree_exten",
"exec_instr",
"exec_straight_opt",
"exec_straight_steps_1",
"exec_straight_steps_2",
"exploit",
"extends",
"find_funct_ptr",
"find_instr_tail",
"find_label",
"find_label_goto_label",
"functions_transl",
"ge",
"goto_label",
"inv",
"it1_is_pare... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
measure (s: Mach.state) : nat | :=
match s with
| Mach.State _ _ _ _ _ _ => 0%nat
| Mach.Callstate _ _ _ _ => 0%nat
| Mach.Returnstate _ _ _ => 1%nat
end. | Definition | measure | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"state"
] | We need to show that, in the simulation diagram, we cannot
take infinitely many Mach transitions that correspond to zero
transitions on the Asm side. Actually, all Mach transitions
correspond to at least one Asm transition, except the
transition from [Machsem.Returnstate] to [Machsem.State].
So, the followin... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
preg_of_not_X15: forall r, negb (mreg_eq r R15) = true -> IR X15 <> preg_of r. | Proof.
intros. change (IR X15) with (preg_of R15). red; intros.
exploit preg_of_injective; eauto. intros; subst r; discriminate.
Qed. | Remark | preg_of_not_X15 | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"IR",
"exploit",
"mreg_eq",
"preg_of",
"preg_of_injective"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
sp_val': forall ms sp rs, agree ms sp rs -> sp = rs XSP. | Proof.
intros. eapply sp_val; eauto.
Qed. | Lemma | sp_val' | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"agree",
"sp_val"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
step_simulation:
forall S1 t S2, Mach.step return_address_offset ge S1 t S2 ->
forall S1' (MS: match_states S1 S1'),
(exists S2', plus step tge S1' t S2' /\ match_states S2 S2')
\/ (measure S2 < measure S1 /\ t = E0 /\ match_states S2 S1')%nat. | Proof.
induction 1; intros; inv MS.
- (* Mlabel *)
left; eapply exec_straight_steps; eauto; intros.
monadInv TR. econstructor; split. apply exec_straight_one. simpl; eauto. auto.
split. apply agree_nextinstr; auto. simpl; congruence.
- (* Mgetstack *)
unfold load_stack in H.
exploit Mem.loadv_extends; eau... | Theorem | step_simulation | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"E0",
"Genv",
"InvBooleans",
"MS",
"SP",
"Simpl",
"Tptr",
"add",
"agree_change_sp",
"agree_exten",
"agree_nextinstr",
"agree_set_mreg",
"agree_set_other",
"agree_set_pair",
"agree_set_res",
"agree_set_undef_mreg",
"agree_undef_caller_save_regs",
"agree_undef_regs",
"alloc_extends... | This is the simulation diagram. We prove it by case analysis on the Mach transition. | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
transf_initial_states:
forall st1, Mach.initial_state prog st1 ->
exists st2, Asm.initial_state tprog st2 /\ match_states st1 st2. | Proof.
intros. inversion H. unfold ge0 in *.
econstructor; split.
econstructor.
eapply (Genv.init_mem_transf_partial TRANSF); eauto.
replace (Genv.symbol_address (Genv.globalenv tprog) (prog_main tprog) Ptrofs.zero)
with (Vptr fb Ptrofs.zero).
econstructor; eauto.
constructor.
apply Mem.extends_ref... | Lemma | transf_initial_states | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"Genv",
"TRANSF",
"Vnullptr",
"extends_refl",
"ge",
"gi",
"globalenv",
"init_mem_transf_partial",
"initial_state",
"match_program_main",
"match_states",
"ptr64",
"symbol_address",
"symbols_preserved",
"zero"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transf_final_states:
forall st1 st2 r,
match_states st1 st2 -> Mach.final_state st1 r -> Asm.final_state st2 r. | Proof.
intros. inv H0. inv H. constructor. assumption.
compute in H1. inv H1.
generalize (preg_val _ _ _ R0 AG). rewrite H2. intros LD; inv LD. auto.
Qed. | Lemma | transf_final_states | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"final_state",
"inv",
"match_states",
"preg_val"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transf_program_correct:
forward_simulation (Mach.semantics return_address_offset prog) (Asm.semantics tprog). | Proof.
eapply forward_simulation_star with (measure := measure).
apply senv_preserved.
eexact transf_initial_states.
eexact transf_final_states.
exact step_simulation.
Qed. | Theorem | transf_program_correct | aarch64 | aarch64/Asmgenproof.v | [
"Coqlib",
"Errors",
"Integers",
"Floats",
"AST",
"Linking",
"Values",
"Memory",
"Events",
"Globalenvs",
"Smallstep",
"Op",
"Locations",
"Mach",
"Conventions",
"Asm",
"Asmgen",
"Asmgenproof0",
"Asmgenproof1"
] | [
"forward_simulation",
"forward_simulation_star",
"measure",
"return_address_offset",
"semantics",
"senv_preserved",
"step_simulation",
"transf_final_states",
"transf_initial_states"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
preg_of_iregsp_not_PC: forall r, preg_of_iregsp r <> PC. | Proof.
destruct r; simpl; congruence.
Qed. | Lemma | preg_of_iregsp_not_PC | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"preg_of_iregsp"
] | Properties of registers | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
preg_of_not_X16: forall r, preg_of r <> X16. | Proof.
destruct r; simpl; congruence.
Qed. | Lemma | preg_of_not_X16 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"preg_of"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
ireg_of_not_X16: forall r x, ireg_of r = OK x -> x <> X16. | Proof.
unfold ireg_of; intros. destruct (preg_of r) eqn:E; inv H.
red; intros; subst x. elim (preg_of_not_X16 r); auto.
Qed. | Lemma | ireg_of_not_X16 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"inv",
"ireg_of",
"preg_of",
"preg_of_not_X16"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
ireg_of_not_X16': forall r x, ireg_of r = OK x -> IR x <> IR X16. | Proof.
intros. apply ireg_of_not_X16 in H. congruence.
Qed. | Lemma | ireg_of_not_X16' | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"IR",
"ireg_of",
"ireg_of_not_X16"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
Simplif | :=
((rewrite nextinstr_inv by eauto with asmgen)
|| (rewrite nextinstr_inv1 by eauto with asmgen)
|| (rewrite Pregmap.gss)
|| (rewrite nextinstr_pc)
|| (rewrite Pregmap.gso by eauto with asmgen)); auto with asmgen. | Ltac | Simplif | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"gso",
"gss",
"nextinstr_inv",
"nextinstr_inv1",
"nextinstr_pc"
] | Useful simplification tactic | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
Simpl | := repeat Simplif. | Ltac | Simpl | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simplif"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
wf_decomposition: list (Z * Z) -> Prop | :=
| wf_decomp_nil:
wf_decomposition nil
| wf_decomp_cons: forall m n p l,
n = Zzero_ext 16 m -> 0 <= p -> wf_decomposition l ->
wf_decomposition ((n, p) :: l). | Inductive | wf_decomposition | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Zzero_ext"
] | Decomposition of integer literals | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
decompose_int_wf:
forall N n p, 0 <= p -> wf_decomposition (decompose_int N n p). | Proof.
Local Opaque Zzero_ext.
induction N as [ | N]; simpl; intros.
- constructor.
- set (frag := Zzero_ext 16 (Z.shiftr n p)) in *. destruct (Z.eqb frag 0).
+ apply IHN. lia.
+ econstructor. reflexivity. lia. apply IHN; lia.
Qed. | Lemma | decompose_int_wf | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Zzero_ext",
"decompose_int",
"set",
"wf_decomposition"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
recompose_int (accu: Z) (l: list (Z * Z)) : Z | :=
match l with
| nil => accu
| (n, p) :: l => recompose_int (Zinsert accu n p 16) l
end. | Fixpoint | recompose_int | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Zinsert"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
decompose_int_correct:
forall N n p accu,
0 <= p ->
(forall i, p <= i -> Z.testbit accu i = false) ->
(forall i, 0 <= i < p + Z.of_nat N * 16 ->
Z.testbit (recompose_int accu (decompose_int N n p)) i =
if zlt i p then Z.testbit accu i else Z.testbit n i). | Proof.
induction N as [ | N]; intros until accu; intros PPOS ABOVE i RANGE.
- simpl. rewrite zlt_true; auto. extlia.
- rewrite inj_S in RANGE. simpl.
set (frag := Zzero_ext 16 (Z.shiftr n p)).
assert (FRAG: forall i, p <= i < p + 16 -> Z.testbit n i = Z.testbit frag (i - p)).
{ unfold frag; intros. rewrite Zzer... | Lemma | decompose_int_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Zinsert_spec",
"Ztestbit_two_p_m1",
"Zzero_ext",
"Zzero_ext_spec",
"decompose_int",
"extlia",
"proj_sumbool",
"recompose_int",
"set",
"testbit",
"zle_false",
"zle_true",
"zlt",
"zlt_false",
"zlt_true"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
decompose_int_eqmod: forall N n,
eqmod (two_power_nat (N * 16)%nat) (recompose_int 0 (decompose_int N n 0)) n. | Proof.
intros; apply eqmod_same_bits; intros.
rewrite decompose_int_correct. apply zlt_false; lia.
lia. intros; apply Z.testbit_0_l. extlia.
Qed. | Corollary | decompose_int_eqmod | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"decompose_int",
"decompose_int_correct",
"eqmod",
"eqmod_same_bits",
"extlia",
"recompose_int",
"zlt_false"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
decompose_notint_eqmod: forall N n,
eqmod (two_power_nat (N * 16)%nat)
(Z.lnot (recompose_int 0 (decompose_int N (Z.lnot n) 0))) n. | Proof.
intros; apply eqmod_same_bits; intros.
rewrite Z.lnot_spec, decompose_int_correct.
rewrite zlt_false by lia. rewrite Z.lnot_spec by lia. apply negb_involutive.
lia. intros; apply Z.testbit_0_l. extlia. lia.
Qed. | Corollary | decompose_notint_eqmod | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"decompose_int",
"decompose_int_correct",
"eqmod",
"eqmod_same_bits",
"extlia",
"recompose_int",
"zlt_false"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
negate_decomposition_wf:
forall l, wf_decomposition l -> wf_decomposition (negate_decomposition l). | Proof.
induction 1; simpl; econstructor; auto.
instantiate (1 := (Z.lnot m)).
apply equal_same_bits; intros.
rewrite H. change 65535 with (two_p 16 - 1).
rewrite Z.lxor_spec, !Zzero_ext_spec, Z.lnot_spec, Ztestbit_two_p_m1 by lia.
destruct (zlt i 16).
apply xorb_true_r.
auto.
Qed. | Lemma | negate_decomposition_wf | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Ztestbit_two_p_m1",
"Zzero_ext_spec",
"equal_same_bits",
"negate_decomposition",
"wf_decomposition",
"zlt"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
Zinsert_eqmod:
forall n x1 x2 y p l, 0 <= p -> 0 <= l ->
eqmod (two_power_nat n) x1 x2 ->
eqmod (two_power_nat n) (Zinsert x1 y p l) (Zinsert x2 y p l). | Proof.
intros. apply eqmod_same_bits; intros. rewrite ! Zinsert_spec by lia.
destruct (zle p i && zlt i (p + l)); auto.
apply same_bits_eqmod with n; auto.
Qed. | Lemma | Zinsert_eqmod | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Zinsert",
"Zinsert_spec",
"eqmod",
"eqmod_same_bits",
"same_bits_eqmod",
"zle",
"zlt"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
Zinsert_0_l:
forall y p l,
0 <= p -> 0 <= l ->
Z.shiftl (Zzero_ext l y) p = Zinsert 0 (Zzero_ext l y) p l. | Proof.
intros. apply equal_same_bits; intros.
rewrite Zinsert_spec by lia. unfold proj_sumbool.
destruct (zlt i p); [rewrite zle_false by lia|rewrite zle_true by lia]; simpl.
- rewrite Z.testbit_0_l, Z.shiftl_spec_low by auto. auto.
- rewrite Z.shiftl_spec by lia.
destruct (zlt i (p + l)); auto.
rewrite Zzer... | Lemma | Zinsert_0_l | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Zinsert",
"Zinsert_spec",
"Zzero_ext",
"Zzero_ext_spec",
"equal_same_bits",
"proj_sumbool",
"zle_false",
"zle_true",
"zlt",
"zlt_false"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
recompose_int_negated:
forall l, wf_decomposition l ->
forall accu, recompose_int (Z.lnot accu) (negate_decomposition l) = Z.lnot (recompose_int accu l). | Proof.
induction 1; intros accu; simpl.
- auto.
- rewrite <- IHwf_decomposition. f_equal. apply equal_same_bits; intros.
rewrite Z.lnot_spec, ! Zinsert_spec, Z.lxor_spec, Z.lnot_spec by lia.
unfold proj_sumbool.
destruct (zle p i); simpl; auto.
destruct (zlt i (p + 16)); simpl; auto.
change 65535 with (two... | Lemma | recompose_int_negated | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Zinsert_spec",
"Ztestbit_two_p_m1",
"equal_same_bits",
"negate_decomposition",
"proj_sumbool",
"recompose_int",
"wf_decomposition",
"zle",
"zlt",
"zlt_true"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_loadimm_k_w:
forall (rd: ireg) k m l,
wf_decomposition l ->
forall (rs: regset) accu,
rs#rd = Vint (Int.repr accu) ->
exists rs',
exec_straight_opt ge fn (loadimm_k W rd l k) rs m k rs' m
/\ rs'#rd = Vint (Int.repr (recompose_int accu l))
/\ forall r, r <> PC -> r <> rd -> rs'#r = rs#r. | Proof.
induction 1; intros rs accu ACCU; simpl.
- exists rs; split. apply exec_straight_opt_refl. auto.
- destruct (IHwf_decomposition
(nextinstr (rs#rd <- (insert_in_int rs#rd n p 16)))
(Zinsert accu n p 16))
as (rs' & P & Q & R).
Simpl. rewrite ACCU. simpl. f_equal. apply Int.eqm... | Lemma | exec_loadimm_k_w | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"Zinsert",
"Zinsert_eqmod",
"eqm_samerepr",
"eqm_sym",
"eqm_unsigned_repr",
"exec_straight_opt",
"exec_straight_opt_step_opt",
"ge",
"insert_in_int",
"ireg",
"loadimm_k",
"nextinstr",
"recompose_int",
"regset",
"repr",
"wf_decomposition"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_loadimm_z_w:
forall rd l k rs m,
wf_decomposition l ->
exists rs',
exec_straight ge fn (loadimm_z W rd l k) rs m k rs' m
/\ rs'#rd = Vint (Int.repr (recompose_int 0 l))
/\ forall r, r <> PC -> r <> rd -> rs'#r = rs#r. | Proof.
unfold loadimm_z; destruct 1.
- econstructor; split.
apply exec_straight_one. simpl; eauto. auto.
split. Simpl.
intros; Simpl.
- set (accu0 := Zinsert 0 n p 16).
set (rs1 := nextinstr (rs#rd <- (Vint (Int.repr accu0)))).
destruct (exec_loadimm_k_w rd k m l H1 rs1 accu0) as (rs2 & P & Q & R); auto.
... | Lemma | exec_loadimm_z_w | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"Zinsert",
"Zinsert_0_l",
"exec_loadimm_k_w",
"exec_straight",
"exec_straight_opt_step",
"ge",
"loadimm_z",
"nextinstr",
"recompose_int",
"repr",
"set",
"wf_decomposition"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_loadimm_n_w:
forall rd l k rs m,
wf_decomposition l ->
exists rs',
exec_straight ge fn (loadimm_n W rd l k) rs m k rs' m
/\ rs'#rd = Vint (Int.repr (Z.lnot (recompose_int 0 l)))
/\ forall r, r <> PC -> r <> rd -> rs'#r = rs#r. | Proof.
unfold loadimm_n; destruct 1.
- econstructor; split.
apply exec_straight_one. simpl; eauto. auto.
split. Simpl.
intros; Simpl.
- set (accu0 := Z.lnot (Zinsert 0 n p 16)).
set (rs1 := nextinstr (rs#rd <- (Vint (Int.repr accu0)))).
destruct (exec_loadimm_k_w rd k m (negate_decomposition l)
... | Lemma | exec_loadimm_n_w | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"Zinsert",
"Zinsert_0_l",
"exec_loadimm_k_w",
"exec_straight",
"exec_straight_opt_step",
"ge",
"loadimm_n",
"negate_decomposition",
"negate_decomposition_wf",
"nextinstr",
"recompose_int",
"recompose_int_negated",
"repr",
"set",
"wf_decomposition"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_loadimm32:
forall rd n k rs m,
exists rs',
exec_straight ge fn (loadimm32 rd n k) rs m k rs' m
/\ rs'#rd = Vint n
/\ forall r, r <> PC -> r <> rd -> rs'#r = rs#r. | Proof.
unfold loadimm32, loadimm; intros.
destruct (is_logical_imm32 n).
- econstructor; split.
apply exec_straight_one. simpl; eauto. auto.
split. Simpl. rewrite Int.repr_unsigned, Int.or_zero_l; auto.
intros; Simpl.
- set (dz := decompose_int 2%nat (Int.unsigned n) 0).
set (dn := decompose_int 2%nat (Z.ln... | Lemma | exec_loadimm32 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"decompose_int",
"decompose_int_eqmod",
"decompose_int_wf",
"decompose_notint_eqmod",
"eqm_samerepr",
"exec_loadimm_n_w",
"exec_loadimm_z_w",
"exec_straight",
"ge",
"is_logical_imm32",
"leb",
"loadimm",
"loadimm32",
"or_zero_l",
"recompose_int",
"repr",
"repr_unsigned",
... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_loadimm_k_x:
forall (rd: ireg) k m l,
wf_decomposition l ->
forall (rs: regset) accu,
rs#rd = Vlong (Int64.repr accu) ->
exists rs',
exec_straight_opt ge fn (loadimm_k X rd l k) rs m k rs' m
/\ rs'#rd = Vlong (Int64.repr (recompose_int accu l))
/\ forall r, r <> PC -> r <> rd -> rs'#r = rs#r. | Proof.
induction 1; intros rs accu ACCU; simpl.
- exists rs; split. apply exec_straight_opt_refl. auto.
- destruct (IHwf_decomposition
(nextinstr (rs#rd <- (insert_in_long rs#rd n p 16)))
(Zinsert accu n p 16))
as (rs' & P & Q & R).
Simpl. rewrite ACCU. simpl. f_equal. apply Int64.... | Lemma | exec_loadimm_k_x | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"Zinsert",
"Zinsert_eqmod",
"eqm_samerepr",
"eqm_sym",
"eqm_unsigned_repr",
"exec_straight_opt",
"exec_straight_opt_step_opt",
"ge",
"insert_in_long",
"ireg",
"loadimm_k",
"nextinstr",
"recompose_int",
"regset",
"repr",
"wf_decomposition"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_loadimm_z_x:
forall rd l k rs m,
wf_decomposition l ->
exists rs',
exec_straight ge fn (loadimm_z X rd l k) rs m k rs' m
/\ rs'#rd = Vlong (Int64.repr (recompose_int 0 l))
/\ forall r, r <> PC -> r <> rd -> rs'#r = rs#r. | Proof.
unfold loadimm_z; destruct 1.
- econstructor; split.
apply exec_straight_one. simpl; eauto. auto.
split. Simpl.
intros; Simpl.
- set (accu0 := Zinsert 0 n p 16).
set (rs1 := nextinstr (rs#rd <- (Vlong (Int64.repr accu0)))).
destruct (exec_loadimm_k_x rd k m l H1 rs1 accu0) as (rs2 & P & Q & R); auto.... | Lemma | exec_loadimm_z_x | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"Zinsert",
"Zinsert_0_l",
"exec_loadimm_k_x",
"exec_straight",
"exec_straight_opt_step",
"ge",
"loadimm_z",
"nextinstr",
"recompose_int",
"repr",
"set",
"wf_decomposition"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_loadimm_n_x:
forall rd l k rs m,
wf_decomposition l ->
exists rs',
exec_straight ge fn (loadimm_n X rd l k) rs m k rs' m
/\ rs'#rd = Vlong (Int64.repr (Z.lnot (recompose_int 0 l)))
/\ forall r, r <> PC -> r <> rd -> rs'#r = rs#r. | Proof.
unfold loadimm_n; destruct 1.
- econstructor; split.
apply exec_straight_one. simpl; eauto. auto.
split. Simpl.
intros; Simpl.
- set (accu0 := Z.lnot (Zinsert 0 n p 16)).
set (rs1 := nextinstr (rs#rd <- (Vlong (Int64.repr accu0)))).
destruct (exec_loadimm_k_x rd k m (negate_decomposition l)
... | Lemma | exec_loadimm_n_x | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"Zinsert",
"Zinsert_0_l",
"exec_loadimm_k_x",
"exec_straight",
"exec_straight_opt_step",
"ge",
"loadimm_n",
"negate_decomposition",
"negate_decomposition_wf",
"nextinstr",
"recompose_int",
"recompose_int_negated",
"repr",
"set",
"wf_decomposition"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_loadimm64:
forall rd n k rs m,
exists rs',
exec_straight ge fn (loadimm64 rd n k) rs m k rs' m
/\ rs'#rd = Vlong n
/\ forall r, r <> PC -> r <> rd -> rs'#r = rs#r. | Proof.
unfold loadimm64, loadimm; intros.
destruct (is_logical_imm64 n).
- econstructor; split.
apply exec_straight_one. simpl; eauto. auto.
split. Simpl. rewrite Int64.repr_unsigned, Int64.or_zero_l; auto.
intros; Simpl.
- set (dz := decompose_int 4%nat (Int64.unsigned n) 0).
set (dn := decompose_int 4%nat... | Lemma | exec_loadimm64 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"decompose_int",
"decompose_int_eqmod",
"decompose_int_wf",
"decompose_notint_eqmod",
"eqm_samerepr",
"exec_loadimm_n_x",
"exec_loadimm_z_x",
"exec_straight",
"ge",
"is_logical_imm64",
"leb",
"loadimm",
"loadimm64",
"or_zero_l",
"recompose_int",
"repr",
"repr_unsigned",
... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_addimm_aux_32:
forall (insn: iregsp -> iregsp -> Z -> instruction) (sem: val -> val -> val),
(forall rd r1 n rs m,
exec_instr ge fn (insn rd r1 n) rs m =
Next (nextinstr (rs#rd <- (sem rs#r1 (Vint (Int.repr n))))) m) ->
(forall v n1 n2, sem (sem v (Vint n1)) (Vint n2) = sem v (Vint (Int.add n1 n2))... | Proof.
intros insn sem SEM ASSOC; intros. unfold addimm_aux.
set (nlo := Zzero_ext 12 (Int.unsigned n)). set (nhi := Int.unsigned n - nlo).
assert (E: Int.unsigned n = nhi + nlo) by (unfold nhi; lia).
rewrite <- (Int.repr_unsigned n).
destruct (Z.eqb_spec nhi 0); [|destruct (Z.eqb_spec nlo 0)].
- econstructor... | Lemma | exec_addimm_aux_32 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"Zzero_ext",
"add",
"addimm_aux",
"data_preg",
"eqm_samerepr",
"exec_instr",
"exec_straight",
"exec_straight_two",
"ge",
"instruction",
"iregsp",
"nextinstr",
"repr",
"repr_unsigned",
"set",
"unsigned",
"val"
] | Add immediate | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
exec_addimm32:
forall rd r1 n k rs m,
r1 <> X16 ->
exists rs',
exec_straight ge fn (addimm32 rd r1 n k) rs m k rs' m
/\ rs'#rd = Val.add rs#r1 (Vint n)
/\ forall r, data_preg r = true -> r <> rd -> rs'#r = rs#r. | Proof.
intros. unfold addimm32. set (nn := Int.neg n).
destruct (Int.eq n (Int.zero_ext 24 n)); [| destruct (Int.eq nn (Int.zero_ext 24 nn))].
- apply exec_addimm_aux_32 with (sem := Val.add). auto. intros; apply Val.add_assoc.
- rewrite <- Val.sub_opp_add.
apply exec_addimm_aux_32 with (sem := Val.sub). auto.
... | Lemma | exec_addimm32 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"add",
"add_assoc",
"addimm32",
"data_preg",
"eq",
"exec_addimm_aux_32",
"exec_loadimm32",
"exec_straight",
"exec_straight_trans",
"fold",
"ge",
"lt",
"neg",
"neg_add_distr",
"set",
"sub",
"sub_add_opp",
"sub_opp_add",
"zero",
"zero_ext"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_addimm_aux_64:
forall (insn: iregsp -> iregsp -> Z -> instruction) (sem: val -> val -> val),
(forall rd r1 n rs m,
exec_instr ge fn (insn rd r1 n) rs m =
Next (nextinstr (rs#rd <- (sem rs#r1 (Vlong (Int64.repr n))))) m) ->
(forall v n1 n2, sem (sem v (Vlong n1)) (Vlong n2) = sem v (Vlong (Int64.add... | Proof.
intros insn sem SEM ASSOC; intros. unfold addimm_aux.
set (nlo := Zzero_ext 12 (Int64.unsigned n)). set (nhi := Int64.unsigned n - nlo).
assert (E: Int64.unsigned n = nhi + nlo) by (unfold nhi; lia).
rewrite <- (Int64.repr_unsigned n).
destruct (Z.eqb_spec nhi 0); [|destruct (Z.eqb_spec nlo 0)].
- econ... | Lemma | exec_addimm_aux_64 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"Zzero_ext",
"add",
"addimm_aux",
"data_preg",
"eqm_samerepr",
"exec_instr",
"exec_straight",
"exec_straight_two",
"ge",
"instruction",
"iregsp",
"nextinstr",
"repr",
"repr_unsigned",
"set",
"unsigned",
"val"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_addimm64:
forall rd r1 n k rs m,
preg_of_iregsp r1 <> X16 ->
exists rs',
exec_straight ge fn (addimm64 rd r1 n k) rs m k rs' m
/\ rs'#rd = Val.addl rs#r1 (Vlong n)
/\ forall r, data_preg r = true -> r <> rd -> rs'#r = rs#r. | Proof.
intros.
unfold addimm64. set (nn := Int64.neg n).
destruct (Int64.eq n (Int64.zero_ext 24 n)); [| destruct (Int64.eq nn (Int64.zero_ext 24 nn))].
- apply exec_addimm_aux_64 with (sem := Val.addl). auto. intros; apply Val.addl_assoc.
- rewrite <- Val.subl_opp_addl.
apply exec_addimm_aux_64 with (sem := ... | Lemma | exec_addimm64 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"addimm64",
"addl",
"addl_assoc",
"data_preg",
"eq",
"exec_addimm_aux_64",
"exec_loadimm64",
"exec_straight",
"exec_straight_trans",
"fold",
"ge",
"lt",
"neg",
"neg_add_distr",
"preg_of_iregsp",
"set",
"shl'_zero",
"subl",
"subl_addl_opp",
"subl_opp_addl",
"zero",
... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_logicalimm32:
forall (insn1: ireg -> ireg0 -> Z -> instruction)
(insn2: ireg -> ireg0 -> ireg -> shift_op -> instruction)
(sem: val -> val -> val),
(forall rd r1 n rs m,
exec_instr ge fn (insn1 rd r1 n) rs m =
Next (nextinstr (rs#rd <- (sem rs##r1 (Vint (Int.repr n))))) m) ->
(for... | Proof.
intros until sem; intros SEM1 SEM2; intros. unfold logicalimm32.
destruct (is_logical_imm32 n).
- econstructor; split.
apply exec_straight_one. apply SEM1. reflexivity.
split. Simpl. rewrite Int.repr_unsigned; auto. intros; Simpl.
- edestruct (exec_loadimm32 X16 n) as (rs1 & A & B & C).
econstructor;... | Lemma | exec_logicalimm32 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"data_preg",
"eval_shift_op_int",
"exec_instr",
"exec_loadimm32",
"exec_straight",
"exec_straight_trans",
"ge",
"instruction",
"ireg",
"ireg0",
"is_logical_imm32",
"logicalimm32",
"nextinstr",
"repr",
"repr_unsigned",
"shift_op",
"val"
] | Logical immediate | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
exec_logicalimm64:
forall (insn1: ireg -> ireg0 -> Z -> instruction)
(insn2: ireg -> ireg0 -> ireg -> shift_op -> instruction)
(sem: val -> val -> val),
(forall rd r1 n rs m,
exec_instr ge fn (insn1 rd r1 n) rs m =
Next (nextinstr (rs#rd <- (sem rs###r1 (Vlong (Int64.repr n))))) m) ->
... | Proof.
intros until sem; intros SEM1 SEM2; intros. unfold logicalimm64.
destruct (is_logical_imm64 n).
- econstructor; split.
apply exec_straight_one. apply SEM1. reflexivity.
split. Simpl. rewrite Int64.repr_unsigned. auto. intros; Simpl.
- edestruct (exec_loadimm64 X16 n) as (rs1 & A & B & C).
econstructo... | Lemma | exec_logicalimm64 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"data_preg",
"eval_shift_op_long",
"exec_instr",
"exec_loadimm64",
"exec_straight",
"exec_straight_trans",
"ge",
"instruction",
"ireg",
"ireg0",
"is_logical_imm64",
"logicalimm64",
"nextinstr",
"repr",
"repr_unsigned",
"shift_op",
"val"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_loadsymbol: forall rd s ofs k rs m,
rd <> X16 \/ SelectOp.symbol_is_relocatable s = false ->
exists rs',
exec_straight ge fn (loadsymbol rd s ofs k) rs m k rs' m
/\ rs'#rd = Genv.symbol_address ge s ofs
/\ forall r, data_preg r = true -> r <> rd -> rs'#r = rs#r. | Proof.
unfold loadsymbol; intros. destruct (SelectOp.symbol_is_relocatable s).
- predSpec Ptrofs.eq Ptrofs.eq_spec ofs Ptrofs.zero.
+ subst ofs. econstructor; split.
apply exec_straight_one; [simpl; eauto | reflexivity].
split. Simpl. intros; Simpl.
+ exploit exec_addimm64. instantiate (1 := rd). simpl. destruct ... | Lemma | exec_loadsymbol | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Genv",
"Simpl",
"add_zero_l",
"data_preg",
"eq",
"eq_spec",
"exec_addimm64",
"exec_straight",
"exec_straight_two",
"exploit",
"ge",
"loadsymbol",
"of_int64_to_int64",
"predSpec",
"shift_symbol_address_64",
"symbol_address",
"symbol_high_low",
"zero"
] | Load address of symbol | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
transl_shift_not_none:
forall s a, transl_shift s a <> SOnone. | Proof.
destruct s; intros; simpl; congruence.
Qed. | Remark | transl_shift_not_none | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"transl_shift"
] | Shifted operands | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
or_zero_eval_shift_op_int:
forall v s, s <> SOnone -> Val.or (Vint Int.zero) (eval_shift_op_int v s) = eval_shift_op_int v s. | Proof.
intros; destruct s; try congruence; destruct v; auto; simpl;
destruct (Int.ltu n Int.iwordsize); auto; rewrite Int.or_zero_l; auto.
Qed. | Remark | or_zero_eval_shift_op_int | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"eval_shift_op_int",
"iwordsize",
"ltu",
"or",
"or_zero_l",
"zero"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
or_zero_eval_shift_op_long:
forall v s, s <> SOnone -> Val.orl (Vlong Int64.zero) (eval_shift_op_long v s) = eval_shift_op_long v s. | Proof.
intros; destruct s; try congruence; destruct v; auto; simpl;
destruct (Int.ltu n Int64.iwordsize'); auto; rewrite Int64.or_zero_l; auto.
Qed. | Remark | or_zero_eval_shift_op_long | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"eval_shift_op_long",
"iwordsize'",
"ltu",
"or_zero_l",
"orl",
"zero"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
add_zero_eval_shift_op_long:
forall v s, s <> SOnone -> Val.addl (Vlong Int64.zero) (eval_shift_op_long v s) = eval_shift_op_long v s. | Proof.
intros; destruct s; try congruence; destruct v; auto; simpl;
destruct (Int.ltu n Int64.iwordsize'); auto; rewrite Int64.add_zero_l; auto.
Qed. | Remark | add_zero_eval_shift_op_long | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"add_zero_l",
"addl",
"eval_shift_op_long",
"iwordsize'",
"ltu",
"zero"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_eval_shift: forall s v (a: amount32),
eval_shift_op_int v (transl_shift s a) = eval_shift s v a. | Proof.
intros. destruct s; simpl; auto.
Qed. | Lemma | transl_eval_shift | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"amount32",
"eval_shift",
"eval_shift_op_int",
"transl_shift"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_eval_shift': forall s v (a: amount32),
Val.or (Vint Int.zero) (eval_shift_op_int v (transl_shift s a)) = eval_shift s v a. | Proof.
intros. rewrite or_zero_eval_shift_op_int by (apply transl_shift_not_none).
apply transl_eval_shift.
Qed. | Lemma | transl_eval_shift' | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"amount32",
"eval_shift",
"eval_shift_op_int",
"or",
"or_zero_eval_shift_op_int",
"transl_eval_shift",
"transl_shift",
"transl_shift_not_none",
"zero"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_eval_shiftl: forall s v (a: amount64),
eval_shift_op_long v (transl_shift s a) = eval_shiftl s v a. | Proof.
intros. destruct s; simpl; auto.
Qed. | Lemma | transl_eval_shiftl | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"amount64",
"eval_shift_op_long",
"eval_shiftl",
"transl_shift"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_eval_shiftl': forall s v (a: amount64),
Val.orl (Vlong Int64.zero) (eval_shift_op_long v (transl_shift s a)) = eval_shiftl s v a. | Proof.
intros. rewrite or_zero_eval_shift_op_long by (apply transl_shift_not_none).
apply transl_eval_shiftl.
Qed. | Lemma | transl_eval_shiftl' | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"amount64",
"eval_shift_op_long",
"eval_shiftl",
"or_zero_eval_shift_op_long",
"orl",
"transl_eval_shiftl",
"transl_shift",
"transl_shift_not_none",
"zero"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_eval_shiftl'': forall s v (a: amount64),
Val.addl (Vlong Int64.zero) (eval_shift_op_long v (transl_shift s a)) = eval_shiftl s v a. | Proof.
intros. rewrite add_zero_eval_shift_op_long by (apply transl_shift_not_none).
apply transl_eval_shiftl.
Qed. | Lemma | transl_eval_shiftl'' | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"add_zero_eval_shift_op_long",
"addl",
"amount64",
"eval_shift_op_long",
"eval_shiftl",
"transl_eval_shiftl",
"transl_shift",
"transl_shift_not_none",
"zero"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_move_extended_base: forall rd r1 ex k rs m,
exists rs',
exec_straight ge fn (move_extended_base rd r1 ex k) rs m k rs' m
/\ rs' rd = match ex with Xsgn32 => Val.longofint rs#r1 | Xuns32 => Val.longofintu rs#r1 end
/\ forall r, r <> PC -> r <> rd -> rs'#r = rs#r. | Proof.
unfold move_extended_base; destruct ex; econstructor;
(split; [apply exec_straight_one; [simpl;eauto|auto] | split; [Simpl|intros;Simpl]]).
Qed. | Lemma | exec_move_extended_base | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"exec_straight",
"ge",
"longofint",
"longofintu",
"move_extended_base"
] | Zero- and Sign- extensions | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
exec_move_extended: forall rd r1 ex (a: amount64) k rs m,
exists rs',
exec_straight ge fn (move_extended rd r1 ex a k) rs m k rs' m
/\ rs' rd = Op.eval_extend ex rs#r1 a
/\ forall r, r <> PC -> r <> rd -> rs'#r = rs#r. | Proof.
unfold move_extended; intros. predSpec Int.eq Int.eq_spec a Int.zero.
- exploit (exec_move_extended_base rd r1 ex). intros (rs' & A & B & C).
exists rs'; split. eexact A. split. unfold Op.eval_extend. rewrite H. rewrite B.
destruct ex, (rs r1); simpl; auto; rewrite Int64.shl'_zero; auto.
auto.
- Local Op... | Lemma | exec_move_extended | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"addl",
"amount64",
"eq",
"eq_spec",
"eval_extend",
"exec_instr",
"exec_move_extended_base",
"exec_straight",
"exec_straight_trans",
"exploit",
"ge",
"move_extended",
"predSpec",
"shl'_zero",
"transl_eval_shiftl''",
"transl_shift",
"zero"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_arith_extended:
forall (sem: val -> val -> val)
(insnX: iregsp -> iregsp -> ireg -> extend_op -> instruction)
(insnS: ireg -> ireg0 -> ireg -> shift_op -> instruction),
(forall rd r1 r2 x rs m,
exec_instr ge fn (insnX rd r1 r2 x) rs m =
Next (nextinstr (rs#rd <- (sem rs#r1 (eval_ext... | Proof.
intros sem insnX insnS EX ES; intros. unfold arith_extended. destruct (Int.ltu a (Int.repr 5)).
- econstructor; split.
apply exec_straight_one. rewrite EX; eauto. auto.
split. Simpl. f_equal. destruct ex; auto.
intros; Simpl.
- exploit (exec_move_extended_base X16 r2 ex). intros (rs' & A & B & C).
eco... | Lemma | exec_arith_extended | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"amount64",
"arith_extended",
"code",
"data_preg",
"eval_extend",
"eval_shift_op_long",
"exec_instr",
"exec_move_extended_base",
"exec_straight",
"exec_straight_trans",
"exploit",
"extend_op",
"extension",
"ge",
"instruction",
"ir0x",
"ireg",
"ireg0",
"iregsp",
"ltu"... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
exec_shrx32: forall (rd r1: ireg) (n: int) k v (rs: regset) m,
Val.shrx rs#r1 (Vint n) = Some v ->
r1 <> X16 ->
exists rs',
exec_straight ge fn (shrx32 rd r1 n k) rs m k rs' m
/\ rs'#rd = v
/\ forall r, data_preg r = true -> r <> rd -> rs'#r = rs#r. | Proof.
unfold shrx32; intros. apply Val.shrx_shr_2 in H.
destruct (Int.eq n Int.zero) eqn:E.
- econstructor; split. apply exec_straight_one; [simpl;eauto|auto].
split. Simpl. subst v; auto. intros; Simpl.
- econstructor; split. eapply exec_straight_three.
unfold exec_instr. rewrite or_zero_eval_shift_op_int by... | Lemma | exec_shrx32 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"data_preg",
"eq",
"exec_instr",
"exec_straight",
"exec_straight_three",
"ge",
"int",
"ireg",
"or_zero_eval_shift_op_int",
"regset",
"shrx",
"shrx32",
"shrx_shr_2",
"zero"
] | Extended right shift | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
exec_shrx64: forall (rd r1: ireg) (n: int) k v (rs: regset) m,
Val.shrxl rs#r1 (Vint n) = Some v ->
r1 <> X16 ->
exists rs',
exec_straight ge fn (shrx64 rd r1 n k) rs m k rs' m
/\ rs'#rd = v
/\ forall r, data_preg r = true -> r <> rd -> rs'#r = rs#r. | Proof.
unfold shrx64; intros. apply Val.shrxl_shrl_2 in H.
destruct (Int.eq n Int.zero) eqn:E.
- econstructor; split. apply exec_straight_one; [simpl;eauto|auto].
split. Simpl. subst v; auto. intros; Simpl.
- econstructor; split. eapply exec_straight_three.
unfold exec_instr. rewrite or_zero_eval_shift_op_long... | Lemma | exec_shrx64 | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"data_preg",
"eq",
"exec_instr",
"exec_straight",
"exec_straight_three",
"ge",
"int",
"ireg",
"or_zero_eval_shift_op_long",
"regset",
"shrx64",
"shrxl",
"shrxl_shrl_2",
"zero"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
compare_int_spec: forall rs v1 v2 m,
let rs' := compare_int rs v1 v2 m in
rs'#CN = (Val.negative (Val.sub v1 v2))
/\ rs'#CZ = (Val.cmpu (Mem.valid_pointer m) Ceq v1 v2)
/\ rs'#CC = (Val.cmpu (Mem.valid_pointer m) Cge v1 v2)
/\ rs'#CV = (Val.sub_overflow v1 v2). | Proof.
intros; unfold rs'; auto.
Qed. | Lemma | compare_int_spec | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmpu",
"compare_int",
"negative",
"sub",
"sub_overflow",
"valid_pointer"
] | Condition bits | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
eval_testcond_compare_sint: forall c v1 v2 b rs m,
Val.cmp_bool c v1 v2 = Some b ->
eval_testcond (cond_for_signed_cmp c) (compare_int rs v1 v2 m) = Some b. | Proof.
intros. generalize (compare_int_spec rs v1 v2 m).
set (rs' := compare_int rs v1 v2 m). intros (B & C & D & E).
unfold eval_testcond; rewrite B, C, D, E.
destruct v1; try discriminate; destruct v2; try discriminate.
simpl in H; inv H.
unfold Val.cmpu; simpl. destruct c; simpl.
- destruct (Int.eq i i0... | Lemma | eval_testcond_compare_sint | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmp_bool",
"cmpu",
"compare_int",
"compare_int_spec",
"cond_for_signed_cmp",
"eq",
"eval_testcond",
"inv",
"lt",
"lt_not",
"lt_sub_overflow",
"not_lt",
"set"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
eval_testcond_compare_uint: forall c v1 v2 b rs m,
Val.cmpu_bool (Mem.valid_pointer m) c v1 v2 = Some b ->
eval_testcond (cond_for_unsigned_cmp c) (compare_int rs v1 v2 m) = Some b. | Proof.
intros. generalize (compare_int_spec rs v1 v2 m).
set (rs' := compare_int rs v1 v2 m). intros (B & C & D & E).
unfold eval_testcond; rewrite B, C, D, E.
destruct v1; try discriminate; destruct v2; try discriminate.
simpl in H; inv H.
unfold Val.cmpu; simpl. destruct c; simpl.
- destruct (Int.eq i i0... | Lemma | eval_testcond_compare_uint | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmpu",
"cmpu_bool",
"compare_int",
"compare_int_spec",
"cond_for_unsigned_cmp",
"eq",
"eval_testcond",
"inv",
"ltu",
"ltu_not",
"not_ltu",
"set",
"valid_pointer"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
compare_long_spec: forall rs v1 v2 m,
let rs' := compare_long rs v1 v2 m in
rs'#CN = (Val.negativel (Val.subl v1 v2))
/\ rs'#CZ = (Val.maketotal (Val.cmplu (Mem.valid_pointer m) Ceq v1 v2))
/\ rs'#CC = (Val.maketotal (Val.cmplu (Mem.valid_pointer m) Cge v1 v2))
/\ rs'#CV = (Val.subl_overflow v1 v2). | Proof.
intros; unfold rs'; auto.
Qed. | Lemma | compare_long_spec | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmplu",
"compare_long",
"maketotal",
"negativel",
"subl",
"subl_overflow",
"valid_pointer"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
int64_sub_overflow:
forall x y,
Int.xor (Int.repr (Int64.unsigned (Int64.sub_overflow x y Int64.zero)))
(Int.repr (Int64.unsigned (Int64.negative (Int64.sub x y)))) =
(if Int64.lt x y then Int.one else Int.zero). | Proof.
intros.
transitivity (Int.repr (Int64.unsigned (if Int64.lt x y then Int64.one else Int64.zero))).
rewrite <- (Int64.lt_sub_overflow x y).
unfold Int64.sub_overflow, Int64.negative.
set (s := Int64.signed x - Int64.signed y - Int64.signed Int64.zero).
destruct (zle Int64.min_signed s && zle s Int64.m... | Remark | int64_sub_overflow | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"lt",
"lt_sub_overflow",
"max_signed",
"min_signed",
"negative",
"one",
"repr",
"set",
"signed",
"sub",
"sub_overflow",
"unsigned",
"xor",
"zero",
"zle"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
eval_testcond_compare_slong: forall c v1 v2 b rs m,
Val.cmpl_bool c v1 v2 = Some b ->
eval_testcond (cond_for_signed_cmp c) (compare_long rs v1 v2 m) = Some b. | Proof.
intros. generalize (compare_long_spec rs v1 v2 m).
set (rs' := compare_long rs v1 v2 m). intros (B & C & D & E).
unfold eval_testcond; rewrite B, C, D, E.
destruct v1; try discriminate; destruct v2; try discriminate.
simpl in H; inv H.
unfold Val.cmplu; simpl. destruct c; simpl.
- destruct (Int64.eq... | Lemma | eval_testcond_compare_slong | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmpl_bool",
"cmplu",
"compare_long",
"compare_long_spec",
"cond_for_signed_cmp",
"eq",
"eval_testcond",
"int64_sub_overflow",
"inv",
"lt",
"lt_not",
"not_lt",
"set"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
eval_testcond_compare_ulong: forall c v1 v2 b rs m,
Val.cmplu_bool (Mem.valid_pointer m) c v1 v2 = Some b ->
eval_testcond (cond_for_unsigned_cmp c) (compare_long rs v1 v2 m) = Some b. | Proof.
intros. generalize (compare_long_spec rs v1 v2 m).
set (rs' := compare_long rs v1 v2 m). intros (B & C & D & E).
unfold eval_testcond; rewrite B, C, D, E; unfold Val.cmplu.
destruct v1; try discriminate; destruct v2; try discriminate; simpl in H.
- (* int-int *)
inv H. destruct c; simpl.
+ destruct (I... | Lemma | eval_testcond_compare_ulong | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmplu",
"cmplu_bool",
"compare_long",
"compare_long_spec",
"cond_for_unsigned_cmp",
"eq",
"eq_block",
"eval_testcond",
"inv",
"ltu",
"ltu_not",
"not_ltu",
"set",
"unsigned",
"valid_pointer",
"zero"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
compare_float_spec: forall rs f1 f2,
let rs' := compare_float rs (Vfloat f1) (Vfloat f2) in
rs'#CN = (Val.of_bool (Float.cmp Clt f1 f2))
/\ rs'#CZ = (Val.of_bool (Float.cmp Ceq f1 f2))
/\ rs'#CC = (Val.of_bool (negb (Float.cmp Clt f1 f2)))
/\ rs'#CV = (Val.of_bool (negb (Float.ordered f1 f2))). | Proof.
intros; auto.
Qed. | Lemma | compare_float_spec | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmp",
"compare_float",
"of_bool",
"ordered"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
eval_testcond_compare_float: forall c v1 v2 b rs,
Val.cmpf_bool c v1 v2 = Some b ->
eval_testcond (cond_for_float_cmp c) (compare_float rs v1 v2) = Some b. | Proof.
intros. destruct v1; try discriminate; destruct v2; simpl in H; inv H.
generalize (compare_float_spec rs f f0).
set (rs' := compare_float rs (Vfloat f) (Vfloat f0)).
intros (B & C & D & E).
unfold eval_testcond; rewrite B, C, D, E.
Local Transparent Float.cmp Float.ordered.
unfold Float.cmp, Float.... | Lemma | eval_testcond_compare_float | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmp",
"cmpf_bool",
"compare",
"compare_float",
"compare_float_spec",
"cond_for_float_cmp",
"eval_testcond",
"inv",
"ordered",
"set"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
eval_testcond_compare_not_float: forall c v1 v2 b rs,
option_map negb (Val.cmpf_bool c v1 v2) = Some b ->
eval_testcond (cond_for_float_not_cmp c) (compare_float rs v1 v2) = Some b. | Proof.
intros. destruct v1; try discriminate; destruct v2; simpl in H; inv H.
generalize (compare_float_spec rs f f0).
set (rs' := compare_float rs (Vfloat f) (Vfloat f0)).
intros (B & C & D & E).
unfold eval_testcond; rewrite B, C, D, E.
Local Transparent Float.cmp Float.ordered.
unfold Float.cmp, Float.o... | Lemma | eval_testcond_compare_not_float | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmp",
"cmpf_bool",
"compare",
"compare_float",
"compare_float_spec",
"cond_for_float_not_cmp",
"eval_testcond",
"inv",
"option_map",
"ordered",
"set"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
compare_single_spec: forall rs f1 f2,
let rs' := compare_single rs (Vsingle f1) (Vsingle f2) in
rs'#CN = (Val.of_bool (Float32.cmp Clt f1 f2))
/\ rs'#CZ = (Val.of_bool (Float32.cmp Ceq f1 f2))
/\ rs'#CC = (Val.of_bool (negb (Float32.cmp Clt f1 f2)))
/\ rs'#CV = (Val.of_bool (negb (Float32.ordered f1 f2))). | Proof.
intros; auto.
Qed. | Lemma | compare_single_spec | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmp",
"compare_single",
"of_bool",
"ordered"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
eval_testcond_compare_single: forall c v1 v2 b rs,
Val.cmpfs_bool c v1 v2 = Some b ->
eval_testcond (cond_for_float_cmp c) (compare_single rs v1 v2) = Some b. | Proof.
intros. destruct v1; try discriminate; destruct v2; simpl in H; inv H.
generalize (compare_single_spec rs f f0).
set (rs' := compare_single rs (Vsingle f) (Vsingle f0)).
intros (B & C & D & E).
unfold eval_testcond; rewrite B, C, D, E.
Local Transparent Float32.cmp Float32.ordered.
unfold Float32.c... | Lemma | eval_testcond_compare_single | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmp",
"cmpfs_bool",
"compare",
"compare_single",
"compare_single_spec",
"cond_for_float_cmp",
"eval_testcond",
"inv",
"ordered",
"set"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
eval_testcond_compare_not_single: forall c v1 v2 b rs,
option_map negb (Val.cmpfs_bool c v1 v2) = Some b ->
eval_testcond (cond_for_float_not_cmp c) (compare_single rs v1 v2) = Some b. | Proof.
intros. destruct v1; try discriminate; destruct v2; simpl in H; inv H.
generalize (compare_single_spec rs f f0).
set (rs' := compare_single rs (Vsingle f) (Vsingle f0)).
intros (B & C & D & E).
unfold eval_testcond; rewrite B, C, D, E.
Local Transparent Float32.cmp Float32.ordered.
unfold Float32.cm... | Lemma | eval_testcond_compare_not_single | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"cmp",
"cmpfs_bool",
"compare",
"compare_single",
"compare_single_spec",
"cond_for_float_not_cmp",
"eval_testcond",
"inv",
"option_map",
"ordered",
"set"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
compare_float_inv: forall rs v1 v2 r,
match r with CR _ => False | _ => True end ->
(nextinstr (compare_float rs v1 v2))#r = (nextinstr rs)#r. | Proof.
intros; unfold compare_float.
destruct r; try contradiction; destruct v1; auto; destruct v2; auto.
Qed. | Remark | compare_float_inv | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"CR",
"compare_float",
"nextinstr"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
compare_single_inv: forall rs v1 v2 r,
match r with CR _ => False | _ => True end ->
(nextinstr (compare_single rs v1 v2))#r = (nextinstr rs)#r. | Proof.
intros; unfold compare_single.
destruct r; try contradiction; destruct v1; auto; destruct v2; auto.
Qed. | Remark | compare_single_inv | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"CR",
"compare_single",
"nextinstr"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
ArgsInv | :=
repeat (match goal with
| [ H: Error _ = OK _ |- _ ] => discriminate
| [ H: match ?args with nil => _ | _ :: _ => _ end = OK _ |- _ ] => destruct args
| [ H: bind _ _ = OK _ |- _ ] => monadInv H
| [ H: match _ with left _ => _ | right _ => assertion_failed end = OK _ |- _ ] => monadInv H; ArgsInv
| [ H: ... | Ltac | ArgsInv | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"assertion_failed",
"bind",
"freg_of",
"freg_of_eq",
"ireg_of",
"ireg_of_eq",
"monadInv"
] | Translation of conditionals | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
transl_cond_correct:
forall cond args k c rs m,
transl_cond cond args k = OK c ->
exists rs',
exec_straight ge fn c rs m k rs' m
/\ (forall b,
eval_condition cond (map rs (map preg_of args)) m = Some b ->
eval_testcond (cond_for_cond cond) rs' = Some b)
/\ forall r, data_preg r = true -> rs'#... | Proof.
intros until m; intros TR. destruct cond; simpl in TR; ArgsInv.
- (* Ccomp *)
econstructor; split. apply exec_straight_one. simpl; eauto. auto.
split; intros. apply eval_testcond_compare_sint; auto.
destruct r; reflexivity || discriminate.
- (* Ccompu *)
econstructor; split. apply exec_straight_one. s... | Lemma | transl_cond_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"ArgsInv",
"compare_float_inv",
"compare_single_inv",
"cond_for_cond",
"data_preg",
"eval_condition",
"eval_testcond",
"eval_testcond_compare_float",
"eval_testcond_compare_not_float",
"eval_testcond_compare_not_single",
"eval_testcond_compare_single",
"eval_testcond_compare_sint",
"eval_tes... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_cond_branch_correct:
forall cond args lbl k c rs m b,
transl_cond_branch cond args lbl k = OK c ->
eval_condition cond (map rs (map preg_of args)) m = Some b ->
exists rs' insn,
exec_straight_opt ge fn c rs m (insn :: k) rs' m
/\ exec_instr ge fn insn rs' m =
(if b then goto_label fn lbl ... | Proof.
intros until b; intros TR EV.
assert (DFL:
transl_cond_branch_default cond args lbl k = OK c ->
exists rs' insn,
exec_straight_opt ge fn c rs m (insn :: k) rs' m
/\ exec_instr ge fn insn rs' m =
(if b then goto_label fn lbl rs' m else Next (nextinstr rs') m)
/\ forall r, data_... | Lemma | transl_cond_branch_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"ArgsInv",
"cond_for_cond",
"data_preg",
"eq",
"eval_condition",
"exec_instr",
"exec_straight_opt",
"exploit",
"ge",
"goto_label",
"inv",
"is_power2",
"is_power2'",
"map",
"mul_commut",
"mul_one",
"mul_pow2",
"mul_pow2'",
"negate_cmp_bool",
"negate_cmpl_bool",
"negate_cmplu_b... | Translation of conditional branches | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
SimplEval H | :=
match type of H with
| Some _ = None _ => discriminate
| Some _ = Some _ => inv H
| ?a = Some ?b => let A := fresh in assert (A: Val.maketotal a = b) by (rewrite H; reflexivity)
end. | Ltac | SimplEval | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"inv",
"maketotal",
"type"
] | Translation of arithmetic operations | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
TranslOpSimpl | :=
econstructor; split;
[ apply exec_straight_one; [simpl; eauto | reflexivity]
| split; [ rewrite ? transl_eval_shift, ? transl_eval_shiftl;
apply Val.lessdef_same; Simpl; fail
| intros; Simpl; fail ] ]. | Ltac | TranslOpSimpl | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"lessdef_same",
"transl_eval_shift",
"transl_eval_shiftl"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
TranslOpBase | :=
econstructor; split;
[ apply exec_straight_one; [simpl; eauto | reflexivity]
| split; [ rewrite ? transl_eval_shift, ? transl_eval_shiftl; Simpl
| intros; Simpl; fail ] ]. | Ltac | TranslOpBase | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"Simpl",
"transl_eval_shift",
"transl_eval_shiftl"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_op_correct:
forall op args res k (rs: regset) m v c,
transl_op op args res k = OK c ->
eval_operation ge (rs#SP) op (map rs (map preg_of args)) m = Some v ->
exists rs',
exec_straight ge fn c rs m k rs' m
/\ Val.lessdef v rs'#(preg_of res)
/\ forall r, data_preg r = true -> r <> preg_of res -> p... | Proof.
Local Opaque Int.eq Int64.eq Val.add Val.addl Int.zwordsize Int64.zwordsize.
intros until c; intros TR EV.
unfold transl_op in TR; destruct op; ArgsInv; simpl in EV; SimplEval EV; try TranslOpSimpl.
- (* move *)
destruct (preg_of res) eqn:RR; try discriminate; destruct (preg_of m0) eqn:R1; inv TR.
+ Transl... | Lemma | transl_op_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"ArgsInv",
"SP",
"Simpl",
"SimplEval",
"TranslOpBase",
"TranslOpSimpl",
"add",
"add_zero_l",
"addl",
"data_preg",
"destroyed_by_op",
"eq",
"eq_dec",
"eval_condition",
"eval_operation",
"eval_shift",
"eval_shiftl",
"exec_addimm32",
"exec_addimm64",
"exec_arith_extended",
"exec... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_addressing_correct:
forall sz addr args (insn: Asm.addressing -> instruction) k (rs: regset) m c b o,
transl_addressing sz addr args insn k = OK c ->
Op.eval_addressing ge (rs#SP) addr (map rs (map preg_of args)) = Some (Vptr b o) ->
exists ad rs',
exec_straight_opt ge fn c rs m (insn ad :: k) rs' m... | Proof.
intros until o; intros TR EV.
unfold transl_addressing in TR; destruct addr; ArgsInv; SimplEval EV.
- (* Aindexed *)
destruct (offset_representable sz ofs); inv EQ0.
+ econstructor; econstructor; split. apply exec_straight_opt_refl.
auto.
+ exploit (exec_loadimm64 X16 ofs). intros (rs' & A & B & C).
ec... | Lemma | transl_addressing_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"ArgsInv",
"Genv",
"SP",
"Simpl",
"SimplEval",
"add_zero",
"addl",
"addl_assoc",
"addl_commut",
"addressing",
"data_preg",
"eq",
"eval_addressing",
"eval_extend",
"exec_arith_extended",
"exec_loadimm64",
"exec_loadsymbol",
"exec_straight_opt",
"exploit",
"ge",
"instruction",
... | Translation of addressing modes, loads, stores | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
transl_load_correct:
forall chunk addr args dst k c (rs: regset) m vaddr v,
transl_load chunk addr args dst k = OK c ->
Op.eval_addressing ge (rs#SP) addr (map rs (map preg_of args)) = Some vaddr ->
Mem.loadv chunk m vaddr = Some v ->
exists rs',
exec_straight ge fn c rs m k rs' m
/\ rs'#(preg_of dst) ... | Proof.
intros. destruct vaddr; try discriminate.
assert (A: exists sz insn,
transl_addressing sz addr args insn k = OK c
/\ (forall ad rs', exec_instr ge fn (insn ad) rs' m =
exec_load ge chunk (fun v => v) ad (preg_of dst) rs' m)).
{
destruct chunk;... | Lemma | transl_load_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"SP",
"Simpl",
"data_preg",
"eval_addressing",
"exec_instr",
"exec_load",
"exec_straight",
"exec_straight_opt_right",
"exploit",
"freg_of_eq",
"ge",
"ireg_of_eq",
"loadv",
"map",
"monadInv",
"nextinstr",
"preg_of",
"regset",
"transl_addressing",
"transl_addressing_correct",
"... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
transl_store_correct:
forall chunk addr args src k c (rs: regset) m vaddr m',
transl_store chunk addr args src k = OK c ->
Op.eval_addressing ge (rs#SP) addr (map rs (map preg_of args)) = Some vaddr ->
Mem.storev chunk m vaddr rs#(preg_of src) = Some m' ->
exists rs',
exec_straight ge fn c rs m k rs' m'
... | Proof.
intros. destruct vaddr; try discriminate.
assert (A: exists sz insn,
transl_addressing sz addr args insn k = OK c
/\ (forall ad rs', exec_instr ge fn (insn ad) rs' m =
exec_store ge chunk ad rs'#(preg_of src) rs' m)).
{ destruct chunk; monadInv H;... | Lemma | transl_store_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"SP",
"Simpl",
"data_preg",
"eval_addressing",
"exec_instr",
"exec_store",
"exec_straight",
"exec_straight_opt_right",
"exploit",
"freg_of_eq",
"ge",
"ireg_of_eq",
"map",
"monadInv",
"nextinstr",
"preg_of",
"regset",
"storev",
"transl_addressing",
"transl_addressing_correct",
... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
indexed_memory_access_correct: forall insn sz (base: iregsp) ofs k (rs: regset) m b i,
preg_of_iregsp base <> IR X16 ->
Val.offset_ptr rs#base ofs = Vptr b i ->
exists ad rs',
exec_straight_opt ge fn (indexed_memory_access insn sz base ofs k) rs m (insn ad :: k) rs' m
/\ Asm.eval_addressing ge ad rs' = Vpt... | Proof.
unfold indexed_memory_access; intros.
assert (Val.addl rs#base (Vlong (Ptrofs.to_int64 ofs)) = Vptr b i).
{ destruct (rs base); try discriminate. simpl in *. rewrite Ptrofs.of_int64_to_int64 by auto. auto. }
destruct offset_representable.
- econstructor; econstructor; split. apply exec_straight_opt_refl.... | Lemma | indexed_memory_access_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"IR",
"addl",
"eval_addressing",
"exec_loadimm64",
"exec_straight_opt",
"exploit",
"ge",
"indexed_memory_access",
"iregsp",
"of_int64_to_int64",
"offset_ptr",
"offset_representable",
"preg_of_iregsp",
"regset",
"to_int64"
] | Translation of indexed memory accesses | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
loadptr_correct: forall (base: iregsp) ofs dst k m v (rs: regset),
Mem.loadv Mint64 m (Val.offset_ptr rs#base ofs) = Some v ->
preg_of_iregsp base <> IR X16 ->
exists rs',
exec_straight ge fn (loadptr base ofs dst k) rs m k rs' m
/\ rs'#dst = v
/\ forall r, r <> PC -> r <> X16 -> r <> dst -> rs' r = rs r... | Proof.
intros.
destruct (Val.offset_ptr rs#base ofs) eqn:V; try discriminate.
exploit indexed_memory_access_correct; eauto. intros (ad & rs' & A & B & C).
econstructor; split.
eapply exec_straight_opt_right. eexact A.
apply exec_straight_one. simpl. unfold exec_load. rewrite B, H. eauto. auto.
split. Si... | Lemma | loadptr_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"IR",
"Simpl",
"exec_load",
"exec_straight",
"exec_straight_opt_right",
"exploit",
"ge",
"indexed_memory_access_correct",
"iregsp",
"loadptr",
"loadv",
"offset_ptr",
"preg_of_iregsp",
"regset"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
storeptr_correct: forall (base: iregsp) ofs (src: ireg) k m m' (rs: regset),
Mem.storev Mint64 m (Val.offset_ptr rs#base ofs) rs#src = Some m' ->
preg_of_iregsp base <> IR X16 ->
src <> X16 ->
exists rs',
exec_straight ge fn (storeptr src base ofs k) rs m k rs' m'
/\ forall r, r <> PC -> r <> X16 -> rs' ... | Proof.
intros.
destruct (Val.offset_ptr rs#base ofs) eqn:V; try discriminate.
exploit indexed_memory_access_correct; eauto. intros (ad & rs' & A & B & C).
econstructor; split.
eapply exec_straight_opt_right. eexact A.
apply exec_straight_one. simpl. unfold exec_store. rewrite B, C, H by eauto with asmgen.... | Lemma | storeptr_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"IR",
"Simpl",
"exec_store",
"exec_straight",
"exec_straight_opt_right",
"exploit",
"ge",
"indexed_memory_access_correct",
"ireg",
"iregsp",
"offset_ptr",
"preg_of_iregsp",
"regset",
"storeptr",
"storev"
] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
loadind_correct: forall (base: iregsp) ofs ty dst k c (rs: regset) m v,
loadind base ofs ty dst k = OK c ->
Mem.loadv (chunk_of_type ty) m (Val.offset_ptr rs#base ofs) = Some v ->
preg_of_iregsp base <> IR X16 ->
exists rs',
exec_straight ge fn c rs m k rs' m
/\ rs'#(preg_of dst) = v
/\ forall r, data_... | Proof.
intros.
destruct (Val.offset_ptr rs#base ofs) eqn:V; try discriminate.
assert (X: exists sz insn,
c = indexed_memory_access insn sz base ofs k
/\ (forall ad rs', exec_instr ge fn (insn ad) rs' m =
exec_load ge (chunk_of_type ty) (fun v => v) ad (p... | Lemma | loadind_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"IR",
"Simpl",
"chunk_of_type",
"data_preg",
"exec_instr",
"exec_load",
"exec_straight",
"exec_straight_opt_right",
"exploit",
"ge",
"indexed_memory_access",
"indexed_memory_access_correct",
"inv",
"iregsp",
"loadind",
"loadv",
"offset_ptr",
"preg_of",
"preg_of_iregsp",
"regset... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
storeind_correct: forall (base: iregsp) ofs ty src k c (rs: regset) m m',
storeind src base ofs ty k = OK c ->
Mem.storev (chunk_of_type ty) m (Val.offset_ptr rs#base ofs) rs#(preg_of src) = Some m' ->
preg_of_iregsp base <> IR X16 ->
exists rs',
exec_straight ge fn c rs m k rs' m'
/\ forall r, data_preg... | Proof.
intros.
destruct (Val.offset_ptr rs#base ofs) eqn:V; try discriminate.
assert (X: exists sz insn,
c = indexed_memory_access insn sz base ofs k
/\ (forall ad rs', exec_instr ge fn (insn ad) rs' m =
exec_store ge (chunk_of_type ty) ad rs'#(preg_of s... | Lemma | storeind_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"IR",
"Simpl",
"chunk_of_type",
"data_preg",
"exec_instr",
"exec_store",
"exec_straight",
"exec_straight_opt_right",
"exploit",
"ge",
"indexed_memory_access",
"indexed_memory_access_correct",
"inv",
"iregsp",
"offset_ptr",
"preg_of",
"preg_of_iregsp",
"regset",
"storeind",
"sto... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
make_epilogue_correct:
forall ge0 f m stk soff cs m' ms rs k tm,
load_stack m (Vptr stk soff) Tptr f.(fn_link_ofs) = Some (parent_sp cs) ->
load_stack m (Vptr stk soff) Tptr f.(fn_retaddr_ofs) = Some (parent_ra cs) ->
Mem.free m stk 0 f.(fn_stacksize) = Some m' ->
agree ms (Vptr stk soff) rs ->
Mem.extends ... | Proof.
intros until tm; intros LP LRA FREE AG MEXT MCS.
exploit Mem.loadv_extends. eauto. eexact LP. auto. simpl. intros (parent' & LP' & LDP').
exploit Mem.loadv_extends. eauto. eexact LRA. auto. simpl. intros (ra' & LRA' & LDRA').
exploit lessdef_parent_sp; eauto. intros EQ; subst parent'; clear LDP'.
explo... | Lemma | make_epilogue_correct | aarch64 | aarch64/Asmgenproof1.v | [
"Coq",
"Recdef",
"Zwf",
"Zbits",
"Coqlib",
"Maps",
"Errors",
"AST",
"Integers",
"Floats",
"Values",
"Memory",
"Globalenvs",
"Op",
"Locations",
"Mach",
"Asm",
"Conventions",
"Asmgen",
"Asmgenproof0"
] | [
"FREE",
"SP",
"Simpl",
"Tptr",
"agree",
"agree_change_sp",
"agree_exten",
"agree_nextinstr",
"agree_set_other",
"exec_straight",
"exec_straight_trans",
"exploit",
"extends",
"free",
"free_parallel_extends",
"ge",
"lessdef_parent_ra",
"lessdef_parent_sp",
"load_stack",
"loadptr_... | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 | |
platform_builtin : Type | := . | Inductive | platform_builtin | aarch64 | aarch64/Builtins1.v | [
"Coq",
"String",
"Coqlib",
"AST",
"Integers",
"Floats",
"Values",
"Builtins0"
] | [] | https://github.com/AbsInt/CompCert | 0ef26dad76446c803da02d7368eb4f9d074c1401 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.