forked from AbsInt/CompCert
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathAsmgenproof1.v
1418 lines (1343 loc) · 57.4 KB
/
Asmgenproof1.v
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
(* *********************************************************************)
(* *)
(* The Compcert verified compiler *)
(* *)
(* Xavier Leroy, INRIA Paris *)
(* *)
(* Copyright Institut National de Recherche en Informatique et en *)
(* Automatique. All rights reserved. This file is distributed *)
(* under the terms of the INRIA Non-Commercial License Agreement. *)
(* *)
(* *********************************************************************)
(** Correctness proof for x86-64 generation: auxiliary results. *)
Require Import Coqlib.
Require Import AST Errors Integers Floats Values Memory Globalenvs.
Require Import Op Locations Conventions Mach Asm.
Require Import Asmgen Asmgenproof0.
Local Open Scope error_monad_scope.
(** * Correspondence between Mach registers and x86 registers *)
Lemma agree_nextinstr_nf:
forall ms sp rs,
agree ms sp rs -> agree ms sp (nextinstr_nf rs).
Proof.
intros. unfold nextinstr_nf. apply agree_nextinstr.
apply agree_undef_nondata_regs. auto.
simpl; intros. intuition (subst r; auto).
Qed.
(** Useful properties of the PC register. *)
Lemma nextinstr_nf_inv:
forall r rs,
match r with PC => False | CR _ => False | _ => True end ->
(nextinstr_nf rs)#r = rs#r.
Proof.
intros. unfold nextinstr_nf. rewrite nextinstr_inv.
simpl. repeat rewrite Pregmap.gso; auto;
red; intro; subst; contradiction.
red; intro; subst; contradiction.
Qed.
Lemma nextinstr_nf_inv1:
forall r rs,
data_preg r = true -> (nextinstr_nf rs)#r = rs#r.
Proof.
intros. apply nextinstr_nf_inv. destruct r; auto || discriminate.
Qed.
Lemma nextinstr_nf_set_preg:
forall rs m v,
(nextinstr_nf (rs#(preg_of m) <- v))#PC = Val.offset_ptr rs#PC Ptrofs.one.
Proof.
intros. unfold nextinstr_nf.
transitivity (nextinstr (rs#(preg_of m) <- v) PC). auto.
apply nextinstr_set_preg.
Qed.
(** Useful simplification tactic *)
Ltac Simplif :=
match goal with
| [ |- nextinstr_nf _ _ = _ ] =>
((rewrite nextinstr_nf_inv by auto with asmgen)
|| (rewrite nextinstr_nf_inv1 by auto with asmgen)); auto
| [ |- nextinstr _ _ = _ ] =>
((rewrite nextinstr_inv by auto with asmgen)
|| (rewrite nextinstr_inv1 by auto with asmgen)); auto
| [ |- Pregmap.get ?x (Pregmap.set ?x _ _) = _ ] =>
rewrite Pregmap.gss; auto
| [ |- Pregmap.set ?x _ _ ?x = _ ] =>
rewrite Pregmap.gss; auto
| [ |- Pregmap.get _ (Pregmap.set _ _ _) = _ ] =>
rewrite Pregmap.gso by (auto with asmgen); auto
| [ |- Pregmap.set _ _ _ _ = _ ] =>
rewrite Pregmap.gso by (auto with asmgen); auto
end.
Ltac Simplifs := repeat Simplif.
(** * Correctness of x86-64 constructor functions *)
Section CONSTRUCTORS.
Variable ge: genv.
Variable fn: function.
(** Smart constructor for moves. *)
Lemma mk_mov_correct:
forall rd rs k c rs1 m,
mk_mov rd rs k = OK c ->
exists rs2,
exec_straight ge fn c rs1 m k rs2 m
/\ rs2#rd = rs1#rs
/\ forall r, data_preg r = true -> r <> rd -> rs2#r = rs1#r.
Proof.
unfold mk_mov; intros.
destruct rd; try (monadInv H); destruct rs; monadInv H.
(* mov *)
econstructor. split. apply exec_straight_one. simpl. eauto. auto.
split. Simplifs. intros; Simplifs.
(* movsd *)
econstructor. split. apply exec_straight_one. simpl. eauto. auto.
split. Simplifs. intros; Simplifs.
Qed.
(** Properties of division *)
Lemma divu_modu_exists:
forall v1 v2,
Val.divu v1 v2 <> None \/ Val.modu v1 v2 <> None ->
exists n d q r,
v1 = Vint n /\ v2 = Vint d
/\ Int.divmodu2 Int.zero n d = Some(q, r)
/\ Val.divu v1 v2 = Some (Vint q) /\ Val.modu v1 v2 = Some (Vint r).
Proof.
intros v1 v2; unfold Val.divu, Val.modu.
destruct v1; try (intuition discriminate).
destruct v2; try (intuition discriminate).
predSpec Int.eq Int.eq_spec i0 Int.zero ; try (intuition discriminate).
intros _. exists i, i0, (Int.divu i i0), (Int.modu i i0); intuition auto.
apply Int.divmodu2_divu_modu; auto.
Qed.
Lemma divs_mods_exists:
forall v1 v2,
Val.divs v1 v2 <> None \/ Val.mods v1 v2 <> None ->
exists nh nl d q r,
Val.shr v1 (Vint (Int.repr 31)) = Vint nh /\ v1 = Vint nl /\ v2 = Vint d
/\ Int.divmods2 nh nl d = Some(q, r)
/\ Val.divs v1 v2 = Some (Vint q) /\ Val.mods v1 v2 = Some (Vint r).
Proof.
intros v1 v2; unfold Val.divs, Val.mods.
destruct v1; try (intuition discriminate).
destruct v2; try (intuition discriminate).
destruct (Int.eq i0 Int.zero
|| Int.eq i (Int.repr Int.min_signed) && Int.eq i0 Int.mone) eqn:OK;
try (intuition discriminate).
intros _.
InvBooleans.
exists (Int.shr i (Int.repr 31)), i, i0, (Int.divs i i0), (Int.mods i i0); intuition auto.
rewrite Int.shr_lt_zero. apply Int.divmods2_divs_mods.
red; intros; subst i0; rewrite Int.eq_true in H; discriminate.
revert H0. predSpec Int.eq Int.eq_spec i (Int.repr Int.min_signed); auto.
predSpec Int.eq Int.eq_spec i0 Int.mone; auto.
discriminate.
Qed.
Lemma divlu_modlu_exists:
forall v1 v2,
Val.divlu v1 v2 <> None \/ Val.modlu v1 v2 <> None ->
exists n d q r,
v1 = Vlong n /\ v2 = Vlong d
/\ Int64.divmodu2 Int64.zero n d = Some(q, r)
/\ Val.divlu v1 v2 = Some (Vlong q) /\ Val.modlu v1 v2 = Some (Vlong r).
Proof.
intros v1 v2; unfold Val.divlu, Val.modlu.
destruct v1; try (intuition discriminate).
destruct v2; try (intuition discriminate).
predSpec Int64.eq Int64.eq_spec i0 Int64.zero ; try (intuition discriminate).
intros _. exists i, i0, (Int64.divu i i0), (Int64.modu i i0); intuition auto.
apply Int64.divmodu2_divu_modu; auto.
Qed.
Lemma divls_modls_exists:
forall v1 v2,
Val.divls v1 v2 <> None \/ Val.modls v1 v2 <> None ->
exists nh nl d q r,
Val.shrl v1 (Vint (Int.repr 63)) = Vlong nh /\ v1 = Vlong nl /\ v2 = Vlong d
/\ Int64.divmods2 nh nl d = Some(q, r)
/\ Val.divls v1 v2 = Some (Vlong q) /\ Val.modls v1 v2 = Some (Vlong r).
Proof.
intros v1 v2; unfold Val.divls, Val.modls.
destruct v1; try (intuition discriminate).
destruct v2; try (intuition discriminate).
destruct (Int64.eq i0 Int64.zero
|| Int64.eq i (Int64.repr Int64.min_signed) && Int64.eq i0 Int64.mone) eqn:OK;
try (intuition discriminate).
intros _.
InvBooleans.
exists (Int64.shr i (Int64.repr 63)), i, i0, (Int64.divs i i0), (Int64.mods i i0); intuition auto.
rewrite Int64.shr_lt_zero. apply Int64.divmods2_divs_mods.
red; intros; subst i0; rewrite Int64.eq_true in H; discriminate.
revert H0. predSpec Int64.eq Int64.eq_spec i (Int64.repr Int64.min_signed); auto.
predSpec Int64.eq Int64.eq_spec i0 Int64.mone; auto.
discriminate.
Qed.
(** Smart constructor for [shrx] *)
Lemma mk_shrximm_correct:
forall n k c (rs1: regset) v m,
mk_shrximm n k = OK c ->
Val.shrx (rs1#RAX) (Vint n) = Some v ->
exists rs2,
exec_straight ge fn c rs1 m k rs2 m
/\ rs2#RAX = v
/\ forall r, data_preg r = true -> r <> RAX -> r <> RCX -> rs2#r = rs1#r.
Proof.
unfold mk_shrximm; intros. inv H.
exploit Val.shrx_shr; eauto. intros [x [y [A [B C]]]].
inversion B; clear B; subst y; subst v; clear H0.
set (tnm1 := Int.sub (Int.shl Int.one n) Int.one).
set (x' := Int.add x tnm1).
set (rs2 := nextinstr (compare_ints (Vint x) (Vint Int.zero) rs1 m)).
set (rs3 := nextinstr (rs2#RCX <- (Vint x'))).
set (rs4 := nextinstr (if Int.lt x Int.zero then rs3#RAX <- (Vint x') else rs3)).
set (rs5 := nextinstr_nf (rs4#RAX <- (Val.shr rs4#RAX (Vint n)))).
assert (rs3#RAX = Vint x). unfold rs3. Simplifs.
assert (rs3#RCX = Vint x'). unfold rs3. Simplifs.
exists rs5. split.
apply exec_straight_step with rs2 m. simpl. rewrite A. simpl. rewrite Int.and_idem. auto. auto.
apply exec_straight_step with rs3 m. simpl.
change (rs2 RAX) with (rs1 RAX). rewrite A. simpl.
rewrite Int.repr_unsigned. rewrite Int.add_zero_l. auto. auto.
apply exec_straight_step with rs4 m. simpl.
rewrite Int.lt_sub_overflow. unfold rs4. destruct (Int.lt x Int.zero); simpl; auto.
unfold rs4. destruct (Int.lt x Int.zero); simpl; auto.
apply exec_straight_one. auto. auto.
split. unfold rs5. Simplifs. unfold rs4. rewrite nextinstr_inv; auto with asmgen.
destruct (Int.lt x Int.zero). rewrite Pregmap.gss. rewrite A; auto. rewrite A; rewrite H; auto.
intros. unfold rs5. Simplifs. unfold rs4. Simplifs.
transitivity (rs3#r). destruct (Int.lt x Int.zero). Simplifs. auto.
unfold rs3. Simplifs. unfold rs2. Simplifs.
unfold compare_ints. Simplifs.
Qed.
(** Smart constructor for [shrxl] *)
Lemma mk_shrxlimm_correct:
forall n k c (rs1: regset) v m,
mk_shrxlimm n k = OK c ->
Val.shrxl (rs1#RAX) (Vint n) = Some v ->
exists rs2,
exec_straight ge fn c rs1 m k rs2 m
/\ rs2#RAX = v
/\ forall r, data_preg r = true -> r <> RAX -> r <> RDX -> rs2#r = rs1#r.
Proof.
unfold mk_shrxlimm; intros. exploit Val.shrxl_shrl_2; eauto. intros EQ.
destruct (Int.eq n Int.zero); inv H.
- econstructor; split. apply exec_straight_one. simpl; reflexivity. auto.
split. Simplifs. intros; Simplifs.
- set (v1 := Val.shrl (rs1 RAX) (Vint (Int.repr 63))) in *.
set (v2 := Val.shrlu v1 (Vint (Int.sub (Int.repr 64) n))) in *.
set (v3 := Val.addl (rs1 RAX) v2) in *.
set (v4 := Val.shrl v3 (Vint n)) in *.
set (rs2 := nextinstr_nf (rs1#RDX <- v1)).
set (rs3 := nextinstr_nf (rs2#RDX <- v2)).
set (rs4 := nextinstr (rs3#RAX <- v3)).
set (rs5 := nextinstr_nf (rs4#RAX <- v4)).
assert (X: forall v1 v2,
Val.addl v1 (Val.addl v2 (Vlong Int64.zero)) = Val.addl v1 v2).
{ intros. unfold Val.addl; destruct Archi.ptr64 eqn:SF, v0; auto; destruct v5; auto.
rewrite Int64.add_zero; auto.
rewrite Ptrofs.add_zero; auto.
rewrite Int64.add_zero; auto.
rewrite Int64.add_zero; auto. }
exists rs5; split.
eapply exec_straight_trans with (rs2 := rs3).
eapply exec_straight_two with (rs2 := rs2); reflexivity.
eapply exec_straight_two with (rs2 := rs4).
simpl. rewrite X. reflexivity. reflexivity. reflexivity. reflexivity.
split. unfold rs5; Simplifs.
intros. unfold rs5; Simplifs. unfold rs4; Simplifs. unfold rs3; Simplifs. unfold rs2; Simplifs.
Qed.
(** Smart constructor for integer conversions *)
Lemma mk_intconv_correct:
forall mk sem rd rs k c rs1 m,
mk_intconv mk rd rs k = OK c ->
(forall c rd rs r m,
exec_instr ge c (mk rd rs) r m = Next (nextinstr (r#rd <- (sem r#rs))) m) ->
exists rs2,
exec_straight ge fn c rs1 m k rs2 m
/\ rs2#rd = sem rs1#rs
/\ forall r, data_preg r = true -> r <> rd -> r <> RAX -> rs2#r = rs1#r.
Proof.
unfold mk_intconv; intros. destruct (Archi.ptr64 || low_ireg rs); monadInv H.
econstructor. split. apply exec_straight_one. rewrite H0. eauto. auto.
split. Simplifs. intros. Simplifs.
econstructor. split. eapply exec_straight_two.
simpl. eauto. apply H0. auto. auto.
split. Simplifs. intros. Simplifs.
Qed.
(** Smart constructor for small stores *)
Lemma addressing_mentions_correct:
forall a r (rs1 rs2: regset),
(forall (r': ireg), r' <> r -> rs1 r' = rs2 r') ->
addressing_mentions a r = false ->
eval_addrmode32 ge a rs1 = eval_addrmode32 ge a rs2.
Proof.
intros until rs2; intro AG. unfold addressing_mentions, eval_addrmode32.
destruct a. intros. destruct (orb_false_elim _ _ H). unfold proj_sumbool in *.
decEq. destruct base; auto. apply AG. destruct (ireg_eq r i); congruence.
decEq. destruct ofs as [[r' sc] | ]; auto. rewrite AG; auto. destruct (ireg_eq r r'); congruence.
Qed.
Lemma mk_storebyte_correct:
forall addr r k c rs1 m1 m2,
mk_storebyte addr r k = OK c ->
Mem.storev Mint8unsigned m1 (eval_addrmode ge addr rs1) (rs1 r) = Some m2 ->
exists rs2,
exec_straight ge fn c rs1 m1 k rs2 m2
/\ forall r, data_preg r = true -> preg_notin r (if Archi.ptr64 then nil else AX :: CX :: nil) -> rs2#r = rs1#r.
Proof.
unfold mk_storebyte; intros.
destruct (Archi.ptr64 || low_ireg r) eqn:E.
(* low reg *)
monadInv H. econstructor; split. apply exec_straight_one.
simpl. unfold exec_store. rewrite H0. eauto. auto.
intros; Simplifs.
(* high reg *)
InvBooleans. rewrite H1; simpl. destruct (addressing_mentions addr RAX) eqn:E; monadInv H.
(* RAX is mentioned. *)
assert (r <> RCX). { red; intros; subst r; discriminate H2. }
set (rs2 := nextinstr (rs1#RCX <- (eval_addrmode32 ge addr rs1))).
set (rs3 := nextinstr (rs2#RAX <- (rs1 r))).
econstructor; split.
apply exec_straight_three with rs2 m1 rs3 m1.
simpl. auto.
simpl. replace (rs2 r) with (rs1 r). auto. symmetry. unfold rs2; Simplifs.
simpl. unfold exec_store. unfold eval_addrmode; rewrite H1; simpl. rewrite Int.add_zero.
change (rs3 RAX) with (rs1 r).
change (rs3 RCX) with (eval_addrmode32 ge addr rs1).
replace (Val.add (eval_addrmode32 ge addr rs1) (Vint Int.zero))
with (eval_addrmode ge addr rs1).
rewrite H0. eauto.
unfold eval_addrmode in *; rewrite H1 in *.
destruct (eval_addrmode32 ge addr rs1); simpl in H0; try discriminate H0.
simpl. rewrite H1. rewrite Ptrofs.add_zero; auto.
auto. auto. auto.
intros. destruct H4. Simplifs. unfold rs3; Simplifs. unfold rs2; Simplifs.
(* RAX is not mentioned *)
set (rs2 := nextinstr (rs1#RAX <- (rs1 r))).
econstructor; split.
apply exec_straight_two with rs2 m1.
simpl. auto.
simpl. unfold exec_store. unfold eval_addrmode in *; rewrite H1 in *.
rewrite (addressing_mentions_correct addr RAX rs2 rs1); auto.
change (rs2 RAX) with (rs1 r). rewrite H0. eauto.
intros. unfold rs2; Simplifs.
auto. auto.
intros. destruct H3. simpl. Simplifs. unfold rs2; Simplifs.
Qed.
(** Accessing slots in the stack frame *)
Remark eval_addrmode_indexed:
forall (base: ireg) ofs (rs: regset),
match rs#base with Vptr _ _ => True | _ => False end ->
eval_addrmode ge (Addrmode (Some base) None (inl _ (Ptrofs.unsigned ofs))) rs = Val.offset_ptr rs#base ofs.
Proof.
intros. destruct (rs#base) eqn:BASE; try contradiction.
intros; unfold eval_addrmode; destruct Archi.ptr64 eqn:SF; simpl; rewrite BASE; simpl; rewrite SF; simpl.
- apply f_equal. apply f_equal. rewrite Int64.add_zero_l. rewrite <- (Ptrofs.repr_unsigned ofs) at 2. auto with ptrofs.
- apply f_equal. apply f_equal. rewrite Int.add_zero_l. rewrite <- (Ptrofs.repr_unsigned ofs) at 2. auto with ptrofs.
Qed.
Ltac loadind_correct_solve :=
match goal with
| H: Error _ = OK _ |- _ => discriminate H
| H: OK _ = OK _ |- _ => inv H
| H: match ?x with _ => _ end = OK _ |- _ => destruct x eqn:?; loadind_correct_solve
| _ => idtac
end.
Lemma loadind_correct:
forall (base: ireg) ofs ty dst k (rs: regset) c 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 ->
exists rs',
exec_straight ge fn c rs m k rs' m
/\ rs'#(preg_of dst) = v
/\ forall r, data_preg r = true -> r <> preg_of dst -> rs'#r = rs#r.
Proof.
unfold loadind; intros.
set (addr := Addrmode (Some base) None (inl (ident * ptrofs) (Ptrofs.unsigned ofs))) in *.
assert (eval_addrmode ge addr rs = Val.offset_ptr rs#base ofs).
{ apply eval_addrmode_indexed. destruct (rs base); auto || discriminate. }
rewrite <- H1 in H0.
exists (nextinstr_nf (rs#(preg_of dst) <- v)); split.
- loadind_correct_solve; apply exec_straight_one; auto; simpl in *; unfold exec_load; rewrite ?Heqb, ?H0; auto.
- intuition Simplifs.
Qed.
Lemma storeind_correct:
forall (base: ireg) ofs ty src k (rs: regset) c 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' ->
exists rs',
exec_straight ge fn c rs m k rs' m'
/\ forall r, data_preg r = true -> preg_notin r (destroyed_by_setstack ty) -> rs'#r = rs#r.
Proof.
unfold storeind; intros.
set (addr := Addrmode (Some base) None (inl (ident * ptrofs) (Ptrofs.unsigned ofs))) in *.
assert (eval_addrmode ge addr rs = Val.offset_ptr rs#base ofs).
{ apply eval_addrmode_indexed. destruct (rs base); auto || discriminate. }
rewrite <- H1 in H0.
loadind_correct_solve; simpl in H0;
(econstructor; split;
[apply exec_straight_one; [simpl; unfold exec_store; rewrite ?Heqb, H0;eauto|auto]
|simpl; intros; unfold undef_regs; repeat Simplifs]).
Qed.
(** Translation of addressing modes *)
Lemma transl_addressing_mode_32_correct:
forall addr args am (rs: regset) v,
transl_addressing addr args = OK am ->
eval_addressing32 ge (rs RSP) addr (List.map rs (List.map preg_of args)) = Some v ->
Val.lessdef v (eval_addrmode32 ge am rs).
Proof.
assert (A: forall id ofs, Archi.ptr64 = false ->
Val.add (Vint Int.zero) (Genv.symbol_address ge id ofs) = Genv.symbol_address ge id ofs).
{ intros. unfold Val.add; rewrite H. unfold Genv.symbol_address.
destruct (Genv.find_symbol ge id); auto. rewrite Ptrofs.add_zero; auto. }
assert (C: forall v i,
Val.lessdef (Val.mul v (Vint (Int.repr i)))
(if zeq i 1 then v else Val.mul v (Vint (Int.repr i)))).
{ intros. destruct (zeq i 1); subst; auto.
destruct v; simpl; auto. rewrite Int.mul_one; auto. }
unfold transl_addressing; intros.
destruct addr; repeat (destruct args; try discriminate H); simpl in H0; FuncInv;
monadInv H; try (erewrite ! ireg_of_eq by eauto); unfold eval_addrmode32.
- simpl; rewrite Int.add_zero_l; auto.
- rewrite Val.add_assoc. apply Val.add_lessdef; auto.
- rewrite Val.add_permut. apply Val.add_lessdef; auto. simpl; rewrite Int.add_zero_l; auto.
- apply Val.add_lessdef; auto. apply Val.add_lessdef; auto.
- rewrite ! A by auto. auto.
- rewrite Val.add_commut. rewrite A by auto. auto.
- rewrite Val.add_permut. rewrite Val.add_commut. apply Val.add_lessdef; auto. rewrite A; auto.
- simpl. unfold Val.add; rewrite Heqb.
destruct (rs RSP); simpl; auto.
rewrite Int.add_zero_l. apply Val.lessdef_same; f_equal; f_equal.
symmetry. transitivity (Ptrofs.repr (Ptrofs.signed i)). auto with ptrofs. auto with ints.
Qed.
Lemma transl_addressing_mode_64_correct:
forall addr args am (rs: regset) v,
transl_addressing addr args = OK am ->
eval_addressing64 ge (rs RSP) addr (List.map rs (List.map preg_of args)) = Some v ->
Val.lessdef v (eval_addrmode64 ge am rs).
Proof.
assert (A: forall id ofs, Archi.ptr64 = true ->
Val.addl (Vlong Int64.zero) (Genv.symbol_address ge id ofs) = Genv.symbol_address ge id ofs).
{ intros. unfold Val.addl; rewrite H. unfold Genv.symbol_address.
destruct (Genv.find_symbol ge id); auto. rewrite Ptrofs.add_zero; auto. }
assert (C: forall v i,
Val.lessdef (Val.mull v (Vlong (Int64.repr i)))
(if zeq i 1 then v else Val.mull v (Vlong (Int64.repr i)))).
{ intros. destruct (zeq i 1); subst; auto.
destruct v; simpl; auto. rewrite Int64.mul_one; auto. }
unfold transl_addressing; intros.
destruct addr; repeat (destruct args; try discriminate H); simpl in H0; FuncInv;
monadInv H; try (erewrite ! ireg_of_eq by eauto); unfold eval_addrmode64.
- simpl; rewrite Int64.add_zero_l; auto.
- rewrite Val.addl_assoc. apply Val.addl_lessdef; auto.
- rewrite Val.addl_permut. apply Val.addl_lessdef; auto. simpl; rewrite Int64.add_zero_l; auto.
- apply Val.addl_lessdef; auto. apply Val.addl_lessdef; auto.
- rewrite ! A by auto. auto.
- unfold Val.addl; rewrite Heqb. destruct (rs RSP); auto. simpl.
rewrite Int64.add_zero_l. apply Val.lessdef_same; f_equal; f_equal.
symmetry. transitivity (Ptrofs.repr (Ptrofs.signed i)). auto with ptrofs. auto with ints.
Qed.
Lemma transl_addressing_mode_correct:
forall addr args am (rs: regset) v,
transl_addressing addr args = OK am ->
eval_addressing ge (rs RSP) addr (List.map rs (List.map preg_of args)) = Some v ->
Val.lessdef v (eval_addrmode ge am rs).
Proof.
unfold eval_addressing, eval_addrmode; intros. destruct Archi.ptr64.
eapply transl_addressing_mode_64_correct; eauto.
eapply transl_addressing_mode_32_correct; eauto.
Qed.
Lemma normalize_addrmode_32_correct:
forall am rs, eval_addrmode32 ge (normalize_addrmode_32 am) rs = eval_addrmode32 ge am rs.
Proof.
intros; destruct am as [base ofs [n|r]]; simpl; auto. rewrite Int.repr_signed. auto.
Qed.
Lemma normalize_addrmode_64_correct:
forall am rs,
eval_addrmode64 ge am rs =
match normalize_addrmode_64 am with
| (am', None) => eval_addrmode64 ge am' rs
| (am', Some delta) => Val.addl (eval_addrmode64 ge am' rs) (Vlong delta)
end.
Proof.
intros; destruct am as [base ofs [n|[id delta]]]; simpl.
- destruct (offset_in_range n); auto; simpl.
rewrite ! Val.addl_assoc. apply f_equal. apply f_equal. simpl. rewrite Int64.add_zero_l; auto.
- destruct Archi.ptr64 eqn:SF; auto; simpl;
destruct (ptroffset_in_range delta); auto. simpl.
rewrite ! Val.addl_assoc. apply f_equal. apply f_equal.
rewrite <- Genv.shift_symbol_address_64 by auto.
f_equal. rewrite Ptrofs.add_zero_l, Ptrofs.of_int64_to_int64 by auto. auto.
Qed.
(** Processor conditions and comparisons *)
Lemma compare_ints_spec:
forall rs v1 v2 m,
let rs' := nextinstr (compare_ints v1 v2 rs m) in
rs'#ZF = Val.cmpu (Mem.valid_pointer m) Ceq v1 v2
/\ rs'#CF = Val.cmpu (Mem.valid_pointer m) Clt v1 v2
/\ rs'#SF = Val.negative (Val.sub v1 v2)
/\ rs'#OF = Val.sub_overflow v1 v2
/\ (forall r, data_preg r = true -> rs'#r = rs#r).
Proof.
intros. unfold rs'; unfold compare_ints.
split. auto.
split. auto.
split. auto.
split. auto.
intros. Simplifs.
Qed.
Lemma testcond_for_signed_comparison_32_correct:
forall c v1 v2 rs m b,
Val.cmp_bool c v1 v2 = Some b ->
eval_testcond (testcond_for_signed_comparison c)
(nextinstr (compare_ints v1 v2 rs m)) = Some b.
Proof.
intros. generalize (compare_ints_spec rs v1 v2 m).
set (rs' := nextinstr (compare_ints v1 v2 rs m)).
intros [A [B [C [D E]]]].
destruct v1; destruct v2; simpl in H; inv H.
unfold eval_testcond. rewrite A; rewrite B; rewrite C; rewrite D.
simpl. unfold Val.cmp, Val.cmpu.
rewrite Int.lt_sub_overflow.
destruct c; simpl.
destruct (Int.eq i i0); auto.
destruct (Int.eq i i0); auto.
destruct (Int.lt i i0); auto.
rewrite Int.not_lt. destruct (Int.lt i i0); simpl; destruct (Int.eq i i0); auto.
rewrite (Int.lt_not i i0). destruct (Int.lt i i0); destruct (Int.eq i i0); reflexivity.
destruct (Int.lt i i0); reflexivity.
Qed.
Lemma testcond_for_unsigned_comparison_32_correct:
forall c v1 v2 rs m b,
Val.cmpu_bool (Mem.valid_pointer m) c v1 v2 = Some b ->
eval_testcond (testcond_for_unsigned_comparison c)
(nextinstr (compare_ints v1 v2 rs m)) = Some b.
Proof.
intros. generalize (compare_ints_spec rs v1 v2 m).
set (rs' := nextinstr (compare_ints v1 v2 rs m)).
intros [A [B [C [D E]]]].
unfold eval_testcond. rewrite A; rewrite B. unfold Val.cmpu, Val.cmp.
destruct v1; destruct v2; simpl in H; FuncInv; subst.
- (* int int *)
destruct c; simpl; auto.
destruct (Int.eq i i0); reflexivity.
destruct (Int.eq i i0); auto.
destruct (Int.ltu i i0); auto.
rewrite Int.not_ltu. destruct (Int.ltu i i0); simpl; destruct (Int.eq i i0); auto.
rewrite (Int.ltu_not i i0). destruct (Int.ltu i i0); destruct (Int.eq i i0); reflexivity.
destruct (Int.ltu i i0); reflexivity.
- (* int ptr *)
unfold Val.cmpu_bool; rewrite Heqb1.
destruct (Int.eq i Int.zero &&
(Mem.valid_pointer m b0 (Ptrofs.unsigned i0) || Mem.valid_pointer m b0 (Ptrofs.unsigned i0 - 1))); try discriminate H.
destruct c; simpl in *; inv H; reflexivity.
- (* ptr int *)
unfold Val.cmpu_bool; rewrite Heqb1.
destruct (Int.eq i0 Int.zero &&
(Mem.valid_pointer m b0 (Ptrofs.unsigned i) || Mem.valid_pointer m b0 (Ptrofs.unsigned i - 1))); try discriminate H.
destruct c; simpl in *; inv H; reflexivity.
- (* ptr ptr *)
unfold Val.cmpu_bool; rewrite Heqb2.
fold (Mem.weak_valid_pointer m b0 (Ptrofs.unsigned i)) in *.
fold (Mem.weak_valid_pointer m b1 (Ptrofs.unsigned i0)) in *.
destruct (eq_block b0 b1).
destruct (Mem.weak_valid_pointer m b0 (Ptrofs.unsigned i) &&
Mem.weak_valid_pointer m b1 (Ptrofs.unsigned i0)); inv H.
destruct c; simpl; auto.
destruct (Ptrofs.eq i i0); auto.
destruct (Ptrofs.eq i i0); auto.
destruct (Ptrofs.ltu i i0); auto.
rewrite Ptrofs.not_ltu. destruct (Ptrofs.ltu i i0); simpl; destruct (Ptrofs.eq i i0); auto.
rewrite (Ptrofs.ltu_not i i0). destruct (Ptrofs.ltu i i0); destruct (Ptrofs.eq i i0); reflexivity.
destruct (Ptrofs.ltu i i0); reflexivity.
destruct (Mem.valid_pointer m b0 (Ptrofs.unsigned i) &&
Mem.valid_pointer m b1 (Ptrofs.unsigned i0)); try discriminate H.
destruct c; simpl in *; inv H; reflexivity.
Qed.
Lemma compare_longs_spec:
forall rs v1 v2 m,
let rs' := nextinstr (compare_longs v1 v2 rs m) in
rs'#ZF = Val.maketotal (Val.cmplu (Mem.valid_pointer m) Ceq v1 v2)
/\ rs'#CF = Val.maketotal (Val.cmplu (Mem.valid_pointer m) Clt v1 v2)
/\ rs'#SF = Val.negativel (Val.subl v1 v2)
/\ rs'#OF = Val.subl_overflow v1 v2
/\ (forall r, data_preg r = true -> rs'#r = rs#r).
Proof.
intros. unfold rs'; unfold compare_longs.
split. auto.
split. auto.
split. auto.
split. auto.
intros. Simplifs.
Qed.
Lemma 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.max_signed);
destruct (Int64.lt (Int64.sub x y) Int64.zero);
auto.
destruct (Int64.lt x y); auto.
Qed.
Lemma testcond_for_signed_comparison_64_correct:
forall c v1 v2 rs m b,
Val.cmpl_bool c v1 v2 = Some b ->
eval_testcond (testcond_for_signed_comparison c)
(nextinstr (compare_longs v1 v2 rs m)) = Some b.
Proof.
intros. generalize (compare_longs_spec rs v1 v2 m).
set (rs' := nextinstr (compare_longs v1 v2 rs m)).
intros [A [B [C [D E]]]].
destruct v1; destruct v2; simpl in H; inv H.
unfold eval_testcond. rewrite A; rewrite B; rewrite C; rewrite D.
simpl; rewrite int64_sub_overflow.
destruct c; simpl.
destruct (Int64.eq i i0); auto.
destruct (Int64.eq i i0); auto.
destruct (Int64.lt i i0); auto.
rewrite Int64.not_lt. destruct (Int64.lt i i0); simpl; destruct (Int64.eq i i0); auto.
rewrite (Int64.lt_not i i0). destruct (Int64.lt i i0); destruct (Int64.eq i i0); reflexivity.
destruct (Int64.lt i i0); reflexivity.
Qed.
Lemma testcond_for_unsigned_comparison_64_correct:
forall c v1 v2 rs m b,
Val.cmplu_bool (Mem.valid_pointer m) c v1 v2 = Some b ->
eval_testcond (testcond_for_unsigned_comparison c)
(nextinstr (compare_longs v1 v2 rs m)) = Some b.
Proof.
intros. generalize (compare_longs_spec rs v1 v2 m).
set (rs' := nextinstr (compare_longs v1 v2 rs m)).
intros [A [B [C [D E]]]].
unfold eval_testcond. rewrite A; rewrite B.
destruct v1; destruct v2; simpl in H; FuncInv; subst.
- (* int int *)
destruct c; simpl; auto.
destruct (Int64.eq i i0); reflexivity.
destruct (Int64.eq i i0); auto.
destruct (Int64.ltu i i0); auto.
rewrite Int64.not_ltu. destruct (Int64.ltu i i0); simpl; destruct (Int64.eq i i0); auto.
rewrite (Int64.ltu_not i i0). destruct (Int64.ltu i i0); destruct (Int64.eq i i0); reflexivity.
destruct (Int64.ltu i i0); reflexivity.
- (* int ptr *)
unfold Val.cmplu; simpl; destruct Archi.ptr64; try discriminate.
destruct (Int64.eq i Int64.zero &&
(Mem.valid_pointer m b0 (Ptrofs.unsigned i0) || Mem.valid_pointer m b0 (Ptrofs.unsigned i0 - 1))) eqn:?; try discriminate H.
destruct c; simpl in *; inv H; auto.
- (* ptr int *)
unfold Val.cmplu; simpl; destruct Archi.ptr64; try discriminate.
destruct (Int64.eq i0 Int64.zero &&
(Mem.valid_pointer m b0 (Ptrofs.unsigned i) || Mem.valid_pointer m b0 (Ptrofs.unsigned i - 1))) eqn:?; try discriminate H.
destruct c; simpl in *; inv H; auto.
- (* ptr ptr *)
unfold Val.cmplu; simpl; destruct Archi.ptr64; try discriminate H.
fold (Mem.weak_valid_pointer m b0 (Ptrofs.unsigned i)) in *.
fold (Mem.weak_valid_pointer m b1 (Ptrofs.unsigned i0)) in *.
destruct (eq_block b0 b1).
destruct (Mem.weak_valid_pointer m b0 (Ptrofs.unsigned i) &&
Mem.weak_valid_pointer m b1 (Ptrofs.unsigned i0)); inv H.
destruct c; simpl; auto.
destruct (Ptrofs.eq i i0); auto.
destruct (Ptrofs.eq i i0); auto.
destruct (Ptrofs.ltu i i0); auto.
rewrite Ptrofs.not_ltu. destruct (Ptrofs.ltu i i0); simpl; destruct (Ptrofs.eq i i0); auto.
rewrite (Ptrofs.ltu_not i i0). destruct (Ptrofs.ltu i i0); destruct (Ptrofs.eq i i0); reflexivity.
destruct (Ptrofs.ltu i i0); reflexivity.
destruct (Mem.valid_pointer m b0 (Ptrofs.unsigned i) &&
Mem.valid_pointer m b1 (Ptrofs.unsigned i0)); try discriminate H.
destruct c; simpl in *; inv H; reflexivity.
Qed.
Lemma compare_floats_spec:
forall rs n1 n2,
let rs' := nextinstr (compare_floats (Vfloat n1) (Vfloat n2) rs) in
rs'#ZF = Val.of_bool (Float.cmp Ceq n1 n2 || negb (Float.ordered n1 n2))
/\ rs'#CF = Val.of_bool (negb (Float.cmp Cge n1 n2))
/\ rs'#PF = Val.of_bool (negb (Float.ordered n1 n2))
/\ (forall r, data_preg r = true -> rs'#r = rs#r).
Proof.
intros. unfold rs'; unfold compare_floats.
split. auto.
split. auto.
split. auto.
intros. Simplifs.
Qed.
Lemma compare_floats32_spec:
forall rs n1 n2,
let rs' := nextinstr (compare_floats32 (Vsingle n1) (Vsingle n2) rs) in
rs'#ZF = Val.of_bool (Float32.cmp Ceq n1 n2 || negb (Float32.ordered n1 n2))
/\ rs'#CF = Val.of_bool (negb (Float32.cmp Cge n1 n2))
/\ rs'#PF = Val.of_bool (negb (Float32.ordered n1 n2))
/\ (forall r, data_preg r = true -> rs'#r = rs#r).
Proof.
intros. unfold rs'; unfold compare_floats32.
split. auto.
split. auto.
split. auto.
intros. Simplifs.
Qed.
Definition eval_extcond (xc: extcond) (rs: regset) : option bool :=
match xc with
| Cond_base c =>
eval_testcond c rs
| Cond_and c1 c2 =>
match eval_testcond c1 rs, eval_testcond c2 rs with
| Some b1, Some b2 => Some (b1 && b2)
| _, _ => None
end
| Cond_or c1 c2 =>
match eval_testcond c1 rs, eval_testcond c2 rs with
| Some b1, Some b2 => Some (b1 || b2)
| _, _ => None
end
end.
Definition swap_floats {A: Type} (c: comparison) (n1 n2: A) : A :=
match c with
| Clt | Cle => n2
| Ceq | Cne | Cgt | Cge => n1
end.
Lemma testcond_for_float_comparison_correct:
forall c n1 n2 rs,
eval_extcond (testcond_for_condition (Ccompf c))
(nextinstr (compare_floats (Vfloat (swap_floats c n1 n2))
(Vfloat (swap_floats c n2 n1)) rs)) =
Some(Float.cmp c n1 n2).
Proof.
intros.
generalize (compare_floats_spec rs (swap_floats c n1 n2) (swap_floats c n2 n1)).
set (rs' := nextinstr (compare_floats (Vfloat (swap_floats c n1 n2))
(Vfloat (swap_floats c n2 n1)) rs)).
intros [A [B [C D]]].
unfold eval_extcond, eval_testcond. rewrite A; rewrite B; rewrite C.
destruct c; simpl.
- (* eq *)
Transparent Float.cmp Float.ordered.
unfold Float.ordered, Float.cmp; destruct (Float.compare n1 n2) as [[]|]; reflexivity.
- (* ne *)
unfold Float.ordered, Float.cmp; destruct (Float.compare n1 n2) as [[]|]; reflexivity.
- (* lt *)
rewrite <- (Float.cmp_swap Clt n2 n1). simpl. unfold Float.ordered.
destruct (Float.compare n2 n1) as [[]|]; reflexivity.
- (* le *)
rewrite <- (Float.cmp_swap Cge n1 n2). simpl.
destruct (Float.compare n1 n2) as [[]|]; auto.
- (* gt *)
unfold Float.ordered, Float.cmp; destruct (Float.compare n1 n2) as [[]|]; reflexivity.
- (* ge *)
destruct (Float.cmp Cge n1 n2); auto.
Opaque Float.cmp Float.ordered.
Qed.
Lemma testcond_for_neg_float_comparison_correct:
forall c n1 n2 rs,
eval_extcond (testcond_for_condition (Cnotcompf c))
(nextinstr (compare_floats (Vfloat (swap_floats c n1 n2))
(Vfloat (swap_floats c n2 n1)) rs)) =
Some(negb(Float.cmp c n1 n2)).
Proof.
intros.
generalize (compare_floats_spec rs (swap_floats c n1 n2) (swap_floats c n2 n1)).
set (rs' := nextinstr (compare_floats (Vfloat (swap_floats c n1 n2))
(Vfloat (swap_floats c n2 n1)) rs)).
intros [A [B [C D]]].
unfold eval_extcond, eval_testcond. rewrite A; rewrite B; rewrite C.
destruct c; simpl.
- (* eq *)
Transparent Float.cmp Float.ordered.
unfold Float.ordered, Float.cmp; destruct (Float.compare n1 n2) as [[]|]; reflexivity.
- (* ne *)
unfold Float.ordered, Float.cmp; destruct (Float.compare n1 n2) as [[]|]; reflexivity.
- (* lt *)
rewrite <- (Float.cmp_swap Clt n2 n1). simpl. unfold Float.ordered.
destruct (Float.compare n2 n1) as [[]|]; reflexivity.
- (* le *)
rewrite <- (Float.cmp_swap Cge n1 n2). simpl.
destruct (Float.compare n1 n2) as [[]|]; auto.
- (* gt *)
unfold Float.ordered, Float.cmp; destruct (Float.compare n1 n2) as [[]|]; reflexivity.
- (* ge *)
destruct (Float.cmp Cge n1 n2); auto.
Opaque Float.cmp Float.ordered.
Qed.
Lemma testcond_for_float32_comparison_correct:
forall c n1 n2 rs,
eval_extcond (testcond_for_condition (Ccompfs c))
(nextinstr (compare_floats32 (Vsingle (swap_floats c n1 n2))
(Vsingle (swap_floats c n2 n1)) rs)) =
Some(Float32.cmp c n1 n2).
Proof.
intros.
generalize (compare_floats32_spec rs (swap_floats c n1 n2) (swap_floats c n2 n1)).
set (rs' := nextinstr (compare_floats32 (Vsingle (swap_floats c n1 n2))
(Vsingle (swap_floats c n2 n1)) rs)).
intros [A [B [C D]]].
unfold eval_extcond, eval_testcond. rewrite A; rewrite B; rewrite C.
destruct c; simpl.
- (* eq *)
Transparent Float32.cmp Float32.ordered.
unfold Float32.ordered, Float32.cmp; destruct (Float32.compare n1 n2) as [[]|]; reflexivity.
- (* ne *)
unfold Float32.ordered, Float32.cmp; destruct (Float32.compare n1 n2) as [[]|]; reflexivity.
- (* lt *)
rewrite <- (Float32.cmp_swap Clt n2 n1). simpl. unfold Float32.ordered.
destruct (Float32.compare n2 n1) as [[]|]; reflexivity.
- (* le *)
rewrite <- (Float32.cmp_swap Cge n1 n2). simpl.
destruct (Float32.compare n1 n2) as [[]|]; auto.
- (* gt *)
unfold Float32.ordered, Float32.cmp; destruct (Float32.compare n1 n2) as [[]|]; reflexivity.
- (* ge *)
destruct (Float32.cmp Cge n1 n2); auto.
Opaque Float32.cmp Float32.ordered.
Qed.
Lemma testcond_for_neg_float32_comparison_correct:
forall c n1 n2 rs,
eval_extcond (testcond_for_condition (Cnotcompfs c))
(nextinstr (compare_floats32 (Vsingle (swap_floats c n1 n2))
(Vsingle (swap_floats c n2 n1)) rs)) =
Some(negb(Float32.cmp c n1 n2)).
Proof.
intros.
generalize (compare_floats32_spec rs (swap_floats c n1 n2) (swap_floats c n2 n1)).
set (rs' := nextinstr (compare_floats32 (Vsingle (swap_floats c n1 n2))
(Vsingle (swap_floats c n2 n1)) rs)).
intros [A [B [C D]]].
unfold eval_extcond, eval_testcond. rewrite A; rewrite B; rewrite C.
destruct c; simpl.
- (* eq *)
Transparent Float32.cmp Float32.ordered.
unfold Float32.ordered, Float32.cmp; destruct (Float32.compare n1 n2) as [[]|]; reflexivity.
- (* ne *)
unfold Float32.ordered, Float32.cmp; destruct (Float32.compare n1 n2) as [[]|]; reflexivity.
- (* lt *)
rewrite <- (Float32.cmp_swap Clt n2 n1). simpl. unfold Float32.ordered.
destruct (Float32.compare n2 n1) as [[]|]; reflexivity.
- (* le *)
rewrite <- (Float32.cmp_swap Cge n1 n2). simpl.
destruct (Float32.compare n1 n2) as [[]|]; auto.
- (* gt *)
unfold Float32.ordered, Float32.cmp; destruct (Float32.compare n1 n2) as [[]|]; reflexivity.
- (* ge *)
destruct (Float32.cmp Cge n1 n2); auto.
Opaque Float32.cmp Float32.ordered.
Qed.
Remark swap_floats_commut:
forall (A B: Type) c (f: A -> B) x y, swap_floats c (f x) (f y) = f (swap_floats c x y).
Proof.
intros. destruct c; auto.
Qed.
Remark compare_floats_inv:
forall vx vy rs r,
r <> CR ZF -> r <> CR CF -> r <> CR PF -> r <> CR SF -> r <> CR OF ->
compare_floats vx vy rs r = rs r.
Proof.
intros.
assert (DFL: undef_regs (CR ZF :: CR CF :: CR PF :: CR SF :: CR OF :: nil) rs r = rs r).
simpl. Simplifs.
unfold compare_floats; destruct vx; destruct vy; auto. Simplifs.
Qed.
Remark compare_floats32_inv:
forall vx vy rs r,
r <> CR ZF -> r <> CR CF -> r <> CR PF -> r <> CR SF -> r <> CR OF ->
compare_floats32 vx vy rs r = rs r.
Proof.
intros.
assert (DFL: undef_regs (CR ZF :: CR CF :: CR PF :: CR SF :: CR OF :: nil) rs r = rs r).
simpl. Simplifs.
unfold compare_floats32; destruct vx; destruct vy; auto. Simplifs.
Qed.
Lemma 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
/\ match eval_condition cond (map rs (map preg_of args)) m with
| None => True
| Some b => eval_extcond (testcond_for_condition cond) rs' = Some b
end
/\ forall r, data_preg r = true -> rs'#r = rs r.
Proof.
unfold transl_cond; intros.
destruct cond; repeat (destruct args; try discriminate); monadInv H.
- (* comp *)
simpl. rewrite (ireg_of_eq _ _ EQ). rewrite (ireg_of_eq _ _ EQ1).
econstructor. split. apply exec_straight_one. simpl. eauto. auto.
split. destruct (Val.cmp_bool c0 (rs x) (rs x0)) eqn:?; auto.
eapply testcond_for_signed_comparison_32_correct; eauto.
intros. unfold compare_ints. Simplifs.
- (* compu *)
simpl. rewrite (ireg_of_eq _ _ EQ). rewrite (ireg_of_eq _ _ EQ1).
econstructor. split. apply exec_straight_one. simpl. eauto. auto.
split. destruct (Val.cmpu_bool (Mem.valid_pointer m) c0 (rs x) (rs x0)) eqn:?; auto.
eapply testcond_for_unsigned_comparison_32_correct; eauto.
intros. unfold compare_ints. Simplifs.
- (* compimm *)
simpl. rewrite (ireg_of_eq _ _ EQ). destruct (Int.eq_dec n Int.zero).
econstructor; split. apply exec_straight_one. simpl; eauto. auto.
split. destruct (rs x); simpl; auto. subst. rewrite Int.and_idem.
eapply testcond_for_signed_comparison_32_correct; eauto.
intros. unfold compare_ints. Simplifs.
econstructor; split. apply exec_straight_one. simpl; eauto. auto.
split. destruct (Val.cmp_bool c0 (rs x) (Vint n)) eqn:?; auto.
eapply testcond_for_signed_comparison_32_correct; eauto.
intros. unfold compare_ints. Simplifs.
- (* compuimm *)
simpl. rewrite (ireg_of_eq _ _ EQ).
econstructor. split. apply exec_straight_one. simpl. eauto. auto.
split. destruct (Val.cmpu_bool (Mem.valid_pointer m) c0 (rs x) (Vint n)) eqn:?; auto.
eapply testcond_for_unsigned_comparison_32_correct; eauto.
intros. unfold compare_ints. Simplifs.
- (* compl *)
simpl. rewrite (ireg_of_eq _ _ EQ). rewrite (ireg_of_eq _ _ EQ1).
econstructor. split. apply exec_straight_one. simpl. eauto. auto.
split. destruct (Val.cmpl_bool c0 (rs x) (rs x0)) eqn:?; auto.
eapply testcond_for_signed_comparison_64_correct; eauto.
intros. unfold compare_longs. Simplifs.
- (* complu *)
simpl. rewrite (ireg_of_eq _ _ EQ). rewrite (ireg_of_eq _ _ EQ1).
econstructor. split. apply exec_straight_one. simpl. eauto. auto.
split. destruct (Val.cmplu_bool (Mem.valid_pointer m) c0 (rs x) (rs x0)) eqn:?; auto.
eapply testcond_for_unsigned_comparison_64_correct; eauto.
intros. unfold compare_longs. Simplifs.
- (* compimm *)
simpl. rewrite (ireg_of_eq _ _ EQ). destruct (Int64.eq_dec n Int64.zero).
econstructor; split. apply exec_straight_one. simpl; eauto. auto.
split. destruct (rs x); simpl; auto. subst. rewrite Int64.and_idem.
eapply testcond_for_signed_comparison_64_correct; eauto.
intros. unfold compare_longs. Simplifs.
econstructor; split. apply exec_straight_one. simpl; eauto. auto.
split. destruct (Val.cmpl_bool c0 (rs x) (Vlong n)) eqn:?; auto.
eapply testcond_for_signed_comparison_64_correct; eauto.
intros. unfold compare_longs. Simplifs.
- (* compuimm *)
simpl. rewrite (ireg_of_eq _ _ EQ).
econstructor. split. apply exec_straight_one. simpl. eauto. auto.
split. destruct (Val.cmplu_bool (Mem.valid_pointer m) c0 (rs x) (Vlong n)) eqn:?; auto.
eapply testcond_for_unsigned_comparison_64_correct; eauto.
intros. unfold compare_longs. Simplifs.
- (* compf *)
simpl. rewrite (freg_of_eq _ _ EQ). rewrite (freg_of_eq _ _ EQ1).
exists (nextinstr (compare_floats (swap_floats c0 (rs x) (rs x0)) (swap_floats c0 (rs x0) (rs x)) rs)).
split. apply exec_straight_one.
destruct c0; simpl; auto.
unfold nextinstr. rewrite Pregmap.gss. rewrite compare_floats_inv; auto with asmgen.
split. destruct (rs x); destruct (rs x0); simpl; auto.
repeat rewrite swap_floats_commut. apply testcond_for_float_comparison_correct.
intros. Simplifs. apply compare_floats_inv; auto with asmgen.
- (* notcompf *)
simpl. rewrite (freg_of_eq _ _ EQ). rewrite (freg_of_eq _ _ EQ1).
exists (nextinstr (compare_floats (swap_floats c0 (rs x) (rs x0)) (swap_floats c0 (rs x0) (rs x)) rs)).
split. apply exec_straight_one.
destruct c0; simpl; auto.
unfold nextinstr. rewrite Pregmap.gss. rewrite compare_floats_inv; auto with asmgen.
split. destruct (rs x); destruct (rs x0); simpl; auto.
repeat rewrite swap_floats_commut. apply testcond_for_neg_float_comparison_correct.
intros. Simplifs. apply compare_floats_inv; auto with asmgen.
- (* compfs *)
simpl. rewrite (freg_of_eq _ _ EQ). rewrite (freg_of_eq _ _ EQ1).
exists (nextinstr (compare_floats32 (swap_floats c0 (rs x) (rs x0)) (swap_floats c0 (rs x0) (rs x)) rs)).
split. apply exec_straight_one.
destruct c0; simpl; auto.
unfold nextinstr. rewrite Pregmap.gss. rewrite compare_floats32_inv; auto with asmgen.