phanerozoic/Coq-CompCert · Datasets at Hugging Face

fact stringlengths 7 4.84k	type stringclasses 18 values	library stringclasses 14 values	imports listlengths 0 27	filename stringclasses 205 values	symbolic_name stringlengths 1 49	docstring stringlengths 6 2.5k ⌀
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: ...	Inductive	aarch64	[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]	aarch64/Asmgenproof.v	match_states	Semantic preservation is proved using simulation diagrams of the following form. << st1 --------------- st2 \| \| t\| *\|t \| \| v v st1'--------------- st2' >> The invariant is the ...
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...	Lemma	aarch64	[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]	aarch64/Asmgenproof.v	exec_straight_steps	null
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...	Lemma	aarch64	[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]	aarch64/Asmgenproof.v	exec_straight_steps_goto	null
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...	Lemma	aarch64	[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]	aarch64/Asmgenproof.v	exec_straight_opt_steps_goto	null
measure (s: Mach.state) : nat := match s with \| Mach.State _ _ _ _ _ _ => 0%nat \| Mach.Callstate _ _ _ _ => 0%nat \| Mach.Returnstate _ _ _ => 1%nat end.	Definition	aarch64	[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]	aarch64/Asmgenproof.v	measure	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...
preg_of_not_X15: forall r, negb (mreg_eq r R15) = true -> IR X15 <> preg_of r.	Remark	aarch64	[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]	aarch64/Asmgenproof.v	preg_of_not_X15	null
sp_val': forall ms sp rs, agree ms sp rs -> sp = rs XSP.	Lemma	aarch64	[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]	aarch64/Asmgenproof.v	sp_val	null
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.	Theorem	aarch64	[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]	aarch64/Asmgenproof.v	step_simulation	This is the simulation diagram. We prove it by case analysis on the Mach transition.
transf_initial_states: forall st1, Mach.initial_state prog st1 -> exists st2, Asm.initial_state tprog st2 /\ match_states st1 st2.	Lemma	aarch64	[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]	aarch64/Asmgenproof.v	transf_initial_states	null
transf_final_states: forall st1 st2 r, match_states st1 st2 -> Mach.final_state st1 r -> Asm.final_state st2 r.	Lemma	aarch64	[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]	aarch64/Asmgenproof.v	transf_final_states	null
transf_program_correct: forward_simulation (Mach.semantics return_address_offset prog) (Asm.semantics tprog).	Theorem	aarch64	[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]	aarch64/Asmgenproof.v	transf_program_correct	null
preg_of_iregsp_not_PC: forall r, preg_of_iregsp r <> PC.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	preg_of_iregsp_not_PC	Properties of registers
preg_of_not_X16: forall r, preg_of r <> X16.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	preg_of_not_X16	null
ireg_of_not_X16: forall r x, ireg_of r = OK x -> x <> X16.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	ireg_of_not_X16	null
ireg_of_not_X16': forall r x, ireg_of r = OK x -> IR x <> IR X16.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	ireg_of_not_X16	null
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	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	wf_decomposition	Decomposition of integer literals
decompose_int_wf: forall N n p, 0 <= p -> wf_decomposition (decompose_int N n p).	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	decompose_int_wf	null
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	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	recompose_int	null
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).	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	decompose_int_correct	null
decompose_int_eqmod: forall N n, eqmod (two_power_nat (N * 16)%nat) (recompose_int 0 (decompose_int N n 0)) n.	Corollary	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	decompose_int_eqmod	null
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.	Corollary	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	decompose_notint_eqmod	null
negate_decomposition_wf: forall l, wf_decomposition l -> wf_decomposition (negate_decomposition l).	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	negate_decomposition_wf	null
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).	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	Zinsert_eqmod	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	Zinsert_0_l	null
recompose_int_negated: forall l, wf_decomposition l -> forall accu, recompose_int (Z.lnot accu) (negate_decomposition l) = Z.lnot (recompose_int accu l).	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	recompose_int_negated	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_loadimm_k_w	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_loadimm_z_w	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_loadimm_n_w	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_loadimm32	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_loadimm_k_x	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_loadimm_z_x	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_loadimm_n_x	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_loadimm64	null
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))...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_addimm_aux_32	Add immediate
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_addimm32	null
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...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_addimm_aux_64	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_addimm64	null
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...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_logicalimm32	Logical immediate
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) -> ...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_logicalimm64	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_loadsymbol	Load address of symbol
transl_shift_not_none: forall s a, transl_shift s a <> SOnone.	Remark	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_shift_not_none	Shifted operands
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.	Remark	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	or_zero_eval_shift_op_int	null
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.	Remark	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	or_zero_eval_shift_op_long	null
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.	Remark	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	add_zero_eval_shift_op_long	null
transl_eval_shift: forall s v (a: amount32), eval_shift_op_int v (transl_shift s a) = eval_shift s v a.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_eval_shift	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_eval_shift	null
transl_eval_shiftl: forall s v (a: amount64), eval_shift_op_long v (transl_shift s a) = eval_shiftl s v a.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_eval_shiftl	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_eval_shiftl	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_eval_shiftl	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_move_extended_base	Zero- and Sign- extensions
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_move_extended	null
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...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_arith_extended	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_shrx32	Extended right shift
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	exec_shrx64	null
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).	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	compare_int_spec	Condition bits
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	eval_testcond_compare_sint	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	eval_testcond_compare_uint	null
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).	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	compare_long_spec	null
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).	Remark	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	int64_sub_overflow	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	eval_testcond_compare_slong	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	eval_testcond_compare_ulong	null
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))).	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	compare_float_spec	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	eval_testcond_compare_float	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	eval_testcond_compare_not_float	null
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))).	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	compare_single_spec	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	eval_testcond_compare_single	null
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.	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	eval_testcond_compare_not_single	null
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.	Remark	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	compare_float_inv	null
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.	Remark	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	compare_single_inv	null
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'#...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_cond_correct	null
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 ...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_cond_branch_correct	Translation of conditional branches
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...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_op_correct	null
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...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_addressing_correct	Translation of addressing modes, loads, stores
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) ...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_load_correct	null
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' ...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	transl_store_correct	null
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...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	indexed_memory_access_correct	Translation of indexed memory accesses
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...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	loadptr_correct	null
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' ...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	storeptr_correct	null
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_...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	loadind_correct	null
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...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	storeind_correct	null
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 ...	Lemma	aarch64	[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]	aarch64/Asmgenproof1.v	make_epilogue_correct	null
platform_builtin : Type := .	Inductive	aarch64	[ "Coq.String", "Coqlib", "AST", "Integers", "Floats", "Values", "Builtins0" ]	aarch64/Builtins1.v	platform_builtin	null
platform_builtin_table : list (string * platform_builtin) := nil.	Definition	aarch64	[ "Coq.String", "Coqlib", "AST", "Integers", "Floats", "Values", "Builtins0" ]	aarch64/Builtins1.v	platform_builtin_table	null
platform_builtin_sig (b: platform_builtin) : signature := match b with end.	Definition	aarch64	[ "Coq.String", "Coqlib", "AST", "Integers", "Floats", "Values", "Builtins0" ]	aarch64/Builtins1.v	platform_builtin_sig	null
platform_builtin_sem (b: platform_builtin) : builtin_sem (sig_res (platform_builtin_sig b)) := match b with end.	Definition	aarch64	[ "Coq.String", "Coqlib", "AST", "Integers", "Floats", "Values", "Builtins0" ]	aarch64/Builtins1.v	platform_builtin_sem	null
eq_platform_builtin: forall (x y: platform_builtin), {x=y} + {x<>y}.	Definition	aarch64	[ "Coq.String", "Coqlib", "AST", "Integers", "Floats", "Values", "Builtins0" ]	aarch64/Builtins1.v	eq_platform_builtin	null
combine_compimm_ne_0 (x: valnum) : option(condition * list valnum) := match get x with \| Some(Op (Ocmp c) ys) => Some (c, ys) \| Some(Op (Oxorimm n) ys) => if Int.eq n (Int.zero_ext 12 n) then Some (Ccompimm Cne n, ys) else None \| _ => None end.	Function	aarch64	[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]	aarch64/CombineOp.v	combine_compimm_ne_0	null
combine_compimm_eq_0 (x: valnum) : option(condition * list valnum) := match get x with \| Some(Op (Ocmp c) ys) => Some (negate_condition c, ys) \| Some(Op (Oxorimm n) ys) => if Int.eq n (Int.zero_ext 12 n) then Some (Ccompimm Ceq n, ys) else None \| _ => None end.	Function	aarch64	[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]	aarch64/CombineOp.v	combine_compimm_eq_0	null
combine_compimm_eq_1 (x: valnum) : option(condition * list valnum) := match get x with \| Some(Op (Ocmp c) ys) => Some (c, ys) \| _ => None end.	Function	aarch64	[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]	aarch64/CombineOp.v	combine_compimm_eq_1	null
combine_compimm_ne_1 (x: valnum) : option(condition * list valnum) := match get x with \| Some(Op (Ocmp c) ys) => Some (negate_condition c, ys) \| _ => None end.	Function	aarch64	[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]	aarch64/CombineOp.v	combine_compimm_ne_1	null
combine_cond (cond: condition) (args: list valnum) : option(condition * list valnum) := match cond, args with \| Ccompimm Cne n, x::nil => if Int.eq_dec n Int.zero then combine_compimm_ne_0 x else if Int.eq_dec n Int.one then combine_compimm_ne_1 x else None \| Ccompimm Ceq n, x::nil => if I...	Function	aarch64	[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]	aarch64/CombineOp.v	combine_cond	null
combine_cond' (cond: condition) (args: list valnum) : option bool := match cond, args with \| (Ccomp c \| Ccompu c \| Ccompl c \| Ccomplu c), x :: y :: nil => combine_comparison c x y \| _, _ => None end.	Definition	aarch64	[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]	aarch64/CombineOp.v	combine_cond	null
combine_addr (addr: addressing) (args: list valnum) : option(addressing * list valnum) := match addr, args with \| Aindexed n, x::nil => match get x with \| Some(Op (Oaddlimm m) ys) => Some(Aindexed (Int64.add m n), ys) \| _ => None end \| _, _ => None end.	Function	aarch64	[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]	aarch64/CombineOp.v	combine_addr	null
combine_op (op: operation) (args: list valnum) : option(operation * list valnum) := match op, args with \| Oaddimm n, x :: nil => match get x with \| Some(Op (Oaddimm m) ys) => Some(Oaddimm (Int.add m n), ys) \| _ => None end \| Oandimm n, x :: nil => match get x with \| Some(Op (Oa...	Function	aarch64	[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]	aarch64/CombineOp.v	combine_op	null
get_op_sound: forall v op vl, get v = Some (Op op vl) -> eval_operation ge sp op (map valu vl) m = Some (valu v).	Lemma	aarch64	[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]	aarch64/CombineOpproof.v	get_op_sound	null
combine_compimm_ne_0_sound: forall x cond args, combine_compimm_ne_0 get x = Some(cond, args) -> eval_condition cond (map valu args) m = Val.cmp_bool Cne (valu x) (Vint Int.zero) /\ eval_condition cond (map valu args) m = Val.cmpu_bool (Mem.valid_pointer m) Cne (valu x) (Vint Int.zero).	Lemma	aarch64	[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]	aarch64/CombineOpproof.v	combine_compimm_ne_0_sound	null
combine_compimm_eq_0_sound: forall x cond args, combine_compimm_eq_0 get x = Some(cond, args) -> eval_condition cond (map valu args) m = Val.cmp_bool Ceq (valu x) (Vint Int.zero) /\ eval_condition cond (map valu args) m = Val.cmpu_bool (Mem.valid_pointer m) Ceq (valu x) (Vint Int.zero).	Lemma	aarch64	[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]	aarch64/CombineOpproof.v	combine_compimm_eq_0_sound	null
combine_compimm_eq_1_sound: forall x cond args, combine_compimm_eq_1 get x = Some(cond, args) -> eval_condition cond (map valu args) m = Val.cmp_bool Ceq (valu x) (Vint Int.one) /\ eval_condition cond (map valu args) m = Val.cmpu_bool (Mem.valid_pointer m) Ceq (valu x) (Vint Int.one).	Lemma	aarch64	[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]	aarch64/CombineOpproof.v	combine_compimm_eq_1_sound	null
combine_compimm_ne_1_sound: forall x cond args, combine_compimm_ne_1 get x = Some(cond, args) -> eval_condition cond (map valu args) m = Val.cmp_bool Cne (valu x) (Vint Int.one) /\ eval_condition cond (map valu args) m = Val.cmpu_bool (Mem.valid_pointer m) Cne (valu x) (Vint Int.one).	Lemma	aarch64	[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]	aarch64/CombineOpproof.v	combine_compimm_ne_1_sound	null
combine_cond_sound: forall cond args cond' args', combine_cond get cond args = Some(cond', args') -> eval_condition cond' (map valu args') m = eval_condition cond (map valu args) m.	Theorem	aarch64	[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]	aarch64/CombineOpproof.v	combine_cond_sound	null

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: ...

Inductive

aarch64

[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]

aarch64/Asmgenproof.v

match_states

Semantic preservation is proved using simulation diagrams of the following form. << st1 --------------- st2 | | t| *|t | | v v st1'--------------- st2' >> The invariant is the ...

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...

Lemma

aarch64

[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]

aarch64/Asmgenproof.v

exec_straight_steps

null

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...

Lemma

aarch64

[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]

aarch64/Asmgenproof.v

exec_straight_steps_goto

null

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...

Lemma

aarch64

[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]

aarch64/Asmgenproof.v

exec_straight_opt_steps_goto

null

measure (s: Mach.state) : nat := match s with | Mach.State _ _ _ _ _ _ => 0%nat | Mach.Callstate _ _ _ _ => 0%nat | Mach.Returnstate _ _ _ => 1%nat end.

Definition

aarch64

[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]

aarch64/Asmgenproof.v

measure

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...

preg_of_not_X15: forall r, negb (mreg_eq r R15) = true -> IR X15 <> preg_of r.

Remark

aarch64

[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]

aarch64/Asmgenproof.v

preg_of_not_X15

null

sp_val': forall ms sp rs, agree ms sp rs -> sp = rs XSP.

Lemma

aarch64

[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]

aarch64/Asmgenproof.v

sp_val

null

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.

Theorem

aarch64

[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]

aarch64/Asmgenproof.v

step_simulation

This is the simulation diagram. We prove it by case analysis on the Mach transition.

transf_initial_states: forall st1, Mach.initial_state prog st1 -> exists st2, Asm.initial_state tprog st2 /\ match_states st1 st2.

Lemma

aarch64

[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]

aarch64/Asmgenproof.v

transf_initial_states

null

transf_final_states: forall st1 st2 r, match_states st1 st2 -> Mach.final_state st1 r -> Asm.final_state st2 r.

Lemma

aarch64

[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]

aarch64/Asmgenproof.v

transf_final_states

null

transf_program_correct: forward_simulation (Mach.semantics return_address_offset prog) (Asm.semantics tprog).

Theorem

aarch64

[ "Coqlib", "Errors", "Integers", "Floats", "AST", "Linking", "Values", "Memory", "Events", "Globalenvs", "Smallstep", "Op", "Locations", "Mach", "Conventions", "Asm", "Asmgen", "Asmgenproof0", "Asmgenproof1" ]

aarch64/Asmgenproof.v

transf_program_correct

null

preg_of_iregsp_not_PC: forall r, preg_of_iregsp r <> PC.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

preg_of_iregsp_not_PC

Properties of registers

preg_of_not_X16: forall r, preg_of r <> X16.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

preg_of_not_X16

null

ireg_of_not_X16: forall r x, ireg_of r = OK x -> x <> X16.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

ireg_of_not_X16

null

ireg_of_not_X16': forall r x, ireg_of r = OK x -> IR x <> IR X16.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

ireg_of_not_X16

null

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

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

wf_decomposition

Decomposition of integer literals

decompose_int_wf: forall N n p, 0 <= p -> wf_decomposition (decompose_int N n p).

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

decompose_int_wf

null

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

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

recompose_int

null

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).

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

decompose_int_correct

null

decompose_int_eqmod: forall N n, eqmod (two_power_nat (N * 16)%nat) (recompose_int 0 (decompose_int N n 0)) n.

Corollary

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

decompose_int_eqmod

null

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.

Corollary

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

decompose_notint_eqmod

null

negate_decomposition_wf: forall l, wf_decomposition l -> wf_decomposition (negate_decomposition l).

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

negate_decomposition_wf

null

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).

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

Zinsert_eqmod

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

Zinsert_0_l

null

recompose_int_negated: forall l, wf_decomposition l -> forall accu, recompose_int (Z.lnot accu) (negate_decomposition l) = Z.lnot (recompose_int accu l).

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

recompose_int_negated

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_loadimm_k_w

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_loadimm_z_w

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_loadimm_n_w

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_loadimm32

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_loadimm_k_x

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_loadimm_z_x

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_loadimm_n_x

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_loadimm64

null

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))...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_addimm_aux_32

Add immediate

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_addimm32

null

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...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_addimm_aux_64

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_addimm64

null

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...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_logicalimm32

Logical immediate

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) -> ...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_logicalimm64

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_loadsymbol

Load address of symbol

transl_shift_not_none: forall s a, transl_shift s a <> SOnone.

Remark

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_shift_not_none

Shifted operands

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.

Remark

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

or_zero_eval_shift_op_int

null

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.

Remark

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

or_zero_eval_shift_op_long

null

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.

Remark

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

add_zero_eval_shift_op_long

null

transl_eval_shift: forall s v (a: amount32), eval_shift_op_int v (transl_shift s a) = eval_shift s v a.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_eval_shift

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_eval_shift

null

transl_eval_shiftl: forall s v (a: amount64), eval_shift_op_long v (transl_shift s a) = eval_shiftl s v a.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_eval_shiftl

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_eval_shiftl

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_eval_shiftl

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_move_extended_base

Zero- and Sign- extensions

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_move_extended

null

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...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_arith_extended

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_shrx32

Extended right shift

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

exec_shrx64

null

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).

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

compare_int_spec

Condition bits

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

eval_testcond_compare_sint

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

eval_testcond_compare_uint

null

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).

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

compare_long_spec

null

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).

Remark

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

int64_sub_overflow

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

eval_testcond_compare_slong

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

eval_testcond_compare_ulong

null

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))).

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

compare_float_spec

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

eval_testcond_compare_float

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

eval_testcond_compare_not_float

null

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))).

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

compare_single_spec

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

eval_testcond_compare_single

null

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.

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

eval_testcond_compare_not_single

null

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.

Remark

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

compare_float_inv

null

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.

Remark

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

compare_single_inv

null

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'#...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_cond_correct

null

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 ...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_cond_branch_correct

Translation of conditional branches

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...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_op_correct

null

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...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_addressing_correct

Translation of addressing modes, loads, stores

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) ...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_load_correct

null

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' ...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

transl_store_correct

null

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...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

indexed_memory_access_correct

Translation of indexed memory accesses

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...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

loadptr_correct

null

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' ...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

storeptr_correct

null

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_...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

loadind_correct

null

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...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

storeind_correct

null

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 ...

Lemma

aarch64

[ "Coq.Recdef", "Coq.Zwf", "Zbits", "Coqlib", "Maps", "Errors", "AST", "Integers", "Floats", "Values", "Memory", "Globalenvs", "Op", "Locations", "Mach", "Asm", "Conventions", "Asmgen", "Asmgenproof0" ]

aarch64/Asmgenproof1.v

make_epilogue_correct

null

platform_builtin : Type := .

Inductive

aarch64

[ "Coq.String", "Coqlib", "AST", "Integers", "Floats", "Values", "Builtins0" ]

aarch64/Builtins1.v

platform_builtin

null

platform_builtin_table : list (string * platform_builtin) := nil.

Definition

aarch64

[ "Coq.String", "Coqlib", "AST", "Integers", "Floats", "Values", "Builtins0" ]

aarch64/Builtins1.v

platform_builtin_table

null

platform_builtin_sig (b: platform_builtin) : signature := match b with end.

Definition

aarch64

[ "Coq.String", "Coqlib", "AST", "Integers", "Floats", "Values", "Builtins0" ]

aarch64/Builtins1.v

platform_builtin_sig

null

platform_builtin_sem (b: platform_builtin) : builtin_sem (sig_res (platform_builtin_sig b)) := match b with end.

Definition

aarch64

[ "Coq.String", "Coqlib", "AST", "Integers", "Floats", "Values", "Builtins0" ]

aarch64/Builtins1.v

platform_builtin_sem

null

eq_platform_builtin: forall (x y: platform_builtin), {x=y} + {x<>y}.

Definition

aarch64

[ "Coq.String", "Coqlib", "AST", "Integers", "Floats", "Values", "Builtins0" ]

aarch64/Builtins1.v

eq_platform_builtin

null

combine_compimm_ne_0 (x: valnum) : option(condition * list valnum) := match get x with | Some(Op (Ocmp c) ys) => Some (c, ys) | Some(Op (Oxorimm n) ys) => if Int.eq n (Int.zero_ext 12 n) then Some (Ccompimm Cne n, ys) else None | _ => None end.

Function

aarch64

[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]

aarch64/CombineOp.v

combine_compimm_ne_0

null

combine_compimm_eq_0 (x: valnum) : option(condition * list valnum) := match get x with | Some(Op (Ocmp c) ys) => Some (negate_condition c, ys) | Some(Op (Oxorimm n) ys) => if Int.eq n (Int.zero_ext 12 n) then Some (Ccompimm Ceq n, ys) else None | _ => None end.

Function

aarch64

[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]

aarch64/CombineOp.v

combine_compimm_eq_0

null

combine_compimm_eq_1 (x: valnum) : option(condition * list valnum) := match get x with | Some(Op (Ocmp c) ys) => Some (c, ys) | _ => None end.

Function

aarch64

[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]

aarch64/CombineOp.v

combine_compimm_eq_1

null

combine_compimm_ne_1 (x: valnum) : option(condition * list valnum) := match get x with | Some(Op (Ocmp c) ys) => Some (negate_condition c, ys) | _ => None end.

Function

aarch64

[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]

aarch64/CombineOp.v

combine_compimm_ne_1

null

combine_cond (cond: condition) (args: list valnum) : option(condition * list valnum) := match cond, args with | Ccompimm Cne n, x::nil => if Int.eq_dec n Int.zero then combine_compimm_ne_0 x else if Int.eq_dec n Int.one then combine_compimm_ne_1 x else None | Ccompimm Ceq n, x::nil => if I...

Function

aarch64

[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]

aarch64/CombineOp.v

combine_cond

null

Definition

aarch64

[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]

aarch64/CombineOp.v

combine_cond

null

combine_addr (addr: addressing) (args: list valnum) : option(addressing * list valnum) := match addr, args with | Aindexed n, x::nil => match get x with | Some(Op (Oaddlimm m) ys) => Some(Aindexed (Int64.add m n), ys) | _ => None end | _, _ => None end.

Function

aarch64

[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]

aarch64/CombineOp.v

combine_addr

null

combine_op (op: operation) (args: list valnum) : option(operation * list valnum) := match op, args with | Oaddimm n, x :: nil => match get x with | Some(Op (Oaddimm m) ys) => Some(Oaddimm (Int.add m n), ys) | _ => None end | Oandimm n, x :: nil => match get x with | Some(Op (Oa...

Function

aarch64

[ "Coqlib", "AST", "Integers", "Op", "CSEdomain" ]

aarch64/CombineOp.v

combine_op

null

get_op_sound: forall v op vl, get v = Some (Op op vl) -> eval_operation ge sp op (map valu vl) m = Some (valu v).

Lemma

aarch64

[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]

aarch64/CombineOpproof.v

get_op_sound

null

combine_compimm_ne_0_sound: forall x cond args, combine_compimm_ne_0 get x = Some(cond, args) -> eval_condition cond (map valu args) m = Val.cmp_bool Cne (valu x) (Vint Int.zero) /\ eval_condition cond (map valu args) m = Val.cmpu_bool (Mem.valid_pointer m) Cne (valu x) (Vint Int.zero).

Lemma

aarch64

[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]

aarch64/CombineOpproof.v

combine_compimm_ne_0_sound

null

combine_compimm_eq_0_sound: forall x cond args, combine_compimm_eq_0 get x = Some(cond, args) -> eval_condition cond (map valu args) m = Val.cmp_bool Ceq (valu x) (Vint Int.zero) /\ eval_condition cond (map valu args) m = Val.cmpu_bool (Mem.valid_pointer m) Ceq (valu x) (Vint Int.zero).

Lemma

aarch64

[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]

aarch64/CombineOpproof.v

combine_compimm_eq_0_sound

null

combine_compimm_eq_1_sound: forall x cond args, combine_compimm_eq_1 get x = Some(cond, args) -> eval_condition cond (map valu args) m = Val.cmp_bool Ceq (valu x) (Vint Int.one) /\ eval_condition cond (map valu args) m = Val.cmpu_bool (Mem.valid_pointer m) Ceq (valu x) (Vint Int.one).

Lemma

aarch64

[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]

aarch64/CombineOpproof.v

combine_compimm_eq_1_sound

null

combine_compimm_ne_1_sound: forall x cond args, combine_compimm_ne_1 get x = Some(cond, args) -> eval_condition cond (map valu args) m = Val.cmp_bool Cne (valu x) (Vint Int.one) /\ eval_condition cond (map valu args) m = Val.cmpu_bool (Mem.valid_pointer m) Cne (valu x) (Vint Int.one).

Lemma

aarch64

[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]

aarch64/CombineOpproof.v

combine_compimm_ne_1_sound

null

combine_cond_sound: forall cond args cond' args', combine_cond get cond args = Some(cond', args') -> eval_condition cond' (map valu args') m = eval_condition cond (map valu args) m.

Theorem

aarch64

[ "Coq.FunInd", "Coqlib", "AST", "Integers", "Values", "Memory", "Op", "Registers", "RTL", "CSEdomain", "CombineOp" ]

aarch64/CombineOpproof.v

combine_cond_sound

null